@scenid/react-formulator 0.4.4 → 0.5.1

package/dist/index.esm.js

@@ -27,8 +27,7 @@ import { createSvgIcon, unstable_useId, useControlled, useEventCallback, setRef,
 import _MenuItem from '@material-ui/core/esm/MenuItem';
 import _Switch from '@material-ui/core/esm/Switch';
 import _Checkbox from '@material-ui/core/esm/Checkbox';
-import _Select from '@material-ui/core/esm/Select';
-import _InputLabel from '@material-ui/core/esm/InputLabel';
+import _ClickAwayListener from '@material-ui/core/esm/ClickAwayListener';
 import _Clear from '@material-ui/icons/esm/Clear';
 import _Save from '@material-ui/icons/esm/Save';
 import _Button from '@material-ui/core/esm/Button';
@@ -19646,7 +19645,7 @@ function require_Error () {
 
 	  var _super2 = _createSuper(ValidationError);
 
-	  function ValidationError(message, path, validator, options) {
+	  function ValidationError(message, path, validator, options, index) {
 	    var _this2;
 
 	    (0, _classCallCheck2["default"])(this, ValidationError);
@@ -19654,6 +19653,7 @@ function require_Error () {
 	    _this2.path = path;
 	    _this2.validator = validator;
 	    _this2.options = options;
+	    _this2.index = index;
 	    return _this2;
 	  }
 
@@ -20211,90 +20211,149 @@ function requireCompiler () {
 		      return compileTypeDefinition;
 		    }()
 		  }, {
-		    key: "compileField",
+		    key: "compileOptions",
 		    value: function () {
-		      var _compileField = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(uncompiledField, name) {
-		        var field, prohibited, required, optional, type, defaultDef;
+		      var _compileOptions = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(options) {
+		        var res;
 		        return _regenerator["default"].wrap(function _callee9$(_context9) {
 		          while (1) {
 		            switch (_context9.prev = _context9.next) {
+		              case 0:
+		                if (!((0, _helpers.isObject)(options) && options.$ref !== undefined)) {
+		                  _context9.next = 7;
+		                  break;
+		                }
+
+		                _context9.next = 3;
+		                return this.resolveRef(options.$ref);
+
+		              case 3:
+		                res = _context9.sent;
+
+		                if (!(0, _helpers.isObject)(res)) {
+		                  _context9.next = 6;
+		                  break;
+		                }
+
+		                return _context9.abrupt("return", Object.keys(res));
+
+		              case 6:
+		                return _context9.abrupt("return", res);
+
+		              case 7:
+		                return _context9.abrupt("return", options);
+
+		              case 8:
+		              case "end":
+		                return _context9.stop();
+		            }
+		          }
+		        }, _callee9, this);
+		      }));
+
+		      function compileOptions(_x12) {
+		        return _compileOptions.apply(this, arguments);
+		      }
+
+		      return compileOptions;
+		    }()
+		  }, {
+		    key: "compileField",
+		    value: function () {
+		      var _compileField = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10(uncompiledField, name) {
+		        var field, prohibited, required, optional, type, defaultDef, options;
+		        return _regenerator["default"].wrap(function _callee10$(_context10) {
+		          while (1) {
+		            switch (_context10.prev = _context10.next) {
 		              case 0:
 		                field = (0, _helpers.deepCopy)(uncompiledField);
-		                prohibited = field.prohibited, required = field.required, optional = field.optional, type = field.type, defaultDef = field["default"];
+		                prohibited = field.prohibited, required = field.required, optional = field.optional, type = field.type, defaultDef = field["default"], options = field.options;
 
 		                if (!(type === undefined)) {
-		                  _context9.next = 4;
+		                  _context10.next = 4;
 		                  break;
 		                }
 
 		                throw new _Error.SchemaError("Field \"".concat(name, "\" is missing a type definition"));
 
 		              case 4:
-		                _context9.next = 6;
+		                _context10.next = 6;
 		                return this.compileTypeDefinition(type, name);
 
 		              case 6:
-		                field.type = _context9.sent;
+		                field.type = _context10.sent;
 
 		                if (!(defaultDef !== undefined)) {
-		                  _context9.next = 11;
+		                  _context10.next = 11;
 		                  break;
 		                }
 
-		                _context9.next = 10;
+		                _context10.next = 10;
 		                return this.compileTypeDefinition(defaultDef, name);
 
 		              case 10:
-		                field["default"] = _context9.sent;
+		                field["default"] = _context10.sent;
 
 		              case 11:
-		                if (!(prohibited !== undefined)) {
-		                  _context9.next = 15;
+		                if (!options) {
+		                  _context10.next = 15;
 		                  break;
 		                }
 
-		                _context9.next = 14;
-		                return this.compileRules(prohibited, name);
+		                _context10.next = 14;
+		                return this.compileOptions(options);
 
 		              case 14:
-		                field.prohibited = _context9.sent;
+		                field.options = _context10.sent;
 
 		              case 15:
-		                if (!(required !== undefined)) {
-		                  _context9.next = 19;
+		                if (!(prohibited !== undefined)) {
+		                  _context10.next = 19;
 		                  break;
 		                }
 
-		                _context9.next = 18;
-		                return this.compileRules(required, name);
+		                _context10.next = 18;
+		                return this.compileRules(prohibited, name);
 
 		              case 18:
-		                field.required = _context9.sent;
+		                field.prohibited = _context10.sent;
 
 		              case 19:
-		                if (!(optional !== undefined)) {
-		                  _context9.next = 23;
+		                if (!(required !== undefined)) {
+		                  _context10.next = 23;
 		                  break;
 		                }
 
-		                _context9.next = 22;
-		                return this.compileRules(optional, name);
+		                _context10.next = 22;
+		                return this.compileRules(required, name);
 
 		              case 22:
-		                field.optional = _context9.sent;
+		                field.required = _context10.sent;
 
 		              case 23:
-		                return _context9.abrupt("return", field);
+		                if (!(optional !== undefined)) {
+		                  _context10.next = 27;
+		                  break;
+		                }
+
+		                _context10.next = 26;
+		                return this.compileRules(optional, name);
+
+		              case 26:
+		                field.optional = _context10.sent;
+
+		              case 27:
+		                return _context10.abrupt("return", field);
 
-		              case 24:
+		              case 28:
 		              case "end":
-		                return _context9.stop();
+		                return _context10.stop();
 		            }
 		          }
-		        }, _callee9, this);
+		        }, _callee10, this);
 		      }));
 
-		      function compileField(_x12, _x13) {
+		      function compileField(_x13, _x14) {
 		        return _compileField.apply(this, arguments);
 		      }
 
@@ -20303,135 +20362,135 @@ function requireCompiler () {
 		  }, {
 		    key: "compileCatalog",
 		    value: function () {
-		      var _compileCatalog = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12(uncompiledCatalog) {
+		      var _compileCatalog = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13(uncompiledCatalog) {
 		        var _this2 = this;
 
 		        var catalog, result;
-		        return _regenerator["default"].wrap(function _callee12$(_context12) {
+		        return _regenerator["default"].wrap(function _callee13$(_context13) {
 		          while (1) {
-		            switch (_context12.prev = _context12.next) {
+		            switch (_context13.prev = _context13.next) {
 		              case 0:
 		                catalog = (0, _helpers.deepCopy)(uncompiledCatalog);
 
 		                if ((0, _helpers.isObject)(catalog)) {
-		                  _context12.next = 3;
+		                  _context13.next = 3;
 		                  break;
 		                }
 
 		                throw new _Error.SchemaError("Invalid type of \"".concat((0, _typeof2["default"])(catalog), "\" for catalog."));
 
 		              case 3:
-		                _context12.next = 5;
+		                _context13.next = 5;
 		                return Promise.all(Object.entries(catalog).map( /*#__PURE__*/function () {
-		                  var _ref6 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11(e) {
-		                    return _regenerator["default"].wrap(function _callee11$(_context11) {
+		                  var _ref6 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12(e) {
+		                    return _regenerator["default"].wrap(function _callee12$(_context12) {
 		                      while (1) {
-		                        switch (_context11.prev = _context11.next) {
+		                        switch (_context12.prev = _context12.next) {
 		                          case 0:
 		                            if (!(0, _helpers.isObject)(e[1])) {
-		                              _context11.next = 2;
+		                              _context12.next = 2;
 		                              break;
 		                            }
 
-		                            return _context11.abrupt("return", (0, _defineProperty2["default"])({}, e[0], e[1]));
+		                            return _context12.abrupt("return", (0, _defineProperty2["default"])({}, e[0], e[1]));
 
 		                          case 2:
 		                            if (Array.isArray(e[1])) {
-		                              _context11.next = 4;
+		                              _context12.next = 4;
 		                              break;
 		                            }
 
 		                            throw new _Error.SchemaError("Invalid type of \"".concat((0, _typeof2["default"])(e[1]), "\" for catalog at path \"").concat(e[0], "\"."));
 
 		                          case 4:
-		                            _context11.t0 = _defineProperty2["default"];
-		                            _context11.t1 = {};
-		                            _context11.t2 = e[0];
-		                            _context11.next = 9;
+		                            _context12.t0 = _defineProperty2["default"];
+		                            _context12.t1 = {};
+		                            _context12.t2 = e[0];
+		                            _context12.next = 9;
 		                            return Promise.all(e[1].map( /*#__PURE__*/function () {
-		                              var _ref8 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10(ee) {
+		                              var _ref8 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11(ee) {
 		                                var res;
-		                                return _regenerator["default"].wrap(function _callee10$(_context10) {
+		                                return _regenerator["default"].wrap(function _callee11$(_context11) {
 		                                  while (1) {
-		                                    switch (_context10.prev = _context10.next) {
+		                                    switch (_context11.prev = _context11.next) {
 		                                      case 0:
 		                                        if ((0, _helpers.isObject)(ee)) {
-		                                          _context10.next = 2;
+		                                          _context11.next = 2;
 		                                          break;
 		                                        }
 
-		                                        return _context10.abrupt("return", ee);
+		                                        return _context11.abrupt("return", ee);
 
 		                                      case 2:
 		                                        if (!(ee.$ref === undefined)) {
-		                                          _context10.next = 4;
+		                                          _context11.next = 4;
 		                                          break;
 		                                        }
 
 		                                        throw new _Error.SchemaError("Objects inside a catalog Array need to define a $ref at path \"".concat(e[0], "\"."));
 
 		                                      case 4:
-		                                        _context10.next = 6;
+		                                        _context11.next = 6;
 		                                        return _this2.resolveRef(ee.$ref);
 
 		                                      case 6:
-		                                        res = _context10.sent;
+		                                        res = _context11.sent;
 
 		                                        if (!(0, _helpers.isObject)(res)) {
-		                                          _context10.next = 9;
+		                                          _context11.next = 9;
 		                                          break;
 		                                        }
 
-		                                        return _context10.abrupt("return", Object.keys(res));
+		                                        return _context11.abrupt("return", Object.keys(res));
 
 		                                      case 9:
-		                                        return _context10.abrupt("return", res);
+		                                        return _context11.abrupt("return", res);
 
 		                                      case 10:
 		                                      case "end":
-		                                        return _context10.stop();
+		                                        return _context11.stop();
 		                                    }
 		                                  }
-		                                }, _callee10);
+		                                }, _callee11);
 		                              }));
 
-		                              return function (_x16) {
+		                              return function (_x17) {
 		                                return _ref8.apply(this, arguments);
 		                              };
 		                            }()));
 
 		                          case 9:
-		                            _context11.t3 = _context11.sent;
-		                            return _context11.abrupt("return", (0, _context11.t0)(_context11.t1, _context11.t2, _context11.t3));
+		                            _context12.t3 = _context12.sent;
+		                            return _context12.abrupt("return", (0, _context12.t0)(_context12.t1, _context12.t2, _context12.t3));
 
 		                          case 11:
 		                          case "end":
-		                            return _context11.stop();
+		                            return _context12.stop();
 		                        }
 		                      }
-		                    }, _callee11);
+		                    }, _callee12);
 		                  }));
 
-		                  return function (_x15) {
+		                  return function (_x16) {
 		                    return _ref6.apply(this, arguments);
 		                  };
 		                }()));
 
 		              case 5:
-		                result = _context12.sent;
-		                return _context12.abrupt("return", result.reduce(function (l, r) {
+		                result = _context13.sent;
+		                return _context13.abrupt("return", result.reduce(function (l, r) {
 		                  return _objectSpread(_objectSpread({}, l), r);
 		                }, {}));
 
 		              case 7:
 		              case "end":
-		                return _context12.stop();
+		                return _context13.stop();
 		            }
 		          }
-		        }, _callee12);
+		        }, _callee13);
 		      }));
 
-		      function compileCatalog(_x14) {
+		      function compileCatalog(_x15) {
 		        return _compileCatalog.apply(this, arguments);
 		      }
 
@@ -20440,16 +20499,16 @@ function requireCompiler () {
 		  }, {
 		    key: "process",
 		    value: function () {
-		      var _process = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13(schemaArg, resolver) {
+		      var _process = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14(schemaArg, resolver) {
 		        var schema, catalog, properties, fieldNames, i, name, field;
-		        return _regenerator["default"].wrap(function _callee13$(_context13) {
+		        return _regenerator["default"].wrap(function _callee14$(_context14) {
 		          while (1) {
-		            switch (_context13.prev = _context13.next) {
+		            switch (_context14.prev = _context14.next) {
 		              case 0:
 		                this.resolver = resolver;
 
 		                if ((0, _helpers.isObject)(schemaArg)) {
-		                  _context13.next = 3;
+		                  _context14.next = 3;
 		                  break;
 		                }
 
@@ -20462,15 +20521,15 @@ function requireCompiler () {
 		                catalog = schema.catalog, properties = schema.properties;
 
 		                if (!(catalog !== undefined)) {
-		                  _context13.next = 11;
+		                  _context14.next = 11;
 		                  break;
 		                }
 
-		                _context13.next = 10;
+		                _context14.next = 10;
 		                return this.compileCatalog(catalog);
 
 		              case 10:
-		                schema.catalog = _context13.sent;
+		                schema.catalog = _context14.sent;
 
 		              case 11:
 		                fieldNames = Object.keys(properties);
@@ -20478,35 +20537,35 @@ function requireCompiler () {
 
 		              case 13:
 		                if (!(i < fieldNames.length)) {
-		                  _context13.next = 22;
+		                  _context14.next = 22;
 		                  break;
 		                }
 
 		                name = fieldNames[i];
 		                field = properties[name];
-		                _context13.next = 18;
+		                _context14.next = 18;
 		                return this.compileField(field, name);
 
 		              case 18:
-		                properties[name] = _context13.sent;
+		                properties[name] = _context14.sent;
 
 		              case 19:
 		                i++;
-		                _context13.next = 13;
+		                _context14.next = 13;
 		                break;
 
 		              case 22:
-		                return _context13.abrupt("return", schema);
+		                return _context14.abrupt("return", schema);
 
 		              case 23:
 		              case "end":
-		                return _context13.stop();
+		                return _context14.stop();
 		            }
 		          }
-		        }, _callee13, this);
+		        }, _callee14, this);
 		      }));
 
-		      function process(_x17, _x18) {
+		      function process(_x18, _x19) {
 		        return _process.apply(this, arguments);
 		      }
 
@@ -28321,24 +28380,36 @@ function requireValidator () {
 		    }
 		  }, {
 		    key: "validateType",
-		    value: function validateType(name, field, value, otherFields) {
+		    value: function validateType(name, field, value, otherFields, index) {
 		      var type = field.type,
 		          validator = field.validator,
 		          options = field.options;
 
+		      if (type === 'array' && validator && Array.isArray(value)) {
+		        for (var i = 0; i < value.length; i++) {
+		          this.validateType(name, {
+		            type: 'string',
+		            validator: validator,
+		            options: options
+		          }, value[i], otherFields, i);
+		        }
+
+		        return true;
+		      }
+
 		      if (validator === undefined) {
-		        if (type === undefined) throw new _Error.SchemaError("Invalid type definition \"".concat(type, "\" at path \"").concat(name, "\"."));
+		        if (type === undefined) throw new _Error.SchemaError("Invalid type definition \"".concat(type, "\" at path \"").concat(name).concat(index ? "[".concat(index, "]") : '', "\"."));
 
 		        if (this.validateBaseType(type, value) === false) {
-		          if (Array.isArray(type)) throw new _Error.ValidationError("\"".concat(value, "\" is not valid for \"").concat(name, "\""), name, 'enum', type);else throw new _Error.ValidationError("\"".concat(value, "\" is not of type \"").concat(type, "\""), name, type);
+		          if (Array.isArray(type)) throw new _Error.ValidationError("invalid value for \"".concat(name).concat(index ? "[".concat(index, "]") : '', "\""), name, 'enum', type, index);else throw new _Error.ValidationError("value is not of type \"".concat(type, "\" in \"").concat(name).concat(index ? "[".concat(index, "]") : '', "\""), name, type, index);
 		        }
 		      } else {
 		        var func = _TypeValidator["default"]["is".concat(validator)];
 
-		        if (typeof func !== 'function') throw new _Error.SchemaError("Unknown validator \"".concat(validator, "\" at path \"").concat(name, "\"."));
+		        if (typeof func !== 'function') throw new _Error.SchemaError("Unknown validator \"".concat(validator, "\" at path \"").concat(name).concat(index ? "[".concat(index, "]") : '', "\"."));
 
 		        if (func(String(value), options, otherFields) === false) {
-		          throw new _Error.ValidationError('invalid', name, validator, options);
+		          throw new _Error.ValidationError('invalid', name, validator, options, index);
 		        }
 		      }
 
@@ -28425,12 +28496,14 @@ function requireValidator () {
 		        this.validateType(name, schema[name], value, data);
 		      } catch (e) {
 		        if (!(e instanceof _Error.ValidationError)) throw e;
-		        return new FieldResult(name, data[name], undefined, isProhibited, isRequired, isOptional, true, [{
+		        var errorEntry = {
 		          message: e.message,
 		          path: e.path,
 		          validator: e.validator,
 		          options: e.options
-		        }]);
+		        };
+		        if (e.index) errorEntry.index = e.index;
+		        return new FieldResult(name, data[name], undefined, isProhibited, isRequired, isOptional, true, [errorEntry]);
 		      }
 
 		      return new FieldResult(name, data[name], this.castType(name, type, value), isProhibited, isRequired, isOptional);
@@ -32063,8 +32136,9 @@ var getValue$1 = function getValue(value, catalog) {
 var FormRepeater = function FormRepeater(_ref) {
   var variant = _ref.variant,
       name = _ref.name,
+      label = _ref.label,
       value = _ref.value,
-      catalog = _ref.catalog,
+      options = _ref.options,
       onChange = _ref.onChange;
 
   var _useState = useState(value || []),
@@ -32082,6 +32156,11 @@ var FormRepeater = function FormRepeater(_ref) {
       inputValue = _useState6[0],
       setInputValue = _useState6[1];
 
+  var _useState7 = useState(''),
+      _useState8 = _slicedToArray(_useState7, 2),
+      catalogSelectValue = _useState8[0],
+      setCatalogSelectValue = _useState8[1];
+
   var handleEntryAdd = function handleEntryAdd() {
     if (inputValue.length > 0) {
       setEntries([].concat(_toConsumableArray(entries), [inputValue]));
@@ -32092,6 +32171,7 @@ var FormRepeater = function FormRepeater(_ref) {
   var handleCancelNewEntry = function handleCancelNewEntry() {
     setInEdit(false);
     setInputValue('');
+    setCatalogSelectValue('');
   };
 
   var handleEntryDel = function handleEntryDel(delIndex) {
@@ -32112,15 +32192,23 @@ var FormRepeater = function FormRepeater(_ref) {
   }, [entries]);
   var blockedOptions = [];
 
-  if (catalog) {
-    blockedOptions = Object.entries(catalog).filter(function (e) {
-      return value.includes(e[0]);
+  if (options) {
+    blockedOptions = Object.entries(options).filter(function (e) {
+      return Array.isArray(value) && value.includes(e[0]);
     }).map(function (e) {
       return e[0];
     });
   }
 
-  return /*#__PURE__*/React__default.createElement(_Box, null, /*#__PURE__*/React__default.createElement(_List, {
+  return /*#__PURE__*/React__default.createElement(_Box, null, /*#__PURE__*/React__default.createElement(_Typography, {
+    variant: "body1"
+  }, label), (!entries || (entries === null || entries === void 0 ? void 0 : entries.length) === 0) && /*#__PURE__*/React__default.createElement(_Box, {
+    mt: 1,
+    pl: 2
+  }, /*#__PURE__*/React__default.createElement(_Typography, {
+    variant: "body2",
+    color: "textSecondary"
+  }, "Keine Eintr\xE4ge vorhanden")), /*#__PURE__*/React__default.createElement(_List, {
     dense: true
   }, entries.map(function (entry, index) {
     return (
@@ -32129,7 +32217,7 @@ var FormRepeater = function FormRepeater(_ref) {
       React__default.createElement(_ListItem, {
         key: "entry-".concat(index)
       }, /*#__PURE__*/React__default.createElement(_ListItemText, {
-        primary: getValue$1(entry, catalog)
+        primary: getValue$1(entry, options)
       }), /*#__PURE__*/React__default.createElement(_ListItemSecondaryAction, null, /*#__PURE__*/React__default.createElement(_IconButton, {
         edge: "end",
         "aria-label": "delete",
@@ -32147,10 +32235,16 @@ var FormRepeater = function FormRepeater(_ref) {
     onClick: function onClick() {
       return setInEdit(true);
     }
-  }, "Eintrag hinzuf\xFCgen")), inEdit && !catalog && /*#__PURE__*/React__default.createElement(_Box, {
+  }, "Eintr\xE4ge hinzuf\xFCgen")), inEdit && !options && /*#__PURE__*/React__default.createElement(_Box, {
     width: "100%",
     display: "flex",
     alignItems: "center"
+  }, /*#__PURE__*/React__default.createElement(_ClickAwayListener, {
+    onClickAway: function onClickAway() {
+      if (inputValue === '') {
+        setInEdit(false);
+      }
+    }
   }, /*#__PURE__*/React__default.createElement(_FormControl, {
     variant: "filled",
     fullWidth: true
@@ -32182,22 +32276,24 @@ var FormRepeater = function FormRepeater(_ref) {
     onChange: function onChange(e) {
       return setInputValue(e.target.value);
     }
-  }))), inEdit && catalog && /*#__PURE__*/React__default.createElement(_Box, {
+  })))), inEdit && options && /*#__PURE__*/React__default.createElement(_Box, {
     width: "100%",
     display: "flex",
     alignItems: "center"
   }, /*#__PURE__*/React__default.createElement(_FormControl, {
     variant: "filled",
     fullWidth: true
-  }, /*#__PURE__*/React__default.createElement(_InputLabel, null, "Neuer Eintrag"), /*#__PURE__*/React__default.createElement(_Select, {
-    defaultValue: "please-select",
+  }, /*#__PURE__*/React__default.createElement(_TextField, {
+    label: "Eintrag ausw\xE4hlen",
+    select: true,
+    variant: variant,
+    value: catalogSelectValue,
+    onBlur: handleCancelNewEntry,
     onChange: function onChange(e) {
-      return setEntries([].concat(_toConsumableArray(entries), [e.target.value]));
+      setCatalogSelectValue('');
+      setEntries([].concat(_toConsumableArray(entries), [e.target.value]));
     }
-  }, /*#__PURE__*/React__default.createElement(_MenuItem, {
-    value: "please-select",
-    disabled: true
-  }, "Eintrag hinzuf\xFCgen"), Object.entries(catalog).sort(function (a, b) {
+  }, Object.entries(options).sort(function (a, b) {
     return a[1].localeCompare(b[1]);
   }).map(function (e) {
     return /*#__PURE__*/React__default.createElement(_MenuItem, {
@@ -32210,9 +32306,10 @@ var FormRepeater = function FormRepeater(_ref) {
 
 FormRepeater.propTypes = {
   variant: PropTypes__default.oneOf(['standard', 'filled', 'outlined']),
-  name: PropTypes__default.string.isRequired,
+  name: PropTypes__default.string,
+  label: PropTypes__default.string,
   value: PropTypes__default.any,
-  catalog: PropTypes__default.object,
+  options: PropTypes__default.object,
   onChange: PropTypes__default.func.isRequired
 };
 
@@ -76023,11 +76120,22 @@ var FormulatorFormSection = /*#__PURE__*/function (_React$Component) {
       var mapEntry = isRender ? renderComponentMap[field] : componentMap[mapKey];
       var component = mapEntry,
           props = {};
+      console.log(schema.properties, fieldEntry);
+
+      if (mapKey === 'array' && schema.properties[fieldEntry].options) {
+        props.options = schema.properties[fieldEntry].options.reduce(function (l, r) {
+          var _translations$fieldEn;
+
+          return _objectSpread$1(_objectSpread$1({}, l), {}, _defineProperty({}, r, (translations === null || translations === void 0 ? void 0 : (_translations$fieldEn = translations[fieldEntry]) === null || _translations$fieldEn === void 0 ? void 0 : _translations$fieldEn[r]) || r));
+        }, {});
+      }
 
       if (mapKey === 'select') {
         props.options = type.map(function (value) {
+          var _translations$field;
+
           return {
-            label: translations[field] && translations[field][value] || value,
+            label: (translations === null || translations === void 0 ? void 0 : (_translations$field = translations.field) === null || _translations$field === void 0 ? void 0 : _translations$field.value) || value,
             value: value
           };
         });