@react-typed-forms/schemas 1.0.0-dev.2 → 1.0.0-dev.20

package/lib/index.js

@@ -1,20 +1,1622 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var React = require('react');
+var core = require('@react-typed-forms/core');
+var jsonata = require('jsonata');
+var clsx = require('clsx');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var jsonata__default = /*#__PURE__*/_interopDefaultLegacy(jsonata);
+var clsx__default = /*#__PURE__*/_interopDefaultLegacy(clsx);
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+exports.FieldType = void 0;
+(function (FieldType) {
+  FieldType["String"] = "String";
+  FieldType["Bool"] = "Bool";
+  FieldType["Int"] = "Int";
+  FieldType["Date"] = "Date";
+  FieldType["DateTime"] = "DateTime";
+  FieldType["Double"] = "Double";
+  FieldType["EntityRef"] = "EntityRef";
+  FieldType["Compound"] = "Compound";
+  FieldType["AutoId"] = "AutoId";
+  FieldType["Image"] = "Image";
+  FieldType["Any"] = "Any";
+})(exports.FieldType || (exports.FieldType = {}));
+exports.ControlDefinitionType = void 0;
+(function (ControlDefinitionType) {
+  ControlDefinitionType["Data"] = "Data";
+  ControlDefinitionType["Group"] = "Group";
+  ControlDefinitionType["Display"] = "Display";
+  ControlDefinitionType["Action"] = "Action";
+})(exports.ControlDefinitionType || (exports.ControlDefinitionType = {}));
+exports.DynamicPropertyType = void 0;
+(function (DynamicPropertyType) {
+  DynamicPropertyType["Visible"] = "Visible";
+  DynamicPropertyType["DefaultValue"] = "DefaultValue";
+})(exports.DynamicPropertyType || (exports.DynamicPropertyType = {}));
+exports.ExpressionType = void 0;
+(function (ExpressionType) {
+  ExpressionType["Jsonata"] = "Jsonata";
+  ExpressionType["FieldValue"] = "FieldValue";
+  ExpressionType["UserMatch"] = "UserMatch";
+})(exports.ExpressionType || (exports.ExpressionType = {}));
+exports.AdornmentPlacement = void 0;
+(function (AdornmentPlacement) {
+  AdornmentPlacement["ControlStart"] = "ControlStart";
+  AdornmentPlacement["ControlEnd"] = "ControlEnd";
+  AdornmentPlacement["LabelStart"] = "LabelStart";
+  AdornmentPlacement["LabelEnd"] = "LabelEnd";
+})(exports.AdornmentPlacement || (exports.AdornmentPlacement = {}));
+exports.ControlAdornmentType = void 0;
+(function (ControlAdornmentType) {
+  ControlAdornmentType["Tooltip"] = "Tooltip";
+  ControlAdornmentType["Accordion"] = "Accordion";
+  ControlAdornmentType["HelpText"] = "HelpText";
+})(exports.ControlAdornmentType || (exports.ControlAdornmentType = {}));
+exports.DataRenderType = void 0;
+(function (DataRenderType) {
+  DataRenderType["Standard"] = "Standard";
+  DataRenderType["Radio"] = "Radio";
+  DataRenderType["HtmlEditor"] = "HtmlEditor";
+  DataRenderType["IconList"] = "IconList";
+  DataRenderType["CheckList"] = "CheckList";
+  DataRenderType["UserSelection"] = "UserSelection";
+  DataRenderType["Synchronised"] = "Synchronised";
+  DataRenderType["IconSelector"] = "IconSelector";
+  DataRenderType["DateTime"] = "DateTime";
+  DataRenderType["Checkbox"] = "Checkbox";
+  DataRenderType["Dropdown"] = "Dropdown";
+})(exports.DataRenderType || (exports.DataRenderType = {}));
+exports.SyncTextType = void 0;
+(function (SyncTextType) {
+  SyncTextType["Camel"] = "Camel";
+  SyncTextType["Snake"] = "Snake";
+  SyncTextType["Pascal"] = "Pascal";
+})(exports.SyncTextType || (exports.SyncTextType = {}));
+exports.GroupRenderType = void 0;
+(function (GroupRenderType) {
+  GroupRenderType["Standard"] = "Standard";
+  GroupRenderType["Grid"] = "Grid";
+  GroupRenderType["GroupElement"] = "GroupElement";
+})(exports.GroupRenderType || (exports.GroupRenderType = {}));
+exports.DisplayDataType = void 0;
+(function (DisplayDataType) {
+  DisplayDataType["Text"] = "Text";
+  DisplayDataType["Html"] = "Html";
+})(exports.DisplayDataType || (exports.DisplayDataType = {}));
+exports.ValidatorType = void 0;
+(function (ValidatorType) {
+  ValidatorType["Jsonata"] = "Jsonata";
+  ValidatorType["Date"] = "Date";
+})(exports.ValidatorType || (exports.ValidatorType = {}));
+exports.DateComparison = void 0;
+(function (DateComparison) {
+  DateComparison["NotBefore"] = "NotBefore";
+  DateComparison["NotAfter"] = "NotAfter";
+})(exports.DateComparison || (exports.DateComparison = {}));
+function isDataControlDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Data;
+}
+function isGroupControlsDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Group;
+}
+function isDisplayControlsDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Display;
+}
+function isActionControlsDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Action;
+}
+function visitControlDefinition(x, visitor, defaultValue) {
+  switch (x.type) {
+    case exports.ControlDefinitionType.Action:
+      return visitor.action(x);
+    case exports.ControlDefinitionType.Data:
+      return visitor.data(x);
+    case exports.ControlDefinitionType.Display:
+      return visitor.display(x);
+    case exports.ControlDefinitionType.Group:
+      return visitor.group(x);
+    default:
+      return defaultValue(x);
+  }
+}
+function dataControl(field, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Data,
+    field: field
+  }, options);
+}
+function fieldValueExpr(field, value) {
+  return {
+    type: exports.ExpressionType.FieldValue,
+    field: field,
+    value: value
+  };
+}
+function visibility(expr) {
+  return {
+    type: exports.DynamicPropertyType.Visible,
+    expr: expr
+  };
+}
+function isGridRenderer(options) {
+  return options.type === exports.GroupRenderType.Grid;
+}
+
+function buildSchema(def) {
+  return Object.entries(def).map(function (x) {
+    return x[1](x[0]);
+  });
+}
+function stringField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.String,
+    displayName: displayName
+  }, options));
+}
+function stringOptionsField(displayName) {
+  return makeScalarField({
+    type: exports.FieldType.String,
+    displayName: displayName,
+    options: [].slice.call(arguments, 1)
+  });
+}
+function withScalarOptions(options, v) {
+  return function (n) {
+    return _extends({}, v(n), options);
+  };
+}
+function makeScalarField(options) {
+  return function (n) {
+    return _extends({}, defaultScalarField(n, n), options);
+  };
+}
+function makeCompoundField(options) {
+  return function (n) {
+    return _extends({}, defaultCompoundField(n, n, false), options);
+  };
+}
+function intField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Int,
+    displayName: displayName
+  }, options));
+}
+function boolField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Bool,
+    displayName: displayName
+  }, options));
+}
+function compoundField(displayName, fields, other) {
+  return function (field) {
+    return _extends({}, defaultCompoundField(field, displayName, false), other, {
+      children: fields
+    });
+  };
+}
+function defaultScalarField(field, displayName) {
+  return {
+    field: field,
+    displayName: displayName,
+    type: exports.FieldType.String
+  };
+}
+function defaultCompoundField(field, displayName, collection) {
+  return {
+    tags: [],
+    field: field,
+    displayName: displayName,
+    type: exports.FieldType.Compound,
+    collection: collection,
+    system: false,
+    treeChildren: false,
+    children: [],
+    onlyForTypes: [],
+    required: true
+  };
+}
+
+function applyDefaultValues(v, fields) {
+  if (!v) return defaultValueForFields(fields);
+  var applyValue = fields.filter(function (x) {
+    return isCompoundField(x) || !(x.field in v);
+  });
+  if (!applyValue.length) return v;
+  var out = _extends({}, v);
+  applyValue.forEach(function (x) {
+    out[x.field] = x.field in v ? applyDefaultForField(v[x.field], x, fields) : defaultValueForField(x);
+  });
+  return out;
+}
+function applyDefaultForField(v, field, parent, notElement) {
+  if (field.collection && !notElement) {
+    return (v != null ? v : []).map(function (x) {
+      return applyDefaultForField(x, field, parent, true);
+    });
+  }
+  if (isCompoundField(field)) {
+    if (!v && !field.required) return v;
+    return applyDefaultValues(v, field.treeChildren ? parent : field.children);
+  }
+  return defaultValueForField(field);
+}
+function defaultValueForFields(fields) {
+  return Object.fromEntries(fields.map(function (x) {
+    return [x.field, defaultValueForField(x)];
+  }));
+}
+function defaultValueForField(sf) {
+  if (isCompoundField(sf)) {
+    return sf.required ? sf.collection ? [] : defaultValueForFields(sf.children) : undefined;
+  }
+  if (sf.collection) return [];
+  return sf.defaultValue;
+}
+function elementValueForField(sf) {
+  if (isCompoundField(sf)) {
+    return defaultValueForFields(sf.children);
+  }
+  return sf.defaultValue;
+}
+function findScalarField(fields, field) {
+  return findField(fields, field);
+}
+function findCompoundField(fields, field) {
+  return findField(fields, field);
+}
+function findField(fields, field) {
+  return fields.find(function (x) {
+    return x.field === field;
+  });
+}
+function isScalarField(sf) {
+  return !isCompoundField(sf);
+}
+function isCompoundField(sf) {
+  return sf.type === exports.FieldType.Compound;
+}
+function isDataControl(c) {
+  return c.type === exports.ControlDefinitionType.Data;
+}
+function isGroupControl(c) {
+  return c.type === exports.ControlDefinitionType.Group;
+}
+function fieldHasTag(field, tag) {
+  var _field$tags;
+  return Boolean((_field$tags = field.tags) == null ? void 0 : _field$tags.includes(tag));
+}
+function fieldDisplayName(field) {
+  var _field$displayName;
+  return (_field$displayName = field.displayName) != null ? _field$displayName : field.field;
+}
+function hasOptions(o) {
+  var _o$options$length, _o$options;
+  return ((_o$options$length = (_o$options = o.options) == null ? void 0 : _o$options.length) != null ? _o$options$length : 0) > 0;
+}
+function defaultControlForField(sf) {
+  if (isCompoundField(sf)) {
+    return {
+      type: exports.ControlDefinitionType.Group,
+      title: sf.displayName,
+      compoundField: sf.field,
+      groupOptions: {
+        type: exports.GroupRenderType.Grid,
+        hideTitle: false
+      },
+      children: sf.children.map(defaultControlForField)
+    };
+  } else if (isScalarField(sf)) {
+    var _sf$tags;
+    var htmlEditor = (_sf$tags = sf.tags) == null ? void 0 : _sf$tags.includes("_HtmlEditor");
+    return {
+      type: exports.ControlDefinitionType.Data,
+      title: sf.displayName,
+      field: sf.field,
+      required: sf.required,
+      renderOptions: {
+        type: htmlEditor ? exports.DataRenderType.HtmlEditor : exports.DataRenderType.Standard
+      }
+    };
+  }
+  throw "Unknown schema field";
+}
+function findReferencedControl(field, control) {
+  if (isDataControl(control) && field === control.field) return control;
+  if (isGroupControl(control)) {
+    if (control.compoundField) return field === control.compoundField ? control : undefined;
+    return findReferencedControlInArray(field, control.children);
+  }
+  return undefined;
+}
+function findReferencedControlInArray(field, controls) {
+  for (var _iterator = _createForOfIteratorHelperLoose(controls), _step; !(_step = _iterator()).done;) {
+    var c = _step.value;
+    var ref = findReferencedControl(field, c);
+    if (ref) return ref;
+  }
+  return undefined;
+}
+function addMissingControls(fields, controls) {
+  var changes = fields.flatMap(function (x) {
+    if (fieldHasTag(x, "_NoControl")) return [];
+    var existing = findReferencedControlInArray(x.field, controls);
+    if (!existing || isCompoundField(x)) return {
+      field: x,
+      existing: existing
+    };
+    return [];
+  });
+  var changedCompounds = controls.map(function (x) {
+    var ex = changes.find(function (c) {
+      return c.existing === x;
+    });
+    if (!ex) return x;
+    var cf = x;
+    return _extends({}, cf, {
+      children: addMissingControls(ex.field.children, cf.children)
+    });
+  });
+  return changedCompounds.concat(changes.filter(function (x) {
+    return !x.existing;
+  }).map(function (x) {
+    return defaultControlForField(x.field);
+  }));
+}
+
+var _FormRendererComponentsContext = null;
+function FormRendererComponentsContext() {
+  if (!_FormRendererComponentsContext) {
+    _FormRendererComponentsContext = React.createContext(undefined);
+  }
+  return _FormRendererComponentsContext;
+}
+function FormRendererProvider(_ref) {
+  var _effect = core.useComponentTracking();
+  try {
+    var value = _ref.value,
+      children = _ref.children;
+    var _FormRendererComponen = FormRendererComponentsContext(),
+      Provider = _FormRendererComponen.Provider;
+    return /*#__PURE__*/React__default["default"].createElement(Provider, {
+      value: value,
+      children: children
+    });
+  } finally {
+    _effect();
+  }
+}
+function useFormRendererComponents() {
+  var c = React.useContext(FormRendererComponentsContext());
+  if (!c) {
+    throw "Need to use FormRendererComponentContext.Provider";
+  }
+  return c;
+}
+function controlTitle(title, field) {
+  return title ? title : fieldDisplayName(field);
+}
+function renderControl(definition, formState, hooks, key) {
+  var fields = formState.fields;
+  return visitControlDefinition(definition, {
+    data: function data(def) {
+      var fieldData = findScalarField(fields, def.field);
+      if (!fieldData) return /*#__PURE__*/React__default["default"].createElement("h1", {
+        key: key
+      }, "No schema field for: ", def.field);
+      return /*#__PURE__*/React__default["default"].createElement(DataRenderer, {
+        key: key,
+        formState: formState,
+        hooks: hooks,
+        controlDef: def,
+        fieldData: fieldData
+      });
+    },
+    group: function group(d) {
+      return /*#__PURE__*/React__default["default"].createElement(GroupRenderer, {
+        key: key,
+        hooks: hooks,
+        groupDef: d,
+        formState: formState
+      });
+    },
+    action: function action(d) {
+      return /*#__PURE__*/React__default["default"].createElement(ActionRenderer, {
+        key: key,
+        hooks: hooks,
+        formState: formState,
+        actionDef: d
+      });
+    },
+    display: function display(d) {
+      return /*#__PURE__*/React__default["default"].createElement(DisplayRenderer, {
+        key: key,
+        hooks: hooks,
+        formState: formState,
+        displayDef: d
+      });
+    }
+  }, function () {
+    return /*#__PURE__*/React__default["default"].createElement("h1", null, "Unknown control: ", definition.type);
+  });
+}
+/** @trackControls */
+function DataRenderer(_ref2) {
+  var _effect2 = core.useComponentTracking();
+  try {
+    var _props$customRender;
+    var hooks = _ref2.hooks,
+      formState = _ref2.formState,
+      controlDef = _ref2.controlDef,
+      fieldData = _ref2.fieldData;
+    var renderer = useFormRendererComponents();
+    var props = hooks.useDataProperties(formState, controlDef, fieldData, renderer);
+    return ((_props$customRender = props.customRender) != null ? _props$customRender : renderer.renderData)(props);
+  } finally {
+    _effect2();
+  }
+}
+/** @trackControls */ /** @trackControls */
+function ActionRenderer(_ref3) {
+  var _effect3 = core.useComponentTracking();
+  try {
+    var hooks = _ref3.hooks,
+      formState = _ref3.formState,
+      actionDef = _ref3.actionDef;
+    var _useFormRendererCompo = useFormRendererComponents(),
+      renderAction = _useFormRendererCompo.renderAction;
+    var actionControlProperties = hooks.useActionProperties(formState, actionDef);
+    return renderAction(actionControlProperties);
+  } finally {
+    _effect3();
+  }
+}
+/** @trackControls */ /** @trackControls */
+function GroupRenderer(_ref4) {
+  var _effect4 = core.useComponentTracking();
+  try {
+    var hooks = _ref4.hooks,
+      formState = _ref4.formState,
+      groupDef = _ref4.groupDef;
+    var renderers = useFormRendererComponents();
+    var groupProps = hooks.useGroupProperties(formState, groupDef, hooks, renderers);
+    return renderers.renderGroup(groupProps);
+  } finally {
+    _effect4();
+  }
+}
+/** @trackControls */ /** @trackControls */
+function DisplayRenderer(_ref5) {
+  var _effect5 = core.useComponentTracking();
+  try {
+    var hooks = _ref5.hooks,
+      formState = _ref5.formState,
+      displayDef = _ref5.displayDef;
+    var _useFormRendererCompo2 = useFormRendererComponents(),
+      renderDisplay = _useFormRendererCompo2.renderDisplay;
+    var displayProps = hooks.useDisplayProperties(formState, displayDef);
+    return renderDisplay(displayProps);
+  } finally {
+    _effect5();
+  }
+}
+function controlForField(field, formState) {
+  var _ref6;
+  var refField = findField(formState.fields, field);
+  return (_ref6 = refField && formState.data.fields[refField.field]) != null ? _ref6 : core.newControl(undefined);
+}
+function fieldForControl(c) {
+  return isDataControl(c) ? c.field : isGroupControl(c) ? c.compoundField : undefined;
+}
+var AlwaysVisible = {
+  value: true,
+  canChange: false
+};
+function createAction(label, onClick, actionId) {
+  return {
+    definition: {
+      type: exports.ControlDefinitionType.Action,
+      actionId: actionId != null ? actionId : label,
+      title: label
+    },
+    visible: AlwaysVisible,
+    onClick: onClick
+  };
+}
+function visitControlData(definition, _ref7, cb) {
+  var fields = _ref7.fields,
+    _data = _ref7.data;
+  return visitControlDefinition(definition, {
+    data: function data(def) {
+      var fieldData = findScalarField(fields, def.field);
+      if (!fieldData) return undefined;
+      return cb(def, _data.fields[fieldData.field]);
+    },
+    group: function group(d) {
+      if (d.compoundField) {
+        var compound = findCompoundField(fields, d.compoundField);
+        if (!compound) return;
+        fields = compound.children;
+        _data = _data.fields[compound.field];
+      }
+      var childState = {
+        fields: fields,
+        data: _data
+      };
+      for (var _iterator = _createForOfIteratorHelperLoose(d.children), _step; !(_step = _iterator()).done;) {
+        var c = _step.value;
+        var res = visitControlData(c, childState, cb);
+        if (res !== undefined) return res;
+      }
+      return undefined;
+    },
+    action: function action(d) {
+      return undefined;
+    },
+    display: function display(d) {
+      return undefined;
+    }
+  }, function () {
+    return undefined;
+  });
+}
+
+function useDefaultValue(definition, field, formState, hooks) {
+  var _definition$dynamic;
+  var valueExpression = (_definition$dynamic = definition.dynamic) == null ? void 0 : _definition$dynamic.find(function (x) {
+    return x.type === exports.DynamicPropertyType.DefaultValue;
+  });
+  if (valueExpression) {
+    return hooks.useExpression(valueExpression.expr, formState).value;
+  }
+  return field.defaultValue;
+}
+function useIsControlVisible(definition, formState, hooks) {
+  var _definition$dynamic2, _ref2, _onlyForTypes$length;
+  var visibleExpression = (_definition$dynamic2 = definition.dynamic) == null ? void 0 : _definition$dynamic2.find(function (x) {
+    return x.type === exports.DynamicPropertyType.Visible;
+  });
+  if (visibleExpression && visibleExpression.expr) {
+    var exprValue = hooks.useExpression(visibleExpression.expr, formState).value;
+    return {
+      value: Boolean(exprValue),
+      canChange: true
+    };
+  }
+  var schemaFields = formState.fields;
+  var _useMemo = React.useMemo(function () {
+      var _ref, _formState$data$field;
+      var typeField = schemaFields.find(function (x) {
+        return isScalarField(x) && x.isTypeField;
+      });
+      var typeControl = (_ref = typeField && ((_formState$data$field = formState.data.fields) == null ? void 0 : _formState$data$field[typeField.field])) != null ? _ref : core.newControl(undefined);
+      var compoundField = isGroupControl(definition) && definition.compoundField ? formState.data.fields[definition.compoundField] : undefined;
+      return {
+        typeControl: typeControl,
+        compoundField: compoundField
+      };
+    }, [schemaFields, formState.data]),
+    typeControl = _useMemo.typeControl,
+    compoundField = _useMemo.compoundField;
+  var fieldName = fieldForControl(definition);
+  var onlyForTypes = (_ref2 = fieldName ? findField(schemaFields, fieldName) : undefined) == null ? void 0 : _ref2.onlyForTypes;
+  var canChange = Boolean(compoundField || ((_onlyForTypes$length = onlyForTypes == null ? void 0 : onlyForTypes.length) != null ? _onlyForTypes$length : 0) > 0);
+  var value = (!compoundField || compoundField.value != null) && (!onlyForTypes || onlyForTypes.length === 0 || Boolean(typeControl.value && onlyForTypes.includes(typeControl.value)));
+  return {
+    value: value,
+    canChange: canChange
+  };
+}
+function getDefaultScalarControlProperties(definition, field, visible, defaultValue, control, formState) {
+  var _definition$renderOpt, _definition$required, _ref3, _formState$readonly;
+  return {
+    definition: definition,
+    field: field,
+    defaultValue: defaultValue,
+    options: getOptionsForScalarField(field),
+    renderOptions: (_definition$renderOpt = definition.renderOptions) != null ? _definition$renderOpt : {
+      type: exports.DataRenderType.Standard
+    },
+    required: (_definition$required = definition.required) != null ? _definition$required : false,
+    visible: visible,
+    readonly: (_ref3 = (_formState$readonly = formState.readonly) != null ? _formState$readonly : definition.readonly) != null ? _ref3 : false,
+    control: control,
+    formState: formState
+  };
+}
+function getOptionsForScalarField(field) {
+  var _opts$length;
+  var opts = field.options;
+  if ((_opts$length = opts == null ? void 0 : opts.length) != null ? _opts$length : 0 > 0) {
+    return opts;
+  }
+  return undefined;
+}
+function createDefaultSchemaHooks() {
+  function useExpression(expr, formState) {
+    switch (expr.type) {
+      case exports.ExpressionType.Jsonata:
+        var jExpr = expr;
+        var compiledExpr = React.useMemo(function () {
+          return jsonata__default["default"](jExpr.expression);
+        }, [jExpr.expression]);
+        var control = core.useControl();
+        core.useControlEffect(function () {
+          return formState.data.value;
+        }, function (v) {
+          try {
+            return Promise.resolve(compiledExpr.evaluate(v)).then(function (_compiledExpr$evaluat) {
+              control.value = _compiledExpr$evaluat;
+            });
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        });
+        return control;
+      case exports.ExpressionType.FieldValue:
+        var fvExpr = expr;
+        return core.useComputed(function () {
+          var fv = controlForField(fvExpr.field, formState).value;
+          return Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value;
+        });
+      default:
+        return core.useControl(undefined);
+    }
+  }
+  function useValidators(formState, isVisible, control, required, validators) {
+    if (required) core.useValidator(control, function (v) {
+      return isVisible && (v == null || v == "") ? "Please enter a value" : null;
+    }, "required");
+    validators == null || validators.forEach(function (v, i) {
+      switch (v.type) {
+        case exports.ValidatorType.Date:
+          processDateValidator(v);
+          break;
+        case exports.ValidatorType.Jsonata:
+          var errorMsg = useExpression(v, formState);
+          core.useControlEffect(function () {
+            return [isVisible, errorMsg.value];
+          }, function (_ref4) {
+            var isVisible = _ref4[0],
+              msg = _ref4[1];
+            return control.setError(v.type + i, isVisible ? msg : null);
+          }, true);
+          break;
+      }
+      function processDateValidator(dv) {
+        var comparisonDate;
+        if (dv.fixedDate) {
+          comparisonDate = Date.parse(dv.fixedDate);
+        } else {
+          var nowDate = new Date();
+          comparisonDate = Date.UTC(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate());
+          if (dv.daysFromCurrent) {
+            comparisonDate += dv.daysFromCurrent * 86400000;
+          }
+        }
+        core.useValidator(control, function (v) {
+          if (v) {
+            var selDate = Date.parse(v);
+            var notAfter = dv.comparison === exports.DateComparison.NotAfter;
+            if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
+              return "Date must not be " + (notAfter ? "after" : "before") + " " + new Date(comparisonDate).toDateString();
+            }
+          }
+          return null;
+        }, "date" + i);
+      }
+    });
+  }
+  return {
+    useExpression: useExpression,
+    useValidators: useValidators
+  };
+}
+var defaultFormEditHooks = createFormEditHooks(createDefaultSchemaHooks());
+function createFormEditHooks(schemaHooks) {
+  return {
+    schemaHooks: schemaHooks,
+    useDataProperties: function useDataProperties(formState, definition, field, renderer) {
+      var visible = useIsControlVisible(definition, formState, schemaHooks);
+      var isVisible = visible.value && !formState.invisible;
+      var defaultValue = useDefaultValue(definition, field, formState, schemaHooks);
+      var scalarControl = formState.data.fields[field.field];
+      React.useEffect(function () {
+        if (!isVisible) scalarControl.value = null;else if (scalarControl.current.value == null) {
+          scalarControl.value = defaultValue;
+        }
+      }, [isVisible, defaultValue]);
+      var dataProps = getDefaultScalarControlProperties(definition, field, visible, defaultValue, scalarControl, formState);
+      schemaHooks.useValidators(formState, isVisible, scalarControl, dataProps.required, definition.validators);
+      React.useEffect(function () {
+        var subscription = scalarControl.subscribe(function (c) {
+          return c.touched = true;
+        }, core.ControlChange.Validate);
+        return function () {
+          return scalarControl.unsubscribe(subscription);
+        };
+      }, []);
+      if (!field.collection) return dataProps;
+      return _extends({}, dataProps, {
+        array: defaultArrayRendererProps(scalarControl, field, definition, dataProps.readonly, function (c) {
+          return renderer.renderData(_extends({}, dataProps, {
+            control: c
+          }));
+        })
+      });
+    },
+    useDisplayProperties: function useDisplayProperties(fs, definition) {
+      var visible = useIsControlVisible(definition, fs, schemaHooks);
+      return {
+        visible: visible,
+        definition: definition
+      };
+    },
+    useGroupProperties: function useGroupProperties(fs, definition, hooks, renderers) {
+      var _definition$groupOpti;
+      var visible = useIsControlVisible(definition, fs, schemaHooks);
+      var field = definition.compoundField ? findCompoundField(fs.fields, definition.compoundField) : undefined;
+      var newFs = _extends({}, fs, {
+        fields: field ? field.children : fs.fields,
+        data: field ? fs.data.fields[field.field] : fs.data,
+        invisible: !visible.value || fs.invisible
+      });
+      var groupProps = {
+        visible: visible,
+        hooks: hooks,
+        hideTitle: (_definition$groupOpti = definition.groupOptions.hideTitle) != null ? _definition$groupOpti : false,
+        childCount: definition.children.length,
+        renderChild: function renderChild(i) {
+          return renderControl(definition.children[i], newFs, hooks, i);
+        },
+        definition: definition
+      };
+      if (field != null && field.collection) {
+        return _extends({}, groupProps, {
+          array: defaultArrayRendererProps(newFs.data, field, definition, fs.readonly, function (e) {
+            return renderers.renderGroup(_extends({}, groupProps, {
+              hideTitle: true,
+              renderChild: function renderChild(i) {
+                return renderControl(definition.children[i], _extends({}, newFs, {
+                  data: e
+                }), hooks, i);
+              }
+            }));
+          })
+        });
+      }
+      return groupProps;
+    },
+    useActionProperties: function useActionProperties(formState, definition) {
+      var visible = useIsControlVisible(definition, formState, schemaHooks);
+      return {
+        visible: visible,
+        onClick: function onClick() {},
+        definition: definition
+      };
+    }
+  };
+}
+function defaultArrayRendererProps(control, field, definition, readonly, renderElem) {
+  var _control$elements$len, _control$elements;
+  return {
+    control: control,
+    childCount: (_control$elements$len = (_control$elements = control.elements) == null ? void 0 : _control$elements.length) != null ? _control$elements$len : 0,
+    field: field,
+    definition: definition,
+    addAction: !readonly ? {
+      definition: {
+        title: "Add " + controlTitle(definition.title, field),
+        type: exports.ControlDefinitionType.Action,
+        actionId: "addElement"
+      },
+      visible: {
+        value: true,
+        canChange: false
+      },
+      onClick: function onClick() {
+        return core.addElement(control, elementValueForField(field));
+      }
+    } : undefined,
+    removeAction: !readonly ? function (i) {
+      return {
+        definition: {
+          title: "Remove",
+          type: exports.ControlDefinitionType.Action,
+          actionId: "removeElement"
+        },
+        visible: {
+          value: true,
+          canChange: false
+        },
+        onClick: function onClick() {
+          return core.removeElement(control, control.elements[i]);
+        }
+      };
+    } : undefined,
+    childKey: function childKey(i) {
+      return control.elements[i].uniqueId;
+    },
+    renderChild: function renderChild(i) {
+      var c = control.elements[i];
+      return /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
+        key: c.uniqueId
+      }, renderElem(c));
+    }
+  };
+}
+function useControlsWithDefaults(definition, sf) {
+  return React.useMemo(function () {
+    return definition.children.length ? definition : _extends({}, definition, {
+      children: addMissingControls(sf, [])
+    });
+  }, [sf, definition]);
+}
+
+var _excluded = ["control", "convert"],
+  _excluded2 = ["errorText", "value", "onChange"],
+  _excluded3 = ["state", "options", "className", "convert", "required", "emptyText", "requiredText"];
+function createFormRenderer(customRenderers, defaultRenderers) {
+  var _customRenderers$find, _customRenderers$find2, _customRenderers$find3;
+  if (customRenderers === void 0) {
+    customRenderers = [];
+  }
+  if (defaultRenderers === void 0) {
+    defaultRenderers = createClassStyledRenderers();
+  }
+  var dataRegistrations = customRenderers.filter(isDataRegistration);
+  var adornmentRegistrations = customRenderers.filter(isAdornmentRegistration);
+  var labelRenderer = (_customRenderers$find = customRenderers.find(isLabelRegistration)) != null ? _customRenderers$find : defaultRenderers.label;
+  var arrayRenderer = (_customRenderers$find2 = customRenderers.find(isArrayRegistration)) != null ? _customRenderers$find2 : defaultRenderers.array;
+  var renderVisibility = ((_customRenderers$find3 = customRenderers.find(isVisibilityRegistration)) != null ? _customRenderers$find3 : defaultRenderers.visibility).render;
+  var formRenderers = {
+    renderAction: renderAction,
+    renderData: _renderData,
+    renderGroup: _renderGroup,
+    renderDisplay: renderDisplay,
+    renderLabel: renderLabel,
+    renderArray: renderArray,
+    renderVisibility: renderVisibility,
+    renderAdornment: renderAdornment
+  };
+  function renderAdornment(props) {
+    var _adornmentRegistratio;
+    var renderer = (_adornmentRegistratio = adornmentRegistrations.find(function (x) {
+      return isOneOf(x.adornmentType, props.definition.type);
+    })) != null ? _adornmentRegistratio : defaultRenderers.adornment;
+    return renderer.render(props);
+  }
+  function renderArray(props) {
+    return arrayRenderer.render(props, formRenderers);
+  }
+  function renderLabel(props, elem) {
+    return labelRenderer.render(props, elem, formRenderers);
+  }
+  function withAdornments(definition, adornments) {
+    var _definition$adornment, _definition$adornment2;
+    var rAdornments = adornments ? adornments : (_definition$adornment = (_definition$adornment2 = definition.adornments) == null ? void 0 : _definition$adornment2.map(function (x, i) {
+      return renderAdornment({
+        definition: x,
+        key: i
+      });
+    })) != null ? _definition$adornment : [];
+    function combineAdornments(placement) {
+      return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, rAdornments.filter(function (x) {
+        return x.child && x.child[0] === placement;
+      }).map(function (x) {
+        return x.child[1];
+      }));
+    }
+    return [rAdornments, combineAdornments, function (mainElem) {
+      return !adornments ? mainElem : rAdornments.reduce(function (e, n) {
+        var _n$wrap;
+        return (_n$wrap = n.wrap == null ? void 0 : n.wrap(e)) != null ? _n$wrap : e;
+      }, mainElem);
+    }];
+  }
+  function _renderData(props, adornments) {
+    var _dataRegistrations$fi;
+    var definition = props.definition,
+      renderType = props.renderOptions.type,
+      visible = props.visible,
+      required = props.required,
+      control = props.control,
+      field = props.field;
+    var options = hasOptions(props);
+    var renderer = (_dataRegistrations$fi = dataRegistrations.find(function (x) {
+      var _x$collection, _field$collection, _x$options;
+      return ((_x$collection = x.collection) != null ? _x$collection : false) === ((_field$collection = field.collection) != null ? _field$collection : false) && ((_x$options = x.options) != null ? _x$options : false) === options && isOneOf(x.schemaType, field.type) && isOneOf(x.renderType, renderType) && (!x.match || x.match(props));
+    })) != null ? _dataRegistrations$fi : defaultRenderers.data;
+    var _withAdornments = withAdornments(definition, adornments),
+      rAdornments = _withAdornments[0],
+      renderAdornment = _withAdornments[1],
+      wrapElem = _withAdornments[2];
+    return wrapElem(renderer.render(props, createLabel, _extends({}, formRenderers, {
+      renderData: function renderData(p) {
+        return _renderData(p, rAdornments);
+      }
+    })));
+    function createLabel(labelProps) {
+      var _labelProps$title;
+      return _extends({
+        visible: visible,
+        required: required,
+        control: control,
+        forId: "c" + control.uniqueId,
+        renderAdornment: renderAdornment
+      }, labelProps, {
+        title: (_labelProps$title = labelProps == null ? void 0 : labelProps.title) != null ? _labelProps$title : controlTitle(definition.title, field)
+      });
+    }
+  }
+  function _renderGroup(props, adornments) {
+    var definition = props.definition,
+      visible = props.visible,
+      field = props.field;
+    var _withAdornments2 = withAdornments(props.definition, adornments),
+      rAdornments = _withAdornments2[0],
+      renderAdornment = _withAdornments2[1],
+      wrapElem = _withAdornments2[2];
+    var title = props.hideTitle ? undefined : field ? controlTitle(definition.title, field) : definition.title;
+    return wrapElem(defaultRenderers.group.render(props, createLabel, _extends({}, formRenderers, {
+      renderGroup: function renderGroup(p) {
+        return _renderGroup(p, rAdornments);
+      }
+    })));
+    function createLabel(labelProps) {
+      return _extends({
+        required: false,
+        visible: visible,
+        group: true,
+        renderAdornment: renderAdornment,
+        title: title
+      }, labelProps);
+    }
+  }
+  function renderAction(props, adornments) {
+    var _customRenderers$find4;
+    var renderer = (_customRenderers$find4 = customRenderers.find(isActionRegistration)) != null ? _customRenderers$find4 : defaultRenderers.action;
+    var _withAdornments3 = withAdornments(props.definition, adornments),
+      wrapElem = _withAdornments3[2];
+    return wrapElem(renderer.render(props, formRenderers));
+  }
+  function renderDisplay(props, adornments) {
+    var _withAdornments4 = withAdornments(props.definition, adornments),
+      wrapElem = _withAdornments4[2];
+    return wrapElem(defaultRenderers.display.render(props, formRenderers));
+  }
+  return formRenderers;
+}
+function createDefaultActionRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function render(_ref, _ref2) {
+    var visible = _ref.visible,
+      onClick = _ref.onClick,
+      title = _ref.definition.title;
+    var renderVisibility = _ref2.renderVisibility;
+    return renderVisibility(visible, /*#__PURE__*/React__default["default"].createElement("button", {
+      className: options.className,
+      onClick: onClick
+    }, title));
+  }
+  return {
+    render: render,
+    type: "action"
+  };
+}
+function createDefaultLabelRenderer(options) {
+  if (options === void 0) {
+    options = {
+      requiredElement: /*#__PURE__*/React__default["default"].createElement("span", null, " *")
+    };
+  }
+  return {
+    render: function render(p, elem, _ref3) {
+      var renderVisibility = _ref3.renderVisibility;
+      return renderVisibility(p.visible, /*#__PURE__*/React__default["default"].createElement(DefaultLabelRenderer, _extends({}, p, options, {
+        children: elem
+      })));
+    },
+    type: "label"
+  };
+}
+function DefaultLabelRenderer(_ref4) {
+  var _effect = core.useComponentTracking();
+  try {
+    var className = _ref4.className,
+      labelClass = _ref4.labelClass,
+      title = _ref4.title,
+      forId = _ref4.forId,
+      required = _ref4.required,
+      children = _ref4.children,
+      group = _ref4.group,
+      groupLabelClass = _ref4.groupLabelClass,
+      renderAdornment = _ref4.renderAdornment,
+      requiredElement = _ref4.requiredElement;
+    return title ? /*#__PURE__*/React__default["default"].createElement("div", {
+      className: className
+    }, renderAdornment(exports.AdornmentPlacement.LabelStart), /*#__PURE__*/React__default["default"].createElement("label", {
+      htmlFor: forId,
+      className: clsx__default["default"](labelClass, group && groupLabelClass)
+    }, title, required && requiredElement), renderAdornment(exports.AdornmentPlacement.LabelEnd), renderAdornment(exports.AdornmentPlacement.ControlStart), children, renderAdornment(exports.AdornmentPlacement.ControlEnd)) : /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, children);
+  } finally {
+    _effect();
+  }
+}
+function createDefaultArrayRenderer(options) {
+  var _ref5 = options != null ? options : {},
+    className = _ref5.className,
+    removableClass = _ref5.removableClass,
+    childClass = _ref5.childClass,
+    removableChildClass = _ref5.removableChildClass,
+    removeActionClass = _ref5.removeActionClass,
+    addActionClass = _ref5.addActionClass;
+  function render(_ref6, _ref7) {
+    var childCount = _ref6.childCount,
+      renderChild = _ref6.renderChild,
+      addAction = _ref6.addAction,
+      removeAction = _ref6.removeAction,
+      childKey = _ref6.childKey;
+    var renderAction = _ref7.renderAction;
+    return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement("div", {
+      className: clsx__default["default"](className, removeAction && removableClass)
+    }, Array.from({
+      length: childCount
+    }, function (_, x) {
+      return removeAction ? /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
+        key: childKey(x)
+      }, /*#__PURE__*/React__default["default"].createElement("div", {
+        className: clsx__default["default"](childClass, removableChildClass)
+      }, renderChild(x)), /*#__PURE__*/React__default["default"].createElement("div", {
+        className: removeActionClass
+      }, renderAction(removeAction(x)))) : /*#__PURE__*/React__default["default"].createElement("div", {
+        key: childKey(x),
+        className: childClass
+      }, renderChild(x));
+    })), addAction && /*#__PURE__*/React__default["default"].createElement("div", {
+      className: addActionClass
+    }, renderAction(addAction)));
+  }
+  return {
+    render: render,
+    type: "array"
+  };
+}
+function createDefaultGroupRenderer(options) {
+  var _ref8 = options != null ? options : {},
+    className = _ref8.className,
+    _ref8$gridStyles = _ref8.gridStyles,
+    gridStyles = _ref8$gridStyles === void 0 ? defaultGridStyles : _ref8$gridStyles,
+    _ref8$defaultGridColu = _ref8.defaultGridColumns,
+    defaultGridColumns = _ref8$defaultGridColu === void 0 ? 2 : _ref8$defaultGridColu,
+    gridClassName = _ref8.gridClassName,
+    standardClassName = _ref8.standardClassName;
+  function defaultGridStyles(_ref9) {
+    var _ref9$columns = _ref9.columns,
+      columns = _ref9$columns === void 0 ? defaultGridColumns : _ref9$columns;
+    return {
+      className: gridClassName,
+      style: {
+        display: "grid",
+        gridTemplateColumns: "repeat(" + columns + ", 1fr)"
+      }
+    };
+  }
+  function render(props, defaultLabel, _ref10) {
+    var renderLabel = _ref10.renderLabel,
+      renderArray = _ref10.renderArray;
+    var childCount = props.childCount,
+      renderChild = props.renderChild,
+      definition = props.definition;
+    return renderLabel(defaultLabel(), props.array ? renderArray(props.array) : renderChildren());
+    function renderChildren() {
+      var groupOptions = definition.groupOptions;
+      var _ref11 = isGridRenderer(groupOptions) ? gridStyles(groupOptions) : {
+          className: standardClassName
+        },
+        style = _ref11.style,
+        gcn = _ref11.className;
+      return /*#__PURE__*/React__default["default"].createElement("div", {
+        className: clsx__default["default"](className, gcn),
+        style: style
+      }, Array.from({
+        length: childCount
+      }, function (_, x) {
+        return renderChild(x);
+      }));
+    }
+  }
+  return {
+    type: "group",
+    render: render
+  };
+}
+function createDefaultDisplayRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function doRender(_ref12) {
+    var displayData = _ref12.definition.displayData;
+    switch (displayData.type) {
+      case exports.DisplayDataType.Text:
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: options.textClassName
+        }, displayData.text);
+      case exports.DisplayDataType.Html:
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: options.htmlClassName,
+          dangerouslySetInnerHTML: {
+            __html: displayData.html
+          }
+        });
+      default:
+        return /*#__PURE__*/React__default["default"].createElement("h1", null, "Unknown display type: ", displayData.type);
+    }
+  }
+  return {
+    render: function render(p, _ref13) {
+      var renderVisibility = _ref13.renderVisibility;
+      return renderVisibility(p.visible, doRender(p));
+    },
+    type: "display"
+  };
+}
+var DefaultBoolOptions = [{
+  name: "Yes",
+  value: true
+}, {
+  name: "No",
+  value: false
+}];
+function createDefaultDataRenderer(options) {
+  var _options$selectOption;
+  if (options === void 0) {
+    options = {};
+  }
+  var selectRenderer = createSelectRenderer((_options$selectOption = options.selectOptions) != null ? _options$selectOption : {});
+  var _optionRenderer$boole = _extends({
+      optionRenderer: selectRenderer,
+      booleanOptions: DefaultBoolOptions
+    }, options),
+    inputClass = _optionRenderer$boole.inputClass,
+    booleanOptions = _optionRenderer$boole.booleanOptions,
+    optionRenderer = _optionRenderer$boole.optionRenderer;
+  return createDataRenderer(function (props, defaultLabel, renderers) {
+    if (props.array) {
+      return renderers.renderArray(props.array);
+    }
+    var renderType = props.renderOptions.type;
+    var fieldType = props.field.type;
+    var isBool = fieldType === exports.FieldType.Bool;
+    if (booleanOptions != null && isBool && props.options == null) {
+      return renderers.renderData(_extends({}, props, {
+        options: booleanOptions
+      }));
+    }
+    if (renderType === exports.DataRenderType.Standard && hasOptions(props)) {
+      return optionRenderer.render(props, defaultLabel, renderers);
+    }
+    switch (renderType) {
+      case exports.DataRenderType.Dropdown:
+        return selectRenderer.render(props, defaultLabel, renderers);
+    }
+    var l = defaultLabel();
+    return renderers.renderLabel(l, renderType === exports.DataRenderType.Checkbox ? /*#__PURE__*/React__default["default"].createElement(core.Fcheckbox, {
+      control: props.control
+    }) : /*#__PURE__*/React__default["default"].createElement(ControlInput, {
+      className: inputClass,
+      id: l.forId,
+      readOnly: props.readonly,
+      control: props.control,
+      convert: createInputConversion(props.field.type)
+    }));
+  });
+}
+function ControlInput(_ref14) {
+  var _effect2 = core.useComponentTracking();
+  try {
+    var control = _ref14.control,
+      convert = _ref14.convert,
+      props = _objectWithoutPropertiesLoose(_ref14, _excluded);
+    var _formControlProps = core.formControlProps(control),
+      errorText = _formControlProps.errorText,
+      value = _formControlProps.value,
+      onChange = _formControlProps.onChange,
+      inputProps = _objectWithoutPropertiesLoose(_formControlProps, _excluded2);
+    return /*#__PURE__*/React__default["default"].createElement("input", _extends({}, inputProps, {
+      type: convert[0],
+      value: value == null ? "" : convert[2](value),
+      onChange: function onChange(e) {
+        control.value = convert[1](e.target.value);
+      }
+    }, props));
+  } finally {
+    _effect2();
+  }
+}
+function createDefaultAdornmentRenderer(options) {
+  return {
+    type: "adornment",
+    render: function render() {
+      return {};
+    }
+  };
+}
+function createDefaultVisibilityRenderer(options) {
+  return {
+    type: "visibility",
+    render: function render(visible, children) {
+      return visible.value ? children : /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+    }
+  };
+}
+function createDefaultRenderers(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    data: createDefaultDataRenderer(options.data),
+    display: createDefaultDisplayRenderer(options.display),
+    action: createDefaultActionRenderer(options.action),
+    array: createDefaultArrayRenderer(options.array),
+    group: createDefaultGroupRenderer(options.group),
+    label: createDefaultLabelRenderer(options.label),
+    visibility: createDefaultVisibilityRenderer(),
+    adornment: createDefaultAdornmentRenderer()
+  };
+}
+function createClassStyledRenderers() {
+  return createDefaultRenderers({
+    label: {
+      className: "control"
+    },
+    group: {
+      className: "group"
+    },
+    array: {
+      className: "control-array"
+    },
+    action: {
+      className: "action"
+    },
+    data: {
+      inputClass: "data"
+    },
+    display: {
+      htmlClassName: "html",
+      textClassName: "text"
+    }
+  });
+}
+function isAdornmentRegistration(x) {
+  return x.type === "adornment";
+}
+function isDataRegistration(x) {
+  return x.type === "data";
+}
+function isLabelRegistration(x) {
+  return x.type === "label";
+}
+function isActionRegistration(x) {
+  return x.type === "action";
+}
+function isArrayRegistration(x) {
+  return x.type === "array";
+}
+function isVisibilityRegistration(x) {
+  return x.type === "visibility";
+}
+function isOneOf(x, v) {
+  return x == null ? true : Array.isArray(x) ? x.includes(v) : v === x;
+}
+function createArrayRenderer(render, options) {
+  return _extends({
+    type: "array",
+    render: render
+  }, options);
+}
+function createDataRenderer(render, options) {
+  return _extends({
+    type: "data",
+    render: render
+  }, options);
+}
+function createDataRendererLabelled(_render, options) {
+  return _extends({
+    type: "data",
+    render: function render(props, defaultLabel, renderers) {
+      var dl = defaultLabel();
+      return renderers.renderLabel(dl, _render(props, dl.forId, renderers));
+    }
+  }, options);
+}
+function createLabelRenderer(options) {
+  return _extends({
+    type: "label"
+  }, options);
+}
+function createAdornmentRenderer(render, options) {
+  return _extends({
+    type: "adornment"
+  }, options, {
+    render: render
+  });
+}
+function createSelectRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return createDataRendererLabelled(function (props, id) {
+    return /*#__PURE__*/React__default["default"].createElement(SelectDataRenderer, {
+      className: options.className,
+      state: props.control,
+      id: id,
+      options: props.options,
+      required: props.required,
+      emptyText: options.emptyText,
+      requiredText: options.requiredText,
+      convert: createSelectConversion(props.field.type)
+    });
+  }, {
+    options: true
+  });
+}
+function SelectDataRenderer(_ref15) {
+  var _effect3 = core.useComponentTracking();
+  try {
+    var state = _ref15.state,
+      options = _ref15.options,
+      className = _ref15.className,
+      convert = _ref15.convert,
+      required = _ref15.required,
+      _ref15$emptyText = _ref15.emptyText,
+      emptyText = _ref15$emptyText === void 0 ? "N/A" : _ref15$emptyText,
+      _ref15$requiredText = _ref15.requiredText,
+      requiredText = _ref15$requiredText === void 0 ? "<please select>" : _ref15$requiredText,
+      props = _objectWithoutPropertiesLoose(_ref15, _excluded3);
+    var value = state.value,
+      disabled = state.disabled;
+    var _useState = React.useState(!required || value == null),
+      showEmpty = _useState[0];
+    var optionStringMap = React.useMemo(function () {
+      return Object.fromEntries(options.map(function (x) {
+        return [convert(x.value), x.value];
+      }));
+    }, [options]);
+    return /*#__PURE__*/React__default["default"].createElement("select", _extends({}, props, {
+      className: className,
+      onChange: function onChange(v) {
+        return state.value = optionStringMap[v.target.value];
+      },
+      value: convert(value),
+      disabled: disabled
+    }), showEmpty && /*#__PURE__*/React__default["default"].createElement("option", {
+      value: ""
+    }, required ? requiredText : emptyText), options.map(function (x, i) {
+      return /*#__PURE__*/React__default["default"].createElement("option", {
+        key: i,
+        value: convert(x.value),
+        disabled: x.disabled
+      }, x.name);
+    }));
+  } finally {
+    _effect3();
+  }
+}
+function createSelectConversion(ft) {
+  switch (ft) {
+    case exports.FieldType.String:
+    case exports.FieldType.Int:
+    case exports.FieldType.Double:
+      return function (a) {
+        return a;
+      };
+    default:
+      return function (a) {
+        var _a$toString;
+        return (_a$toString = a == null ? void 0 : a.toString()) != null ? _a$toString : "";
+      };
+  }
+}
+function createInputConversion(ft) {
+  switch (ft) {
+    case exports.FieldType.String:
+      return ["text", function (a) {
+        return a;
+      }, function (a) {
+        return a;
+      }];
+    case exports.FieldType.Bool:
+      return ["text", function (a) {
+        return a === "true";
+      }, function (a) {
+        var _a$toString2;
+        return (_a$toString2 = a == null ? void 0 : a.toString()) != null ? _a$toString2 : "";
+      }];
+    case exports.FieldType.Int:
+      return ["number", function (a) {
+        return a !== "" ? parseInt(a) : null;
+      }, function (a) {
+        return a == null ? "" : a;
+      }];
+    case exports.FieldType.Date:
+      return ["date", function (a) {
+        return a;
+      }, function (a) {
+        return a;
+      }];
+    case exports.FieldType.Double:
+      return ["number", function (a) {
+        return parseFloat(a);
+      }, function (a) {
+        return a;
+      }];
+    default:
+      return ["text", function (a) {
+        return a;
+      }, function (a) {
+        return a;
+      }];
+  }
+}
+
+var defaultTailwindTheme = {
+  label: {
+    className: "flex flex-col",
+    groupLabelClass: "font-bold",
+    requiredElement: /*#__PURE__*/React__default["default"].createElement("span", {
+      className: "text-red-500"
+    }, " *")
+  },
+  array: {
+    removableClass: "grid grid-cols-[1fr_auto] items-center gap-x-2",
+    childClass: "grow"
+  },
+  group: {
+    standardClassName: "space-y-4",
+    gridClassName: "gap-x-2 gap-y-4"
+  },
+  action: {
+    className: "bg-primary rounded-lg p-3 text-white"
+  }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./schemaBuilder"), exports);
-__exportStar(require("./controlRender"), exports);
-__exportStar(require("./hooks"), exports);
+
+exports.AlwaysVisible = AlwaysVisible;
+exports.ControlInput = ControlInput;
+exports.DefaultBoolOptions = DefaultBoolOptions;
+exports.DefaultLabelRenderer = DefaultLabelRenderer;
+exports.FormRendererProvider = FormRendererProvider;
+exports.SelectDataRenderer = SelectDataRenderer;
+exports.addMissingControls = addMissingControls;
+exports.applyDefaultForField = applyDefaultForField;
+exports.applyDefaultValues = applyDefaultValues;
+exports.boolField = boolField;
+exports.buildSchema = buildSchema;
+exports.compoundField = compoundField;
+exports.controlForField = controlForField;
+exports.controlTitle = controlTitle;
+exports.createAction = createAction;
+exports.createAdornmentRenderer = createAdornmentRenderer;
+exports.createArrayRenderer = createArrayRenderer;
+exports.createDataRenderer = createDataRenderer;
+exports.createDataRendererLabelled = createDataRendererLabelled;
+exports.createDefaultActionRenderer = createDefaultActionRenderer;
+exports.createDefaultAdornmentRenderer = createDefaultAdornmentRenderer;
+exports.createDefaultArrayRenderer = createDefaultArrayRenderer;
+exports.createDefaultDataRenderer = createDefaultDataRenderer;
+exports.createDefaultDisplayRenderer = createDefaultDisplayRenderer;
+exports.createDefaultGroupRenderer = createDefaultGroupRenderer;
+exports.createDefaultLabelRenderer = createDefaultLabelRenderer;
+exports.createDefaultRenderers = createDefaultRenderers;
+exports.createDefaultSchemaHooks = createDefaultSchemaHooks;
+exports.createDefaultVisibilityRenderer = createDefaultVisibilityRenderer;
+exports.createFormEditHooks = createFormEditHooks;
+exports.createFormRenderer = createFormRenderer;
+exports.createInputConversion = createInputConversion;
+exports.createLabelRenderer = createLabelRenderer;
+exports.createSelectConversion = createSelectConversion;
+exports.createSelectRenderer = createSelectRenderer;
+exports.dataControl = dataControl;
+exports.defaultCompoundField = defaultCompoundField;
+exports.defaultControlForField = defaultControlForField;
+exports.defaultFormEditHooks = defaultFormEditHooks;
+exports.defaultScalarField = defaultScalarField;
+exports.defaultTailwindTheme = defaultTailwindTheme;
+exports.defaultValueForField = defaultValueForField;
+exports.defaultValueForFields = defaultValueForFields;
+exports.elementValueForField = elementValueForField;
+exports.fieldDisplayName = fieldDisplayName;
+exports.fieldForControl = fieldForControl;
+exports.fieldHasTag = fieldHasTag;
+exports.fieldValueExpr = fieldValueExpr;
+exports.findCompoundField = findCompoundField;
+exports.findField = findField;
+exports.findScalarField = findScalarField;
+exports.getDefaultScalarControlProperties = getDefaultScalarControlProperties;
+exports.getOptionsForScalarField = getOptionsForScalarField;
+exports.hasOptions = hasOptions;
+exports.intField = intField;
+exports.isActionControlsDefinition = isActionControlsDefinition;
+exports.isCompoundField = isCompoundField;
+exports.isDataControl = isDataControl;
+exports.isDataControlDefinition = isDataControlDefinition;
+exports.isDisplayControlsDefinition = isDisplayControlsDefinition;
+exports.isGridRenderer = isGridRenderer;
+exports.isGroupControl = isGroupControl;
+exports.isGroupControlsDefinition = isGroupControlsDefinition;
+exports.isScalarField = isScalarField;
+exports.makeCompoundField = makeCompoundField;
+exports.makeScalarField = makeScalarField;
+exports.renderControl = renderControl;
+exports.stringField = stringField;
+exports.stringOptionsField = stringOptionsField;
+exports.useControlsWithDefaults = useControlsWithDefaults;
+exports.useDefaultValue = useDefaultValue;
+exports.useFormRendererComponents = useFormRendererComponents;
+exports.useIsControlVisible = useIsControlVisible;
+exports.visibility = visibility;
+exports.visitControlData = visitControlData;
+exports.visitControlDefinition = visitControlDefinition;
+exports.withScalarOptions = withScalarOptions;
+//# sourceMappingURL=index.js.map