@react-typed-forms/schemas 14.4.1 → 15.0.0

package/CHANGELOG.json

@@ -0,0 +1,17 @@
+{
+  "name": "@react-typed-forms/schemas",
+  "entries": [
+    {
+      "version": "15.0.0",
+      "tag": "@react-typed-forms/schemas_v15.0.0",
+      "date": "Tue, 25 Feb 2025 09:07:22 GMT",
+      "comments": {
+        "major": [
+          {
+            "comment": "Form Tree API refactor"
+          }
+        ]
+      }
+    }
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log - @react-typed-forms/schemas
+
+This log was last generated on Tue, 25 Feb 2025 09:07:22 GMT and should not be manually modified.
+
+## 15.0.0
+Tue, 25 Feb 2025 09:07:22 GMT
+
+### Breaking changes
+
+- Form Tree API refactor
+

package/jest.config.js

@@ -2,7 +2,7 @@
 export default {
   testEnvironment: "node",
   transform: {
-    "^.+.tsx?$": ["ts-jest", {}],
+    "^.+\\.tsx?$": ["ts-jest", { tsconfig: "tsconfig.test.json" }],
   },
   preset: "ts-jest",
 };

package/lib/controlBuilder.d.ts

@@ -52,7 +52,7 @@ export declare const emptyGroupDefinition: GroupedControlsDefinition;
 export declare function useControlDefinitionForSchema(sf: SchemaField[], definition?: GroupedControlsDefinition): GroupedControlsDefinition;
 export interface EditorGroup {
     parent: string;
-    group: GroupedControlsDefinition;
+    group: ControlDefinition;
 }
 export interface CustomRenderOptions {
     value: string;

package/lib/controlDefinition.d.ts

@@ -358,20 +358,20 @@ export interface FormNode {
     definition: ControlDefinition;
     tree: FormTree;
     parent?: FormNode;
-    getChildNodes(dontFollowRef?: boolean): FormNode[];
+    getChildNodes(): FormNode[];
 }
-export declare function defaultGetChildNodes(parent: FormNode, children?: ControlDefinition[] | null): FormNode[];
 export interface FormTreeLookup {
     getForm(formId: string): FormTree | undefined;
 }
-export interface FormTree extends FormTreeLookup {
-    rootNode: FormNode;
-    getChildrenForId(id: string, parent: FormNode): FormNode[];
+export declare abstract class FormTree implements FormTreeLookup {
+    abstract rootNode: FormNode;
+    abstract getByRefId(id: string): FormNode | undefined;
+    abstract addChild(parent: FormNode, control: ControlDefinition): FormNode;
+    abstract getForm(formId: string): FormTree | undefined;
+    createTempNode(id: string, definition: ControlDefinition, children?: FormNode[], parent?: FormNode): FormNode;
+    createChildNodes(parent: FormNode, definitions: ControlDefinition[] | undefined | null): FormNode[];
 }
-export declare function wrapFormNode(node: FormNode, getChildren?: (dontFollowRef?: boolean) => FormNode[]): FormNode;
-export declare function nodeForControl(definition: ControlDefinition, tree: FormTree, indexOrId?: number | string, parent?: FormNode): FormNode;
 export declare function legacyFormNode(definition: ControlDefinition): FormNode;
-export declare function createFormTreeWithRoot(createRootNode: (tree: FormTree) => FormNode, getChildrenForId: (id: string, parent: FormNode) => FormNode[], getForm?: FormTreeLookup): FormTree;
 export declare function createFormTree(controls: ControlDefinition[], getForm?: FormTreeLookup): FormTree;
 export declare function createFormLookup<A extends Record<string, ControlDefinition[]>>(formMap: A): {
     getForm(formId: keyof A): FormTree;

package/lib/hooks.d.ts

@@ -7,6 +7,7 @@ import { SchemaDataNode, SchemaInterface } from "./schemaField";
 import { EntityExpression } from "./entityExpression";
 export type EvalExpressionHook<A = any> = DynamicHookGenerator<Control<A | undefined>, ControlDataContext>;
 export type UseEvalExpressionHook = (expr: EntityExpression | undefined | null, coerce: (v: any) => any) => DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
+export declare function optionalHook(expr: EntityExpression | undefined | null, useHook: UseEvalExpressionHook, coerce: (v: any) => any): DynamicHookGenerator<Control<any> | undefined, ControlDataContext> | undefined;
 export declare function useEvalVisibilityHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, overrideDataNode?: SchemaDataNode): EvalExpressionHook<boolean>;
 export declare function useEvalReadonlyHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<boolean>;
 export declare function useEvalStyleHook(useEvalExpressionHook: UseEvalExpressionHook, property: DynamicPropertyType, definition: ControlDefinition): EvalExpressionHook<React.CSSProperties>;

package/lib/index.cjs

@@ -41,6 +41,9 @@ function _extends() {
     return n;
   }, _extends.apply(null, arguments);
 }
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
 function _objectWithoutPropertiesLoose(r, e) {
   if (null == r) return {};
   var t = {};
@@ -50,6 +53,11 @@ function _objectWithoutPropertiesLoose(r, e) {
   }
   return t;
 }
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
 function _unsupportedIterableToArray(r, a) {
   if (r) {
     if ("string" == typeof r) return _arrayLikeToArray(r, a);
@@ -451,45 +459,95 @@ function isCheckEntryClasses(options) {
       return false;
   }
 }
-function defaultGetChildNodes(parent, children) {
-  var _children$map;
-  return (_children$map = children == null ? void 0 : children.map(function (x, i) {
-    return nodeForControl(x, parent.tree, i, parent);
-  })) != null ? _children$map : [];
-}
-function wrapFormNode(node, getChildren) {
-  return _extends({}, node, {
-    getChildNodes: getChildren != null ? getChildren : function (dfr) {
-      return node.getChildNodes(dfr);
-    }
-  });
-}
-function nodeForControl(definition, tree, indexOrId, parent) {
-  return {
-    id: parent ? parent.id + "/" + indexOrId : "",
-    definition: definition,
-    tree: tree,
-    parent: parent,
-    getChildNodes: function getChildNodes(dontFollowRef) {
-      var children = this.definition.children;
-      if (!dontFollowRef && this.definition.childRefId) {
-        return this.tree.getChildrenForId(this.definition.childRefId, this);
+var FormNodeImpl = /*#__PURE__*/function () {
+  function FormNodeImpl(id, definition, tree, parent) {
+    this.id = void 0;
+    this.definition = void 0;
+    this.tree = void 0;
+    this.parent = void 0;
+    this.children = [];
+    this.id = id;
+    this.definition = definition;
+    this.tree = tree;
+    this.parent = parent;
+  }
+  var _proto = FormNodeImpl.prototype;
+  _proto.getChildNodes = function getChildNodes() {
+    return this.children;
+  };
+  return FormNodeImpl;
+}();
+var FormTree = /*#__PURE__*/function () {
+  function FormTree() {}
+  var _proto2 = FormTree.prototype;
+  _proto2.createTempNode = function createTempNode(id, definition, children, parent) {
+    var _this = this;
+    var tempNode = {
+      id: id,
+      definition: definition,
+      tree: this,
+      parent: parent,
+      getChildNodes: function getChildNodes() {
+        return children != null ? children : _this.createChildNodes(tempNode, definition.children);
       }
-      return defaultGetChildNodes(this, children);
-    }
+    };
+    return tempNode;
   };
-}
+  _proto2.createChildNodes = function createChildNodes(parent, definitions) {
+    var _definitions$map,
+      _this2 = this;
+    return (_definitions$map = definitions == null ? void 0 : definitions.map(function (x, i) {
+      return _this2.createTempNode(parent.id + "_" + i, x, undefined, parent);
+    })) != null ? _definitions$map : [];
+  };
+  return FormTree;
+}();
+var FormTreeImpl = /*#__PURE__*/function (_FormTree) {
+  function FormTreeImpl(forms) {
+    var _this3;
+    _this3 = _FormTree.call(this) || this;
+    _this3.forms = void 0;
+    _this3.controlMap = {};
+    _this3.rootNode = void 0;
+    _this3.idCount = 1;
+    _this3.forms = forms;
+    _this3.rootNode = new FormNodeImpl("", {
+      type: "Group"
+    }, _this3);
+    return _this3;
+  }
+  _inheritsLoose(FormTreeImpl, _FormTree);
+  var _proto3 = FormTreeImpl.prototype;
+  _proto3.getByRefId = function getByRefId(id) {
+    return this.controlMap[id];
+  };
+  _proto3.register = function register(node) {
+    var _this4 = this;
+    this.controlMap[node.id] = node;
+    node.getChildNodes().forEach(function (x) {
+      return _this4.register(x);
+    });
+  };
+  _proto3.addChild = function addChild(parent, control) {
+    var _control$children,
+      _this5 = this;
+    var node = new FormNodeImpl(control.id ? control.id : "c" + this.idCount++, control, this, parent);
+    (_control$children = control.children) == null || _control$children.forEach(function (x) {
+      return _this5.addChild(node, x);
+    });
+    parent.getChildNodes().push(node);
+    this.register(node);
+    return node;
+  };
+  _proto3.getForm = function getForm(formId) {
+    return this.forms.getForm(formId);
+  };
+  return FormTreeImpl;
+}(FormTree);
 function legacyFormNode(definition) {
-  return createFormLookup({
-    $legacy: [definition]
-  }).getForm("$legacy").rootNode.getChildNodes()[0];
-}
-function getControlIds(definition) {
-  var _definition$children$, _definition$children;
-  var childEntries = (_definition$children$ = (_definition$children = definition.children) == null ? void 0 : _definition$children.flatMap(getControlIds)) != null ? _definition$children$ : [];
-  return !definition.id ? childEntries : [[definition.id, definition]].concat(childEntries);
+  return createFormTree([definition]).rootNode.getChildNodes()[0];
 }
-function createFormTreeWithRoot(createRootNode, getChildrenForId, getForm) {
+function createFormTree(controls, getForm) {
   if (getForm === void 0) {
     getForm = {
       getForm: function getForm() {
@@ -497,34 +555,12 @@ function createFormTreeWithRoot(createRootNode, getChildrenForId, getForm) {
       }
     };
   }
-  var tree = _extends({}, getForm, {
-    getChildrenForId: getChildrenForId,
-    rootNode: undefined
+  var tree = new FormTreeImpl(getForm);
+  controls.forEach(function (x) {
+    return tree.addChild(tree.rootNode, x);
   });
-  tree.rootNode = createRootNode(tree);
   return tree;
 }
-function createFormTree(controls, getForm) {
-  if (getForm === void 0) {
-    getForm = {
-      getForm: function getForm() {
-        return undefined;
-      }
-    };
-  }
-  var controlMap = Object.fromEntries(controls.flatMap(getControlIds));
-  return createFormTreeWithRoot(function (tree) {
-    return nodeForControl({
-      children: controls,
-      type: exports.ControlDefinitionType.Group
-    }, tree);
-  }, function (id, parent) {
-    var _controlMap$id$childr, _controlMap$id;
-    return (_controlMap$id$childr = (_controlMap$id = controlMap[id]) == null || (_controlMap$id = _controlMap$id.children) == null ? void 0 : _controlMap$id.map(function (x, i) {
-      return nodeForControl(x, parent.tree, i, parent);
-    })) != null ? _controlMap$id$childr : [];
-  }, getForm);
-}
 function createFormLookup(formMap) {
   var lookup = {
     getForm: getForm
@@ -983,61 +1019,102 @@ function findNonDataGroups(controls) {
  * Adds missing controls to the provided control definitions based on the schema fields.
  * @param fields - The schema fields to use for adding missing controls.
  * @param controls - The control definitions to add missing controls to.
+ * @param warning - An optional function to call with warning messages.
  * @returns The control definitions with missing controls added.
  */
-function addMissingControls(fields, controls) {
-  return addMissingControlsForSchema(rootSchemaNode(fields), controls);
+function addMissingControls(fields, controls, warning) {
+  return addMissingControlsForSchema(rootSchemaNode(fields), controls, warning);
+}
+function registerSchemaEntries(formNode, parentSchema) {
+  var formToSchema = {};
+  var schemaToForm = {};
+  function register(node, parentSchema) {
+    var c = node.definition;
+    var controlPath = fieldPathForDefinition(c);
+    var dataSchema = controlPath ? schemaForFieldPath(controlPath, parentSchema) : undefined;
+    if (isGroupControl(c) && dataSchema == null) dataSchema = parentSchema;
+    if (dataSchema) {
+      var _schemaToForm$dataSch;
+      formToSchema[node.id] = dataSchema;
+      var formNodes = (_schemaToForm$dataSch = schemaToForm[dataSchema.id]) != null ? _schemaToForm$dataSch : [];
+      formNodes.push(node);
+      schemaToForm[dataSchema.id] = formNodes;
+    }
+    node.getChildNodes().forEach(function (x) {
+      var _dataSchema;
+      return register(x, (_dataSchema = dataSchema) != null ? _dataSchema : parentSchema);
+    });
+  }
+  register(formNode, parentSchema);
+  return {
+    formToSchema: formToSchema,
+    schemaToForm: schemaToForm,
+    register: register
+  };
 }
 /**
  * Adds missing controls to the provided control definitions based on the schema fields.
  * @param schema - The root schema node to use for adding missing controls.
  * @param controls - The control definitions to add missing controls to.
+ * @param warning - An optional function to call with warning messages.
  * @returns The control definitions with missing controls added.
  */
-function addMissingControlsForSchema(schema, controls) {
-  var controlMap = {};
-  var schemaControlMap = {};
-  var rootControls = controls.map(function (c) {
-    return toControlAndSchema(c, schema);
-  });
-  var rootSchema = {
-    schema: schema,
-    children: rootControls
-  };
-  addSchemaMapEntry("", rootSchema);
-  rootControls.forEach(addReferences);
-  var fields = schema.getChildNodes();
-  fields.forEach(addMissing);
-  return rootControls.map(toDefinition);
+function addMissingControlsForSchema(schema, controls, warning) {
+  var _toDefinition$childre;
+  var tree = createFormTree(controls);
+  addMissingControlsToForm(schema, tree, warning);
+  return (_toDefinition$childre = toDefinition(tree.rootNode).children) != null ? _toDefinition$childre : [];
   function toDefinition(c) {
-    var children = c.children.length ? c.children.map(toDefinition) : null;
-    return _extends({}, c.control, {
+    var children = c.getChildNodes().length ? c.getChildNodes().map(toDefinition) : null;
+    return _extends({}, c.definition, {
       children: children
     });
   }
+}
+/**
+ * Adds missing controls to the provided form tree based on the schema fields.
+ * @param schema - The root schema node to use for adding missing controls.
+ * @param tree - The form tree to add missing controls to.
+ * @param warning - An optional function to call with warning messages.
+ */
+function addMissingControlsToForm(schema, tree, warning) {
+  var _registerSchemaEntrie = registerSchemaEntries(tree.rootNode, schema),
+    formToSchema = _registerSchemaEntrie.formToSchema,
+    schemaToForm = _registerSchemaEntrie.schemaToForm,
+    register = _registerSchemaEntrie.register;
+  schema.getChildNodes().forEach(addMissing);
+  return;
   function addMissing(schemaNode) {
     if (fieldHasTag(schemaNode.field, exports.SchemaTags.NoControl)) return;
-    var existingControls = schemaControlMap[schemaNode.id];
+    var skipChildren = false;
+    var existingControls = schemaToForm[schemaNode.id];
     if (!existingControls) {
       var eligibleParents = getEligibleParents(schemaNode);
       var desiredGroup = getTagParam(schemaNode.field, exports.SchemaTags.ControlGroup);
-      var parentGroup = desiredGroup ? controlMap[desiredGroup] : undefined;
-      if (!parentGroup && desiredGroup) console.warn("No group '" + desiredGroup + "' for " + schemaNode.id);
-      if (parentGroup && eligibleParents.indexOf(parentGroup.schema.id) < 0) {
-        console.warn("Target group '" + desiredGroup + "' is not an eligible parent for '" + schemaNode.id + "'");
+      var parentGroup = desiredGroup ? tree.getByRefId(desiredGroup) : undefined;
+      if (!parentGroup && desiredGroup) warning == null || warning("No group '" + desiredGroup + "' for " + schemaNode.id);
+      if (parentGroup && eligibleParents.indexOf(formToSchema[parentGroup.id].id) < 0) {
+        warning == null || warning("Target group '" + desiredGroup + "' is not an eligible parent for '" + schemaNode.id + "'");
         parentGroup = undefined;
       }
       if (!parentGroup && eligibleParents.length) {
-        var _schemaControlMap$eli;
-        parentGroup = (_schemaControlMap$eli = schemaControlMap[eligibleParents[0]]) == null ? void 0 : _schemaControlMap$eli[0];
+        var _schemaToForm$eligibl;
+        parentGroup = (_schemaToForm$eligibl = schemaToForm[eligibleParents[0]]) == null ? void 0 : _schemaToForm$eligibl[0];
       }
       if (parentGroup) {
         var _newControl = defaultControlForField(schemaNode.field, true);
-        _newControl.field = relativePath(parentGroup.schema, schemaNode);
-        parentGroup.children.push(toControlAndSchema(_newControl, parentGroup.schema, parentGroup));
-      } else console.warn("Could not find a parent group for: " + schemaNode.id);
+        skipChildren = !!_newControl.childRefId;
+        var parentSchemaNode = formToSchema[parentGroup.id];
+        _newControl.field = relativePath(parentSchemaNode, schemaNode);
+        var newNode = tree.addChild(parentGroup, _newControl);
+        register(newNode, parentSchemaNode);
+      } else warning == null || warning("Could not find a parent group for: " + schemaNode.id);
+    } else {
+      skipChildren = existingControls.some(function (x) {
+        return x.definition.childRefId;
+      });
     }
-    schemaNode.getChildNodes(true).forEach(addMissing);
+    if (!skipChildren) schemaNode.getChildNodes(true).forEach(addMissing);
   }
   function getEligibleParents(schemaNode) {
     var eligibleParents = [];
@@ -1056,44 +1133,6 @@ function addMissingControlsForSchema(schema, controls) {
       }
     }
   }
-  function addReferences(c) {
-    c.children.forEach(addReferences);
-    if (c.control.childRefId) {
-      var ref = controlMap[c.control.childRefId];
-      if (ref) {
-        ref.children.forEach(function (x) {
-          return toControlAndSchema(x.control, c.schema, c, true);
-        });
-        return;
-      }
-      console.warn("Missing reference", c.control.childRefId);
-    }
-  }
-  function addSchemaMapEntry(schemaId, entry) {
-    if (!schemaControlMap[schemaId]) schemaControlMap[schemaId] = [];
-    schemaControlMap[schemaId].push(entry);
-  }
-  function toControlAndSchema(c, parentSchema, parentNode, dontRegister) {
-    var _c$children$map, _c$children;
-    var controlPath = fieldPathForDefinition(c);
-    var dataSchema = controlPath ? schemaForFieldPath(controlPath, parentSchema) : undefined;
-    if (isGroupControl(c) && dataSchema == null) dataSchema = parentSchema;
-    var entry = {
-      schema: dataSchema,
-      control: c,
-      children: [],
-      parent: parentNode
-    };
-    entry.children = (_c$children$map = (_c$children = c.children) == null ? void 0 : _c$children.map(function (x) {
-      var _dataSchema;
-      return toControlAndSchema(x, (_dataSchema = dataSchema) != null ? _dataSchema : parentSchema, entry, dontRegister);
-    })) != null ? _c$children$map : [];
-    if (!dontRegister && c.id) controlMap[c.id] = entry;
-    if (dataSchema) {
-      addSchemaMapEntry(dataSchema.id, entry);
-    }
-    return entry;
-  }
 }
 /**
  * Custom hook to use an updated reference.
@@ -1182,8 +1221,8 @@ function cleanDataForSchema(v, fields, removeIfDefault) {
  * @returns An array of referenced classes.
  */
 function getAllReferencedClasses(c, collectExtra) {
-  var _c$children2, _collectExtra;
-  var childClasses = (_c$children2 = c.children) == null ? void 0 : _c$children2.flatMap(function (x) {
+  var _c$children, _collectExtra;
+  var childClasses = (_c$children = c.children) == null ? void 0 : _c$children.flatMap(function (x) {
     return getAllReferencedClasses(x, collectExtra);
   });
   var go = getGroupClassOverrides(c);
@@ -1806,6 +1845,9 @@ function _finallyRethrows(body, finalizer) {
   }
   return finalizer(false, result);
 }
+function optionalHook(expr, useHook, coerce) {
+  return expr && expr.type ? useHook(expr, coerce) : undefined;
+}
 function useEvalVisibilityHook(useEvalExpressionHook, definition, overrideDataNode) {
   var dynamicVisibility = useEvalDynamicBoolHook(definition, exports.DynamicPropertyType.Visible, useEvalExpressionHook);
   return makeDynamicPropertyHook(dynamicVisibility, function (ctx, _ref) {
@@ -2446,10 +2488,11 @@ function useControlRendererComponent(controlOrFormNode, renderer, options, paren
     dataNode: dataNode,
     formNode: formNode
   });
+  if (formNode == null) debugger;
   var Component = React.useCallback(function () {
     var stopTracking = core.useComponentTracking();
     try {
-      var _options$formData, _dataNode, _definition$adornment2, _definition$adornment3, _options$adjustLayout;
+      var _options$formData, _dataNode, _definition$adornment2, _definition$adornment3, _formNode$tree$getByR, _options$adjustLayout;
       var _r$current = r.current,
         c = _r$current.definition,
         _options = _r$current.options,
@@ -2557,8 +2600,9 @@ function useControlRendererComponent(controlOrFormNode, renderer, options, paren
           formOptions: myOptions
         });
       })) != null ? _definition$adornment2 : [];
+      var otherChildNodes = definition.childRefId && ((_formNode$tree$getByR = _formNode.tree.getByRefId(definition.childRefId)) == null ? void 0 : _formNode$tree$getByR.getChildNodes());
       var labelAndChildren = renderControlLayout({
-        formNode: _formNode,
+        formNode: otherChildNodes ? _formNode.tree.createTempNode(_formNode.id, definition, otherChildNodes) : _formNode,
         definition: c,
         renderer: renderer,
         renderChild: function renderChild(k, child, options) {
@@ -3219,6 +3263,7 @@ function isArrayRegistration(x) {
 exports.AppendAdornmentPriority = AppendAdornmentPriority;
 exports.ControlRenderer = ControlRenderer;
 exports.DefaultSchemaInterface = DefaultSchemaInterface;
+exports.FormTree = FormTree;
 exports.NewControlRenderer = NewControlRenderer;
 exports.WrapAdornmentPriority = WrapAdornmentPriority;
 exports.accordionOptions = accordionOptions;
@@ -3227,6 +3272,7 @@ exports.actionHandlers = actionHandlers;
 exports.addFieldOption = addFieldOption;
 exports.addMissingControls = addMissingControls;
 exports.addMissingControlsForSchema = addMissingControlsForSchema;
+exports.addMissingControlsToForm = addMissingControlsToForm;
 exports.adornmentOptions = adornmentOptions;
 exports.appendMarkup = appendMarkup;
 exports.appendMarkupAt = appendMarkupAt;
@@ -3257,7 +3303,6 @@ exports.createDisplayRenderer = createDisplayRenderer;
 exports.createFormLookup = createFormLookup;
 exports.createFormRenderer = createFormRenderer;
 exports.createFormTree = createFormTree;
-exports.createFormTreeWithRoot = createFormTreeWithRoot;
 exports.createGroupRenderer = createGroupRenderer;
 exports.createLabelRenderer = createLabelRenderer;
 exports.createLayoutRenderer = createLayoutRenderer;
@@ -3271,7 +3316,6 @@ exports.defaultCompoundField = defaultCompoundField;
 exports.defaultControlForField = defaultControlForField;
 exports.defaultDataProps = defaultDataProps;
 exports.defaultEvalHooks = defaultEvalHooks;
-exports.defaultGetChildNodes = defaultGetChildNodes;
 exports.defaultScalarField = defaultScalarField;
 exports.defaultSchemaInterface = defaultSchemaInterface;
 exports.defaultUseEvalExpressionHook = defaultUseEvalExpressionHook;
@@ -3366,7 +3410,7 @@ exports.matchesType = matchesType;
 exports.mergeField = mergeField;
 exports.mergeFields = mergeFields;
 exports.mergeObjects = mergeObjects;
-exports.nodeForControl = nodeForControl;
+exports.optionalHook = optionalHook;
 exports.radioButtonOptions = radioButtonOptions;
 exports.relativePath = relativePath;
 exports.renderControlLayout = renderControlLayout;
@@ -3418,7 +3462,6 @@ exports.visitControlDefinition = visitControlDefinition;
 exports.visitFormData = visitFormData;
 exports.visitFormDataInContext = visitFormDataInContext;
 exports.withScalarOptions = withScalarOptions;
-exports.wrapFormNode = wrapFormNode;
 exports.wrapLayout = wrapLayout;
 exports.wrapMarkup = wrapMarkup;
 exports.wrapMarkupAt = wrapMarkupAt;