@connect-soft/form-generator 1.1.0-alpha9 → 1.1.2

package/dist/index.js

@@ -3304,7 +3304,7 @@ const ArrayFieldRenderer = /*#__PURE__*/React.memo(t0 => {
           remove: () => remove(index_0),
           move: toIndex => move(index_0, toIndex),
           fields: renderItem(index_0),
-          fieldNames: arrayField.fields.map(_temp),
+          fieldNames: arrayField.fields.map(_temp$1),
           namePrefix: `${field.name}.${index_0}`
         });
       };
@@ -3343,7 +3343,7 @@ const ArrayFieldRenderer = /*#__PURE__*/React.memo(t0 => {
   return t1;
 });
 ArrayFieldRenderer.displayName = 'ArrayFieldRenderer';
-function _temp(f) {
+function _temp$1(f) {
   return f.name;
 }
 
@@ -3404,7 +3404,10 @@ function createTemplateFields(fieldEntries) {
       return undefined;
     }
   };
-  return new Proxy({}, handler);
+  return {
+    templateFields: new Proxy({}, handler),
+    accessedFields
+  };
 }
 
 const FieldsContext = /*#__PURE__*/React.createContext(null);
@@ -3568,6 +3571,232 @@ function useFieldsContext() {
   return React.useContext(FieldsContext);
 }
 
+function isSchemaRequired(schema) {
+  return !schema.isOptional() && !schema.isNullable();
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  while (current instanceof zod.z.ZodOptional || current instanceof zod.z.ZodNullable) {
+    current = current.unwrap();
+  }
+  if (current instanceof zod.z.ZodDefault) {
+    current = current._def.innerType;
+  }
+  return current;
+}
+function getSchemaTypeName(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (unwrapped instanceof zod.z.ZodString) return 'string';
+  if (unwrapped instanceof zod.z.ZodNumber) return 'number';
+  if (unwrapped instanceof zod.z.ZodBoolean) return 'boolean';
+  if (unwrapped instanceof zod.z.ZodDate) return 'date';
+  if (unwrapped instanceof zod.z.ZodArray) return 'array';
+  if (unwrapped instanceof zod.z.ZodObject) return 'object';
+  if (unwrapped instanceof zod.z.ZodEnum) return 'enum';
+  return 'unknown';
+}
+function getCheckDef(check) {
+  var _a;
+  if ((_a = check._zod) === null || _a === void 0 ? void 0 : _a.def) {
+    const def = check._zod.def;
+    return {
+      type: def.check,
+      value: def.value,
+      minimum: def.minimum,
+      maximum: def.maximum,
+      length: def.length,
+      regex: def.pattern || def.regex,
+      format: def.format,
+      inclusive: def.inclusive
+    };
+  }
+  if (check.kind) {
+    return {
+      type: check.kind,
+      value: check.value,
+      regex: check.regex
+    };
+  }
+  return null;
+}
+function getNumberConstraints(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (!(unwrapped instanceof zod.z.ZodNumber)) {
+    return {};
+  }
+  const constraints = {};
+  const checks = unwrapped._def.checks;
+  if (checks) {
+    for (const check of checks) {
+      const def = getCheckDef(check);
+      if (!def) continue;
+      if (def.type === 'greater_than' || def.type === 'min') {
+        constraints.min = def.value;
+      } else if (def.type === 'less_than' || def.type === 'max') {
+        constraints.max = def.value;
+      } else if (def.type === 'multiple_of' || def.type === 'multipleOf') {
+        constraints.step = def.value;
+      } else if (def.type === 'number_format' && (def.format === 'safeint' || def.format === 'int')) {
+        constraints.step = 1;
+      } else if (def.type === 'int' || def.type === 'integer') {
+        constraints.step = 1;
+      }
+    }
+  }
+  return constraints;
+}
+function getStringConstraints(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (!(unwrapped instanceof zod.z.ZodString)) {
+    return {};
+  }
+  const constraints = {};
+  const checks = unwrapped._def.checks;
+  if (checks) {
+    for (const check of checks) {
+      const def = getCheckDef(check);
+      if (!def) continue;
+      if (def.type === 'min_length' && def.minimum !== undefined) {
+        constraints.minLength = def.minimum;
+      } else if (def.type === 'min' && def.value !== undefined) {
+        constraints.minLength = def.value;
+      } else if (def.type === 'max_length' && def.maximum !== undefined) {
+        constraints.maxLength = def.maximum;
+      } else if (def.type === 'max' && def.value !== undefined) {
+        constraints.maxLength = def.value;
+      } else if (def.type === 'length_equals' && def.length !== undefined) {
+        constraints.minLength = def.length;
+        constraints.maxLength = def.length;
+      } else if (def.type === 'length' && def.value !== undefined) {
+        constraints.minLength = def.value;
+        constraints.maxLength = def.value;
+      } else if (def.type === 'string_format' && def.regex) {
+        constraints.pattern = def.regex.source;
+      } else if (def.type === 'regex' && def.regex) {
+        constraints.pattern = def.regex.source;
+      }
+    }
+  }
+  return constraints;
+}
+function getDateConstraints(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (!(unwrapped instanceof zod.z.ZodDate)) {
+    return {};
+  }
+  const constraints = {};
+  const checks = unwrapped._def.checks;
+  if (checks) {
+    for (const check of checks) {
+      const def = getCheckDef(check);
+      if (!def) continue;
+      if (def.type === 'greater_than' || def.type === 'min') {
+        const value = def.value;
+        constraints.min = value instanceof Date ? value : new Date(value);
+      } else if (def.type === 'less_than' || def.type === 'max') {
+        const value = def.value;
+        constraints.max = value instanceof Date ? value : new Date(value);
+      }
+    }
+  }
+  return constraints;
+}
+function getSchemaRequirements(schema) {
+  const result = {};
+  const shape = schema.shape;
+  for (const key in shape) {
+    result[key] = isSchemaRequired(shape[key]);
+  }
+  return result;
+}
+function analyzeSchema(schema) {
+  const shape = schema.shape;
+  return Object.entries(shape).map(([name, fieldSchema]) => {
+    const type = getSchemaTypeName(fieldSchema);
+    const info = {
+      name,
+      required: isSchemaRequired(fieldSchema),
+      type,
+      schema: fieldSchema
+    };
+    if (type === 'number') {
+      const constraints = getNumberConstraints(fieldSchema);
+      if (constraints.min !== undefined) info.min = constraints.min;
+      if (constraints.max !== undefined) info.max = constraints.max;
+      if (constraints.step !== undefined) info.step = constraints.step;
+    } else if (type === 'string') {
+      const constraints = getStringConstraints(fieldSchema);
+      if (constraints.minLength !== undefined) info.minLength = constraints.minLength;
+      if (constraints.maxLength !== undefined) info.maxLength = constraints.maxLength;
+      if (constraints.pattern !== undefined) info.pattern = constraints.pattern;
+    } else if (type === 'date') {
+      const constraints = getDateConstraints(fieldSchema);
+      if (constraints.min !== undefined) info.minDate = constraints.min;
+      if (constraints.max !== undefined) info.maxDate = constraints.max;
+    }
+    return info;
+  });
+}
+function mergeSchemaRequirements(schema, fields) {
+  const requirements = getSchemaRequirements(schema);
+  return fields.map(field => {
+    const schemaRequired = requirements[field.name];
+    if (schemaRequired !== undefined) {
+      return {
+        ...field,
+        required: schemaRequired
+      };
+    }
+    return field;
+  });
+}
+function mergeSchemaConstraints(schema, fields) {
+  const fieldInfoMap = new Map();
+  analyzeSchema(schema).forEach(info => {
+    fieldInfoMap.set(info.name, info);
+  });
+  return fields.map(field => {
+    const schemaInfo = fieldInfoMap.get(field.name);
+    if (!schemaInfo) {
+      return field;
+    }
+    const merged = {
+      ...field,
+      required: schemaInfo.required
+    };
+    if (schemaInfo.type === 'number') {
+      if (schemaInfo.min !== undefined) {
+        merged.min = schemaInfo.min;
+      }
+      if (schemaInfo.max !== undefined) {
+        merged.max = schemaInfo.max;
+      }
+      if (schemaInfo.step !== undefined) {
+        merged.step = schemaInfo.step;
+      }
+    }
+    if (schemaInfo.type === 'string') {
+      if (schemaInfo.minLength !== undefined) {
+        merged.minLength = schemaInfo.minLength;
+      }
+      if (schemaInfo.maxLength !== undefined) {
+        merged.maxLength = schemaInfo.maxLength;
+      }
+      if (schemaInfo.pattern !== undefined) {
+        merged.pattern = schemaInfo.pattern;
+      }
+    }
+    if (schemaInfo.type === 'date') {
+      if (schemaInfo.minDate !== undefined) {
+        merged.min = schemaInfo.minDate.toISOString().split('T')[0];
+      }
+      if (schemaInfo.maxDate !== undefined) {
+        merged.max = schemaInfo.maxDate.toISOString().split('T')[0];
+      }
+    }
+    return merged;
+  });
+}
 function deepMerge(target, source) {
   const result = {
     ...target
@@ -3630,6 +3859,33 @@ function buildArrayItemSchema(arrayField) {
   }
   return zod.z.object(itemShape);
 }
+function setNestedShape(shape, path, validator) {
+  const parts = path.split('.');
+  if (parts.length === 1) {
+    shape[path] = validator;
+    return;
+  }
+  const [head, ...rest] = parts;
+  const nestedPath = rest.join('.');
+  const existingNested = shape[head];
+  const nestedShape = existingNested ? {
+    ...existingNested.shape
+  } : {};
+  setNestedShape(nestedShape, nestedPath, validator);
+  shape[head] = zod.z.object(nestedShape);
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split('.');
+  if (parts.length === 1) {
+    obj[path] = value;
+    return;
+  }
+  const [head, ...rest] = parts;
+  if (!(head in obj) || typeof obj[head] !== 'object' || obj[head] === null) {
+    obj[head] = {};
+  }
+  setNestedValue(obj[head], rest.join('.'), value);
+}
 function buildSchema(fields) {
   const shape = {};
   for (const field of fields) {
@@ -3641,10 +3897,10 @@ function buildSchema(fields) {
       if (field.maxItems !== undefined) {
         arraySchema = arraySchema.max(field.maxItems);
       }
-      shape[field.name] = arraySchema;
+      setNestedShape(shape, field.name, arraySchema);
     } else {
       const validator = getValidatorForField(field);
-      shape[field.name] = field.required ? validator : validator.optional();
+      setNestedShape(shape, field.name, field.required ? validator : validator.optional());
     }
   }
   return zod.z.object(shape);
@@ -3672,12 +3928,84 @@ function buildDefaultValues(fields) {
         values[field.name] = [];
       }
     } else {
-      values[field.name] = (_a = field.defaultValue) !== null && _a !== void 0 ? _a : '';
+      setNestedValue(values, field.name, (_a = field.defaultValue) !== null && _a !== void 0 ? _a : '');
     }
   }
   return values;
 }
 
+const TemplateFieldContext = /*#__PURE__*/React.createContext(null);
+function TemplateFieldProvider({
+  children,
+  fieldEntries,
+  accessedFields
+}) {
+  return jsxRuntime.jsx(TemplateFieldContext.Provider, {
+    value: {
+      fieldEntries,
+      accessedFields
+    },
+    children: children
+  });
+}
+function useTemplateField(name) {
+  const $ = compilerRuntime.c(3);
+  const context = React.useContext(TemplateFieldContext);
+  if (!context) {
+    throw new Error("useTemplateField must be used within FormGenerator with a custom layout (children render function).");
+  }
+  const {
+    fieldEntries,
+    accessedFields
+  } = context;
+  let t0;
+  if ($[0] !== fieldEntries || $[1] !== name) {
+    t0 = fieldEntries.get(name);
+    $[0] = fieldEntries;
+    $[1] = name;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const entry = t0;
+  if (entry) {
+    accessedFields.add(name);
+    return entry.element;
+  }
+}
+function RemainingFields() {
+  const $ = compilerRuntime.c(3);
+  const context = React.useContext(TemplateFieldContext);
+  if (!context) {
+    throw new Error("RemainingFields must be used within FormGenerator with a custom layout (children render function).");
+  }
+  const {
+    fieldEntries,
+    accessedFields
+  } = context;
+  let t0;
+  if ($[0] !== accessedFields || $[1] !== fieldEntries) {
+    const remaining = Array.from(fieldEntries.entries()).filter(t1 => {
+      const [name] = t1;
+      return !accessedFields.has(name);
+    }).map(_temp);
+    t0 = jsxRuntime.jsx(jsxRuntime.Fragment, {
+      children: remaining
+    });
+    $[0] = accessedFields;
+    $[1] = fieldEntries;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function _temp(t0) {
+  const [, entry] = t0;
+  return entry.element;
+}
+RemainingFields.displayName = 'RemainingFields';
+
 function FormGenerator(props) {
   const {
     fields,
@@ -3717,17 +4045,31 @@ function FormGenerator(props) {
     mode
   });
   const handleSubmit = form.handleSubmit(async data => {
-    await onSubmit(data);
+    const context = {
+      isDirty: form.formState.isDirty,
+      dirtyFields: form.formState.dirtyFields,
+      isValid: form.formState.isValid,
+      errors: form.formState.errors,
+      touchedFields: form.formState.touchedFields,
+      isSubmitting: form.formState.isSubmitting,
+      submitCount: form.formState.submitCount,
+      defaultValues: mergedDefaultValues,
+      form: form
+    };
+    await onSubmit(data, context);
   });
   const handleReset = React.useCallback(() => {
     form.reset(mergedDefaultValues);
   }, [form, mergedDefaultValues]);
   React.useImperativeHandle(ref, () => ({
-    setValues: values => {
+    setValues: (values, options_0) => {
+      var _a, _b;
+      const shouldDirty = (_a = options_0 === null || options_0 === void 0 ? void 0 : options_0.shouldDirty) !== null && _a !== void 0 ? _a : true;
+      const shouldValidate = (_b = options_0 === null || options_0 === void 0 ? void 0 : options_0.shouldValidate) !== null && _b !== void 0 ? _b : true;
       Object.entries(values).forEach(([key, value]) => {
         form.setValue(key, value, {
-          shouldValidate: true,
-          shouldDirty: true
+          shouldValidate,
+          shouldDirty
         });
       });
     },
@@ -3739,6 +4081,12 @@ function FormGenerator(props) {
         form.reset(mergedDefaultValues);
       }
     },
+    setDefaultValues: values_1 => {
+      const newDefaults = deepMerge(mergedDefaultValues, values_1);
+      form.reset(newDefaults, {
+        keepDirtyValues: false
+      });
+    },
     submit: async () => {
       await handleSubmit();
     },
@@ -3790,7 +4138,10 @@ function FormGenerator(props) {
     });
     return entries;
   }, [regularFields, FieldWrapper]);
-  const templateFields = React.useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
+  const {
+    templateFields,
+    accessedFields
+  } = React.useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
   const buttons = React.useMemo(() => {
     const result = {
       submit: jsxRuntime.jsx(SubmitButton, {
@@ -3809,10 +4160,10 @@ function FormGenerator(props) {
     }
     return result;
   }, [SubmitButton, disabled, form.formState.isSubmitting, submitText, showReset, resetText, handleReset]);
-  const renderField = React.useCallback((field_1, options_0) => {
+  const renderField = React.useCallback((field_1, options_1) => {
     return jsxRuntime.jsx(FieldRenderer, {
       field: field_1,
-      namePrefix: options_0 === null || options_0 === void 0 ? void 0 : options_0.namePrefix
+      namePrefix: options_1 === null || options_1 === void 0 ? void 0 : options_1.namePrefix
     });
   }, []);
   if (!children) {
@@ -3870,11 +4221,15 @@ function FormGenerator(props) {
     ...form,
     children: jsxRuntime.jsx(FieldsProvider, {
       fields: fields,
-      children: jsxRuntime.jsx("form", {
-        ref: formRef,
-        onSubmit: handleSubmit,
-        className: className,
-        children: renderFn(renderProps)
+      children: jsxRuntime.jsx(TemplateFieldProvider, {
+        fieldEntries: fieldEntries,
+        accessedFields: accessedFields,
+        children: jsxRuntime.jsx("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: renderFn(renderProps)
+        })
       })
     })
   });
@@ -3905,6 +4260,12 @@ function StrictFormGenerator(props) {
     validateTypes
   } = props;
   const formRef = React.useRef(null);
+  const fieldsWithRequirements = React.useMemo(() => {
+    if (schema && typeof schema === 'object' && 'shape' in schema) {
+      return mergeSchemaConstraints(schema, fields);
+    }
+    return fields;
+  }, [schema, fields]);
   React.useMemo(() => {
     if (validateTypes) {
       const registeredTypes = getRegisteredFieldTypes();
@@ -3912,30 +4273,44 @@ function StrictFormGenerator(props) {
         throwOnError: false,
         warn: true
       };
-      validateFieldTypes(fields, registeredTypes, options);
+      validateFieldTypes(fieldsWithRequirements, registeredTypes, options);
     }
-  }, [fields, validateTypes]);
+  }, [fieldsWithRequirements, validateTypes]);
   const mergedDefaultValues = React.useMemo(() => {
-    const builtDefaults = buildDefaultValues(fields);
+    const builtDefaults = buildDefaultValues(fieldsWithRequirements);
     return defaultValues ? deepMerge(builtDefaults, defaultValues) : builtDefaults;
-  }, [fields, defaultValues]);
+  }, [fieldsWithRequirements, defaultValues]);
   const form = useForm({
     resolver: a(schema),
     defaultValues: mergedDefaultValues,
     mode
   });
   const handleSubmit = form.handleSubmit(async data => {
-    await onSubmit(data);
+    const context = {
+      isDirty: form.formState.isDirty,
+      dirtyFields: form.formState.dirtyFields,
+      isValid: form.formState.isValid,
+      errors: form.formState.errors,
+      touchedFields: form.formState.touchedFields,
+      isSubmitting: form.formState.isSubmitting,
+      submitCount: form.formState.submitCount,
+      defaultValues: mergedDefaultValues,
+      form: form
+    };
+    await onSubmit(data, context);
   });
   const handleReset = React.useCallback(() => {
     form.reset(mergedDefaultValues);
   }, [form, mergedDefaultValues]);
   React.useImperativeHandle(ref, () => ({
-    setValues: values => {
+    setValues: (values, options_0) => {
+      var _a, _b;
+      const shouldDirty = (_a = options_0 === null || options_0 === void 0 ? void 0 : options_0.shouldDirty) !== null && _a !== void 0 ? _a : true;
+      const shouldValidate = (_b = options_0 === null || options_0 === void 0 ? void 0 : options_0.shouldValidate) !== null && _b !== void 0 ? _b : true;
       Object.entries(values).forEach(([key, value]) => {
         form.setValue(key, value, {
-          shouldValidate: true,
-          shouldDirty: true
+          shouldValidate,
+          shouldDirty
         });
       });
     },
@@ -3947,6 +4322,12 @@ function StrictFormGenerator(props) {
         form.reset(mergedDefaultValues);
       }
     },
+    setDefaultValues: values_1 => {
+      const newDefaults = deepMerge(mergedDefaultValues, values_1);
+      form.reset(newDefaults, {
+        keepDirtyValues: false
+      });
+    },
     submit: async () => {
       await handleSubmit();
     },
@@ -3965,7 +4346,7 @@ function StrictFormGenerator(props) {
   } = React.useMemo(() => {
     const regular = [];
     const arrays = [];
-    fields.forEach(field => {
+    fieldsWithRequirements.forEach(field => {
       if (isArrayField(field)) {
         arrays.push(field);
       } else {
@@ -3976,7 +4357,7 @@ function StrictFormGenerator(props) {
       regularFields: regular,
       arrayFields: arrays
     };
-  }, [fields]);
+  }, [fieldsWithRequirements]);
   const fieldEntries = React.useMemo(() => {
     const entries = new Map();
     regularFields.forEach((field_0, index) => {
@@ -3998,7 +4379,10 @@ function StrictFormGenerator(props) {
     });
     return entries;
   }, [regularFields, FieldWrapper]);
-  const templateFields = React.useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
+  const {
+    templateFields,
+    accessedFields
+  } = React.useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
   const buttons = React.useMemo(() => {
     const result = {
       submit: jsxRuntime.jsx(SubmitButton, {
@@ -4017,17 +4401,17 @@ function StrictFormGenerator(props) {
     }
     return result;
   }, [SubmitButton, disabled, form.formState.isSubmitting, submitText, showReset, resetText, handleReset]);
-  const renderField = React.useCallback((field_1, options_0) => {
+  const renderField = React.useCallback((field_1, options_1) => {
     return jsxRuntime.jsx(FieldRenderer, {
       field: field_1,
-      namePrefix: options_0 === null || options_0 === void 0 ? void 0 : options_0.namePrefix
+      namePrefix: options_1 === null || options_1 === void 0 ? void 0 : options_1.namePrefix
     });
   }, []);
   if (!children) {
     return jsxRuntime.jsx(FormProvider, {
       ...form,
       children: jsxRuntime.jsx(FieldsProvider, {
-        fields: fields,
+        fields: fieldsWithRequirements,
         children: jsxRuntime.jsxs("form", {
           ref: formRef,
           onSubmit: handleSubmit,
@@ -4077,12 +4461,16 @@ function StrictFormGenerator(props) {
   return jsxRuntime.jsx(FormProvider, {
     ...form,
     children: jsxRuntime.jsx(FieldsProvider, {
-      fields: fields,
-      children: jsxRuntime.jsx("form", {
-        ref: formRef,
-        onSubmit: handleSubmit,
-        className: className,
-        children: renderFn(renderProps)
+      fields: fieldsWithRequirements,
+      children: jsxRuntime.jsx(TemplateFieldProvider, {
+        fieldEntries: fieldEntries,
+        accessedFields: accessedFields,
+        children: jsxRuntime.jsx("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: renderFn(renderProps)
+        })
       })
     })
   });
@@ -4101,20 +4489,30 @@ exports.FieldRenderer = FieldRenderer;
 exports.FieldsProvider = FieldsProvider;
 exports.FormGenerator = FormGenerator;
 exports.FormProvider = FormProvider;
+exports.RemainingFields = RemainingFields;
 exports.StrictFormGenerator = StrictFormGenerator;
+exports.analyzeSchema = analyzeSchema;
 exports.clearAllRegistries = clearAllRegistries;
 exports.clearFieldRegistry = clearFieldRegistry;
 exports.clearFormComponentRegistry = clearFormComponentRegistry;
 exports.createArrayField = createArrayField;
 exports.createField = createField;
 exports.createFieldFactory = createFieldFactory;
+exports.getDateConstraints = getDateConstraints;
 exports.getFieldComponent = getFieldComponent;
 exports.getFormComponent = getFormComponent;
 exports.getFormComponents = getFormComponents;
+exports.getNumberConstraints = getNumberConstraints;
 exports.getRegisteredFieldTypes = getRegisteredFieldTypes;
+exports.getSchemaRequirements = getSchemaRequirements;
+exports.getSchemaTypeName = getSchemaTypeName;
+exports.getStringConstraints = getStringConstraints;
 exports.hasFieldType = hasFieldType;
 exports.hasFormComponent = hasFormComponent;
 exports.isArrayField = isArrayField;
+exports.isSchemaRequired = isSchemaRequired;
+exports.mergeSchemaConstraints = mergeSchemaConstraints;
+exports.mergeSchemaRequirements = mergeSchemaRequirements;
 exports.registerField = registerField;
 exports.registerFields = registerFields;
 exports.registerFormComponent = registerFormComponent;
@@ -4124,12 +4522,14 @@ exports.strictFields = strictFields;
 exports.typedField = typedField;
 exports.typedFields = typedFields;
 exports.unregisterField = unregisterField;
+exports.unwrapSchema = unwrapSchema;
 exports.useArrayField = useArrayField;
 exports.useFieldArray = useFieldArray;
 exports.useFieldProps = useFieldProps;
 exports.useFieldsContext = useFieldsContext;
 exports.useForm = useForm;
 exports.useFormContext = useFormContext;
+exports.useTemplateField = useTemplateField;
 exports.useWatch = useWatch;
 exports.validateFieldType = validateFieldType;
 exports.validateFieldTypes = validateFieldTypes;