@connect-soft/form-generator 1.1.0-alpha8 → 1.1.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
-import React, { createElement, Fragment, memo, useCallback, useMemo, useRef, useImperativeHandle } from 'react';
+import React, { createElement, Fragment, memo, useCallback, useContext, createContext, useRef, useMemo, useImperativeHandle } from 'react';
 import * as n$1 from 'zod/v4/core';
 import { c } from 'react/compiler-runtime';
 import { z } from 'zod';
@@ -3284,7 +3284,7 @@ const ArrayFieldRenderer = /*#__PURE__*/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}`
         });
       };
@@ -3323,7 +3323,7 @@ const ArrayFieldRenderer = /*#__PURE__*/memo(t0 => {
   return t1;
 });
 ArrayFieldRenderer.displayName = 'ArrayFieldRenderer';
-function _temp(f) {
+function _temp$1(f) {
   return f.name;
 }
 
@@ -3384,9 +3384,399 @@ function createTemplateFields(fieldEntries) {
       return undefined;
     }
   };
-  return new Proxy({}, handler);
+  return {
+    templateFields: new Proxy({}, handler),
+    accessedFields
+  };
 }
 
+const FieldsContext = /*#__PURE__*/createContext(null);
+function FieldsProvider(t0) {
+  const $ = c(9);
+  const {
+    children,
+    fields,
+    namePrefix
+  } = t0;
+  let map;
+  if ($[0] !== fields || $[1] !== namePrefix) {
+    map = new Map();
+    const addFields = (items, prefix) => {
+      items.forEach(item => {
+        if ("fields" in item && Array.isArray(item.fields)) {
+          const arrayPrefix = prefix ? `${prefix}.${item.name}` : item.name;
+          addFields(item.fields, arrayPrefix);
+        } else {
+          const fieldName = prefix ? `${prefix}.${item.name}` : item.name;
+          map.set(fieldName, item);
+          if (prefix) {
+            map.set(item.name, item);
+          }
+        }
+      });
+    };
+    addFields(fields, namePrefix);
+    $[0] = fields;
+    $[1] = namePrefix;
+    $[2] = map;
+  } else {
+    map = $[2];
+  }
+  const fieldsMap = map;
+  let t1;
+  if ($[3] !== fieldsMap || $[4] !== namePrefix) {
+    t1 = {
+      fields: fieldsMap,
+      namePrefix
+    };
+    $[3] = fieldsMap;
+    $[4] = namePrefix;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const value = t1;
+  let t2;
+  if ($[6] !== children || $[7] !== value) {
+    t2 = jsx(FieldsContext.Provider, {
+      value,
+      children
+    });
+    $[6] = children;
+    $[7] = value;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  return t2;
+}
+function useFieldProps(name) {
+  const $ = c(23);
+  const context = useContext(FieldsContext);
+  const form = useFormContext();
+  if (!context) {
+    throw new Error("useFieldProps must be used within FormGenerator or FieldsProvider");
+  }
+  if (!form) {
+    throw new Error("useFieldProps must be used within a FormProvider context");
+  }
+  const {
+    fields,
+    namePrefix
+  } = context;
+  const fullName = namePrefix ? `${namePrefix}.${name}` : name;
+  let t0;
+  if ($[0] !== fields || $[1] !== fullName || $[2] !== name) {
+    t0 = fields.get(fullName) || fields.get(name);
+    $[0] = fields;
+    $[1] = fullName;
+    $[2] = name;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  const field = t0;
+  if (!field) {
+    throw new Error(`Field "${name}" not found in form fields. ` + `Available fields: ${Array.from(fields.keys()).join(", ")}`);
+  }
+  let t1;
+  if ($[4] !== form.control || $[5] !== fullName) {
+    t1 = {
+      control: form.control,
+      name: fullName
+    };
+    $[4] = form.control;
+    $[5] = fullName;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  const {
+    field: controllerField,
+    fieldState
+  } = useController(t1);
+  let t2;
+  if ($[7] !== field || $[8] !== fullName) {
+    t2 = {
+      ...field,
+      name: fullName
+    };
+    $[7] = field;
+    $[8] = fullName;
+    $[9] = t2;
+  } else {
+    t2 = $[9];
+  }
+  let t3;
+  if ($[10] !== fieldState.error || $[11] !== fieldState.invalid || $[12] !== fieldState.isDirty || $[13] !== fieldState.isTouched) {
+    t3 = {
+      invalid: fieldState.invalid,
+      error: fieldState.error,
+      isDirty: fieldState.isDirty,
+      isTouched: fieldState.isTouched
+    };
+    $[10] = fieldState.error;
+    $[11] = fieldState.invalid;
+    $[12] = fieldState.isDirty;
+    $[13] = fieldState.isTouched;
+    $[14] = t3;
+  } else {
+    t3 = $[14];
+  }
+  let t4;
+  if ($[15] !== controllerField.name || $[16] !== controllerField.onBlur || $[17] !== controllerField.onChange || $[18] !== controllerField.ref || $[19] !== controllerField.value || $[20] !== t2 || $[21] !== t3) {
+    t4 = {
+      name: controllerField.name,
+      value: controllerField.value,
+      onChange: controllerField.onChange,
+      onBlur: controllerField.onBlur,
+      ref: controllerField.ref,
+      field: t2,
+      fieldState: t3
+    };
+    $[15] = controllerField.name;
+    $[16] = controllerField.onBlur;
+    $[17] = controllerField.onChange;
+    $[18] = controllerField.ref;
+    $[19] = controllerField.value;
+    $[20] = t2;
+    $[21] = t3;
+    $[22] = t4;
+  } else {
+    t4 = $[22];
+  }
+  return t4;
+}
+function useFieldsContext() {
+  return useContext(FieldsContext);
+}
+
+function isSchemaRequired(schema) {
+  return !schema.isOptional() && !schema.isNullable();
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  while (current instanceof z.ZodOptional || current instanceof z.ZodNullable) {
+    current = current.unwrap();
+  }
+  if (current instanceof z.ZodDefault) {
+    current = current._def.innerType;
+  }
+  return current;
+}
+function getSchemaTypeName(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (unwrapped instanceof z.ZodString) return 'string';
+  if (unwrapped instanceof z.ZodNumber) return 'number';
+  if (unwrapped instanceof z.ZodBoolean) return 'boolean';
+  if (unwrapped instanceof z.ZodDate) return 'date';
+  if (unwrapped instanceof z.ZodArray) return 'array';
+  if (unwrapped instanceof z.ZodObject) return 'object';
+  if (unwrapped instanceof 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 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 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 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
@@ -3497,10 +3887,79 @@ function buildDefaultValues(fields) {
   return values;
 }
 
-function hasSchema(props) {
-  return props.schema !== undefined;
+const TemplateFieldContext = /*#__PURE__*/createContext(null);
+function TemplateFieldProvider({
+  children,
+  fieldEntries,
+  accessedFields
+}) {
+  return jsx(TemplateFieldContext.Provider, {
+    value: {
+      fieldEntries,
+      accessedFields
+    },
+    children: children
+  });
+}
+function useTemplateField(name) {
+  const $ = c(3);
+  const context = 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 $ = c(3);
+  const context = 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 = jsx(Fragment$1, {
+      children: remaining
+    });
+    $[0] = accessedFields;
+    $[1] = fieldEntries;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
 }
-function FormGeneratorImpl(props) {
+function _temp(t0) {
+  const [, entry] = t0;
+  return entry.element;
+}
+RemainingFields.displayName = 'RemainingFields';
+
+function FormGenerator(props) {
   const {
     fields,
     defaultValues,
@@ -3516,6 +3975,8 @@ function FormGeneratorImpl(props) {
     ref,
     validateTypes
   } = props;
+  const onSubmit = props.onSubmit;
+  const formRef = useRef(null);
   useMemo(() => {
     if (validateTypes) {
       const registeredTypes = getRegisteredFieldTypes();
@@ -3526,15 +3987,7 @@ function FormGeneratorImpl(props) {
       validateFieldTypes(fields, registeredTypes, options);
     }
   }, [fields, validateTypes]);
-  const userSchema = hasSchema(props) ? props.schema : undefined;
-  const onSubmit = props.onSubmit;
-  const formRef = useRef(null);
-  const schema = useMemo(() => {
-    if (userSchema) {
-      return userSchema;
-    }
-    return buildSchema(fields);
-  }, [fields, userSchema]);
+  const schema = useMemo(() => buildSchema(fields), [fields]);
   const mergedDefaultValues = useMemo(() => {
     const builtDefaults = buildDefaultValues(fields);
     return defaultValues ? deepMerge(builtDefaults, defaultValues) : builtDefaults;
@@ -3545,17 +3998,31 @@ function FormGeneratorImpl(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 = useCallback(() => {
     form.reset(mergedDefaultValues);
   }, [form, mergedDefaultValues]);
   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
         });
       });
     },
@@ -3567,6 +4034,12 @@ function FormGeneratorImpl(props) {
         form.reset(mergedDefaultValues);
       }
     },
+    setDefaultValues: values_1 => {
+      const newDefaults = deepMerge(mergedDefaultValues, values_1);
+      form.reset(newDefaults, {
+        keepDirtyValues: false
+      });
+    },
     submit: async () => {
       await handleSubmit();
     },
@@ -3618,7 +4091,10 @@ function FormGeneratorImpl(props) {
     });
     return entries;
   }, [regularFields, FieldWrapper]);
-  const templateFields = useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
+  const {
+    templateFields,
+    accessedFields
+  } = useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
   const buttons = useMemo(() => {
     const result = {
       submit: jsx(SubmitButton, {
@@ -3637,40 +4113,43 @@ function FormGeneratorImpl(props) {
     }
     return result;
   }, [SubmitButton, disabled, form.formState.isSubmitting, submitText, showReset, resetText, handleReset]);
-  const renderField = useCallback((field_1, options_0) => {
+  const renderField = useCallback((field_1, options_1) => {
     return 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 jsx(FormProvider, {
       ...form,
-      children: jsxs("form", {
-        ref: formRef,
-        onSubmit: handleSubmit,
-        className: className,
-        children: [jsxs(FieldsWrapper, {
-          children: [regularFields.map((field_2, index_0) => jsx(FieldWrapper, {
-            name: field_2.name,
-            type: field_2.type,
-            className: field_2.className,
-            children: jsx(FieldRenderer, {
-              field: field_2
-            })
-          }, field_2.name || `field-${index_0}`)), arrayFields.map(arrayField => jsx(FieldWrapper, {
-            name: arrayField.name,
-            type: "array",
-            className: arrayField.className,
-            children: jsx(ArrayFieldRenderer, {
-              field: arrayField
-            })
-          }, arrayField.name))]
-        }), jsx(SubmitButton, {
-          disabled: disabled || form.formState.isSubmitting,
-          isSubmitting: form.formState.isSubmitting,
-          children: submitText
-        })]
+      children: jsx(FieldsProvider, {
+        fields: fields,
+        children: jsxs("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: [jsxs(FieldsWrapper, {
+            children: [regularFields.map((field_2, index_0) => jsx(FieldWrapper, {
+              name: field_2.name,
+              type: field_2.type,
+              className: field_2.className,
+              children: jsx(FieldRenderer, {
+                field: field_2
+              })
+            }, field_2.name || `field-${index_0}`)), arrayFields.map(arrayField => jsx(FieldWrapper, {
+              name: arrayField.name,
+              type: "array",
+              className: arrayField.className,
+              children: jsx(ArrayFieldRenderer, {
+                field: arrayField
+              })
+            }, arrayField.name))]
+          }), jsx(SubmitButton, {
+            disabled: disabled || form.formState.isSubmitting,
+            isSubmitting: form.formState.isSubmitting,
+            children: submitText
+          })]
+        })
       })
     });
   }
@@ -3693,17 +4172,265 @@ function FormGeneratorImpl(props) {
   const renderFn = children;
   return jsx(FormProvider, {
     ...form,
-    children: jsx("form", {
-      ref: formRef,
-      onSubmit: handleSubmit,
-      className: className,
-      children: renderFn(renderProps)
+    children: jsx(FieldsProvider, {
+      fields: fields,
+      children: jsx(TemplateFieldProvider, {
+        fieldEntries: fieldEntries,
+        accessedFields: accessedFields,
+        children: jsx("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: renderFn(renderProps)
+        })
+      })
     })
   });
 }
-function FormGenerator(props) {
-  return FormGeneratorImpl(props);
+
+function typedField() {
+  return field => field;
+}
+function typedFields(fields) {
+  return fields;
+}
+function StrictFormGenerator(props) {
+  const {
+    schema,
+    fields,
+    onSubmit,
+    defaultValues,
+    className,
+    submitText = 'Submit',
+    disabled,
+    mode = 'onChange',
+    title,
+    description,
+    showReset = false,
+    resetText = 'Reset',
+    children,
+    ref,
+    validateTypes
+  } = props;
+  const formRef = useRef(null);
+  const fieldsWithRequirements = useMemo(() => {
+    if (schema && typeof schema === 'object' && 'shape' in schema) {
+      return mergeSchemaConstraints(schema, fields);
+    }
+    return fields;
+  }, [schema, fields]);
+  useMemo(() => {
+    if (validateTypes) {
+      const registeredTypes = getRegisteredFieldTypes();
+      const options = typeof validateTypes === 'object' ? validateTypes : {
+        throwOnError: false,
+        warn: true
+      };
+      validateFieldTypes(fieldsWithRequirements, registeredTypes, options);
+    }
+  }, [fieldsWithRequirements, validateTypes]);
+  const mergedDefaultValues = useMemo(() => {
+    const builtDefaults = buildDefaultValues(fieldsWithRequirements);
+    return defaultValues ? deepMerge(builtDefaults, defaultValues) : builtDefaults;
+  }, [fieldsWithRequirements, defaultValues]);
+  const form = useForm({
+    resolver: a(schema),
+    defaultValues: mergedDefaultValues,
+    mode
+  });
+  const handleSubmit = form.handleSubmit(async 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 = useCallback(() => {
+    form.reset(mergedDefaultValues);
+  }, [form, mergedDefaultValues]);
+  useImperativeHandle(ref, () => ({
+    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,
+          shouldDirty
+        });
+      });
+    },
+    getValues: () => form.getValues(),
+    reset: values_0 => {
+      if (values_0) {
+        form.reset(deepMerge(mergedDefaultValues, values_0));
+      } else {
+        form.reset(mergedDefaultValues);
+      }
+    },
+    setDefaultValues: values_1 => {
+      const newDefaults = deepMerge(mergedDefaultValues, values_1);
+      form.reset(newDefaults, {
+        keepDirtyValues: false
+      });
+    },
+    submit: async () => {
+      await handleSubmit();
+    },
+    clearErrors: () => form.clearErrors(),
+    setError: (name, error) => form.setError(name, error),
+    isValid: () => form.formState.isValid,
+    isDirty: () => form.formState.isDirty,
+    form: form
+  }), [form, handleSubmit, mergedDefaultValues]);
+  const SubmitButton = getFormComponent('SubmitButton');
+  const FieldWrapper = getFormComponent('FieldWrapper');
+  const FieldsWrapper = getFormComponent('FieldsWrapper');
+  const {
+    regularFields,
+    arrayFields
+  } = useMemo(() => {
+    const regular = [];
+    const arrays = [];
+    fieldsWithRequirements.forEach(field => {
+      if (isArrayField(field)) {
+        arrays.push(field);
+      } else {
+        regular.push(field);
+      }
+    });
+    return {
+      regularFields: regular,
+      arrayFields: arrays
+    };
+  }, [fieldsWithRequirements]);
+  const fieldEntries = useMemo(() => {
+    const entries = new Map();
+    regularFields.forEach((field_0, index) => {
+      if (!field_0.hidden) {
+        const element = jsx(FieldWrapper, {
+          name: field_0.name,
+          type: field_0.type,
+          className: field_0.className,
+          children: jsx(FieldRenderer, {
+            field: field_0
+          })
+        }, field_0.name || `field-${index}`);
+        entries.set(field_0.name, {
+          field: field_0,
+          element,
+          accessed: false
+        });
+      }
+    });
+    return entries;
+  }, [regularFields, FieldWrapper]);
+  const {
+    templateFields,
+    accessedFields
+  } = useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
+  const buttons = useMemo(() => {
+    const result = {
+      submit: jsx(SubmitButton, {
+        disabled: disabled || form.formState.isSubmitting,
+        isSubmitting: form.formState.isSubmitting,
+        children: submitText
+      }, "submit")
+    };
+    if (showReset) {
+      result.reset = jsx("button", {
+        type: "button",
+        onClick: handleReset,
+        disabled: disabled,
+        children: resetText
+      }, "reset");
+    }
+    return result;
+  }, [SubmitButton, disabled, form.formState.isSubmitting, submitText, showReset, resetText, handleReset]);
+  const renderField = useCallback((field_1, options_1) => {
+    return jsx(FieldRenderer, {
+      field: field_1,
+      namePrefix: options_1 === null || options_1 === void 0 ? void 0 : options_1.namePrefix
+    });
+  }, []);
+  if (!children) {
+    return jsx(FormProvider, {
+      ...form,
+      children: jsx(FieldsProvider, {
+        fields: fieldsWithRequirements,
+        children: jsxs("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: [jsxs(FieldsWrapper, {
+            children: [regularFields.map((field_2, index_0) => jsx(FieldWrapper, {
+              name: field_2.name,
+              type: field_2.type,
+              className: field_2.className,
+              children: jsx(FieldRenderer, {
+                field: field_2
+              })
+            }, field_2.name || `field-${index_0}`)), arrayFields.map(arrayField => jsx(FieldWrapper, {
+              name: arrayField.name,
+              type: "array",
+              className: arrayField.className,
+              children: jsx(ArrayFieldRenderer, {
+                field: arrayField
+              })
+            }, arrayField.name))]
+          }), jsx(SubmitButton, {
+            disabled: disabled || form.formState.isSubmitting,
+            isSubmitting: form.formState.isSubmitting,
+            children: submitText
+          })]
+        })
+      })
+    });
+  }
+  const renderProps = {
+    fields: templateFields,
+    arrays: Object.fromEntries(arrayFields.map(arrayField_0 => [arrayField_0.name, {
+      field: arrayField_0
+    }])),
+    buttons,
+    title,
+    description,
+    form: form,
+    isSubmitting: form.formState.isSubmitting,
+    isValid: form.formState.isValid,
+    isDirty: form.formState.isDirty,
+    renderField,
+    FieldWrapper,
+    FieldsWrapper
+  };
+  const renderFn = children;
+  return jsx(FormProvider, {
+    ...form,
+    children: jsx(FieldsProvider, {
+      fields: fieldsWithRequirements,
+      children: jsx(TemplateFieldProvider, {
+        fieldEntries: fieldEntries,
+        accessedFields: accessedFields,
+        children: jsx("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: renderFn(renderProps)
+        })
+      })
+    })
+  });
+}
+function createFieldFactory(_schema) {
+  return field => field;
 }
 
-export { ArrayFieldRenderer, Controller, FieldRenderer, FormGenerator, FormProvider, clearAllRegistries, clearFieldRegistry, clearFormComponentRegistry, createArrayField, createField, getFieldComponent, getFormComponent, getFormComponents, getRegisteredFieldTypes, hasFieldType, hasFormComponent, isArrayField, registerField, registerFields, registerFormComponent, registerFormComponents, resetFormComponentRegistry, strictFields, unregisterField, useArrayField, useFieldArray, useForm, useFormContext, useWatch, validateFieldType, validateFieldTypes };
+export { ArrayFieldRenderer, Controller, FieldRenderer, FieldsProvider, FormGenerator, FormProvider, RemainingFields, StrictFormGenerator, analyzeSchema, clearAllRegistries, clearFieldRegistry, clearFormComponentRegistry, createArrayField, createField, createFieldFactory, getDateConstraints, getFieldComponent, getFormComponent, getFormComponents, getNumberConstraints, getRegisteredFieldTypes, getSchemaRequirements, getSchemaTypeName, getStringConstraints, hasFieldType, hasFormComponent, isArrayField, isSchemaRequired, mergeSchemaConstraints, mergeSchemaRequirements, registerField, registerFields, registerFormComponent, registerFormComponents, resetFormComponentRegistry, strictFields, typedField, typedFields, unregisterField, unwrapSchema, useArrayField, useFieldArray, useFieldProps, useFieldsContext, useForm, useFormContext, useTemplateField, useWatch, validateFieldType, validateFieldTypes };
 //# sourceMappingURL=index.mjs.map