@react-typed-forms/schemas 10.2.0 → 10.3.0

package/lib/index.js

@@ -313,49 +313,100 @@ function defaultControlForField(sf) {
   }
   throw "Unknown schema field";
 }
-function findReferencedControl(field, control) {
-  if (isDataControl(control) && field === control.field) return control;
-  if (isGroupControl(control)) {
-    var _control$children;
-    if (control.compoundField) return field === control.compoundField ? control : undefined;
-    return findReferencedControlInArray(field, (_control$children = control.children) != null ? _control$children : []);
-  }
-  return undefined;
+function findControlsForCompound(compound, definition) {
+  if (isDataControlDefinition(definition) && compound.field === definition.field) {
+    return [definition];
+  }
+  if (isGroupControlsDefinition(definition)) {
+    var _definition$children$, _definition$children;
+    if (definition.compoundField === compound.field) return [definition];
+    return (_definition$children$ = (_definition$children = definition.children) == null ? void 0 : _definition$children.flatMap(function (d) {
+      return findControlsForCompound(compound, d);
+    })) != null ? _definition$children$ : [];
+  }
+  return [];
+}
+function findCompoundGroups(fields, controls) {
+  return Object.fromEntries(fields.filter(isCompoundField).map(function (cf) {
+    var groups = controls.flatMap(function (x) {
+      return findControlsForCompound(cf, x);
+    });
+    return [cf.field, {
+      groups: groups.concat(findNonDataGroups(groups.flatMap(function (x) {
+        var _x$children;
+        return (_x$children = x.children) != null ? _x$children : [];
+      }))),
+      children: findCompoundGroups(cf.children, groups.flatMap(function (x) {
+        var _x$children2;
+        return (_x$children2 = x.children) != null ? _x$children2 : [];
+      }))
+    }];
+  }));
 }
-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;
+function existsInGroups(field, lookup) {
+  var itself = lookup.groups.find(function (c) {
+    var _c$children;
+    return (_c$children = c.children) == null ? void 0 : _c$children.find(function (x) {
+      return isDataControlDefinition(x) && x.field === field.field || isGroupControlsDefinition(x) && x.compoundField === field.field;
+    });
+  });
+  if (!itself) return [[field, lookup]];
+  if (isCompoundField(field)) {
+    var childLookup = lookup.children[field.field];
+    if (!childLookup) return [[field, lookup]];
+    return field.children.flatMap(function (c) {
+      return existsInGroups(c, childLookup);
+    });
   }
-  return undefined;
+  return [];
+}
+function findNonDataGroups(controls) {
+  return controls.flatMap(function (control) {
+    var _control$children2;
+    return isGroupControlsDefinition(control) && !control.compoundField ? [control].concat(findNonDataGroups((_control$children2 = control.children) != null ? _control$children2 : [])) : [];
+  });
+}
+function cloneChildren(c) {
+  var _c$children2;
+  if (c.children) return _extends({}, c, {
+    children: (_c$children2 = c.children) == null ? void 0 : _c$children2.map(cloneChildren)
+  });
+  return c;
 }
 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 [];
+  controls = controls.map(cloneChildren);
+  var rootMapping = findCompoundGroups(fields, controls);
+  var rootGroups = findNonDataGroups([{
+    type: exports.ControlDefinitionType.Group,
+    children: controls
+  }]);
+  var rootLookup = {
+    children: rootMapping,
+    groups: rootGroups
+  };
+  var missingFields = fields.filter(function (x) {
+    return !fieldHasTag(x, "_NoControl");
+  }).flatMap(function (x) {
+    return existsInGroups(x, rootLookup);
   });
-  var changedCompounds = controls.map(function (x) {
-    var _cf$children;
-    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 = cf.children) != null ? _cf$children : [])
+  missingFields.forEach(function (_ref) {
+    var _f$tags, _insertGroup;
+    var f = _ref[0],
+      lookup = _ref[1];
+    var groupToAdd = (_f$tags = f.tags) == null ? void 0 : _f$tags.find(function (x) {
+      return x.startsWith("_ControlGroup:");
     });
+    var insertGroup = undefined;
+    if (groupToAdd) {
+      var groupName = groupToAdd.substring(14);
+      insertGroup = lookup.groups.find(function (x) {
+        return x.title === groupName;
+      });
+    }
+    if (!insertGroup) insertGroup = lookup.groups[0];
+    (_insertGroup = insertGroup) == null || (_insertGroup = _insertGroup.children) == null || _insertGroup.push(defaultControlForField(f));
   });
-  return changedCompounds.concat(changes.filter(function (x) {
-    return !x.existing;
-  }).map(function (x) {
-    return defaultControlForField(x.field);
-  }));
+  return controls;
 }
 function useUpdatedRef(a) {
   var r = React.useRef(a);
@@ -472,8 +523,8 @@ function cleanDataForSchema(v, fields) {
   return out;
 }
 function getAllReferencedClasses(c, collectExtra) {
-  var _c$children, _collectExtra;
-  var childClasses = (_c$children = c.children) == null ? void 0 : _c$children.flatMap(function (x) {
+  var _c$children3, _collectExtra;
+  var childClasses = (_c$children3 = c.children) == null ? void 0 : _c$children3.flatMap(function (x) {
     return getAllReferencedClasses(x, collectExtra);
   });
   var tc = clsx__default["default"]([c.styleClass, c.layoutClass, c.labelClass].concat((_collectExtra = collectExtra == null ? void 0 : collectExtra(c)) != null ? _collectExtra : []).map(getOverrideClass));
@@ -543,8 +594,8 @@ function makeHook(runHook, state, deps) {
 }
 function useDynamicHooks(hooks) {
   var hookEntries = Object.entries(hooks);
-  var deps = hookEntries.map(function (_ref) {
-    var x = _ref[1];
+  var deps = hookEntries.map(function (_ref2) {
+    var x = _ref2[1];
     return toDepString(x.deps);
   }).join(",");
   var ref = React.useRef({});
@@ -553,9 +604,9 @@ function useDynamicHooks(hooks) {
     return s[x[0]] = x[1].state;
   });
   return React.useCallback(function (p) {
-    return Object.fromEntries(hookEntries.map(function (_ref2) {
-      var f = _ref2[0],
-        hg = _ref2[1];
+    return Object.fromEntries(hookEntries.map(function (_ref3) {
+      var f = _ref3[0],
+        hg = _ref3[1];
       return [f, hg.runHook(p, ref.current[f])];
     }));
   }, [deps]);
@@ -2670,12 +2721,16 @@ exports.dynamicReadonly = dynamicReadonly;
 exports.dynamicVisibility = dynamicVisibility;
 exports.elementValueForField = elementValueForField;
 exports.emptyGroupDefinition = emptyGroupDefinition;
+exports.existsInGroups = existsInGroups;
 exports.fieldDisplayName = fieldDisplayName;
 exports.fieldEqExpr = fieldEqExpr;
 exports.fieldHasTag = fieldHasTag;
 exports.findChildDefinition = findChildDefinition;
 exports.findCompoundField = findCompoundField;
+exports.findCompoundGroups = findCompoundGroups;
+exports.findControlsForCompound = findControlsForCompound;
 exports.findField = findField;
+exports.findNonDataGroups = findNonDataGroups;
 exports.findScalarField = findScalarField;
 exports.getAllReferencedClasses = getAllReferencedClasses;
 exports.getControlData = getControlData;