@react-typed-forms/schemas 1.0.0-dev.15 → 1.0.0-dev.17

package/lib/index.js

@@ -1,31 +1,618 @@
-"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]; } };
+var React = require('react');
+var core = require('@react-typed-forms/core');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+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];
+        }
+      }
     }
-    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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldDisplayName = exports.fieldHasTag = void 0;
-__exportStar(require("./types"), exports);
-__exportStar(require("./schemaBuilder"), exports);
-__exportStar(require("./controlRender"), exports);
-__exportStar(require("./hooks"), exports);
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+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.ControlAdornmentType = void 0;
+(function (ControlAdornmentType) {
+  ControlAdornmentType["Tooltip"] = "Tooltip";
+  ControlAdornmentType["Accordion"] = "Accordion";
+})(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";
+})(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 = {}));
+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 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 fieldHasTag(field, tag) {
-    var _a;
-    return Boolean((_a = field.tags) === null || _a === void 0 ? void 0 : _a.includes(tag));
+  var _field$tags;
+  return Boolean((_field$tags = field.tags) == null ? void 0 : _field$tags.includes(tag));
 }
-exports.fieldHasTag = fieldHasTag;
 function fieldDisplayName(field) {
-    var _a;
-    return (_a = field.displayName) !== null && _a !== void 0 ? _a : field.field;
+  var _field$displayName;
+  return (_field$displayName = field.displayName) != null ? _field$displayName : field.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 isScalarField(sf) {
+  return !isCompoundField(sf);
+}
+function isCompoundField(sf) {
+  return sf.type === exports.FieldType.Compound;
+}
+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 controlTitle(title, field) {
+  return title ? title : fieldDisplayName(field);
+}
+function renderControl(definition, formState, hooks, key, wrapChild) {
+  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", null, "No schema field for: ", def.field);
+      return /*#__PURE__*/React__default["default"].createElement(DataRenderer, {
+        key: key,
+        wrapElem: wrapElem,
+        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,
+        wrapElem: wrapElem
+      });
+    },
+    action: function action(d) {
+      return /*#__PURE__*/React__default["default"].createElement(ActionRenderer, {
+        key: key,
+        hooks: hooks,
+        formState: formState,
+        wrapElem: wrapElem,
+        actionDef: d
+      });
+    },
+    display: function display(d) {
+      return /*#__PURE__*/React__default["default"].createElement(DisplayRenderer, {
+        key: key,
+        hooks: hooks,
+        formState: formState,
+        wrapElem: wrapElem,
+        displayDef: d
+      });
+    }
+  }, function () {
+    return /*#__PURE__*/React__default["default"].createElement("h1", null, "Unknown control: ", definition.type);
+  });
+  function wrapElem(e) {
+    var _wrapChild;
+    return (_wrapChild = wrapChild == null ? void 0 : wrapChild(key, e)) != null ? _wrapChild : e;
+  }
+}
+/** @trackControls */
+function DataRenderer(_ref2) {
+  var _effect2 = core.useComponentTracking();
+  try {
+    var _props$customRender;
+    var hooks = _ref2.hooks,
+      formState = _ref2.formState,
+      controlDef = _ref2.controlDef,
+      wrapElem = _ref2.wrapElem,
+      fieldData = _ref2.fieldData;
+    var renderer = useFormRendererComponents();
+    var props = hooks.useDataProperties(formState, controlDef, fieldData);
+    var scalarProps = {
+      formEditState: formState,
+      field: fieldData,
+      definition: controlDef,
+      properties: props
+    };
+    return wrapElem(((_props$customRender = props.customRender) != null ? _props$customRender : renderer.renderData)(scalarProps, props.control, false, renderer));
+  } finally {
+    _effect2();
+  }
+}
+/** @trackControls */ /** @trackControls */
+function ActionRenderer(_ref3) {
+  var _effect3 = core.useComponentTracking();
+  try {
+    var hooks = _ref3.hooks,
+      formState = _ref3.formState,
+      wrapElem = _ref3.wrapElem,
+      actionDef = _ref3.actionDef;
+    var _useFormRendererCompo = useFormRendererComponents(),
+      renderAction = _useFormRendererCompo.renderAction;
+    var actionControlProperties = hooks.useActionProperties(formState, actionDef);
+    return wrapElem(renderAction({
+      definition: actionDef,
+      properties: actionControlProperties
+    }));
+  } finally {
+    _effect3();
+  }
+}
+/** @trackControls */ /** @trackControls */
+function GroupRenderer(_ref4) {
+  var _effect4 = core.useComponentTracking();
+  try {
+    var hooks = _ref4.hooks,
+      formState = _ref4.formState,
+      groupDef = _ref4.groupDef,
+      wrapElem = _ref4.wrapElem;
+    var renderers = useFormRendererComponents();
+    var groupProps = hooks.useGroupProperties(formState, groupDef, hooks);
+    var compoundField = groupDef.compoundField ? findCompoundField(formState.fields, groupDef.compoundField) : undefined;
+    if (compoundField) {
+      return wrapElem(renderers.renderCompound({
+        definition: groupDef,
+        field: compoundField,
+        properties: groupProps,
+        renderChild: function renderChild(k, c, data, wrapChild) {
+          return renderControl(c, _extends({}, formState, {
+            fields: compoundField.children,
+            data: data
+          }), groupProps.hooks, k, wrapChild);
+        }
+      }, formState.data.fields[compoundField.field], renderers));
+    }
+    return wrapElem(renderers.renderGroup({
+      definition: groupDef,
+      childCount: groupDef.children.length,
+      properties: groupProps,
+      renderChild: function renderChild(c, wrapChild) {
+        return renderControl(groupDef.children[c], formState, groupProps.hooks, c, wrapChild);
+      }
+    }));
+  } finally {
+    _effect4();
+  }
+}
+/** @trackControls */ /** @trackControls */
+function DisplayRenderer(_ref5) {
+  var _effect5 = core.useComponentTracking();
+  try {
+    var hooks = _ref5.hooks,
+      wrapElem = _ref5.wrapElem,
+      formState = _ref5.formState,
+      displayDef = _ref5.displayDef;
+    var _useFormRendererCompo2 = useFormRendererComponents(),
+      renderDisplay = _useFormRendererCompo2.renderDisplay;
+    var displayProps = hooks.useDisplayProperties(formState, displayDef);
+    return wrapElem(renderDisplay({
+      definition: displayDef,
+      properties: 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;
+}
+function isDataControl(c) {
+  return c.type === exports.ControlDefinitionType.Data;
+}
+function isGroupControl(c) {
+  return c.type === exports.ControlDefinitionType.Group;
+}
+
+function useDefaultValue(definition, field, formState, useExpression) {
+  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 useExpression(valueExpression.expr, formState);
+  }
+  return field.defaultValue;
+}
+function useIsControlVisible(definition, formState, useExpression) {
+  var _definition$dynamic2, _ref2;
+  var visibleExpression = (_definition$dynamic2 = definition.dynamic) == null ? void 0 : _definition$dynamic2.find(function (x) {
+    return x.type === exports.DynamicPropertyType.Visible;
+  });
+  if (visibleExpression && visibleExpression.expr) {
+    return Boolean(useExpression(visibleExpression.expr, formState));
+  }
+  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;
+  return (!compoundField || compoundField.value != null) && (!onlyForTypes || onlyForTypes.length === 0 || Boolean(typeControl.value && onlyForTypes.includes(typeControl.value)));
+}
+function getDefaultScalarControlProperties(definition, field, visible, defaultValue, control, readonly) {
+  var _definition$required, _ref3;
+  return {
+    defaultValue: defaultValue,
+    options: getOptionsForScalarField(field),
+    required: (_definition$required = definition.required) != null ? _definition$required : false,
+    visible: visible,
+    readonly: (_ref3 = readonly != null ? readonly : definition.readonly) != null ? _ref3 : false,
+    control: control
+  };
+}
+function getOptionsForScalarField(field) {
+  var _field$options, _field$restrictions, _opts$length;
+  var opts = (_field$options = field.options) != null ? _field$options : (_field$restrictions = field.restrictions) == null ? void 0 : _field$restrictions.options;
+  if ((_opts$length = opts == null ? void 0 : opts.length) != null ? _opts$length : 0 > 0) {
+    return opts;
+  }
+  return undefined;
+}
+var defaultExpressionHook = function defaultExpressionHook(expr, formState) {
+  switch (expr.type) {
+    case exports.ExpressionType.FieldValue:
+      var fvExpr = expr;
+      return controlForField(fvExpr.field, formState).value === fvExpr.value;
+    default:
+      return undefined;
+  }
+};
+function createFormEditHooks(useExpression) {
+  return {
+    useExpression: useExpression,
+    useDataProperties: function useDataProperties(formState, definition, field) {
+      var visible = useIsControlVisible(definition, formState, useExpression);
+      var defaultValue = useDefaultValue(definition, field, formState, useExpression);
+      var scalarControl = formState.data.fields[field.field];
+      React.useEffect(function () {
+        if (!visible) scalarControl.value = null;else if (scalarControl.current.value == null) {
+          scalarControl.value = defaultValue;
+        }
+      }, [visible, defaultValue]);
+      return getDefaultScalarControlProperties(definition, field, visible, defaultValue, scalarControl, formState.readonly);
+    },
+    useDisplayProperties: function useDisplayProperties(fs, definition) {
+      var visible = useIsControlVisible(definition, fs, useExpression);
+      return {
+        visible: visible
+      };
+    },
+    useGroupProperties: function useGroupProperties(fs, definition, hooks) {
+      var visible = useIsControlVisible(definition, fs, useExpression);
+      return {
+        visible: visible,
+        hooks: hooks
+      };
+    },
+    useActionProperties: function useActionProperties(formState, definition) {
+      var visible = useIsControlVisible(definition, formState, useExpression);
+      return {
+        visible: visible,
+        onClick: function onClick() {}
+      };
+    }
+  };
+}
+
+exports.FormRendererProvider = FormRendererProvider;
+exports.applyDefaultForField = applyDefaultForField;
+exports.applyDefaultValues = applyDefaultValues;
+exports.boolField = boolField;
+exports.buildSchema = buildSchema;
+exports.compoundField = compoundField;
+exports.controlForField = controlForField;
+exports.controlTitle = controlTitle;
+exports.createFormEditHooks = createFormEditHooks;
+exports.dataControl = dataControl;
+exports.defaultCompoundField = defaultCompoundField;
+exports.defaultExpressionHook = defaultExpressionHook;
+exports.defaultScalarField = defaultScalarField;
+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.intField = intField;
+exports.isActionControlsDefinition = isActionControlsDefinition;
+exports.isCompoundField = isCompoundField;
+exports.isDataControl = isDataControl;
+exports.isDataControlDefinition = isDataControlDefinition;
+exports.isDisplayControlsDefinition = isDisplayControlsDefinition;
+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.useDefaultValue = useDefaultValue;
+exports.useFormRendererComponents = useFormRendererComponents;
+exports.useIsControlVisible = useIsControlVisible;
+exports.visibility = visibility;
+exports.visitControlDefinition = visitControlDefinition;
+exports.withScalarOptions = withScalarOptions;
+//# sourceMappingURL=index.js.map