@jsonforms/material-renderers 3.0.0-alpha.1 → 3.0.0-beta.1

package/lib/jsonforms-react-material.cjs.js

@@ -0,0 +1,1489 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@jsonforms/core');
+var React = require('react');
+var react = require('@jsonforms/react');
+var isEmpty = require('lodash/isEmpty');
+var union = require('lodash/union');
+var startCase = require('lodash/startCase');
+var range = require('lodash/range');
+var material = require('@mui/material');
+var DeleteIcon = require('@mui/icons-material/Delete');
+var ArrowDownward = require('@mui/icons-material/ArrowDownward');
+var ArrowUpward = require('@mui/icons-material/ArrowUpward');
+var styles$1 = require('@mui/material/styles');
+var AddIcon = require('@mui/icons-material/Add');
+var ErrorOutlineIcon = require('@mui/icons-material/ErrorOutline');
+var merge = require('lodash/merge');
+var omit = require('lodash/omit');
+var dayjs = require('dayjs');
+var customParsing = require('dayjs/plugin/customParseFormat');
+var debounce = require('lodash/debounce');
+var Close = require('@mui/icons-material/Close');
+var map = require('lodash/map');
+var lab = require('@mui/lab');
+var AdapterDayjs = require('@mui/lab/AdapterDayjs');
+var get = require('lodash/get');
+var ExpandMoreIcon = require('@mui/icons-material/ExpandMore');
+var Input = require('@mui/material/Input');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
+var union__default = /*#__PURE__*/_interopDefaultLegacy(union);
+var startCase__default = /*#__PURE__*/_interopDefaultLegacy(startCase);
+var range__default = /*#__PURE__*/_interopDefaultLegacy(range);
+var DeleteIcon__default = /*#__PURE__*/_interopDefaultLegacy(DeleteIcon);
+var ArrowDownward__default = /*#__PURE__*/_interopDefaultLegacy(ArrowDownward);
+var ArrowUpward__default = /*#__PURE__*/_interopDefaultLegacy(ArrowUpward);
+var AddIcon__default = /*#__PURE__*/_interopDefaultLegacy(AddIcon);
+var ErrorOutlineIcon__default = /*#__PURE__*/_interopDefaultLegacy(ErrorOutlineIcon);
+var merge__default = /*#__PURE__*/_interopDefaultLegacy(merge);
+var omit__default = /*#__PURE__*/_interopDefaultLegacy(omit);
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+var customParsing__default = /*#__PURE__*/_interopDefaultLegacy(customParsing);
+var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
+var Close__default = /*#__PURE__*/_interopDefaultLegacy(Close);
+var map__default = /*#__PURE__*/_interopDefaultLegacy(map);
+var AdapterDayjs__default = /*#__PURE__*/_interopDefaultLegacy(AdapterDayjs);
+var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
+var ExpandMoreIcon__default = /*#__PURE__*/_interopDefaultLegacy(ExpandMoreIcon);
+var Input__default = /*#__PURE__*/_interopDefaultLegacy(Input);
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(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);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+var StyledTableCell = styles$1.styled(material.TableCell)({
+    borderBottom: 'none'
+});
+var NoBorderTableCell = function (_a) {
+    var children = _a.children, otherProps = __rest(_a, ["children"]);
+    return (React__default["default"].createElement(StyledTableCell, __assign({}, otherProps), children));
+};
+
+var StyledBadge = material.styled(material.Badge)(function (_a) {
+    var theme = _a.theme;
+    return ({
+        color: theme.palette.error.main
+    });
+});
+var ValidationIcon = function (_a) {
+    var errorMessages = _a.errorMessages, id = _a.id;
+    return (React__default["default"].createElement(material.Tooltip, { id: id, title: errorMessages },
+        React__default["default"].createElement(StyledBadge, { badgeContent: errorMessages.split('\n').length },
+            React__default["default"].createElement(ErrorOutlineIcon__default["default"], { color: 'inherit' }))));
+};
+
+var fixedCellSmall = {
+    paddingLeft: 0,
+    paddingRight: 0,
+};
+var TableToolbar = React__default["default"].memo(function (_a) {
+    var numColumns = _a.numColumns, errors = _a.errors, label = _a.label, path = _a.path, addItem = _a.addItem, schema = _a.schema, enabled = _a.enabled;
+    return (React__default["default"].createElement(material.TableRow, null,
+        React__default["default"].createElement(NoBorderTableCell, { colSpan: numColumns },
+            React__default["default"].createElement(material.Grid, { container: true, justifyContent: 'flex-start', alignItems: 'center', spacing: 2 },
+                React__default["default"].createElement(material.Grid, { item: true },
+                    React__default["default"].createElement(material.Typography, { variant: 'h6' }, label)),
+                React__default["default"].createElement(material.Grid, { item: true },
+                    React__default["default"].createElement(material.Hidden, { smUp: errors.length === 0 },
+                        React__default["default"].createElement(material.Grid, { item: true },
+                            React__default["default"].createElement(ValidationIcon, { id: 'tooltip-validation', errorMessages: errors })))))),
+        enabled ? (React__default["default"].createElement(NoBorderTableCell, { align: 'right', style: fixedCellSmall },
+            React__default["default"].createElement(material.Tooltip, { id: 'tooltip-add', title: "Add to " + label, placement: 'bottom' },
+                React__default["default"].createElement(material.IconButton, { "aria-label": "Add to " + label, onClick: addItem(path, core.createDefaultValue(schema)), size: 'large' },
+                    React__default["default"].createElement(AddIcon__default["default"], null))))) : null));
+});
+
+var styles = {
+    fixedCell: {
+        width: '150px',
+        height: '50px',
+        paddingLeft: 0,
+        paddingRight: 0,
+        textAlign: 'center'
+    },
+    fixedCellSmall: {
+        width: '50px',
+        height: '50px',
+        paddingLeft: 0,
+        paddingRight: 0,
+        textAlign: 'center'
+    }
+};
+var generateCells = function (Cell, schema, rowPath, enabled, cells) {
+    if (schema.type === 'object') {
+        return getValidColumnProps(schema).map(function (prop) {
+            var _a, _b, _c;
+            var cellPath = core.Paths.compose(rowPath, prop);
+            var props = {
+                propName: prop,
+                schema: schema,
+                title: (_c = (_b = (_a = schema.properties) === null || _a === void 0 ? void 0 : _a[prop]) === null || _b === void 0 ? void 0 : _b.title) !== null && _c !== void 0 ? _c : startCase__default["default"](prop),
+                rowPath: rowPath,
+                cellPath: cellPath,
+                enabled: enabled,
+                cells: cells
+            };
+            return React__default["default"].createElement(Cell, __assign({ key: cellPath }, props));
+        });
+    }
+    else {
+        var props = {
+            schema: schema,
+            rowPath: rowPath,
+            cellPath: rowPath,
+            enabled: enabled
+        };
+        return React__default["default"].createElement(Cell, __assign({ key: rowPath }, props));
+    }
+};
+var getValidColumnProps = function (scopedSchema) {
+    if (scopedSchema.type === 'object' && typeof scopedSchema.properties === 'object') {
+        return Object.keys(scopedSchema.properties).filter(function (prop) { return scopedSchema.properties[prop].type !== 'array'; });
+    }
+    return [''];
+};
+var EmptyTable = function (_a) {
+    var numColumns = _a.numColumns;
+    return (React__default["default"].createElement(material.TableRow, null,
+        React__default["default"].createElement(NoBorderTableCell, { colSpan: numColumns },
+            React__default["default"].createElement(material.Typography, { align: 'center' }, "No data"))));
+};
+var TableHeaderCell = React__default["default"].memo(function (_a) {
+    var title = _a.title;
+    return (React__default["default"].createElement(material.TableCell, null, title));
+});
+var ctxToNonEmptyCellProps = function (ctx, ownProps) {
+    var path = ownProps.rowPath +
+        (ownProps.schema.type === 'object' ? '.' + ownProps.propName : '');
+    var errors = core.formatErrorMessage(union__default["default"](core.errorsAt(path, ownProps.schema, function (p) { return p === path; })(ctx.core.errors).map(function (error) { return error.message; })));
+    return {
+        rowPath: ownProps.rowPath,
+        propName: ownProps.propName,
+        schema: ownProps.schema,
+        rootSchema: ctx.core.schema,
+        errors: errors,
+        path: path,
+        enabled: ownProps.enabled,
+        cells: ownProps.cells || ctx.cells,
+        renderers: ownProps.renderers || ctx.renderers
+    };
+};
+var controlWithoutLabel = function (scope) { return ({
+    type: 'Control',
+    scope: scope,
+    label: false
+}); };
+var NonEmptyCellComponent = React__default["default"].memo(function (_a) {
+    var path = _a.path, propName = _a.propName, schema = _a.schema, rootSchema = _a.rootSchema, errors = _a.errors, enabled = _a.enabled, renderers = _a.renderers, cells = _a.cells, isValid = _a.isValid;
+    return (React__default["default"].createElement(NoBorderTableCell, null,
+        schema.properties ? (React__default["default"].createElement(react.DispatchCell, { schema: core.Resolve.schema(schema, "#/properties/" + propName, rootSchema), uischema: controlWithoutLabel("#/properties/" + propName), path: path, enabled: enabled, renderers: renderers, cells: cells })) : (React__default["default"].createElement(react.DispatchCell, { schema: schema, uischema: controlWithoutLabel('#'), path: path, enabled: enabled, renderers: renderers, cells: cells })),
+        React__default["default"].createElement(material.FormHelperText, { error: !isValid }, !isValid && errors)));
+});
+var NonEmptyCell = function (ownProps) {
+    var ctx = react.useJsonForms();
+    var emptyCellProps = ctxToNonEmptyCellProps(ctx, ownProps);
+    var isValid = isEmpty__default["default"](emptyCellProps.errors);
+    return React__default["default"].createElement(NonEmptyCellComponent, __assign({}, emptyCellProps, { isValid: isValid }));
+};
+var NonEmptyRowComponent = function (_a) {
+    var childPath = _a.childPath, schema = _a.schema, rowIndex = _a.rowIndex, openDeleteDialog = _a.openDeleteDialog, moveUpCreator = _a.moveUpCreator, moveDownCreator = _a.moveDownCreator, enableUp = _a.enableUp, enableDown = _a.enableDown, showSortButtons = _a.showSortButtons, enabled = _a.enabled, cells = _a.cells, path = _a.path;
+    var moveUp = React.useMemo(function () { return moveUpCreator(path, rowIndex); }, [moveUpCreator, path, rowIndex]);
+    var moveDown = React.useMemo(function () { return moveDownCreator(path, rowIndex); }, [moveDownCreator, path, rowIndex]);
+    return (React__default["default"].createElement(material.TableRow, { key: childPath, hover: true },
+        generateCells(NonEmptyCell, schema, childPath, enabled, cells),
+        enabled ? (React__default["default"].createElement(NoBorderTableCell, { style: showSortButtons ? styles.fixedCell : styles.fixedCellSmall },
+            React__default["default"].createElement(material.Grid, { container: true, direction: 'row', justifyContent: 'flex-end', alignItems: 'center' },
+                showSortButtons ? (React__default["default"].createElement(React.Fragment, null,
+                    React__default["default"].createElement(material.Grid, { item: true },
+                        React__default["default"].createElement(material.IconButton, { "aria-label": "Move up", onClick: moveUp, disabled: !enableUp, size: 'large' },
+                            React__default["default"].createElement(ArrowUpward__default["default"], null))),
+                    React__default["default"].createElement(material.Grid, { item: true },
+                        React__default["default"].createElement(material.IconButton, { "aria-label": "Move down", onClick: moveDown, disabled: !enableDown, size: 'large' },
+                            React__default["default"].createElement(ArrowDownward__default["default"], null))))) : null,
+                React__default["default"].createElement(material.Grid, { item: true },
+                    React__default["default"].createElement(material.IconButton, { "aria-label": "Delete", onClick: function () { return openDeleteDialog(childPath, rowIndex); }, size: 'large' },
+                        React__default["default"].createElement(DeleteIcon__default["default"], null)))))) : null));
+};
+var NonEmptyRow = React__default["default"].memo(NonEmptyRowComponent);
+var TableRows = function (_a) {
+    var data = _a.data, path = _a.path, schema = _a.schema, openDeleteDialog = _a.openDeleteDialog, moveUp = _a.moveUp, moveDown = _a.moveDown, uischema = _a.uischema, config = _a.config, enabled = _a.enabled, cells = _a.cells;
+    var isEmptyTable = data === 0;
+    if (isEmptyTable) {
+        return React__default["default"].createElement(EmptyTable, { numColumns: getValidColumnProps(schema).length + 1 });
+    }
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(React__default["default"].Fragment, null, range__default["default"](data).map(function (index) {
+        var childPath = core.Paths.compose(path, "" + index);
+        return (React__default["default"].createElement(NonEmptyRow, { key: childPath, childPath: childPath, rowIndex: index, schema: schema, openDeleteDialog: openDeleteDialog, moveUpCreator: moveUp, moveDownCreator: moveDown, enableUp: index !== 0, enableDown: index !== data - 1, showSortButtons: appliedUiSchemaOptions.showSortButtons, enabled: enabled, cells: cells, path: path }));
+    })));
+};
+var MaterialTableControl =  (function (_super) {
+    __extends(MaterialTableControl, _super);
+    function MaterialTableControl() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.addItem = function (path, value) { return _this.props.addItem(path, value); };
+        return _this;
+    }
+    MaterialTableControl.prototype.render = function () {
+        var _a = this.props, label = _a.label, path = _a.path, schema = _a.schema, rootSchema = _a.rootSchema, uischema = _a.uischema, errors = _a.errors, openDeleteDialog = _a.openDeleteDialog, visible = _a.visible, enabled = _a.enabled, cells = _a.cells;
+        var controlElement = uischema;
+        var isObjectSchema = schema.type === 'object';
+        var headerCells = isObjectSchema
+            ? generateCells(TableHeaderCell, schema, path, enabled, cells)
+            : undefined;
+        return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+            React__default["default"].createElement(material.Table, null,
+                React__default["default"].createElement(material.TableHead, null,
+                    React__default["default"].createElement(TableToolbar, { errors: errors, label: label, addItem: this.addItem, numColumns: isObjectSchema ? headerCells.length : 1, path: path, uischema: controlElement, schema: schema, rootSchema: rootSchema, enabled: enabled }),
+                    isObjectSchema && (React__default["default"].createElement(material.TableRow, null,
+                        headerCells,
+                        enabled ? React__default["default"].createElement(material.TableCell, null) : null))),
+                React__default["default"].createElement(material.TableBody, null,
+                    React__default["default"].createElement(TableRows, __assign({ openDeleteDialog: openDeleteDialog }, this.props))))));
+    };
+    return MaterialTableControl;
+}(React__default["default"].Component));
+
+var DeleteDialog = React__default["default"].memo(function (_a) {
+    var open = _a.open, onClose = _a.onClose, onConfirm = _a.onConfirm, onCancel = _a.onCancel;
+    return (React__default["default"].createElement(material.Dialog, { open: open, keepMounted: true, onClose: onClose, "aria-labelledby": 'alert-dialog-confirmdelete-title', "aria-describedby": 'alert-dialog-confirmdelete-description' },
+        React__default["default"].createElement(material.DialogTitle, { id: 'alert-dialog-confirmdelete-title' }, 'Confirm Deletion'),
+        React__default["default"].createElement(material.DialogContent, null,
+            React__default["default"].createElement(material.DialogContentText, { id: 'alert-dialog-confirmdelete-description' }, "Are you sure you want to delete the selected entry?")),
+        React__default["default"].createElement(material.DialogActions, null,
+            React__default["default"].createElement(material.Button, { onClick: onCancel, color: 'primary' }, "No"),
+            React__default["default"].createElement(material.Button, { onClick: onConfirm, color: 'primary' }, "Yes"))));
+});
+
+var MaterialArrayControlRenderer = function (props) {
+    var _a = React.useState(false), open = _a[0], setOpen = _a[1];
+    var _b = React.useState(undefined), path = _b[0], setPath = _b[1];
+    var _c = React.useState(undefined), rowData = _c[0], setRowData = _c[1];
+    var removeItems = props.removeItems, visible = props.visible;
+    var openDeleteDialog = React.useCallback(function (p, rowIndex) {
+        setOpen(true);
+        setPath(p);
+        setRowData(rowIndex);
+    }, [setOpen, setPath, setRowData]);
+    var deleteCancel = React.useCallback(function () { return setOpen(false); }, [setOpen]);
+    var deleteConfirm = React.useCallback(function () {
+        var p = path.substring(0, path.lastIndexOf(('.')));
+        removeItems(p, [rowData])();
+        setOpen(false);
+    }, [setOpen, path, rowData]);
+    var deleteClose = React.useCallback(function () { return setOpen(false); }, [setOpen]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(MaterialTableControl, __assign({}, props, { openDeleteDialog: openDeleteDialog })),
+        React__default["default"].createElement(DeleteDialog, { open: open, onCancel: deleteCancel, onConfirm: deleteConfirm, onClose: deleteClose })));
+};
+var MaterialArrayControlRenderer$1 = react.withJsonFormsArrayLayoutProps(MaterialArrayControlRenderer);
+
+var MaterialObjectRenderer = function (_a) {
+    var renderers = _a.renderers, cells = _a.cells, uischemas = _a.uischemas, schema = _a.schema, label = _a.label, path = _a.path, visible = _a.visible, enabled = _a.enabled, uischema = _a.uischema, rootSchema = _a.rootSchema;
+    var detailUiSchema = React.useMemo(function () {
+        return core.findUISchema(uischemas, schema, uischema.scope, path, 'Group', uischema, rootSchema);
+    }, [uischemas, schema, uischema.scope, path, uischema, rootSchema]);
+    if (isEmpty__default["default"](path)) {
+        detailUiSchema.type = 'VerticalLayout';
+    }
+    else {
+        detailUiSchema.label = label;
+    }
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(react.JsonFormsDispatch, { visible: visible, enabled: enabled, schema: schema, uischema: detailUiSchema, path: path, renderers: renderers, cells: cells })));
+};
+var materialObjectControlTester = core.rankWith(2, core.isObjectControl);
+var MaterialObjectRenderer$1 = react.withJsonFormsDetailProps(MaterialObjectRenderer);
+
+var MaterialAllOfRenderer = function (_a) {
+    var schema = _a.schema, rootSchema = _a.rootSchema, visible = _a.visible, renderers = _a.renderers, cells = _a.cells, path = _a.path, uischemas = _a.uischemas, uischema = _a.uischema;
+    var _schema = core.resolveSubSchemas(schema, rootSchema, 'allOf');
+    var delegateUISchema = core.findMatchingUISchema(uischemas)(_schema, uischema.scope, path);
+    if (delegateUISchema) {
+        return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+            React__default["default"].createElement(react.JsonFormsDispatch, { schema: _schema, uischema: delegateUISchema, path: path, renderers: renderers, cells: cells })));
+    }
+    var allOfRenderInfos = core.createCombinatorRenderInfos(_schema.allOf, rootSchema, 'allOf', uischema, path, uischemas);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible }, allOfRenderInfos.map(function (allOfRenderInfo, allOfIndex) { return (React__default["default"].createElement(react.JsonFormsDispatch, { key: allOfIndex, schema: allOfRenderInfo.schema, uischema: allOfRenderInfo.uischema, path: path, renderers: renderers, cells: cells })); })));
+};
+var materialAllOfControlTester = core.rankWith(3, core.isAllOfControl);
+var MaterialAllOfRenderer$1 = react.withJsonFormsAllOfProps(MaterialAllOfRenderer);
+
+var isLayout = function (uischema) {
+    return uischema.hasOwnProperty('elements');
+};
+var CombinatorProperties =  (function (_super) {
+    __extends(CombinatorProperties, _super);
+    function CombinatorProperties() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CombinatorProperties.prototype.render = function () {
+        var _a = this.props, schema = _a.schema, combinatorKeyword = _a.combinatorKeyword, path = _a.path;
+        var otherProps = omit__default["default"](schema, combinatorKeyword);
+        var foundUISchema = core.Generate.uiSchema(otherProps, 'VerticalLayout');
+        var isLayoutWithElements = false;
+        if (foundUISchema !== null && isLayout(foundUISchema)) {
+            isLayoutWithElements = foundUISchema.elements.length > 0;
+        }
+        if (isLayoutWithElements) {
+            return (React__default["default"].createElement(react.JsonFormsDispatch, { schema: otherProps, path: path, uischema: foundUISchema }));
+        }
+        return null;
+    };
+    return CombinatorProperties;
+}(React__default["default"].Component));
+
+var MaterialAnyOfRenderer = function (_a) {
+    var schema = _a.schema, rootSchema = _a.rootSchema, indexOfFittingSchema = _a.indexOfFittingSchema, visible = _a.visible, path = _a.path, renderers = _a.renderers, cells = _a.cells, uischema = _a.uischema, uischemas = _a.uischemas;
+    var _b = React.useState(indexOfFittingSchema || 0), selectedAnyOf = _b[0], setSelectedAnyOf = _b[1];
+    var handleChange = React.useCallback(function (_ev, value) { return setSelectedAnyOf(value); }, [setSelectedAnyOf]);
+    var anyOf = 'anyOf';
+    var _schema = core.resolveSubSchemas(schema, rootSchema, anyOf);
+    var anyOfRenderInfos = core.createCombinatorRenderInfos(_schema.anyOf, rootSchema, anyOf, uischema, path, uischemas);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(CombinatorProperties, { schema: _schema, combinatorKeyword: 'anyOf', path: path }),
+        React__default["default"].createElement(material.Tabs, { value: selectedAnyOf, onChange: handleChange }, anyOfRenderInfos.map(function (anyOfRenderInfo) { return (React__default["default"].createElement(material.Tab, { key: anyOfRenderInfo.label, label: anyOfRenderInfo.label })); })),
+        anyOfRenderInfos.map(function (anyOfRenderInfo, anyOfIndex) {
+            return selectedAnyOf === anyOfIndex && (React__default["default"].createElement(react.JsonFormsDispatch, { key: anyOfIndex, schema: anyOfRenderInfo.schema, uischema: anyOfRenderInfo.uischema, path: path, renderers: renderers, cells: cells }));
+        })));
+};
+var materialAnyOfControlTester = core.rankWith(3, core.isAnyOfControl);
+var MaterialAnyOfRenderer$1 = react.withJsonFormsAnyOfProps(MaterialAnyOfRenderer);
+
+var MaterialOneOfRenderer = function (_a) {
+    var handleChange = _a.handleChange, schema = _a.schema, path = _a.path, renderers = _a.renderers, cells = _a.cells, rootSchema = _a.rootSchema, id = _a.id, visible = _a.visible, indexOfFittingSchema = _a.indexOfFittingSchema, uischema = _a.uischema, uischemas = _a.uischemas, data = _a.data;
+    var _b = React.useState(false), open = _b[0], setOpen = _b[1];
+    var _c = React.useState(indexOfFittingSchema || 0), selectedIndex = _c[0], setSelectedIndex = _c[1];
+    var _d = React.useState(0), newSelectedIndex = _d[0], setNewSelectedIndex = _d[1];
+    var handleClose = React.useCallback(function () { return setOpen(false); }, [setOpen]);
+    var cancel = React.useCallback(function () {
+        setOpen(false);
+    }, [setOpen]);
+    var _schema = core.resolveSubSchemas(schema, rootSchema, 'oneOf');
+    var oneOfRenderInfos = core.createCombinatorRenderInfos(_schema.oneOf, rootSchema, 'oneOf', uischema, path, uischemas);
+    var openNewTab = function (newIndex) {
+        handleChange(path, core.createDefaultValue(schema.oneOf[newIndex]));
+        setSelectedIndex(newIndex);
+    };
+    var confirm = React.useCallback(function () {
+        openNewTab(newSelectedIndex);
+        setOpen(false);
+    }, [handleChange, core.createDefaultValue, newSelectedIndex]);
+    var handleTabChange = React.useCallback(function (_event, newOneOfIndex) {
+        setNewSelectedIndex(newOneOfIndex);
+        if (isEmpty__default["default"](data)) {
+            openNewTab(newOneOfIndex);
+        }
+        else {
+            setOpen(true);
+        }
+    }, [setOpen, setSelectedIndex, data]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(CombinatorProperties, { schema: _schema, combinatorKeyword: 'oneOf', path: path }),
+        React__default["default"].createElement(material.Tabs, { value: selectedIndex, onChange: handleTabChange }, oneOfRenderInfos.map(function (oneOfRenderInfo) { return React__default["default"].createElement(material.Tab, { key: oneOfRenderInfo.label, label: oneOfRenderInfo.label }); })),
+        oneOfRenderInfos.map(function (oneOfRenderInfo, oneOfIndex) { return (selectedIndex === oneOfIndex && (React__default["default"].createElement(react.JsonFormsDispatch, { key: oneOfIndex, schema: oneOfRenderInfo.schema, uischema: oneOfRenderInfo.uischema, path: path, renderers: renderers, cells: cells }))); }),
+        React__default["default"].createElement(material.Dialog, { open: open, onClose: handleClose, "aria-labelledby": 'alert-dialog-title', "aria-describedby": 'alert-dialog-description' },
+            React__default["default"].createElement(material.DialogTitle, { id: 'alert-dialog-title' }, 'Clear form?'),
+            React__default["default"].createElement(material.DialogContent, null,
+                React__default["default"].createElement(material.DialogContentText, { id: 'alert-dialog-description' }, "Your data will be cleared if you navigate away from this tab. Do you want to proceed?")),
+            React__default["default"].createElement(material.DialogActions, null,
+                React__default["default"].createElement(material.Button, { onClick: cancel, color: 'primary' }, "No"),
+                React__default["default"].createElement(material.Button, { onClick: confirm, color: 'primary', autoFocus: true, id: "oneOf-" + id + "-confirm-yes" }, "Yes")))));
+};
+var materialOneOfControlTester = core.rankWith(3, core.isOneOfControl);
+var MaterialOneOfRenderer$1 = react.withJsonFormsOneOfProps(MaterialOneOfRenderer);
+
+var MuiCheckbox = React__default["default"].memo(function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var inputProps = { autoFocus: !!appliedUiSchemaOptions.focus };
+    var checked = !!data;
+    return (React__default["default"].createElement(material.Checkbox, { checked: checked, onChange: function (_ev, isChecked) { return handleChange(path, isChecked); }, className: className, id: id, disabled: !enabled, inputProps: inputProps }));
+});
+
+var MuiSelect = React__default["default"].memo(function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, options = props.options, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(material.Select, { className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, value: data !== undefined ? data : '', onChange: function (ev) { return handleChange(path, ev.target.value); }, fullWidth: true, variant: 'standard' }, [React__default["default"].createElement(material.MenuItem, { value: '', key: 'empty' })].concat(options.map(function (optionValue) { return (React__default["default"].createElement(material.MenuItem, { value: optionValue.value, key: optionValue.value }, optionValue.label)); }))));
+});
+
+dayjs__default["default"].extend(customParsing__default["default"]);
+var createOnChangeHandler = function (path, handleChange, saveFormat) { return function (time) {
+    if (!time) {
+        handleChange(path, undefined);
+        return;
+    }
+    var result = dayjs__default["default"](time).format(saveFormat);
+    handleChange(path, result === 'Invalid Date' ? undefined : result);
+}; };
+var getData = function (data, saveFormat) {
+    if (!data) {
+        return null;
+    }
+    var dayjsData = dayjs__default["default"](data, saveFormat);
+    if (dayjsData.toString() === 'Invalid Date') {
+        return null;
+    }
+    return dayjsData;
+};
+
+var renderLayoutElements = function (elements, schema, path, enabled, renderers, cells) {
+    return elements.map(function (child, index) { return (React__default["default"].createElement(material.Grid, { item: true, key: path + "-" + index, xs: true },
+        React__default["default"].createElement(react.JsonFormsDispatch, { uischema: child, schema: schema, path: path, enabled: enabled, renderers: renderers, cells: cells }))); });
+};
+var MaterialLayoutRendererComponent = function (_a) {
+    var visible = _a.visible, elements = _a.elements, schema = _a.schema, path = _a.path, enabled = _a.enabled, direction = _a.direction, renderers = _a.renderers, cells = _a.cells;
+    if (isEmpty__default["default"](elements)) {
+        return null;
+    }
+    else {
+        return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+            React__default["default"].createElement(material.Grid, { container: true, direction: direction, spacing: direction === 'row' ? 2 : 0 }, renderLayoutElements(elements, schema, path, enabled, renderers, cells))));
+    }
+};
+var MaterialLayoutRenderer = React__default["default"].memo(MaterialLayoutRendererComponent);
+var withAjvProps = function (Component) {
+    return function (props) {
+        var ctx = react.useJsonForms();
+        var ajv = core.getAjv({ jsonforms: __assign({}, ctx) });
+        return (React__default["default"].createElement(Component, __assign({}, props, { ajv: ajv })));
+    };
+};
+
+var eventToValue$2 = function (ev) { return ev.target.value; };
+var useDebouncedChange = function (handleChange, defaultValue, data, path, eventToValueFunction, timeout) {
+    if (eventToValueFunction === void 0) { eventToValueFunction = eventToValue$2; }
+    if (timeout === void 0) { timeout = 300; }
+    var _a = React.useState(data !== null && data !== void 0 ? data : defaultValue), input = _a[0], setInput = _a[1];
+    React.useEffect(function () {
+        setInput(data !== null && data !== void 0 ? data : defaultValue);
+    }, [data]);
+    var debouncedUpdate = React.useCallback(debounce__default["default"](function (newValue) { return handleChange(path, newValue); }, timeout), [handleChange, path, timeout]);
+    var onChange = React.useCallback(function (ev) {
+        var newValue = eventToValueFunction(ev);
+        setInput(newValue !== null && newValue !== void 0 ? newValue : defaultValue);
+        debouncedUpdate(newValue);
+    }, [debouncedUpdate, eventToValueFunction]);
+    var onClear = React.useCallback(function () { setInput(defaultValue); handleChange(path, undefined); }, [defaultValue, handleChange, path]);
+    return [input, onChange, onClear];
+};
+
+var useFocus = function () {
+    var _a = React.useState(false), focused = _a[0], setFocused = _a[1];
+    var onFocus = React.useCallback(function () { return setFocused(true); }, []);
+    var onBlur = React.useCallback(function () { return setFocused(false); }, []);
+    return [focused, onFocus, onBlur];
+};
+
+var toNumber$1 = function (value) {
+    return value === '' ? undefined : parseInt(value, 10);
+};
+var eventToValue$1 = function (ev) { return toNumber$1(ev.target.value); };
+var MuiInputInteger = React__default["default"].memo(function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, config = props.config;
+    var inputProps = { step: '1' };
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var _a = useDebouncedChange(handleChange, '', data, path, eventToValue$1), inputValue = _a[0], onChange = _a[1];
+    return (React__default["default"].createElement(material.Input, { type: 'number', value: inputValue, onChange: onChange, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, inputProps: inputProps, fullWidth: true }));
+});
+
+var toNumber = function (value) {
+    return value === '' ? undefined : parseFloat(value);
+};
+var eventToValue = function (ev) { return toNumber(ev.target.value); };
+var MuiInputNumber = React__default["default"].memo(function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, config = props.config;
+    var inputProps = { step: '0.1' };
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var _a = useDebouncedChange(handleChange, '', data, path, eventToValue), inputValue = _a[0], onChange = _a[1];
+    return (React__default["default"].createElement(material.Input, { type: 'number', value: inputValue, onChange: onChange, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, inputProps: inputProps, fullWidth: true }));
+});
+
+var MuiInputNumberFormat = React__default["default"].memo(function (props) {
+    var className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, isValid = props.isValid, path = props.path, handleChange = props.handleChange, schema = props.schema, config = props.config;
+    var maxLength = schema.maxLength;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var inputProps;
+    if (appliedUiSchemaOptions.restrict) {
+        inputProps = { maxLength: maxLength };
+    }
+    else {
+        inputProps = {};
+    }
+    var formattedNumber = props.toFormatted(props.data);
+    var validStringNumber = React.useCallback(function (ev) { return props.fromFormatted(ev.currentTarget.value); }, [props.fromFormatted]);
+    var _a = useDebouncedChange(handleChange, '', formattedNumber, path, validStringNumber), inputValue = _a[0], onChange = _a[1];
+    return (React__default["default"].createElement(material.Input, { type: 'text', value: inputValue, onChange: onChange, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, multiline: appliedUiSchemaOptions.multi, fullWidth: !appliedUiSchemaOptions.trim || maxLength === undefined, inputProps: inputProps, error: !isValid }));
+});
+
+var MuiInputText = React__default["default"].memo(function (props) {
+    var _a, _b, _c;
+    var _d = React.useState(false), showAdornment = _d[0], setShowAdornment = _d[1];
+    var data = props.data, config = props.config, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, isValid = props.isValid, path = props.path, handleChange = props.handleChange, schema = props.schema, muiInputProps = props.muiInputProps, inputComponent = props.inputComponent;
+    var maxLength = schema.maxLength;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var inputProps;
+    if (appliedUiSchemaOptions.restrict) {
+        inputProps = { maxLength: maxLength };
+    }
+    else {
+        inputProps = {};
+    }
+    inputProps = merge__default["default"](inputProps, muiInputProps);
+    if (appliedUiSchemaOptions.trim && maxLength !== undefined) {
+        inputProps.size = maxLength;
+    }
+    var _e = useDebouncedChange(handleChange, '', data, path), inputText = _e[0], onChange = _e[1], onClear = _e[2];
+    var onPointerEnter = function () { return setShowAdornment(true); };
+    var onPointerLeave = function () { return setShowAdornment(false); };
+    var theme = material.useTheme();
+    var closeStyle = {
+        background: ((_c = (_b = (_a = theme.jsonforms) === null || _a === void 0 ? void 0 : _a.input) === null || _b === void 0 ? void 0 : _b.delete) === null || _c === void 0 ? void 0 : _c.background) || theme.palette.background.default,
+        borderRadius: '50%'
+    };
+    return (React__default["default"].createElement(material.Input, { type: appliedUiSchemaOptions.format === 'password' ? 'password' : 'text', value: inputText, onChange: onChange, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, multiline: appliedUiSchemaOptions.multi, fullWidth: !appliedUiSchemaOptions.trim || maxLength === undefined, inputProps: inputProps, error: !isValid, onPointerEnter: onPointerEnter, onPointerLeave: onPointerLeave, endAdornment: React__default["default"].createElement(material.InputAdornment, { position: 'end', style: {
+                display: !showAdornment || !enabled || data === undefined ? 'none' : 'flex',
+                position: 'absolute',
+                right: 0
+            } },
+            React__default["default"].createElement(material.IconButton, { "aria-label": 'Clear input field', onClick: onClear, size: 'large' },
+                React__default["default"].createElement(Close__default["default"], { style: closeStyle }))), inputComponent: inputComponent }));
+});
+
+var MuiInputTime = React__default["default"].memo(function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var _a = useDebouncedChange(handleChange, '', data, path), inputValue = _a[0], onChange = _a[1];
+    return (React__default["default"].createElement(material.Input, { type: 'time', value: inputValue, onChange: onChange, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, fullWidth: true }));
+});
+
+var MaterialEnumArrayRenderer = function (_a) {
+    var schema = _a.schema, visible = _a.visible, errors = _a.errors, path = _a.path, options = _a.options, data = _a.data, addItem = _a.addItem, removeItem = _a.removeItem; _a.handleChange; var otherProps = __rest(_a, ["schema", "visible", "errors", "path", "options", "data", "addItem", "removeItem", "handleChange"]);
+    return (React__default["default"].createElement(material.Hidden, { xlUp: !visible },
+        React__default["default"].createElement(material.FormControl, { component: 'fieldset' },
+            React__default["default"].createElement(material.FormGroup, { row: true }, options.map(function (option, index) {
+                var optionPath = core.Paths.compose(path, "" + index);
+                var checkboxValue = (data === null || data === void 0 ? void 0 : data.includes(option.value))
+                    ? option.value
+                    : undefined;
+                return (React__default["default"].createElement(material.FormControlLabel, { id: option.value, key: option.value, control: React__default["default"].createElement(MuiCheckbox, __assign({ key: 'checkbox-' + option.value, isValid: isEmpty__default["default"](errors), path: optionPath, handleChange: function (_childPath, newValue) {
+                            return newValue
+                                ? addItem(path, option.value)
+                                : removeItem(path, option.value);
+                        }, data: checkboxValue, errors: errors, schema: schema, visible: visible }, otherProps)), label: startCase__default["default"](option.label) }));
+            })),
+            React__default["default"].createElement(material.FormHelperText, { error: true }, errors))));
+};
+var hasOneOfItems = function (schema) {
+    return schema.oneOf !== undefined &&
+        schema.oneOf.length > 0 &&
+        schema.oneOf.every(function (entry) {
+            return entry.const !== undefined;
+        });
+};
+var hasEnumItems = function (schema) {
+    return schema.type === 'string' && schema.enum !== undefined;
+};
+var materialEnumArrayRendererTester = core.rankWith(5, core.and(core.uiTypeIs('Control'), core.and(core.schemaMatches(function (schema) {
+    return core.hasType(schema, 'array') &&
+        !Array.isArray(schema.items) &&
+        schema.uniqueItems === true;
+}), core.schemaSubPathMatches('items', function (schema) {
+    return hasOneOfItems(schema) || hasEnumItems(schema);
+}))));
+var MaterialEnumArrayRenderer$1 = react.withJsonFormsMultiEnumProps(MaterialEnumArrayRenderer);
+
+var materialArrayControlTester = core.rankWith(3, core.or(core.isObjectArrayControl, core.isPrimitiveArrayControl));
+
+var materialLabelRendererTester = core.rankWith(1, core.uiTypeIs('Label'));
+var MaterialLabelRenderer = function (_a) {
+    var uischema = _a.uischema, visible = _a.visible;
+    var labelElement = uischema;
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.Typography, { variant: 'h6' }, labelElement.text !== undefined && labelElement.text !== null && labelElement.text)));
+};
+var MaterialLabelRenderer$1 = react.withJsonFormsLayoutProps(MaterialLabelRenderer);
+
+var ArrayLayoutToolbar = React__default["default"].memo(function (_a) {
+    var label = _a.label, errors = _a.errors, addItem = _a.addItem, path = _a.path, createDefault = _a.createDefault;
+    return (React__default["default"].createElement(material.Toolbar, { disableGutters: true },
+        React__default["default"].createElement(material.Grid, { container: true, alignItems: 'center', justifyContent: 'space-between' },
+            React__default["default"].createElement(material.Grid, { item: true },
+                React__default["default"].createElement(material.Typography, { variant: 'h6' }, label)),
+            React__default["default"].createElement(material.Hidden, { smUp: errors.length === 0 },
+                React__default["default"].createElement(material.Grid, { item: true },
+                    React__default["default"].createElement(ValidationIcon, { id: 'tooltip-validation', errorMessages: errors }))),
+            React__default["default"].createElement(material.Grid, { item: true },
+                React__default["default"].createElement(material.Grid, { container: true },
+                    React__default["default"].createElement(material.Grid, { item: true },
+                        React__default["default"].createElement(material.Tooltip, { id: 'tooltip-add', title: "Add to " + label, placement: 'bottom' },
+                            React__default["default"].createElement(material.IconButton, { "aria-label": "Add to " + label, onClick: addItem(path, createDefault()), size: 'large' },
+                                React__default["default"].createElement(AddIcon__default["default"], null)))))))));
+});
+
+var ListWithDetailMasterItem = function (_a) {
+    var index = _a.index, childLabel = _a.childLabel, selected = _a.selected, handleSelect = _a.handleSelect, removeItem = _a.removeItem, path = _a.path;
+    return (React__default["default"].createElement(material.ListItem, { button: true, selected: selected, onClick: handleSelect(index) },
+        React__default["default"].createElement(material.ListItemAvatar, null,
+            React__default["default"].createElement(material.Avatar, { "aria-label": 'Index' }, index + 1)),
+        React__default["default"].createElement(material.ListItemText, { primary: childLabel }),
+        React__default["default"].createElement(material.ListItemSecondaryAction, null,
+            React__default["default"].createElement(material.IconButton, { "aria-label": 'Delete', onClick: removeItem(path, index), size: 'large' },
+                React__default["default"].createElement(DeleteIcon__default["default"], null)))));
+};
+var ListWithDetailMasterItem$1 = react.withJsonFormsMasterListItemProps(ListWithDetailMasterItem);
+
+var MaterialListWithDetailRenderer = function (_a) {
+    var uischemas = _a.uischemas, schema = _a.schema, uischema = _a.uischema, path = _a.path, errors = _a.errors, visible = _a.visible, label = _a.label, required = _a.required, removeItems = _a.removeItems, addItem = _a.addItem, data = _a.data, renderers = _a.renderers, cells = _a.cells, config = _a.config;
+    var _b = React.useState(undefined), selectedIndex = _b[0], setSelectedIndex = _b[1];
+    var handleRemoveItem = React.useCallback(function (p, value) { return function () {
+        removeItems(p, [value])();
+        if (selectedIndex === value) {
+            setSelectedIndex(undefined);
+        }
+        else if (selectedIndex > value) {
+            setSelectedIndex(selectedIndex - 1);
+        }
+    }; }, [removeItems, setSelectedIndex]);
+    var handleListItemClick = React.useCallback(function (index) { return function () { return setSelectedIndex(index); }; }, [setSelectedIndex]);
+    var handleCreateDefaultValue = React.useCallback(function () { return core.createDefaultValue(schema); }, [core.createDefaultValue]);
+    var foundUISchema = React.useMemo(function () {
+        return core.findUISchema(uischemas, schema, uischema.scope, path, undefined, uischema);
+    }, [uischemas, schema, uischema.scope, path, uischema]);
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(ArrayLayoutToolbar, { label: core.computeLabel(label, required, appliedUiSchemaOptions.hideRequiredAsterisk), errors: errors, path: path, addItem: addItem, createDefault: handleCreateDefaultValue }),
+        React__default["default"].createElement(material.Grid, { container: true, direction: 'row', spacing: 2 },
+            React__default["default"].createElement(material.Grid, { item: true, xs: 3 },
+                React__default["default"].createElement(material.List, null, data > 0 ? (map__default["default"](range__default["default"](data), function (index) { return (React__default["default"].createElement(ListWithDetailMasterItem$1, { index: index, path: path, schema: schema, handleSelect: handleListItemClick, removeItem: handleRemoveItem, selected: selectedIndex === index, key: index })); })) : (React__default["default"].createElement("p", null, "No data")))),
+            React__default["default"].createElement(material.Grid, { item: true, xs: true }, selectedIndex !== undefined ? (React__default["default"].createElement(react.JsonFormsDispatch, { renderers: renderers, cells: cells, visible: visible, schema: schema, uischema: foundUISchema, path: core.composePaths(path, "" + selectedIndex) })) : (React__default["default"].createElement(material.Typography, { variant: 'h6' }, "No Selection"))))));
+};
+var materialListWithDetailTester = core.rankWith(4, core.and(core.uiTypeIs('ListWithDetail'), core.isObjectArray));
+var MaterialListWithDetailRenderer$1 = react.withJsonFormsArrayLayoutProps(MaterialListWithDetailRenderer);
+
+var MaterialBooleanControl = function (_a) {
+    var data = _a.data, visible = _a.visible, label = _a.label, id = _a.id, enabled = _a.enabled, uischema = _a.uischema, schema = _a.schema, rootSchema = _a.rootSchema, handleChange = _a.handleChange, errors = _a.errors, path = _a.path, config = _a.config;
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.FormControlLabel, { label: label, id: id, control: React__default["default"].createElement(MuiCheckbox, { id: id + "-input", isValid: isEmpty__default["default"](errors), data: data, enabled: enabled, visible: visible, path: path, uischema: uischema, schema: schema, rootSchema: rootSchema, handleChange: handleChange, errors: errors, config: config }) })));
+};
+var materialBooleanControlTester = core.rankWith(2, core.isBooleanControl);
+var MaterialBooleanControl$1 = react.withJsonFormsControlProps(MaterialBooleanControl);
+
+var MuiToggle = React__default["default"].memo(function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var inputProps = { autoFocus: !!appliedUiSchemaOptions.focus };
+    var checked = !!data;
+    return (React__default["default"].createElement(material.Switch, { checked: checked, onChange: function (_ev, isChecked) { return handleChange(path, isChecked); }, className: className, id: id, disabled: !enabled, inputProps: inputProps }));
+});
+
+var MaterialBooleanToggleControl = function (_a) {
+    var data = _a.data, visible = _a.visible, label = _a.label, id = _a.id, enabled = _a.enabled, uischema = _a.uischema, schema = _a.schema, rootSchema = _a.rootSchema, handleChange = _a.handleChange, errors = _a.errors, path = _a.path, config = _a.config;
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.FormControlLabel, { label: label, id: id, control: React__default["default"].createElement(MuiToggle, { id: id + "-input", isValid: isEmpty__default["default"](errors), data: data, enabled: enabled, visible: visible, path: path, uischema: uischema, schema: schema, rootSchema: rootSchema, handleChange: handleChange, errors: errors, config: config }) })));
+};
+var materialBooleanToggleControlTester = core.rankWith(3, core.and(core.isBooleanControl, core.optionIs('toggle', true)));
+var MaterialBooleanToggleControl$1 = react.withJsonFormsControlProps(MaterialBooleanToggleControl);
+
+var MaterialInputControl = function (props) {
+    var _a = useFocus(), focused = _a[0], onFocus = _a[1], onBlur = _a[2];
+    var id = props.id, description = props.description, errors = props.errors, label = props.label, uischema = props.uischema, visible = props.visible, required = props.required, config = props.config, input = props.input;
+    var isValid = errors.length === 0;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    var firstFormHelperText = showDescription
+        ? description
+        : !isValid
+            ? errors
+            : null;
+    var secondFormHelperText = showDescription && !isValid ? errors : null;
+    var InnerComponent = input;
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.FormControl, { fullWidth: !appliedUiSchemaOptions.trim, onFocus: onFocus, onBlur: onBlur, id: id, variant: 'standard' },
+            React__default["default"].createElement(material.InputLabel, { htmlFor: id + '-input', error: !isValid, required: core.showAsRequired(required, appliedUiSchemaOptions.hideRequiredAsterisk) }, label),
+            React__default["default"].createElement(InnerComponent, __assign({}, props, { id: id + '-input', isValid: isValid, visible: visible })),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid && !showDescription }, firstFormHelperText),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid }, secondFormHelperText))));
+};
+
+var MuiAutocomplete = function (props) {
+    var _a;
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, options = props.options, config = props.config, getOptionLabel = props.getOptionLabel, renderOption = props.renderOption, filterOptions = props.filterOptions;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var _b = React__default["default"].useState(data !== null && data !== void 0 ? data : ''), inputValue = _b[0], setInputValue = _b[1];
+    var findOption = (_a = options.find(function (o) { return o.value === data; })) !== null && _a !== void 0 ? _a : null;
+    return (React__default["default"].createElement(material.Autocomplete, { className: className, id: id, disabled: !enabled, value: findOption, onChange: function (_event, newValue) {
+            handleChange(path, newValue === null || newValue === void 0 ? void 0 : newValue.value);
+        }, inputValue: inputValue, onInputChange: function (_event, newInputValue) {
+            setInputValue(newInputValue);
+        }, autoHighlight: true, autoSelect: true, autoComplete: true, fullWidth: true, options: options, getOptionLabel: getOptionLabel || (function (option) { return option === null || option === void 0 ? void 0 : option.label; }), style: { marginTop: 16 }, renderInput: function (params) { return (React__default["default"].createElement(material.Input, { style: { width: '100%' }, type: 'text', inputProps: params.inputProps, inputRef: params.InputProps.ref, autoFocus: appliedUiSchemaOptions.focus, disabled: !enabled })); }, renderOption: renderOption, filterOptions: filterOptions }));
+};
+
+var MaterialEnumControl = function (props) {
+    var config = props.config, uischema = props.uischema;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(MaterialInputControl, __assign({}, props, { input: appliedUiSchemaOptions.autocomplete === false ? MuiSelect : MuiAutocomplete })));
+};
+var materialEnumControlTester = core.rankWith(2, core.isEnumControl);
+var MaterialEnumControl$1 = react.withJsonFormsEnumProps(MaterialEnumControl);
+
+var MaterialNativeControl = function (props) {
+    var _a;
+    var _b = useFocus(), focused = _b[0], onFocus = _b[1], onBlur = _b[2];
+    var id = props.id, errors = props.errors, label = props.label, schema = props.schema, description = props.description, enabled = props.enabled, visible = props.visible, required = props.required, path = props.path, handleChange = props.handleChange, data = props.data, config = props.config;
+    var isValid = errors.length === 0;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, props.uischema.options);
+    var _c = useDebouncedChange(handleChange, '', data, path), inputValue = _c[0], onChange = _c[1];
+    var fieldType = (_a = appliedUiSchemaOptions.format) !== null && _a !== void 0 ? _a : schema.format;
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.TextField, { required: core.showAsRequired(required, appliedUiSchemaOptions.hideRequiredAsterisk), id: id + '-input', label: label, type: fieldType, error: !isValid, disabled: !enabled, fullWidth: !appliedUiSchemaOptions.trim, onFocus: onFocus, onBlur: onBlur, helperText: !isValid ? errors : showDescription ? description : null, InputLabelProps: { shrink: true }, value: inputValue, onChange: onChange })));
+};
+var materialNativeControlTester = core.rankWith(2, core.or(core.isDateControl, core.isTimeControl));
+var MaterialNativeControl$1 = react.withJsonFormsControlProps(MaterialNativeControl);
+
+var MaterialDateControl = function (props) {
+    var _a, _b;
+    var _c = useFocus(), focused = _c[0], onFocus = _c[1], onBlur = _c[2];
+    var description = props.description, id = props.id, errors = props.errors, label = props.label, uischema = props.uischema, visible = props.visible, enabled = props.enabled, required = props.required, path = props.path, handleChange = props.handleChange, data = props.data, config = props.config;
+    var isValid = errors.length === 0;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    var format = (_a = appliedUiSchemaOptions.dateFormat) !== null && _a !== void 0 ? _a : 'YYYY-MM-DD';
+    var saveFormat = (_b = appliedUiSchemaOptions.dateSaveFormat) !== null && _b !== void 0 ? _b : 'YYYY-MM-DD';
+    var firstFormHelperText = showDescription
+        ? description
+        : !isValid
+            ? errors
+            : null;
+    var secondFormHelperText = showDescription && !isValid ? errors : null;
+    var onChange = React.useMemo(function () { return createOnChangeHandler(path, handleChange, saveFormat); }, [path, handleChange, saveFormat]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(lab.LocalizationProvider, { dateAdapter: AdapterDayjs__default["default"] },
+            React__default["default"].createElement(lab.DatePicker, { label: label, value: getData(data, saveFormat), clearable: true, onChange: onChange, inputFormat: format, disableMaskedInput: true, views: appliedUiSchemaOptions.views, disabled: !enabled, cancelText: appliedUiSchemaOptions.cancelLabel, clearText: appliedUiSchemaOptions.clearLabel, okText: appliedUiSchemaOptions.okLabel, renderInput: function (params) { return (React__default["default"].createElement(material.TextField, __assign({}, params, { id: id + '-input', required: required && !appliedUiSchemaOptions.hideRequiredAsterisk, autoFocus: appliedUiSchemaOptions.focus, error: !isValid, fullWidth: !appliedUiSchemaOptions.trim, inputProps: __assign(__assign({}, params.inputProps), { type: 'text' }), InputLabelProps: data ? { shrink: true } : undefined, onFocus: onFocus, onBlur: onBlur, variant: 'standard' }))); } }),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid && !showDescription }, firstFormHelperText),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid }, secondFormHelperText))));
+};
+var materialDateControlTester = core.rankWith(4, core.isDateControl);
+var MaterialDateControl$1 = react.withJsonFormsControlProps(MaterialDateControl);
+
+var MaterialDateTimeControl = function (props) {
+    var _a, _b;
+    var _c = useFocus(), focused = _c[0], onFocus = _c[1], onBlur = _c[2];
+    var id = props.id, description = props.description, errors = props.errors, label = props.label, uischema = props.uischema, visible = props.visible, enabled = props.enabled, required = props.required, path = props.path, handleChange = props.handleChange, data = props.data, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var isValid = errors.length === 0;
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    var format = (_a = appliedUiSchemaOptions.dateTimeFormat) !== null && _a !== void 0 ? _a : 'YYYY-MM-DD HH:mm';
+    var saveFormat = (_b = appliedUiSchemaOptions.dateTimeSaveFormat) !== null && _b !== void 0 ? _b : undefined;
+    var firstFormHelperText = showDescription
+        ? description
+        : !isValid
+            ? errors
+            : null;
+    var secondFormHelperText = showDescription && !isValid ? errors : null;
+    var onChange = React.useMemo(function () { return createOnChangeHandler(path, handleChange, saveFormat); }, [path, handleChange, saveFormat]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(lab.LocalizationProvider, { dateAdapter: AdapterDayjs__default["default"] },
+            React__default["default"].createElement(lab.DateTimePicker, { label: label, value: getData(data, saveFormat), clearable: true, onChange: onChange, inputFormat: format, disableMaskedInput: true, ampm: !!appliedUiSchemaOptions.ampm, views: appliedUiSchemaOptions.views, disabled: !enabled, cancelText: appliedUiSchemaOptions.cancelLabel, clearText: appliedUiSchemaOptions.clearLabel, okText: appliedUiSchemaOptions.okLabel, renderInput: function (params) { return (React__default["default"].createElement(material.TextField, __assign({}, params, { id: id + '-input', required: required && !appliedUiSchemaOptions.hideRequiredAsterisk, autoFocus: appliedUiSchemaOptions.focus, error: !isValid, fullWidth: !appliedUiSchemaOptions.trim, inputProps: __assign(__assign({}, params.inputProps), { type: 'text' }), InputLabelProps: data ? { shrink: true } : undefined, onFocus: onFocus, onBlur: onBlur, variant: 'standard' }))); } }),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid && !showDescription }, firstFormHelperText),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid }, secondFormHelperText))));
+};
+var materialDateTimeControlTester = core.rankWith(2, core.isDateTimeControl);
+var MaterialDateTimeControl$1 = react.withJsonFormsControlProps(MaterialDateTimeControl);
+
+var MaterialTimeControl = function (props) {
+    var _a, _b;
+    var _c = useFocus(), focused = _c[0], onFocus = _c[1], onBlur = _c[2];
+    var id = props.id, description = props.description, errors = props.errors, label = props.label, uischema = props.uischema, visible = props.visible, enabled = props.enabled, required = props.required, path = props.path, handleChange = props.handleChange, data = props.data, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var isValid = errors.length === 0;
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    var format = (_a = appliedUiSchemaOptions.timeFormat) !== null && _a !== void 0 ? _a : 'HH:mm';
+    var saveFormat = (_b = appliedUiSchemaOptions.timeSaveFormat) !== null && _b !== void 0 ? _b : 'HH:mm:ss';
+    var firstFormHelperText = showDescription
+        ? description
+        : !isValid
+            ? errors
+            : null;
+    var secondFormHelperText = showDescription && !isValid ? errors : null;
+    var onChange = React.useMemo(function () { return createOnChangeHandler(path, handleChange, saveFormat); }, [path, handleChange, saveFormat]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(lab.LocalizationProvider, { dateAdapter: AdapterDayjs__default["default"] },
+            React__default["default"].createElement(lab.TimePicker, { label: label, value: getData(data, saveFormat), clearable: true, onChange: onChange, inputFormat: format, disableMaskedInput: true, ampm: !!appliedUiSchemaOptions.ampm, views: appliedUiSchemaOptions.views, disabled: !enabled, cancelText: appliedUiSchemaOptions.cancelLabel, clearText: appliedUiSchemaOptions.clearLabel, okText: appliedUiSchemaOptions.okLabel, renderInput: function (params) { return (React__default["default"].createElement(material.TextField, __assign({}, params, { id: id + '-input', required: required && !appliedUiSchemaOptions.hideRequiredAsterisk, autoFocus: appliedUiSchemaOptions.focus, error: !isValid, fullWidth: !appliedUiSchemaOptions.trim, inputProps: __assign(__assign({}, params.inputProps), { type: 'text' }), InputLabelProps: data ? { shrink: true } : undefined, onFocus: onFocus, onBlur: onBlur, variant: 'standard' }))); } }),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid && !showDescription }, firstFormHelperText),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid }, secondFormHelperText))));
+};
+var materialTimeControlTester = core.rankWith(4, core.isTimeControl);
+var MaterialTimeControl$1 = react.withJsonFormsControlProps(MaterialTimeControl);
+
+var MaterialSliderControl = function (props) {
+    var _a = useFocus(), focused = _a[0], onFocus = _a[1], onBlur = _a[2];
+    var id = props.id, data = props.data, description = props.description, enabled = props.enabled, errors = props.errors, label = props.label, schema = props.schema, handleChange = props.handleChange, visible = props.visible, path = props.path, required = props.required, config = props.config;
+    var isValid = errors.length === 0;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, props.uischema.options);
+    var labelStyle = {
+        whiteSpace: 'nowrap',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis',
+        width: '100%'
+    };
+    var rangeContainerStyle = {
+        display: 'flex'
+    };
+    var rangeItemStyle = {
+        flexGrow: '1'
+    };
+    var sliderStyle = {
+        marginTop: '7px'
+    };
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    var onChange = React.useCallback(function (_ev, value) { return handleChange(path, Number(value)); }, [path, handleChange]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.FormControl, { fullWidth: !appliedUiSchemaOptions.trim, onFocus: onFocus, onBlur: onBlur, id: id },
+            React__default["default"].createElement(material.FormLabel, { htmlFor: id, error: !isValid, component: 'legend', required: core.showAsRequired(required, appliedUiSchemaOptions.hideRequiredAsterisk) },
+                React__default["default"].createElement(material.Typography, { id: id + '-typo', style: labelStyle, variant: 'caption' }, label)),
+            React__default["default"].createElement("div", { style: rangeContainerStyle },
+                React__default["default"].createElement(material.Typography, { style: rangeItemStyle, variant: 'caption', align: 'left' }, schema.minimum),
+                React__default["default"].createElement(material.Typography, { style: rangeItemStyle, variant: 'caption', align: 'right' }, schema.maximum)),
+            React__default["default"].createElement(material.Slider, { style: sliderStyle, min: schema.minimum, max: schema.maximum, value: Number(data || schema.default), onChange: onChange, id: id + '-input', disabled: !enabled, step: schema.multipleOf || 1 }),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid }, !isValid ? errors : showDescription ? description : null))));
+};
+var materialSliderControlTester = core.rankWith(4, core.isRangeControl);
+var MaterialSliderControl$1 = react.withJsonFormsControlProps(MaterialSliderControl);
+
+var MaterialRadioGroup = function (props) {
+    var _a = useFocus(), focused = _a[0], onFocus = _a[1], onBlur = _a[2];
+    var config = props.config, id = props.id, label = props.label, required = props.required, description = props.description, errors = props.errors, data = props.data, visible = props.visible, options = props.options, handleChange = props.handleChange, path = props.path, enabled = props.enabled;
+    var isValid = errors.length === 0;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, props.uischema.options);
+    var showDescription = !core.isDescriptionHidden(visible, description, focused, appliedUiSchemaOptions.showUnfocusedDescription);
+    var onChange = function (_ev, value) { return handleChange(path, value); };
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.FormControl, { component: 'fieldset', fullWidth: !appliedUiSchemaOptions.trim, onFocus: onFocus, onBlur: onBlur },
+            React__default["default"].createElement(material.FormLabel, { htmlFor: id, error: !isValid, component: 'legend', required: core.showAsRequired(required, appliedUiSchemaOptions.hideRequiredAsterisk) }, label),
+            React__default["default"].createElement(material.RadioGroup, { value: props.data, onChange: onChange, row: true }, options.map(function (option) { return (React__default["default"].createElement(material.FormControlLabel, { value: option.value, key: option.label, control: React__default["default"].createElement(material.Radio, { checked: data === option.value }), label: option.label, disabled: !enabled })); })),
+            React__default["default"].createElement(material.FormHelperText, { error: !isValid }, !isValid ? errors : showDescription ? description : null))));
+};
+
+var MaterialRadioGroupControl = function (props) {
+    return React__default["default"].createElement(MaterialRadioGroup, __assign({}, props));
+};
+var materialRadioGroupControlTester = core.rankWith(20, core.and(core.isEnumControl, core.optionIs('format', 'radio')));
+var MaterialRadioGroupControl$1 = react.withJsonFormsEnumProps(MaterialRadioGroupControl);
+
+var MaterialIntegerControl = function (props) { return (React__default["default"].createElement(MaterialInputControl, __assign({}, props, { input: MuiInputInteger }))); };
+var materialIntegerControlTester = core.rankWith(2, core.isIntegerControl);
+var MaterialIntegerControl$1 = react.withJsonFormsControlProps(MaterialIntegerControl);
+
+var MaterialNumberControl = function (props) { return (React__default["default"].createElement(MaterialInputControl, __assign({}, props, { input: MuiInputNumber }))); };
+var materialNumberControlTester = core.rankWith(2, core.isNumberControl);
+var MaterialNumberControl$1 = react.withJsonFormsControlProps(MaterialNumberControl);
+
+var MaterialTextControl = function (props) { return (React__default["default"].createElement(MaterialInputControl, __assign({}, props, { input: MuiInputText }))); };
+var materialTextControlTester = core.rankWith(1, core.isStringControl);
+var MaterialTextControl$1 = react.withJsonFormsControlProps(MaterialTextControl);
+
+var findEnumSchema = function (schemas) {
+    return schemas.find(function (s) { return s.enum !== undefined && (s.type === 'string' || s.type === undefined); });
+};
+var findTextSchema = function (schemas) {
+    return schemas.find(function (s) { return s.type === 'string' && s.enum === undefined; });
+};
+var MuiAutocompleteInputText = function (props) {
+    var data = props.data, config = props.config, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, isValid = props.isValid, path = props.path, handleChange = props.handleChange, schema = props.schema;
+    var enumSchema = findEnumSchema(schema.anyOf);
+    var stringSchema = findTextSchema(schema.anyOf);
+    var maxLength = stringSchema.maxLength;
+    var appliedUiSchemaOptions = React.useMemo(function () { return merge__default["default"]({}, config, uischema.options); }, [config, uischema.options]);
+    var inputProps = React.useMemo(function () {
+        var propMemo = {};
+        if (appliedUiSchemaOptions.restrict) {
+            propMemo = { maxLength: maxLength };
+        }
+        if (appliedUiSchemaOptions.trim && maxLength !== undefined) {
+            propMemo.size = maxLength;
+        }
+        propMemo.list = props.id + 'datalist';
+        return propMemo;
+    }, [appliedUiSchemaOptions, props.id]);
+    var _a = useDebouncedChange(handleChange, '', data, path), inputText = _a[0], onChange = _a[1];
+    var dataList = (React__default["default"].createElement("datalist", { id: props.id + 'datalist' }, enumSchema.enum.map(function (optionValue) { return (React__default["default"].createElement("option", { value: optionValue, key: optionValue })); })));
+    return (React__default["default"].createElement(material.Input, { type: 'text', value: inputText, onChange: onChange, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, fullWidth: !appliedUiSchemaOptions.trim || maxLength === undefined, inputProps: inputProps, error: !isValid, endAdornment: dataList }));
+};
+var MaterialAnyOfStringOrEnumControl =  (function (_super) {
+    __extends(MaterialAnyOfStringOrEnumControl, _super);
+    function MaterialAnyOfStringOrEnumControl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MaterialAnyOfStringOrEnumControl.prototype.render = function () {
+        return (React__default["default"].createElement(MaterialInputControl, __assign({}, this.props, { input: MuiAutocompleteInputText })));
+    };
+    return MaterialAnyOfStringOrEnumControl;
+}(react.Control));
+var hasEnumAndText = function (schemas) {
+    var enumSchema = findEnumSchema(schemas);
+    var stringSchema = findTextSchema(schemas);
+    var remainingSchemas = schemas.filter(function (s) { return s !== enumSchema || s !== stringSchema; });
+    var wrongType = remainingSchemas.find(function (s) { return s.type && s.type !== 'string'; });
+    return enumSchema && stringSchema && !wrongType;
+};
+var simpleAnyOf = core.and(core.uiTypeIs('Control'), core.schemaMatches(function (schema) { return schema.hasOwnProperty('anyOf') && hasEnumAndText(schema.anyOf); }));
+var materialAnyOfStringOrEnumControlTester = core.rankWith(5, simpleAnyOf);
+var MaterialAnyOfStringOrEnumControl$1 = react.withJsonFormsControlProps(MaterialAnyOfStringOrEnumControl);
+
+var MaterialOneOfEnumControl = function (props) {
+    var config = props.config, uischema = props.uischema;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(MaterialInputControl, __assign({}, props, { input: appliedUiSchemaOptions.autocomplete === false ? MuiSelect : MuiAutocomplete })));
+};
+var materialOneOfEnumControlTester = core.rankWith(5, core.isOneOfEnumControl);
+var MaterialOneOfEnumControl$1 = react.withJsonFormsOneOfEnumProps(MaterialOneOfEnumControl);
+
+var MaterialOneOfRadioGroupControl = function (props) {
+    return React__default["default"].createElement(MaterialRadioGroup, __assign({}, props));
+};
+var materialOneOfRadioGroupControlTester = core.rankWith(20, core.and(core.isOneOfEnumControl, core.optionIs('format', 'radio')));
+var MaterialOneOfRadioGroupControl$1 = react.withJsonFormsOneOfEnumProps(MaterialOneOfRadioGroupControl);
+
+var Unwrapped = {
+    MaterialBooleanControl: MaterialBooleanControl,
+    MaterialBooleanToggleControl: MaterialBooleanToggleControl,
+    MaterialEnumControl: MaterialEnumControl,
+    MaterialNativeControl: MaterialNativeControl,
+    MaterialDateControl: MaterialDateControl,
+    MaterialDateTimeControl: MaterialDateTimeControl,
+    MaterialTimeControl: MaterialTimeControl,
+    MaterialSliderControl: MaterialSliderControl,
+    MaterialRadioGroupControl: MaterialRadioGroupControl,
+    MaterialIntegerControl: MaterialIntegerControl,
+    MaterialNumberControl: MaterialNumberControl,
+    MaterialTextControl: MaterialTextControl,
+    MaterialAnyOfStringOrEnumControl: MaterialAnyOfStringOrEnumControl,
+    MaterialOneOfEnumControl: MaterialOneOfEnumControl,
+    MaterialOneOfRadioGroupControl: MaterialOneOfRadioGroupControl
+};
+
+var groupTester = core.rankWith(1, core.uiTypeIs('Group'));
+var style = { marginBottom: '10px' };
+var GroupComponent = React__default["default"].memo(function (_a) {
+    var visible = _a.visible, enabled = _a.enabled, uischema = _a.uischema, props = __rest(_a, ["visible", "enabled", "uischema"]);
+    var groupLayout = uischema;
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.Card, { style: style },
+            !isEmpty__default["default"](groupLayout.label) && (React__default["default"].createElement(material.CardHeader, { title: groupLayout.label })),
+            React__default["default"].createElement(material.CardContent, null,
+                React__default["default"].createElement(MaterialLayoutRenderer, __assign({}, props, { visible: visible, enabled: enabled, elements: groupLayout.elements }))))));
+});
+var MaterializedGroupLayoutRenderer = function (_a) {
+    var uischema = _a.uischema, schema = _a.schema, path = _a.path, visible = _a.visible, enabled = _a.enabled, renderers = _a.renderers, cells = _a.cells, direction = _a.direction;
+    var groupLayout = uischema;
+    return (React__default["default"].createElement(GroupComponent, { elements: groupLayout.elements, schema: schema, path: path, direction: direction, visible: visible, enabled: enabled, uischema: uischema, renderers: renderers, cells: cells }));
+};
+var MaterialGroupLayout = react.withJsonFormsLayoutProps(MaterializedGroupLayoutRenderer);
+var materialGroupTester = core.withIncreasedRank(1, groupTester);
+
+var materialHorizontalLayoutTester = core.rankWith(2, core.uiTypeIs('HorizontalLayout'));
+var MaterialHorizontalLayoutRenderer = function (_a) {
+    var uischema = _a.uischema, renderers = _a.renderers, cells = _a.cells, schema = _a.schema, path = _a.path, enabled = _a.enabled, visible = _a.visible;
+    var layout = uischema;
+    var childProps = {
+        elements: layout.elements,
+        schema: schema,
+        path: path,
+        enabled: enabled,
+        direction: 'row',
+        visible: visible
+    };
+    return React__default["default"].createElement(MaterialLayoutRenderer, __assign({}, childProps, { renderers: renderers, cells: cells }));
+};
+var MaterialHorizontalLayout = react.withJsonFormsLayoutProps(MaterialHorizontalLayoutRenderer);
+
+var materialVerticalLayoutTester = core.rankWith(1, core.uiTypeIs('VerticalLayout'));
+var MaterialVerticalLayoutRenderer = function (_a) {
+    var uischema = _a.uischema, schema = _a.schema, path = _a.path, enabled = _a.enabled, visible = _a.visible, renderers = _a.renderers, cells = _a.cells;
+    var verticalLayout = uischema;
+    var childProps = {
+        elements: verticalLayout.elements,
+        schema: schema,
+        path: path,
+        enabled: enabled,
+        direction: 'column',
+        visible: visible
+    };
+    return React__default["default"].createElement(MaterialLayoutRenderer, __assign({}, childProps, { renderers: renderers, cells: cells }));
+};
+var MaterialVerticalLayout = react.withJsonFormsLayoutProps(MaterialVerticalLayoutRenderer);
+
+var isSingleLevelCategorization = core.and(core.uiTypeIs('Categorization'), function (uischema) {
+    var categorization = uischema;
+    return (categorization.elements &&
+        categorization.elements.reduce(function (acc, e) { return acc && e.type === 'Category'; }, true));
+});
+var materialCategorizationTester = core.rankWith(1, isSingleLevelCategorization);
+var MaterialCategorizationLayoutRenderer = function (props) {
+    var data = props.data, path = props.path, renderers = props.renderers, cells = props.cells, schema = props.schema, uischema = props.uischema, visible = props.visible, enabled = props.enabled, selected = props.selected, onChange = props.onChange, ajv = props.ajv;
+    var categorization = uischema;
+    var _a = React.useState(selected !== null && selected !== void 0 ? selected : 0), activeCategory = _a[0], setActiveCategory = _a[1];
+    var categories = categorization.elements.filter(function (category) {
+        return core.isVisible(category, data, undefined, ajv);
+    });
+    var childProps = {
+        elements: categories[activeCategory].elements,
+        schema: schema,
+        path: path,
+        direction: 'column',
+        enabled: enabled,
+        visible: visible,
+        renderers: renderers,
+        cells: cells
+    };
+    var onTabChange = function (_event, value) {
+        if (onChange) {
+            onChange(value, activeCategory);
+        }
+        setActiveCategory(value);
+    };
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.AppBar, { position: 'static' },
+            React__default["default"].createElement(material.Tabs, { value: activeCategory, onChange: onTabChange, textColor: 'inherit', indicatorColor: 'secondary', variant: 'scrollable' }, categories.map(function (e, idx) { return (React__default["default"].createElement(material.Tab, { key: idx, label: e.label })); }))),
+        React__default["default"].createElement("div", { style: { marginTop: '0.5em' } },
+            React__default["default"].createElement(MaterialLayoutRenderer, __assign({}, childProps)))));
+};
+var MaterialCategorizationLayout = react.withJsonFormsLayoutProps(withAjvProps(MaterialCategorizationLayoutRenderer));
+
+var iconStyle = { float: 'right' };
+var ExpandPanelRendererComponent = function (props) {
+    var labelHtmlId = React.useState(core.createId('expand-panel'))[0];
+    React.useEffect(function () {
+        return function () {
+            core.removeId(labelHtmlId);
+        };
+    }, [labelHtmlId]);
+    var childLabel = props.childLabel, childPath = props.childPath, index = props.index, expanded = props.expanded, moveDown = props.moveDown, moveUp = props.moveUp, enableMoveDown = props.enableMoveDown, enableMoveUp = props.enableMoveUp, handleExpansion = props.handleExpansion, removeItems = props.removeItems, path = props.path, rootSchema = props.rootSchema, schema = props.schema, uischema = props.uischema, uischemas = props.uischemas, renderers = props.renderers, cells = props.cells, config = props.config;
+    var foundUISchema = React.useMemo(function () {
+        return core.findUISchema(uischemas, schema, uischema.scope, path, undefined, uischema, rootSchema);
+    }, [uischemas, schema, uischema.scope, path, uischema, rootSchema]);
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(material.Accordion, { "aria-labelledby": labelHtmlId, expanded: expanded, onChange: handleExpansion(childPath) },
+        React__default["default"].createElement(material.AccordionSummary, { expandIcon: React__default["default"].createElement(ExpandMoreIcon__default["default"], null) },
+            React__default["default"].createElement(material.Grid, { container: true, alignItems: 'center' },
+                React__default["default"].createElement(material.Grid, { item: true, xs: 7, md: 9 },
+                    React__default["default"].createElement(material.Grid, { container: true, alignItems: 'center' },
+                        React__default["default"].createElement(material.Grid, { item: true, xs: 2, md: 1 },
+                            React__default["default"].createElement(material.Avatar, { "aria-label": 'Index' }, index + 1)),
+                        React__default["default"].createElement(material.Grid, { item: true, xs: 10, md: 11 },
+                            React__default["default"].createElement("span", { id: labelHtmlId }, childLabel)))),
+                React__default["default"].createElement(material.Grid, { item: true, xs: 5, md: 3 },
+                    React__default["default"].createElement(material.Grid, { container: true, justifyContent: 'flex-end' },
+                        React__default["default"].createElement(material.Grid, { item: true },
+                            React__default["default"].createElement(material.Grid, { container: true, direction: 'row', justifyContent: 'center', alignItems: 'center' },
+                                appliedUiSchemaOptions.showSortButtons ? (React__default["default"].createElement(React.Fragment, null,
+                                    React__default["default"].createElement(material.Grid, { item: true },
+                                        React__default["default"].createElement(material.IconButton, { onClick: moveUp(path, index), style: iconStyle, disabled: !enableMoveUp, "aria-label": "Move up", size: 'large' },
+                                            React__default["default"].createElement(ArrowUpward__default["default"], null))),
+                                    React__default["default"].createElement(material.Grid, { item: true },
+                                        React__default["default"].createElement(material.IconButton, { onClick: moveDown(path, index), style: iconStyle, disabled: !enableMoveDown, "aria-label": "Move down", size: 'large' },
+                                            React__default["default"].createElement(ArrowDownward__default["default"], null))))) : (''),
+                                React__default["default"].createElement(material.Grid, { item: true },
+                                    React__default["default"].createElement(material.IconButton, { onClick: removeItems(path, [index]), style: iconStyle, "aria-label": "Delete", size: 'large' },
+                                        React__default["default"].createElement(DeleteIcon__default["default"], null))))))))),
+        React__default["default"].createElement(material.AccordionDetails, null,
+            React__default["default"].createElement(react.JsonFormsDispatch, { schema: schema, uischema: foundUISchema, path: childPath, key: childPath, renderers: renderers, cells: cells }))));
+};
+var ExpandPanelRenderer = React__default["default"].memo(ExpandPanelRendererComponent);
+var ctxDispatchToExpandPanelProps = function (dispatch) { return ({
+    removeItems: React.useCallback(function (path, toDelete) { return function (event) {
+        event.stopPropagation();
+        dispatch(core.update(path, function (array) {
+            toDelete
+                .sort()
+                .reverse()
+                .forEach(function (s) { return array.splice(s, 1); });
+            return array;
+        }));
+    }; }, [dispatch]),
+    moveUp: React.useCallback(function (path, toMove) { return function (event) {
+        event.stopPropagation();
+        dispatch(core.update(path, function (array) {
+            core.moveUp(array, toMove);
+            return array;
+        }));
+    }; }, [dispatch]),
+    moveDown: React.useCallback(function (path, toMove) { return function (event) {
+        event.stopPropagation();
+        dispatch(core.update(path, function (array) {
+            core.moveDown(array, toMove);
+            return array;
+        }));
+    }; }, [dispatch])
+}); };
+var withContextToExpandPanelProps = function (Component) { return function (_a) {
+    var ctx = _a.ctx, props = _a.props;
+    var dispatchProps = ctxDispatchToExpandPanelProps(ctx.dispatch);
+    var childLabelProp = props.childLabelProp, schema = props.schema, path = props.path, index = props.index, uischemas = props.uischemas;
+    var childPath = core.composePaths(path, "" + index);
+    var childData = core.Resolve.data(ctx.core.data, childPath);
+    var childLabel = childLabelProp
+        ? get__default["default"](childData, childLabelProp, '')
+        : get__default["default"](childData, core.getFirstPrimitiveProp(schema), '');
+    return (React__default["default"].createElement(Component, __assign({}, props, dispatchProps, { childLabel: childLabel, childPath: childPath, uischemas: uischemas })));
+}; };
+var withJsonFormsExpandPanelProps = function (Component) {
+    return react.withJsonFormsContext(withContextToExpandPanelProps(Component));
+};
+var ExpandPanelRenderer$1 = withJsonFormsExpandPanelProps(ExpandPanelRenderer);
+
+var MaterialArrayLayoutComponent = function (props) {
+    var _a = React.useState(false), expanded = _a[0], setExpanded = _a[1];
+    var innerCreateDefaultValue = React.useCallback(function () { return core.createDefaultValue(props.schema); }, [props.schema]);
+    var handleChange = React.useCallback(function (panel) { return function (_event, expandedPanel) {
+        setExpanded(expandedPanel ? panel : false);
+    }; }, []);
+    var isExpanded = function (index) {
+        return expanded === core.composePaths(props.path, "" + index);
+    };
+    var data = props.data, path = props.path, schema = props.schema, uischema = props.uischema, errors = props.errors, addItem = props.addItem, renderers = props.renderers, cells = props.cells, label = props.label, required = props.required, rootSchema = props.rootSchema, config = props.config, uischemas = props.uischemas;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, props.uischema.options);
+    return (React__default["default"].createElement("div", null,
+        React__default["default"].createElement(ArrayLayoutToolbar, { label: core.computeLabel(label, required, appliedUiSchemaOptions.hideRequiredAsterisk), errors: errors, path: path, addItem: addItem, createDefault: innerCreateDefaultValue }),
+        React__default["default"].createElement("div", null, data > 0 ? (map__default["default"](range__default["default"](data), function (index) {
+            return (React__default["default"].createElement(ExpandPanelRenderer$1, { index: index, expanded: isExpanded(index), schema: schema, path: path, handleExpansion: handleChange, uischema: uischema, renderers: renderers, cells: cells, key: index, rootSchema: rootSchema, enableMoveUp: index != 0, enableMoveDown: index < data - 1, config: config, childLabelProp: appliedUiSchemaOptions.elementLabelProp, uischemas: uischemas }));
+        })) : (React__default["default"].createElement("p", null, "No data")))));
+};
+var MaterialArrayLayout$1 = React__default["default"].memo(MaterialArrayLayoutComponent);
+
+var MaterialArrayLayoutRenderer = function (_a) {
+    var visible = _a.visible, enabled = _a.enabled, id = _a.id, uischema = _a.uischema, schema = _a.schema, label = _a.label, rootSchema = _a.rootSchema, renderers = _a.renderers, cells = _a.cells, data = _a.data, path = _a.path, errors = _a.errors, uischemas = _a.uischemas, addItem = _a.addItem;
+    var addItemCb = React.useCallback(function (p, value) { return addItem(p, value); }, [
+        addItem
+    ]);
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(MaterialArrayLayout$1, { label: label, uischema: uischema, schema: schema, id: id, rootSchema: rootSchema, errors: errors, enabled: enabled, visible: visible, data: data, path: path, addItem: addItemCb, renderers: renderers, cells: cells, uischemas: uischemas })));
+};
+var materialArrayLayoutTester = core.rankWith(4, core.isObjectArrayWithNesting);
+var MaterialArrayLayout = react.withJsonFormsArrayLayoutProps(MaterialArrayLayoutRenderer);
+
+var MaterialBooleanCell = function (props) {
+    return React__default["default"].createElement(MuiCheckbox, __assign({}, props));
+};
+var materialBooleanCellTester = core.rankWith(2, core.isBooleanControl);
+var MaterialBooleanCell$1 = react.withJsonFormsCellProps(MaterialBooleanCell);
+
+var MaterialBooleanToggleCell = function (props) {
+    return React__default["default"].createElement(MuiToggle, __assign({}, props));
+};
+var materialBooleanToggleCellTester = core.rankWith(3, core.and(core.isBooleanControl, core.optionIs('toggle', true)));
+var MaterialBooleanToggleCell$1 = react.withJsonFormsCellProps(MaterialBooleanToggleCell);
+
+var MaterialDateCell = function (props) {
+    var data = props.data, className = props.className, id = props.id, enabled = props.enabled, uischema = props.uischema, path = props.path, handleChange = props.handleChange, config = props.config;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    return (React__default["default"].createElement(Input__default["default"], { type: 'date', value: data || '', onChange: function (ev) { return handleChange(path, ev.target.value); }, className: className, id: id, disabled: !enabled, autoFocus: appliedUiSchemaOptions.focus, fullWidth: true }));
+};
+var materialDateCellTester = core.rankWith(2, core.isDateControl);
+var MaterialDateCell$1 = react.withJsonFormsCellProps(MaterialDateCell);
+
+var MaterialEnumCell = function (props) { return (React__default["default"].createElement(MuiSelect, __assign({}, props))); };
+var materialEnumCellTester = core.rankWith(2, core.isEnumControl);
+var MaterialEnumCell$1 = react.withJsonFormsEnumCellProps(MaterialEnumCell);
+
+var MaterialIntegerCell = function (props) { return (React__default["default"].createElement(MuiInputInteger, __assign({}, props))); };
+var materialIntegerCellTester = core.rankWith(2, core.isIntegerControl);
+var MaterialIntegerCell$1 = react.withJsonFormsCellProps(MaterialIntegerCell);
+
+var MaterialNumberCell = function (props) { return (React__default["default"].createElement(MuiInputNumber, __assign({}, props))); };
+var materialNumberCellTester = core.rankWith(2, core.isNumberControl);
+var MaterialNumberCell$1 = react.withJsonFormsCellProps(MaterialNumberCell);
+
+var MaterialNumberFormatCell = function (props) { return React__default["default"].createElement(MuiInputNumberFormat, __assign({}, props)); };
+var materialNumberFormatCellTester = core.rankWith(4, core.isNumberFormatControl);
+var MaterialNumberFormatCell$1 = react.withJsonFormsCellProps(MaterialNumberFormatCell);
+
+var MaterialOneOfEnumCell = function (props) { return (React__default["default"].createElement(MuiSelect, __assign({}, props))); };
+var materialOneOfEnumCellTester = core.rankWith(2, core.isOneOfEnumControl);
+var MaterialOneOfEnumCell$1 = react.withJsonFormsOneOfEnumCellProps(MaterialOneOfEnumCell);
+
+var MaterialTextCell = function (props) { return (React__default["default"].createElement(MuiInputText, __assign({}, props))); };
+var materialTextCellTester = core.rankWith(1, core.isStringControl);
+var MaterialTextCell$1 = react.withJsonFormsCellProps(MaterialTextCell);
+
+var MaterialTimeCell = function (props) { return (React__default["default"].createElement(MuiInputTime, __assign({}, props))); };
+var materialTimeCellTester = core.rankWith(2, core.isTimeControl);
+var MaterialTimeCell$1 = react.withJsonFormsCellProps(MaterialTimeCell);
+
+var CustomizableCells = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MaterialBooleanCell: MaterialBooleanCell,
+    MaterialDateCell: MaterialDateCell,
+    MaterialEnumCell: MaterialEnumCell,
+    MaterialIntegerCell: MaterialIntegerCell,
+    MaterialNumberCell: MaterialNumberCell,
+    MaterialNumberFormatCell: MaterialNumberFormatCell,
+    MaterialOneOfEnumCell: MaterialOneOfEnumCell,
+    MaterialTextCell: MaterialTextCell,
+    MaterialTimeCell: MaterialTimeCell
+});
+
+var materialCategorizationStepperTester = core.rankWith(2, core.and(core.uiTypeIs('Categorization'), core.categorizationHasCategory, core.optionIs('variant', 'stepper')));
+var MaterialCategorizationStepperLayoutRenderer = function (props) {
+    var _a = React.useState(0), activeCategory = _a[0], setActiveCategory = _a[1];
+    var handleStep = function (step) {
+        setActiveCategory(step);
+    };
+    var data = props.data, path = props.path, renderers = props.renderers, schema = props.schema, uischema = props.uischema, visible = props.visible, cells = props.cells, config = props.config, ajv = props.ajv;
+    var categorization = uischema;
+    var appliedUiSchemaOptions = merge__default["default"]({}, config, uischema.options);
+    var buttonWrapperStyle = {
+        textAlign: 'right',
+        width: '100%',
+        margin: '1em auto'
+    };
+    var buttonNextStyle = {
+        float: 'right'
+    };
+    var buttonStyle = {
+        marginRight: '1em'
+    };
+    var categories = categorization.elements.filter(function (category) {
+        return core.isVisible(category, data, undefined, ajv);
+    });
+    var childProps = {
+        elements: categories[activeCategory].elements,
+        schema: schema,
+        path: path,
+        direction: 'column',
+        visible: visible,
+        renderers: renderers,
+        cells: cells
+    };
+    return (React__default["default"].createElement(material.Hidden, { xsUp: !visible },
+        React__default["default"].createElement(material.Stepper, { activeStep: activeCategory, nonLinear: true }, categories.map(function (e, idx) { return (React__default["default"].createElement(material.Step, { key: e.label },
+            React__default["default"].createElement(material.StepButton, { onClick: function () { return handleStep(idx); } }, e.label))); })),
+        React__default["default"].createElement("div", null,
+            React__default["default"].createElement(MaterialLayoutRenderer, __assign({}, childProps))),
+        !!appliedUiSchemaOptions.showNavButtons ? (React__default["default"].createElement("div", { style: buttonWrapperStyle },
+            React__default["default"].createElement(material.Button, { style: buttonNextStyle, variant: "contained", color: "primary", disabled: activeCategory >= categories.length - 1, onClick: function () { return handleStep(activeCategory + 1); } }, "Next"),
+            React__default["default"].createElement(material.Button, { style: buttonStyle, color: "secondary", variant: "contained", disabled: activeCategory <= 0, onClick: function () { return handleStep(activeCategory - 1); } }, "Previous"))) : (React__default["default"].createElement(React__default["default"].Fragment, null))));
+};
+var MaterialCategorizationStepperLayout = react.withJsonFormsLayoutProps(withAjvProps(MaterialCategorizationStepperLayoutRenderer));
+
+var materialRenderers = [
+    {
+        tester: materialArrayControlTester,
+        renderer: MaterialArrayControlRenderer$1
+    },
+    { tester: materialBooleanControlTester, renderer: MaterialBooleanControl$1 },
+    { tester: materialBooleanToggleControlTester, renderer: MaterialBooleanToggleControl$1 },
+    { tester: materialNativeControlTester, renderer: MaterialNativeControl$1 },
+    { tester: materialEnumControlTester, renderer: MaterialEnumControl$1 },
+    { tester: materialIntegerControlTester, renderer: MaterialIntegerControl$1 },
+    { tester: materialNumberControlTester, renderer: MaterialNumberControl$1 },
+    { tester: materialTextControlTester, renderer: MaterialTextControl$1 },
+    { tester: materialDateTimeControlTester, renderer: MaterialDateTimeControl$1 },
+    { tester: materialDateControlTester, renderer: MaterialDateControl$1 },
+    { tester: materialTimeControlTester, renderer: MaterialTimeControl$1 },
+    { tester: materialSliderControlTester, renderer: MaterialSliderControl$1 },
+    { tester: materialObjectControlTester, renderer: MaterialObjectRenderer$1 },
+    { tester: materialAllOfControlTester, renderer: MaterialAllOfRenderer$1 },
+    { tester: materialAnyOfControlTester, renderer: MaterialAnyOfRenderer$1 },
+    { tester: materialOneOfControlTester, renderer: MaterialOneOfRenderer$1 },
+    {
+        tester: materialRadioGroupControlTester,
+        renderer: MaterialRadioGroupControl$1
+    },
+    {
+        tester: materialOneOfRadioGroupControlTester,
+        renderer: MaterialOneOfRadioGroupControl$1
+    },
+    { tester: materialOneOfEnumControlTester, renderer: MaterialOneOfEnumControl$1 },
+    { tester: materialGroupTester, renderer: MaterialGroupLayout },
+    {
+        tester: materialHorizontalLayoutTester,
+        renderer: MaterialHorizontalLayout
+    },
+    { tester: materialVerticalLayoutTester, renderer: MaterialVerticalLayout },
+    {
+        tester: materialCategorizationTester,
+        renderer: MaterialCategorizationLayout
+    },
+    {
+        tester: materialCategorizationStepperTester,
+        renderer: MaterialCategorizationStepperLayout
+    },
+    { tester: materialArrayLayoutTester, renderer: MaterialArrayLayout },
+    { tester: materialLabelRendererTester, renderer: MaterialLabelRenderer$1 },
+    {
+        tester: materialListWithDetailTester,
+        renderer: MaterialListWithDetailRenderer$1
+    },
+    {
+        tester: materialAnyOfStringOrEnumControlTester,
+        renderer: MaterialAnyOfStringOrEnumControl$1
+    },
+    {
+        tester: materialEnumArrayRendererTester,
+        renderer: MaterialEnumArrayRenderer$1
+    }
+];
+var materialCells = [
+    { tester: materialBooleanCellTester, cell: MaterialBooleanCell$1 },
+    { tester: materialBooleanToggleCellTester, cell: MaterialBooleanToggleCell$1 },
+    { tester: materialDateCellTester, cell: MaterialDateCell$1 },
+    { tester: materialEnumCellTester, cell: MaterialEnumCell$1 },
+    { tester: materialIntegerCellTester, cell: MaterialIntegerCell$1 },
+    { tester: materialNumberCellTester, cell: MaterialNumberCell$1 },
+    { tester: materialNumberFormatCellTester, cell: MaterialNumberFormatCell$1 },
+    { tester: materialOneOfEnumCellTester, cell: MaterialOneOfEnumCell$1 },
+    { tester: materialTextCellTester, cell: MaterialTextCell$1 },
+    { tester: materialTimeCellTester, cell: MaterialTimeCell$1 }
+];
+
+exports.Customizable = CustomizableCells;
+exports.MaterialAllOfRenderer = MaterialAllOfRenderer$1;
+exports.MaterialAnyOfRenderer = MaterialAnyOfRenderer$1;
+exports.MaterialAnyOfStringOrEnumControl = MaterialAnyOfStringOrEnumControl$1;
+exports.MaterialArrayControlRenderer = MaterialArrayControlRenderer$1;
+exports.MaterialArrayLayout = MaterialArrayLayout;
+exports.MaterialBooleanCell = MaterialBooleanCell$1;
+exports.MaterialBooleanControl = MaterialBooleanControl$1;
+exports.MaterialBooleanToggleCell = MaterialBooleanToggleCell$1;
+exports.MaterialBooleanToggleControl = MaterialBooleanToggleControl$1;
+exports.MaterialCategorizationLayout = MaterialCategorizationLayout;
+exports.MaterialDateCell = MaterialDateCell$1;
+exports.MaterialDateControl = MaterialDateControl$1;
+exports.MaterialDateTimeControl = MaterialDateTimeControl$1;
+exports.MaterialEnumArrayRenderer = MaterialEnumArrayRenderer$1;
+exports.MaterialEnumCell = MaterialEnumCell$1;
+exports.MaterialEnumControl = MaterialEnumControl$1;
+exports.MaterialGroupLayout = MaterialGroupLayout;
+exports.MaterialHorizontalLayout = MaterialHorizontalLayout;
+exports.MaterialInputControl = MaterialInputControl;
+exports.MaterialIntegerCell = MaterialIntegerCell$1;
+exports.MaterialIntegerControl = MaterialIntegerControl$1;
+exports.MaterialLayoutRenderer = MaterialLayoutRenderer;
+exports.MaterialNativeControl = MaterialNativeControl$1;
+exports.MaterialNumberCell = MaterialNumberCell$1;
+exports.MaterialNumberControl = MaterialNumberControl$1;
+exports.MaterialNumberFormatCell = MaterialNumberFormatCell$1;
+exports.MaterialObjectRenderer = MaterialObjectRenderer$1;
+exports.MaterialOneOfEnumCell = MaterialOneOfEnumCell$1;
+exports.MaterialOneOfEnumControl = MaterialOneOfEnumControl$1;
+exports.MaterialOneOfRadioGroupControl = MaterialOneOfRadioGroupControl$1;
+exports.MaterialOneOfRenderer = MaterialOneOfRenderer$1;
+exports.MaterialRadioGroupControl = MaterialRadioGroupControl$1;
+exports.MaterialSliderControl = MaterialSliderControl$1;
+exports.MaterialTextCell = MaterialTextCell$1;
+exports.MaterialTextControl = MaterialTextControl$1;
+exports.MaterialTimeCell = MaterialTimeCell$1;
+exports.MaterialTimeControl = MaterialTimeControl$1;
+exports.MaterialVerticalLayout = MaterialVerticalLayout;
+exports.MuiCheckbox = MuiCheckbox;
+exports.MuiInputInteger = MuiInputInteger;
+exports.MuiInputNumber = MuiInputNumber;
+exports.MuiInputNumberFormat = MuiInputNumberFormat;
+exports.MuiInputText = MuiInputText;
+exports.MuiInputTime = MuiInputTime;
+exports.MuiSelect = MuiSelect;
+exports.Unwrapped = Unwrapped;
+exports.createOnChangeHandler = createOnChangeHandler;
+exports.getData = getData;
+exports.materialAllOfControlTester = materialAllOfControlTester;
+exports.materialAnyOfControlTester = materialAnyOfControlTester;
+exports.materialAnyOfStringOrEnumControlTester = materialAnyOfStringOrEnumControlTester;
+exports.materialArrayControlTester = materialArrayControlTester;
+exports.materialArrayLayoutTester = materialArrayLayoutTester;
+exports.materialBooleanCellTester = materialBooleanCellTester;
+exports.materialBooleanControlTester = materialBooleanControlTester;
+exports.materialBooleanToggleCellTester = materialBooleanToggleCellTester;
+exports.materialBooleanToggleControlTester = materialBooleanToggleControlTester;
+exports.materialCategorizationTester = materialCategorizationTester;
+exports.materialCells = materialCells;
+exports.materialDateCellTester = materialDateCellTester;
+exports.materialDateControlTester = materialDateControlTester;
+exports.materialDateTimeControlTester = materialDateTimeControlTester;
+exports.materialEnumArrayRendererTester = materialEnumArrayRendererTester;
+exports.materialEnumCellTester = materialEnumCellTester;
+exports.materialEnumControlTester = materialEnumControlTester;
+exports.materialGroupTester = materialGroupTester;
+exports.materialHorizontalLayoutTester = materialHorizontalLayoutTester;
+exports.materialIntegerCellTester = materialIntegerCellTester;
+exports.materialIntegerControlTester = materialIntegerControlTester;
+exports.materialNativeControlTester = materialNativeControlTester;
+exports.materialNumberCellTester = materialNumberCellTester;
+exports.materialNumberControlTester = materialNumberControlTester;
+exports.materialNumberFormatCellTester = materialNumberFormatCellTester;
+exports.materialObjectControlTester = materialObjectControlTester;
+exports.materialOneOfControlTester = materialOneOfControlTester;
+exports.materialOneOfEnumCellTester = materialOneOfEnumCellTester;
+exports.materialOneOfEnumControlTester = materialOneOfEnumControlTester;
+exports.materialOneOfRadioGroupControlTester = materialOneOfRadioGroupControlTester;
+exports.materialRadioGroupControlTester = materialRadioGroupControlTester;
+exports.materialRenderers = materialRenderers;
+exports.materialSliderControlTester = materialSliderControlTester;
+exports.materialTextCellTester = materialTextCellTester;
+exports.materialTextControlTester = materialTextControlTester;
+exports.materialTimeCellTester = materialTimeCellTester;
+exports.materialTimeControlTester = materialTimeControlTester;
+exports.materialVerticalLayoutTester = materialVerticalLayoutTester;
+exports.renderLayoutElements = renderLayoutElements;
+exports.useDebouncedChange = useDebouncedChange;
+exports.useFocus = useFocus;
+exports.withAjvProps = withAjvProps;
+//# sourceMappingURL=jsonforms-react-material.cjs.js.map