@react-typed-forms/schemas 10.4.0 → 11.0.1

package/lib/controlRender.d.ts

@@ -154,8 +154,8 @@ export interface ControlRenderOptions extends FormContextOptions {
     elementIndex?: number;
 }
 export declare function useControlRenderer(definition: ControlDefinition, fields: SchemaField[], renderer: FormRenderer, options?: ControlRenderOptions): FC<ControlRenderProps>;
-export declare function lookupSchemaField(c: ControlDefinition, fields: SchemaField[]): SchemaField | undefined;
-export declare function getControlData(schemaField: SchemaField | undefined, parentContext: ControlDataContext, elementIndex: number | undefined): [Control<any> | undefined, Control<any> | undefined, ControlDataContext];
+export declare function lookupSchemaField(c: ControlDefinition, fields: SchemaField[]): SchemaField[] | undefined;
+export declare function getControlData(fieldPath: SchemaField[] | undefined, parentContext: ControlDataContext, elementIndex: number | undefined): [Control<any>, Control<any> | undefined, ControlDataContext];
 export declare function ControlRenderer({ definition, fields, renderer, options, control, parentPath, }: {
     definition: ControlDefinition;
     fields: SchemaField[];

package/lib/hooks.d.ts

@@ -3,20 +3,21 @@ import React from "react";
 import { Control } from "@react-typed-forms/core";
 import { ControlDataContext, DataContext, DynamicHookGenerator } from "./util";
 export type EvalExpressionHook<A = any> = DynamicHookGenerator<Control<A | undefined>, ControlDataContext>;
-export type UseEvalExpressionHook = (expr: EntityExpression | undefined) => DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
-export declare function useEvalVisibilityHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, schemaField?: SchemaField): EvalExpressionHook<boolean>;
+export type UseEvalExpressionHook = (expr: EntityExpression | undefined, coerce: (v: any) => any) => DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
+export declare function useEvalVisibilityHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, fieldPath?: SchemaField[]): 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>;
 export declare function useEvalAllowedOptionsHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<any[]>;
 export declare function useEvalDisabledHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<boolean>;
 export declare function useEvalDisplayHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): DynamicHookGenerator<Control<string | undefined> | undefined, ControlDataContext>;
 export declare function useEvalDefaultValueHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, schemaField: SchemaField | undefined, element: boolean): EvalExpressionHook;
-export declare function defaultEvalHooks(expr: EntityExpression, context: ControlDataContext): Control<any>;
+export declare function defaultEvalHooks(expr: EntityExpression, context: ControlDataContext, coerce: (v: any) => any): Control<any>;
 export declare const defaultUseEvalExpressionHook: UseEvalExpressionHook;
-export declare function makeEvalExpressionHook(f: (expr: EntityExpression, context: ControlDataContext) => Control<any>): UseEvalExpressionHook;
-export declare function useEvalDynamicHook(definition: ControlDefinition, type: DynamicPropertyType, useEvalExpressionHook: UseEvalExpressionHook): DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
-export declare function matchesType(context: ControlDataContext, types?: string[] | null): boolean | undefined;
-export declare function hideDisplayOnly(context: ControlDataContext, field: SchemaField, definition: ControlDefinition, schemaInterface: SchemaInterface): boolean | undefined;
-export declare function useJsonataExpression(jExpr: string, dataContext: DataContext, bindings?: () => Record<string, any>): Control<any>;
+export declare function makeEvalExpressionHook(f: (expr: EntityExpression, context: ControlDataContext, coerce: (v: any) => any) => Control<any>): UseEvalExpressionHook;
+export declare function useEvalDynamicBoolHook(definition: ControlDefinition, type: DynamicPropertyType, useEvalExpressionHook: UseEvalExpressionHook): DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
+export declare function useEvalDynamicHook(definition: ControlDefinition, type: DynamicPropertyType, useEvalExpressionHook: UseEvalExpressionHook, coerce?: (v: any) => any): DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
+export declare function matchesType(context: ControlDataContext, fieldPath?: SchemaField[]): boolean | undefined;
+export declare function hideDisplayOnly(context: ControlDataContext, fieldPath: SchemaField[], definition: ControlDefinition, schemaInterface: SchemaInterface): boolean | undefined;
+export declare function useJsonataExpression(jExpr: string, dataContext: DataContext, bindings?: () => Record<string, any>, coerce?: (v: any) => any): Control<any>;
 export declare function useEvalActionHook(useExpr: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<string | null>;
 export declare function useEvalLabelText(useExpr: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<string | null>;

package/lib/index.js

@@ -420,11 +420,13 @@ function isControlReadonly(c) {
 function getDisplayOnlyOptions(d) {
   return isDataControlDefinition(d) && d.renderOptions && isDisplayOnlyRenderer(d.renderOptions) ? d.renderOptions : undefined;
 }
-function getTypeField(context) {
-  var typeSchemaField = context.fields.find(function (x) {
+function getTypeField(context, fieldPath) {
+  var withoutLast = fieldPath.slice(0, -1);
+  var fieldList = withoutLast.length > 0 ? withoutLast.at(-1).children : context.fields;
+  var typeSchemaField = fieldList.find(function (x) {
     return x.isTypeField;
   });
-  return typeSchemaField ? lookupChildControl(context, typeSchemaField.field) : undefined;
+  return typeSchemaField ? lookupChildControl(context, [].concat(withoutLast, [typeSchemaField])) : undefined;
 }
 function visitControlDataArray(controls, context, cb) {
   if (!controls) return undefined;
@@ -479,8 +481,13 @@ function visitControlData(definition, ctx, cb) {
     }
   }
 }
-function lookupChildControl(data, child) {
-  var childPath = [].concat(data.path, [child]);
+function lookupChildControl(data, path) {
+  return lookupChildControlPath(data, path.map(function (x) {
+    return x.field;
+  }));
+}
+function lookupChildControlPath(data, jsonPath) {
+  var childPath = [].concat(data.path, jsonPath);
   return watchControlLookup(data.data, childPath);
 }
 function cleanDataForSchema(v, fields) {
@@ -625,6 +632,21 @@ function appendElementIndex(dataContext, elementIndex) {
 function applyLengthRestrictions(length, min, max, minValue, maxValue) {
   return [min == null || length > min ? minValue : undefined, max == null || length < max ? maxValue : undefined];
 }
+function findFieldPath(fields, fieldPath) {
+  var fieldNames = fieldPath.split("/");
+  var foundFields = [];
+  var i = 0;
+  var currentFields = fields;
+  while (i < fieldNames.length && currentFields) {
+    var cf = fieldNames[i];
+    var nextField = findField(currentFields, cf);
+    if (!nextField) return undefined;
+    foundFields.push(nextField);
+    currentFields = isCompoundField(nextField) && !nextField.collection ? nextField.children : undefined;
+    i++;
+  }
+  return foundFields.length === fieldNames.length ? foundFields : undefined;
+}
 
 function buildSchema(def) {
   return Object.entries(def).map(function (x) {
@@ -885,43 +907,6 @@ function applyExtensionsToSchema(schemaMap, extensions) {
   return resolveSchemas(extensions.reduce(applyExtensionToSchema, schemaMap));
 }
 
-function useCalculatedControl(calculate) {
-  var c = core.useControl(calculate);
-  core.useControlEffect(calculate, function (v) {
-    return c.value = v;
-  });
-  return c;
-}
-function cc(n) {
-  return n ? n : undefined;
-}
-function trackedStructure(c, tracker) {
-  var cc = c.current;
-  var cv = cc.value;
-  if (cv == null) {
-    tracker(c, core.ControlChange.Structure);
-    return cv;
-  }
-  if (typeof cv !== "object") {
-    tracker(c, core.ControlChange.Value);
-    return cv;
-  }
-  return new Proxy(cv, {
-    get: function get(target, p, receiver) {
-      if (Array.isArray(cv)) {
-        tracker(c, core.ControlChange.Structure);
-        if (typeof p === "symbol" || p[0] >= "9" || p[0] < "0") return Reflect.get(cv, p);
-        var nc = cc.elements[p];
-        if (typeof nc === "function") return nc;
-        if (nc == null) return null;
-        return trackedStructure(nc, tracker);
-      }
-      if (p in cc.fields || p in cv) return trackedStructure(cc.fields[p], tracker);
-      return undefined;
-    }
-  });
-}
-
 function _finallyRethrows(body, finalizer) {
   try {
     var result = body();
@@ -933,24 +918,24 @@ function _finallyRethrows(body, finalizer) {
   }
   return finalizer(false, result);
 }
-function useEvalVisibilityHook(useEvalExpressionHook, definition, schemaField) {
-  var dynamicVisibility = useEvalDynamicHook(definition, exports.DynamicPropertyType.Visible, useEvalExpressionHook);
+function useEvalVisibilityHook(useEvalExpressionHook, definition, fieldPath) {
+  var dynamicVisibility = useEvalDynamicBoolHook(definition, exports.DynamicPropertyType.Visible, useEvalExpressionHook);
   return makeDynamicPropertyHook(dynamicVisibility, function (ctx, _ref) {
-    var schemaField = _ref.schemaField,
+    var fieldPath = _ref.fieldPath,
       definition = _ref.definition;
     return core.useComputed(function () {
-      return matchesType(ctx, schemaField == null ? void 0 : schemaField.onlyForTypes) && (!schemaField || !hideDisplayOnly(ctx, schemaField, definition, ctx.schemaInterface));
+      return matchesType(ctx, fieldPath) && (!fieldPath || !hideDisplayOnly(ctx, fieldPath, definition, ctx.schemaInterface));
     });
   }, {
-    schemaField: schemaField,
+    fieldPath: fieldPath,
     definition: definition
   });
 }
 function useEvalReadonlyHook(useEvalExpressionHook, definition) {
-  var dynamicReadonly = useEvalDynamicHook(definition, exports.DynamicPropertyType.Readonly, useEvalExpressionHook);
+  var dynamicReadonly = useEvalDynamicBoolHook(definition, exports.DynamicPropertyType.Readonly, useEvalExpressionHook);
   return makeDynamicPropertyHook(dynamicReadonly, function (ctx, _ref2) {
     var definition = _ref2.definition;
-    return useCalculatedControl(function () {
+    return core.useCalculatedControl(function () {
       return isControlReadonly(definition);
     });
   }, {
@@ -970,7 +955,7 @@ function useEvalAllowedOptionsHook(useEvalExpressionHook, definition) {
   }, undefined);
 }
 function useEvalDisabledHook(useEvalExpressionHook, definition) {
-  var dynamicDisabled = useEvalDynamicHook(definition, exports.DynamicPropertyType.Disabled, useEvalExpressionHook);
+  var dynamicDisabled = useEvalDynamicBoolHook(definition, exports.DynamicPropertyType.Disabled, useEvalExpressionHook);
   return makeDynamicPropertyHook(dynamicDisabled, function () {
     return core.useControl(false);
   }, undefined);
@@ -995,63 +980,89 @@ function useEvalDefaultValueHook(useEvalExpressionHook, definition, schemaField,
     schemaField: schemaField
   });
 }
-function useDataExpression(fvExpr, fields, data) {
-  var refField = findField(fields, fvExpr.field);
-  var otherField = refField ? lookupChildControl(data, refField.field) : undefined;
-  return useCalculatedControl(function () {
-    return otherField == null ? void 0 : otherField.value;
+function useDataExpression(fvExpr, fields, data, coerce) {
+  if (coerce === void 0) {
+    coerce = function coerce(x) {
+      return x;
+    };
+  }
+  var refField = findFieldPath(fields, fvExpr.field);
+  var otherField = refField ? lookupChildControl(data, refField) : undefined;
+  return core.useCalculatedControl(function () {
+    return coerce(otherField == null ? void 0 : otherField.value);
   });
 }
-function useDataMatchExpression(fvExpr, fields, data) {
-  var refField = findField(fields, fvExpr.field);
-  var otherField = refField ? lookupChildControl(data, refField.field) : undefined;
-  return core.useComputed(function () {
+function useDataMatchExpression(fvExpr, fields, data, coerce) {
+  if (coerce === void 0) {
+    coerce = function coerce(x) {
+      return x;
+    };
+  }
+  var refField = findFieldPath(fields, fvExpr.field);
+  var otherField = refField ? lookupChildControl(data, refField) : undefined;
+  return core.useCalculatedControl(function () {
     var fv = otherField == null ? void 0 : otherField.value;
-    return Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value;
+    return coerce(Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value);
   });
 }
-function defaultEvalHooks(expr, context) {
+function defaultEvalHooks(expr, context, coerce) {
   switch (expr.type) {
     case exports.ExpressionType.Jsonata:
-      return useJsonataExpression(expr.expression, context);
+      return useJsonataExpression(expr.expression, context, undefined, coerce);
     case exports.ExpressionType.Data:
-      return useDataExpression(expr, context.fields, context);
+      return useDataExpression(expr, context.fields, context, coerce);
     case exports.ExpressionType.DataMatch:
-      return useDataMatchExpression(expr, context.fields, context);
+      return useDataMatchExpression(expr, context.fields, context, coerce);
     default:
       return core.useControl(undefined);
   }
 }
 var defaultUseEvalExpressionHook = makeEvalExpressionHook(defaultEvalHooks);
 function makeEvalExpressionHook(f) {
-  return function (expr) {
+  return function (expr, coerce) {
     return {
       deps: expr == null ? void 0 : expr.type,
       state: expr,
       runHook: function runHook(ctx, state) {
-        return state ? f(state, ctx) : undefined;
+        return state ? f(state, ctx, coerce) : undefined;
       }
     };
   };
 }
-function useEvalDynamicHook(definition, type, useEvalExpressionHook) {
+function useEvalDynamicBoolHook(definition, type, useEvalExpressionHook) {
+  return useEvalDynamicHook(definition, type, useEvalExpressionHook, function (x) {
+    return Boolean(x);
+  });
+}
+function useEvalDynamicHook(definition, type, useEvalExpressionHook, coerce) {
   var _definition$dynamic;
+  if (coerce === void 0) {
+    coerce = function coerce(x) {
+      return x;
+    };
+  }
   var expression = (_definition$dynamic = definition.dynamic) == null ? void 0 : _definition$dynamic.find(function (x) {
     return x.type === type;
   });
-  return useEvalExpressionHook(expression == null ? void 0 : expression.expr);
+  return useEvalExpressionHook(expression == null ? void 0 : expression.expr, coerce);
 }
-function matchesType(context, types) {
+function matchesType(context, fieldPath) {
+  var types = fieldPath ? fieldPath[fieldPath.length - 1].onlyForTypes : undefined;
   if (types == null || types.length === 0) return true;
-  var typeField = getTypeField(context);
+  var typeField = getTypeField(context, fieldPath);
   return typeField && types.includes(typeField.value);
 }
-function hideDisplayOnly(context, field, definition, schemaInterface) {
+function hideDisplayOnly(context, fieldPath, definition, schemaInterface) {
   var _lookupChildControl;
   var displayOptions = getDisplayOnlyOptions(definition);
-  return displayOptions && !displayOptions.emptyText && schemaInterface.isEmptyValue(field, (_lookupChildControl = lookupChildControl(context, field.field)) == null ? void 0 : _lookupChildControl.value);
+  return displayOptions && !displayOptions.emptyText && schemaInterface.isEmptyValue(fieldPath.at(-1), (_lookupChildControl = lookupChildControl(context, fieldPath)) == null ? void 0 : _lookupChildControl.value);
 }
-function useJsonataExpression(jExpr, dataContext, bindings) {
+function useJsonataExpression(jExpr, dataContext, bindings, coerce) {
+  if (coerce === void 0) {
+    coerce = function coerce(x) {
+      return x;
+    };
+  }
   var pathString = jsonPathString(dataContext.path, function (x) {
     return "#$i[" + x + "]";
   });
@@ -1087,8 +1098,9 @@ function useJsonataExpression(jExpr, dataContext, bindings) {
           updateSubscriptions = _ref$current[1];
         var _temp = _finallyRethrows(function () {
           var bindingData = bindings ? core.collectChanges(collect, bindings) : undefined;
-          return Promise.resolve(compiledExpr.evaluate(trackedStructure(dataContext.data, collect), bindingData)).then(function (_compiledExpr$evaluat) {
-            control.value = _compiledExpr$evaluat;
+          var _coerce = coerce;
+          return Promise.resolve(compiledExpr.evaluate(core.trackedValue(dataContext.data, collect), bindingData)).then(function (_compiledExpr$evaluat) {
+            control.value = _coerce(_compiledExpr$evaluat);
           });
         }, function (_wasThrown, _result) {
           updateSubscriptions();
@@ -1150,8 +1162,8 @@ function useValidationHook(definition, field) {
       return control.setError("default", "");
     });
     core.useValidator(control, function (v) {
-      return !hidden && dd.required && (v == null || v === "" || Array.isArray(v) && v.length === 0) ? "Please enter a value" : null;
-    }, "required");
+      return !hidden && dd.required && field && schemaInterface.isEmptyValue(field, v) ? "Please enter a value" : null;
+    }, "required", undefined, [hidden, dd.required, !!field]);
     ((_dd$validators = dd.validators) != null ? _dd$validators : []).forEach(function (x, i) {
       switch (x.type) {
         case exports.ValidatorType.Length:
@@ -1224,6 +1236,10 @@ function useDateValidator(control, dv, i) {
   }, "date" + i);
 }
 
+function cc(n) {
+  return n ? n : undefined;
+}
+
 var DefaultSchemaInterface = /*#__PURE__*/function () {
   function DefaultSchemaInterface() {}
   var _proto = DefaultSchemaInterface.prototype;
@@ -1275,10 +1291,11 @@ function useControlRenderer(definition, fields, renderer, options) {
   var elementIndex = options.elementIndex;
   var schemaInterface = (_options$schemaInterf = options.schemaInterface) != null ? _options$schemaInterf : defaultSchemaInterface;
   var useExpr = (_options$useEvalExpre = options.useEvalExpressionHook) != null ? _options$useEvalExpre : defaultUseEvalExpressionHook;
-  var schemaField = lookupSchemaField(definition, fields);
+  var fieldPath = lookupSchemaField(definition, fields);
+  var schemaField = fieldPath == null ? void 0 : fieldPath.at(-1);
   var dynamicHooks = useDynamicHooks({
     defaultValueControl: useEvalDefaultValueHook(useExpr, definition, schemaField, elementIndex != null),
-    visibleControl: useEvalVisibilityHook(useExpr, definition, schemaField),
+    visibleControl: useEvalVisibilityHook(useExpr, definition, fieldPath),
     readonlyControl: useEvalReadonlyHook(useExpr, definition),
     disabledControl: useEvalDisabledHook(useExpr, definition),
     allowedOptions: useEvalAllowedOptionsHook(useExpr, definition),
@@ -1293,7 +1310,7 @@ function useControlRenderer(definition, fields, renderer, options) {
     options: options,
     definition: definition,
     fields: fields,
-    schemaField: schemaField,
+    fieldPath: fieldPath,
     elementIndex: elementIndex
   });
   var Component = React.useCallback(function (_ref) {
@@ -1307,8 +1324,9 @@ function useControlRenderer(definition, fields, renderer, options) {
         c = _r$current.definition,
         _options = _r$current.options,
         _fields = _r$current.fields,
-        _schemaField = _r$current.schemaField,
+        _fieldPath = _r$current.fieldPath,
         _elementIndex = _r$current.elementIndex;
+      var _schemaField = _fieldPath == null ? void 0 : _fieldPath.at(-1);
       var parentDataContext = {
         fields: _fields,
         schemaInterface: schemaInterface,
@@ -1343,12 +1361,12 @@ function useControlRenderer(definition, fields, renderer, options) {
           };
         });
       });
-      var _getControlData = getControlData(_schemaField, parentDataContext, _elementIndex),
+      var _getControlData = getControlData(_fieldPath, parentDataContext, _elementIndex),
         parentControl = _getControlData[0],
         control = _getControlData[1],
         controlDataContext = _getControlData[2];
       core.useControlEffect(function () {
-        return [visibility.value, defaultValueControl.value, control, isDataControlDefinition(definition) && definition.dontClearHidden, parentControl == null ? void 0 : parentControl.isNull, _options.hidden];
+        return [visibility.value, defaultValueControl.value, control, isDataControlDefinition(definition) && definition.dontClearHidden, parentControl.isNull, _options.hidden];
       }, function (_ref2) {
         var vc = _ref2[0],
           dv = _ref2[1],
@@ -1365,11 +1383,13 @@ function useControlRenderer(definition, fields, renderer, options) {
             cd.value = dv;
           }
         }
-        if (parentNull && parentControl != null && parentControl.isNull) {
-          parentControl.value = {};
+        if (parentNull) {
+          parentControl.setValue(function (x) {
+            return x != null ? x : {};
+          });
         }
       }, true);
-      var myOptions = useCalculatedControl(function () {
+      var myOptions = core.useCalculatedControl(function () {
         var _visibility$fields;
         return {
           hidden: _options.hidden || !((_visibility$fields = visibility.fields) != null && _visibility$fields.showing.value),
@@ -1384,7 +1404,7 @@ function useControlRenderer(definition, fields, renderer, options) {
       React.useEffect(function () {
         if (control && typeof myOptions.disabled === "boolean") control.disabled = myOptions.disabled;
       }, [control, myOptions.disabled]);
-      if (parentControl != null && parentControl.isNull) return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+      if (parentControl.isNull) return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
       var adornments = (_definition$adornment = (_definition$adornment2 = definition.adornments) == null ? void 0 : _definition$adornment2.map(function (x) {
         return renderer.renderAdornment({
           adornment: x
@@ -1443,20 +1463,46 @@ function useControlRenderer(definition, fields, renderer, options) {
 }
 function lookupSchemaField(c, fields) {
   var fieldName = isGroupControlsDefinition(c) ? c.compoundField : isDataControlDefinition(c) ? c.field : undefined;
-  return fieldName ? findField(fields, fieldName) : undefined;
+  return fieldName ? findFieldPath(fields, fieldName) : undefined;
 }
-function getControlData(schemaField, parentContext, elementIndex) {
-  var _parentControl$fields, _childControl$element;
+function getControlData(fieldPath, parentContext, elementIndex) {
+  var _fieldPath$slice$map, _parentControl$fields, _childControl$element;
   var data = parentContext.data,
-    path = parentContext.path;
-  var parentControl = data.lookupControl(path);
+    pp = parentContext.path;
+  var extraPath = (_fieldPath$slice$map = fieldPath == null ? void 0 : fieldPath.slice(0, -1).map(function (x) {
+    return x.field;
+  })) != null ? _fieldPath$slice$map : [];
+  var path = [].concat(pp, extraPath);
+  var schemaField = fieldPath == null ? void 0 : fieldPath.at(-1);
+  var _lookupControl = lookupControl(data, path),
+    parentControl = _lookupControl[0],
+    found = _lookupControl[1];
   var childPath = schemaField ? elementIndex != null ? [].concat(path, [schemaField.field, elementIndex]) : [].concat(path, [schemaField.field]) : path;
-  var childControl = schemaField && parentControl ? (_parentControl$fields = parentControl.fields) == null ? void 0 : _parentControl$fields[schemaField.field] : undefined;
+  var childControl = schemaField && found ? (_parentControl$fields = parentControl.fields) == null ? void 0 : _parentControl$fields[schemaField.field] : undefined;
   return [parentControl, childControl && elementIndex != null ? (_childControl$element = childControl.elements) == null ? void 0 : _childControl$element[elementIndex] : childControl, schemaField ? _extends({}, parentContext, {
     path: childPath,
     fields: isCompoundField(schemaField) ? schemaField.children : parentContext.fields
   }) : parentContext];
 }
+function lookupControl(control, path) {
+  var _base;
+  var base = control;
+  var index = 0;
+  while (index < path.length && base) {
+    control = base;
+    var childId = path[index];
+    var c = base.current;
+    if (typeof childId === "string") {
+      var _c$fields;
+      base = (_c$fields = c.fields) == null ? void 0 : _c$fields[childId];
+    } else {
+      var _c$elements;
+      base = (_c$elements = c.elements) == null ? void 0 : _c$elements[childId];
+    }
+    index++;
+  }
+  return [(_base = base) != null ? _base : control, !!base];
+}
 function ControlRenderer(_ref3) {
   var _effect = core.useComponentTracking();
   try {
@@ -2743,6 +2789,7 @@ exports.findCompoundField = findCompoundField;
 exports.findCompoundGroups = findCompoundGroups;
 exports.findControlsForCompound = findControlsForCompound;
 exports.findField = findField;
+exports.findFieldPath = findFieldPath;
 exports.findNonDataGroups = findNonDataGroups;
 exports.findScalarField = findScalarField;
 exports.getAllReferencedClasses = getAllReferencedClasses;
@@ -2774,6 +2821,7 @@ exports.jsonPathString = jsonPathString;
 exports.jsonataExpr = jsonataExpr;
 exports.layoutKeyForPlacement = layoutKeyForPlacement;
 exports.lookupChildControl = lookupChildControl;
+exports.lookupChildControlPath = lookupChildControlPath;
 exports.lookupSchemaField = lookupSchemaField;
 exports.makeCompoundField = makeCompoundField;
 exports.makeEvalExpressionHook = makeEvalExpressionHook;
@@ -2799,6 +2847,7 @@ exports.useEvalAllowedOptionsHook = useEvalAllowedOptionsHook;
 exports.useEvalDefaultValueHook = useEvalDefaultValueHook;
 exports.useEvalDisabledHook = useEvalDisabledHook;
 exports.useEvalDisplayHook = useEvalDisplayHook;
+exports.useEvalDynamicBoolHook = useEvalDynamicBoolHook;
 exports.useEvalDynamicHook = useEvalDynamicHook;
 exports.useEvalLabelText = useEvalLabelText;
 exports.useEvalReadonlyHook = useEvalReadonlyHook;
@@ -2810,6 +2859,7 @@ exports.useValidationHook = useValidationHook;
 exports.visitControlData = visitControlData;
 exports.visitControlDataArray = visitControlDataArray;
 exports.visitControlDefinition = visitControlDefinition;
+exports.watchControlLookup = watchControlLookup;
 exports.withScalarOptions = withScalarOptions;
 exports.wrapMarkup = wrapMarkup;
 exports.wrapMarkupAt = wrapMarkupAt;