@connect-soft/form-generator 1.0.0-alpha → 1.1.0-alpha10

package/dist/index.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var compilerRuntime = require('react/compiler-runtime');
 var jsxRuntime = require('react/jsx-runtime');
 var React = require('react');
 var n$1 = require('zod/v4/core');
+var compilerRuntime = require('react/compiler-runtime');
 var zod = require('zod');
 
 function _interopNamespaceDefault(e) {
@@ -2792,52 +2792,56 @@ const r=(t,r,o)=>{if(t&&"reportValidity"in t){const s=get(o,r);t.setCustomValidi
 
 function t(r,e){try{var o=r();}catch(r){return e(r)}return o&&o.then?o.then(void 0,e):o}function s(r,e){for(var n={};r.length;){var t=r[0],s=t.code,i=t.message,a=t.path.join(".");if(!n[a])if("unionErrors"in t){var u=t.unionErrors[0].errors[0];n[a]={message:u.message,type:u.code};}else n[a]={message:i,type:s};if("unionErrors"in t&&t.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var c=n[a].types,f=c&&c[t.code];n[a]=appendErrors(a,e,n,s,f?[].concat(f,t.message):t.message);}r.shift();}return n}function i(r,e){for(var n={};r.length;){var t=r[0],s=t.code,i=t.message,a=t.path.join(".");if(!n[a])if("invalid_union"===t.code&&t.errors.length>0){var u=t.errors[0][0];n[a]={message:u.message,type:u.code};}else n[a]={message:i,type:s};if("invalid_union"===t.code&&t.errors.forEach(function(e){return e.forEach(function(e){return r.push(e)})}),e){var c=n[a].types,f=c&&c[t.code];n[a]=appendErrors(a,e,n,s,f?[].concat(f,t.message):t.message);}r.shift();}return n}function a(o$1,a,u){if(void 0===u&&(u={}),function(r){return "_def"in r&&"object"==typeof r._def&&"typeName"in r._def}(o$1))return function(n,i,c){try{return Promise.resolve(t(function(){return Promise.resolve(o$1["sync"===u.mode?"parse":"parseAsync"](n,a)).then(function(e){return c.shouldUseNativeValidation&&o({},c),{errors:{},values:u.raw?Object.assign({},n):e}})},function(r){if(function(r){return Array.isArray(null==r?void 0:r.issues)}(r))return {values:{},errors:s$1(s(r.errors,!c.shouldUseNativeValidation&&"all"===c.criteriaMode),c)};throw r}))}catch(r){return Promise.reject(r)}};if(function(r){return "_zod"in r&&"object"==typeof r._zod}(o$1))return function(s,c,f){try{return Promise.resolve(t(function(){return Promise.resolve(("sync"===u.mode?n__namespace.parse:n__namespace.parseAsync)(o$1,s,a)).then(function(e){return f.shouldUseNativeValidation&&o({},f),{errors:{},values:u.raw?Object.assign({},s):e}})},function(r){if(function(r){return r instanceof n__namespace.$ZodError}(r))return {values:{},errors:s$1(i(r.issues,!f.shouldUseNativeValidation&&"all"===f.criteriaMode),f)};throw r}))}catch(r){return Promise.reject(r)}};throw new Error("Invalid input: not a Zod schema")}
 
-function isLayoutBlock(item) {
-  return item.type === 'columns' || item.type === 'section';
+function isArrayField(field) {
+  return field.type === 'array' && 'fields' in field;
+}
+function createField(field) {
+  return field;
+}
+function createArrayField(field) {
+  return {
+    ...field,
+    type: 'array'
+  };
+}
+function strictFields(fields) {
+  return fields;
+}
+function validateFieldType(type, registeredTypes) {
+  if (!registeredTypes.includes(type) && type !== 'array') {
+    throw new Error(`Unregistered field type: "${type}". ` + `Registered types: ${registeredTypes.join(', ')}. ` + `Use registerField("${type}", YourComponent) to register it.`);
+  }
+  return type;
+}
+function validateFieldTypes(fields, registeredTypes, options = {}) {
+  const {
+    throwOnError = false,
+    warn = true
+  } = options;
+  const invalidTypes = [];
+  const checkField = field => {
+    if (field.type === 'array' && 'fields' in field) {
+      field.fields.forEach(checkField);
+    } else if (!registeredTypes.includes(field.type) && field.type !== 'array') {
+      invalidTypes.push(field.type);
+    }
+  };
+  fields.forEach(checkField);
+  if (invalidTypes.length > 0) {
+    const uniqueInvalid = [...new Set(invalidTypes)];
+    const message = `Unregistered field type(s): ${uniqueInvalid.map(t => `"${t}"`).join(', ')}. ` + `Registered types: ${registeredTypes.join(', ')}. ` + 'Register custom types with registerField() or use module augmentation for TypeScript support.';
+    if (throwOnError) {
+      throw new Error(message);
+    } else if (warn && typeof console !== 'undefined') {
+      console.warn(`[FormGenerator] ${message}`);
+    }
+  }
+  return fields;
 }
 
 const fieldRegistry = new Map();
 const componentRegistry = {};
-const layoutRegistry = {};
 const defaultFormComponents = {
-  FormItem: ({
-    className,
-    children
-  }) => /*#__PURE__*/React.createElement('div', {
-    className: className !== null && className !== void 0 ? className : 'form-item'
-  }, children),
-  FormInputLabelWrapper: ({
-    className,
-    orientation,
-    children
-  }) => /*#__PURE__*/React.createElement('div', {
-    'className': className !== null && className !== void 0 ? className : 'form-input-label-wrapper',
-    'data-orientation': orientation !== null && orientation !== void 0 ? orientation : 'vertical'
-  }, children),
-  FormLabel: ({
-    className,
-    children,
-    required,
-    htmlFor
-  }) => /*#__PURE__*/React.createElement('label', {
-    className: className !== null && className !== void 0 ? className : 'form-label',
-    htmlFor
-  }, children, required && /*#__PURE__*/React.createElement('span', {
-    className: 'required-indicator'
-  }, ' *')),
-  FormDescription: ({
-    className,
-    children
-  }) => /*#__PURE__*/React.createElement('p', {
-    className: className !== null && className !== void 0 ? className : 'form-description'
-  }, children),
-  FormMessage: ({
-    className,
-    name
-  }) => /*#__PURE__*/React.createElement('p', {
-    'className': className !== null && className !== void 0 ? className : 'form-message',
-    'data-field': name
-  }),
   SubmitButton: ({
     className,
     children,
@@ -2847,7 +2851,13 @@ const defaultFormComponents = {
     type: 'submit',
     className: className !== null && className !== void 0 ? className : 'form-submit',
     disabled: disabled || isSubmitting
-  }, isSubmitting ? 'Submitting...' : children)
+  }, isSubmitting ? 'Submitting...' : children),
+  FieldWrapper: ({
+    children
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, children),
+  FieldsWrapper: ({
+    children
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, children)
 };
 const htmlInputTypes = {
   text: 'text',
@@ -2990,27 +3000,15 @@ function createDefaultFieldComponent(type) {
   };
   return FallbackComponent;
 }
-function registerField(type, component, options = {}, config = {}) {
-  const {
-    override = true
-  } = config;
-  const exists = fieldRegistry.has(type);
-  if (override === 'only' && !exists) return;
-  if (override === false && exists) return;
+function registerField(type, component, options = {}) {
   fieldRegistry.set(type, {
     component,
     options
   });
 }
-function registerFields(fields, config = {}) {
-  const {
-    override = true
-  } = config;
+function registerFields(fields) {
   Object.entries(fields).forEach(([type, definition]) => {
     var _a;
-    const exists = fieldRegistry.has(type);
-    if (override === 'only' && !exists) return;
-    if (override === false && exists) return;
     if (typeof definition === 'function') {
       fieldRegistry.set(type, {
         component: definition,
@@ -3032,10 +3030,6 @@ function getFieldComponent(type) {
   }
   return createDefaultFieldComponent(type);
 }
-function getFieldOptions(type) {
-  var _a;
-  return (_a = fieldRegistry.get(type)) === null || _a === void 0 ? void 0 : _a.options;
-}
 function getFieldValidator(type) {
   var _a;
   return (_a = fieldRegistry.get(type)) === null || _a === void 0 ? void 0 : _a.options.validator;
@@ -3049,24 +3043,12 @@ function unregisterField(type) {
 function getRegisteredFieldTypes() {
   return Array.from(fieldRegistry.keys());
 }
-function registerFormComponents(components, config = {}) {
-  const {
-    override = true
-  } = config;
+function registerFormComponents(components) {
   Object.keys(components).forEach(key => {
-    const exists = key in componentRegistry;
-    if (override === 'only' && !exists) return;
-    if (override === false && exists) return;
     componentRegistry[key] = components[key];
   });
 }
-function registerFormComponent(name, component, config = {}) {
-  const {
-    override = true
-  } = config;
-  const exists = name in componentRegistry;
-  if (override === 'only' && !exists) return;
-  if (override === false && exists) return;
+function registerFormComponent(name, component) {
   componentRegistry[name] = component;
 }
 function getFormComponent(name) {
@@ -3081,37 +3063,6 @@ function getFormComponents() {
     ...componentRegistry
   };
 }
-function registerLayoutComponents(components, config = {}) {
-  const {
-    override = true
-  } = config;
-  Object.keys(components).forEach(key => {
-    const exists = key in layoutRegistry;
-    if (override === 'only' && !exists) return;
-    if (override === false && exists) return;
-    layoutRegistry[key] = components[key];
-  });
-}
-function registerLayoutComponent(name, component, config = {}) {
-  const {
-    override = true
-  } = config;
-  const exists = name in layoutRegistry;
-  if (override === 'only' && !exists) return;
-  if (override === false && exists) return;
-  layoutRegistry[name] = component;
-}
-function getLayoutComponent(name) {
-  return layoutRegistry[name];
-}
-function hasLayoutComponent(name) {
-  return name in layoutRegistry;
-}
-function clearLayoutRegistry() {
-  Object.keys(layoutRegistry).forEach(key => {
-    delete layoutRegistry[key];
-  });
-}
 function clearFieldRegistry() {
   fieldRegistry.clear();
 }
@@ -3127,7 +3078,6 @@ function resetFormComponentRegistry() {
 function clearAllRegistries() {
   clearFieldRegistry();
   clearFormComponentRegistry();
-  clearLayoutRegistry();
 }
 
 const FieldRenderer = /*#__PURE__*/React.memo(t0 => {
@@ -3140,6 +3090,10 @@ const FieldRenderer = /*#__PURE__*/React.memo(t0 => {
   if (field.hidden) {
     return null;
   }
+  if (!field.name) {
+    console.error(`Field is missing required "name" property. Field type: "${field.type}". ` + "Every field must have a unique name for form state management.");
+    return null;
+  }
   let t1;
   let t2;
   if ($[0] !== field || $[1] !== form || $[2] !== namePrefix) {
@@ -3151,18 +3105,6 @@ const FieldRenderer = /*#__PURE__*/React.memo(t0 => {
         t2 = null;
         break bb0;
       }
-      const FormItemComponent = getFormComponent("FormItem");
-      const FormLabelComponent = getFormComponent("FormLabel");
-      const FormInputLabelWrapper = getFormComponent("FormInputLabelWrapper");
-      const FormDescriptionComponent = getFormComponent("FormDescription");
-      const FormMessageComponent = getFormComponent("FormMessage");
-      if (!FormItemComponent) {
-        console.warn("FormItem component not registered. Use registerFormComponent(\"FormItem\", Component) to register one.");
-        t2 = null;
-        break bb0;
-      }
-      const fieldOptions = getFieldOptions(field.type);
-      const itemClassName = [`form-field-${field.type}`, fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.className, field.className].filter(Boolean).join(" ");
       const fieldName = namePrefix ? `${namePrefix}.${field.name}` : field.name;
       t1 = jsxRuntime.jsx(Controller, {
         control: form.control,
@@ -3172,36 +3114,18 @@ const FieldRenderer = /*#__PURE__*/React.memo(t0 => {
             field: formField,
             fieldState
           } = t3;
-          return jsxRuntime.jsxs(FormItemComponent, {
-            className: itemClassName,
-            children: [jsxRuntime.jsxs(FormInputLabelWrapper, {
-              orientation: fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.inputLabelWrapperOrientation,
-              className: fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.inputLabelWrapper,
-              children: [field.label && FormLabelComponent && jsxRuntime.jsx(FormLabelComponent, {
-                className: fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.labelClassName,
-                required: field.required,
-                htmlFor: fieldName,
-                children: field.label
-              }), jsxRuntime.jsx(FieldComponent, {
-                field: {
-                  ...field,
-                  name: fieldName
-                },
-                formField,
-                fieldState: {
-                  invalid: fieldState.invalid,
-                  error: fieldState.error,
-                  isDirty: fieldState.isDirty,
-                  isTouched: fieldState.isTouched
-                }
-              })]
-            }), field.description && FormDescriptionComponent && jsxRuntime.jsx(FormDescriptionComponent, {
-              className: fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.descriptionClassName,
-              children: field.description
-            }), FormMessageComponent && jsxRuntime.jsx(FormMessageComponent, {
-              className: fieldOptions === null || fieldOptions === void 0 ? void 0 : fieldOptions.messageClassName,
+          return jsxRuntime.jsx(FieldComponent, {
+            field: {
+              ...field,
               name: fieldName
-            })]
+            },
+            formField,
+            fieldState: {
+              invalid: fieldState.invalid,
+              error: fieldState.error,
+              isDirty: fieldState.isDirty,
+              isTouched: fieldState.isTouched
+            }
           });
         }
       });
@@ -3221,135 +3145,655 @@ const FieldRenderer = /*#__PURE__*/React.memo(t0 => {
   return t1;
 });
 FieldRenderer.displayName = 'FieldRenderer';
-const ColumnsRenderer = /*#__PURE__*/React.memo(t0 => {
-  const $ = compilerRuntime.c(6);
+
+function useArrayField(field) {
   const {
-    layout,
-    namePrefix
+    control
+  } = useFormContext();
+  const fieldArray = useFieldArray({
+    control,
+    name: field.name
+  });
+  const {
+    fields: items,
+    append,
+    prepend,
+    remove,
+    move,
+    swap,
+    insert
+  } = fieldArray;
+  const buildEmptyItem = React.useCallback(() => {
+    const item = {};
+    field.fields.forEach(f => {
+      var _a;
+      item[f.name] = (_a = f.defaultValue) !== null && _a !== void 0 ? _a : '';
+    });
+    return item;
+  }, [field.fields]);
+  const handleAppend = React.useCallback(() => {
+    append(buildEmptyItem());
+  }, [append, buildEmptyItem]);
+  const handleAppendWith = React.useCallback(values => {
+    append(values);
+  }, [append]);
+  const handlePrepend = React.useCallback(() => {
+    prepend(buildEmptyItem());
+  }, [prepend, buildEmptyItem]);
+  const handleInsert = React.useCallback((index, values_0) => {
+    insert(index, values_0 !== null && values_0 !== void 0 ? values_0 : buildEmptyItem());
+  }, [insert, buildEmptyItem]);
+  const canAppend = field.maxItems === undefined || items.length < field.maxItems;
+  const canRemove = field.minItems === undefined || items.length > field.minItems;
+  const renderField = React.useCallback((index_0, fieldName) => {
+    const childField = field.fields.find(f_0 => f_0.name === fieldName);
+    if (!childField) {
+      console.warn(`Field "${fieldName}" not found in array field "${field.name}"`);
+      return jsxRuntime.jsx(jsxRuntime.Fragment, {});
+    }
+    return jsxRuntime.jsx(FieldRenderer, {
+      field: childField,
+      namePrefix: `${field.name}.${index_0}`
+    }, `${field.name}.${index_0}.${fieldName}`);
+  }, [field]);
+  const renderItem = React.useCallback(index_1 => {
+    const result = {};
+    field.fields.forEach(childField_0 => {
+      result[childField_0.name] = jsxRuntime.jsx(FieldRenderer, {
+        field: childField_0,
+        namePrefix: `${field.name}.${index_1}`
+      }, `${field.name}.${index_1}.${childField_0.name}`);
+    });
+    return result;
+  }, [field]);
+  return {
+    fieldArray,
+    append: handleAppend,
+    appendWith: handleAppendWith,
+    prepend: handlePrepend,
+    remove,
+    move,
+    swap,
+    insert: handleInsert,
+    field,
+    items: items.map((item_0, index_2) => ({
+      id: item_0.id,
+      index: index_2
+    })),
+    canAppend,
+    canRemove,
+    renderField,
+    renderItem
+  };
+}
+const ArrayFieldRenderer = /*#__PURE__*/React.memo(t0 => {
+  const $ = compilerRuntime.c(28);
+  const {
+    field,
+    children
   } = t0;
-  let t1;
-  let t2;
-  if ($[0] !== layout || $[1] !== namePrefix) {
-    t2 = Symbol.for("react.early_return_sentinel");
-    bb0: {
-      const ColumnsComponent = getLayoutComponent("Columns");
-      if (!ColumnsComponent) {
-        console.warn("Columns layout component not registered. Use registerLayoutComponent(\"Columns\", Component) to register one.");
-        t2 = null;
-        break bb0;
-      }
-      const newPrefix = layout.wrapFieldNames && layout.name ? namePrefix ? `${namePrefix}.${layout.name}` : layout.name : namePrefix;
-      let t3;
-      if ($[4] !== newPrefix) {
-        t3 = (item, index) => jsxRuntime.jsx(FormItemRenderer, {
-          item,
-          namePrefix: newPrefix
-        }, index);
-        $[4] = newPrefix;
-        $[5] = t3;
+  const {
+    items,
+    append,
+    remove,
+    move,
+    canAppend,
+    renderItem,
+    field: arrayField
+  } = useArrayField(field);
+  if (field.hidden) {
+    return null;
+  }
+  if (!children) {
+    let t1;
+    if ($[0] !== append || $[1] !== canAppend || $[2] !== field.className || $[3] !== field.description || $[4] !== field.label || $[5] !== items || $[6] !== renderItem) {
+      let t2;
+      if ($[8] !== renderItem) {
+        t2 = t3 => {
+          const {
+            id,
+            index
+          } = t3;
+          return jsxRuntime.jsx("div", {
+            "data-array-item-index": index,
+            children: Object.values(renderItem(index))
+          }, id);
+        };
+        $[8] = renderItem;
+        $[9] = t2;
       } else {
-        t3 = $[5];
+        t2 = $[9];
       }
-      const renderItem = t3;
-      t1 = jsxRuntime.jsx(ColumnsComponent, {
-        layout,
-        renderItem
+      t1 = jsxRuntime.jsxs("div", {
+        className: field.className,
+        children: [field.label && jsxRuntime.jsx("label", {
+          children: field.label
+        }), field.description && jsxRuntime.jsx("p", {
+          children: field.description
+        }), items.map(t2), canAppend && jsxRuntime.jsx("button", {
+          type: "button",
+          onClick: append,
+          children: "Add Item"
+        })]
       });
+      $[0] = append;
+      $[1] = canAppend;
+      $[2] = field.className;
+      $[3] = field.description;
+      $[4] = field.label;
+      $[5] = items;
+      $[6] = renderItem;
+      $[7] = t1;
+    } else {
+      t1 = $[7];
     }
-    $[0] = layout;
-    $[1] = namePrefix;
-    $[2] = t1;
-    $[3] = t2;
-  } else {
-    t1 = $[2];
-    t2 = $[3];
+    return t1;
   }
-  if (t2 !== Symbol.for("react.early_return_sentinel")) {
-    return t2;
+  let t1;
+  if ($[10] !== arrayField || $[11] !== children || $[12] !== field.className || $[13] !== field.description || $[14] !== field.label || $[15] !== field.name || $[16] !== items || $[17] !== move || $[18] !== remove || $[19] !== renderItem) {
+    let t2;
+    if ($[21] !== arrayField || $[22] !== children || $[23] !== field.name || $[24] !== move || $[25] !== remove || $[26] !== renderItem) {
+      t2 = t3 => {
+        const {
+          id: id_0,
+          index: index_0
+        } = t3;
+        return children({
+          index: index_0,
+          id: id_0,
+          remove: () => remove(index_0),
+          move: toIndex => move(index_0, toIndex),
+          fields: renderItem(index_0),
+          fieldNames: arrayField.fields.map(_temp),
+          namePrefix: `${field.name}.${index_0}`
+        });
+      };
+      $[21] = arrayField;
+      $[22] = children;
+      $[23] = field.name;
+      $[24] = move;
+      $[25] = remove;
+      $[26] = renderItem;
+      $[27] = t2;
+    } else {
+      t2 = $[27];
+    }
+    t1 = jsxRuntime.jsxs("div", {
+      className: field.className,
+      children: [field.label && jsxRuntime.jsx("label", {
+        children: field.label
+      }), field.description && jsxRuntime.jsx("p", {
+        children: field.description
+      }), items.map(t2)]
+    });
+    $[10] = arrayField;
+    $[11] = children;
+    $[12] = field.className;
+    $[13] = field.description;
+    $[14] = field.label;
+    $[15] = field.name;
+    $[16] = items;
+    $[17] = move;
+    $[18] = remove;
+    $[19] = renderItem;
+    $[20] = t1;
+  } else {
+    t1 = $[20];
   }
   return t1;
 });
-ColumnsRenderer.displayName = 'ColumnsRenderer';
-const SectionRenderer = /*#__PURE__*/React.memo(t0 => {
-  const $ = compilerRuntime.c(6);
+ArrayFieldRenderer.displayName = 'ArrayFieldRenderer';
+function _temp(f) {
+  return f.name;
+}
+
+const RESERVED_PROPS = new Set(['all', 'remaining', 'names', 'has', 'render']);
+function createTemplateFields(fieldEntries) {
+  const accessedFields = new Set();
+  const handler = {
+    get(_, prop) {
+      if (typeof prop === 'symbol') {
+        return undefined;
+      }
+      if (prop === 'all') {
+        return Array.from(fieldEntries.values()).map(entry => entry.element);
+      }
+      if (prop === 'remaining') {
+        return Array.from(fieldEntries.entries()).filter(([name]) => !accessedFields.has(name)).map(([, entry]) => entry.element);
+      }
+      if (prop === 'names') {
+        return Array.from(fieldEntries.keys());
+      }
+      if (prop === 'has') {
+        return name => fieldEntries.has(name);
+      }
+      if (prop === 'render') {
+        return (...names) => {
+          return names.filter(name => fieldEntries.has(name)).map(name => {
+            accessedFields.add(name);
+            return fieldEntries.get(name).element;
+          });
+        };
+      }
+      if (fieldEntries.has(prop)) {
+        accessedFields.add(prop);
+        return fieldEntries.get(prop).element;
+      }
+      return undefined;
+    },
+    has(_, prop) {
+      if (typeof prop === 'symbol') {
+        return false;
+      }
+      return RESERVED_PROPS.has(prop) || fieldEntries.has(prop);
+    },
+    ownKeys() {
+      return [...RESERVED_PROPS, ...fieldEntries.keys()];
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      if (typeof prop === 'symbol') {
+        return undefined;
+      }
+      if (RESERVED_PROPS.has(prop) || fieldEntries.has(prop)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          value: this.get(_, prop, {})
+        };
+      }
+      return undefined;
+    }
+  };
+  return new Proxy({}, handler);
+}
+
+const FieldsContext = /*#__PURE__*/React.createContext(null);
+function FieldsProvider(t0) {
+  const $ = compilerRuntime.c(9);
   const {
-    layout,
+    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 ($[0] !== layout || $[1] !== namePrefix) {
-    t2 = Symbol.for("react.early_return_sentinel");
-    bb0: {
-      const SectionComponent = getLayoutComponent("Section");
-      if (!SectionComponent) {
-        console.warn("Section layout component not registered. Use registerLayoutComponent(\"Section\", Component) to register one.");
-        t2 = null;
-        break bb0;
-      }
-      const newPrefix = layout.wrapFieldNames && layout.name ? namePrefix ? `${namePrefix}.${layout.name}` : layout.name : namePrefix;
-      let t3;
-      if ($[4] !== newPrefix) {
-        t3 = (item, index) => jsxRuntime.jsx(FormItemRenderer, {
-          item,
-          namePrefix: newPrefix
-        }, index);
-        $[4] = newPrefix;
-        $[5] = t3;
-      } else {
-        t3 = $[5];
+  if ($[6] !== children || $[7] !== value) {
+    t2 = jsxRuntime.jsx(FieldsContext.Provider, {
+      value,
+      children
+    });
+    $[6] = children;
+    $[7] = value;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  return t2;
+}
+function useFieldProps(name) {
+  const $ = compilerRuntime.c(23);
+  const context = React.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 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;
       }
-      const renderItem = t3;
-      t1 = jsxRuntime.jsx(SectionComponent, {
-        layout,
-        renderItem
-      });
     }
-    $[0] = layout;
-    $[1] = namePrefix;
-    $[2] = t1;
-    $[3] = t2;
-  } else {
-    t1 = $[2];
-    t2 = $[3];
   }
-  if (t2 !== Symbol.for("react.early_return_sentinel")) {
-    return t2;
+  return constraints;
+}
+function getStringConstraints(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (!(unwrapped instanceof zod.z.ZodString)) {
+    return {};
   }
-  return t1;
-});
-SectionRenderer.displayName = 'SectionRenderer';
-const FormItemRenderer = /*#__PURE__*/React.memo(({
-  item,
-  namePrefix
-}) => {
-  if (item.hidden) {
-    return null;
+  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;
+      }
+    }
   }
-  if (isLayoutBlock(item)) {
-    switch (item.type) {
-      case 'columns':
-        return jsxRuntime.jsx(ColumnsRenderer, {
-          layout: item,
-          namePrefix: namePrefix
-        });
-      case 'section':
-        return jsxRuntime.jsx(SectionRenderer, {
-          layout: item,
-          namePrefix: namePrefix
-        });
-      default:
-        console.warn(`Unknown layout type: ${item.type}`);
-        return null;
+  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 jsxRuntime.jsx(FieldRenderer, {
-    field: item,
-    namePrefix: namePrefix
+  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;
   });
-});
-FormItemRenderer.displayName = 'FormItemRenderer';
-
+}
+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
@@ -3375,8 +3819,9 @@ const defaultValidators = {
   tel: stringValidator,
   number: field => {
     let schema = zod.z.coerce.number();
-    if (field.min !== undefined) schema = schema.min(field.min);
-    if (field.max !== undefined) schema = schema.max(field.max);
+    const numberField = field;
+    if (numberField.min !== undefined) schema = schema.min(numberField.min);
+    if (numberField.max !== undefined) schema = schema.max(numberField.max);
     return schema;
   },
   checkbox: () => zod.z.coerce.boolean(),
@@ -3403,205 +3848,553 @@ function getValidatorForField(field) {
   }
   return zod.z.any();
 }
-function buildSchema(items) {
+function buildArrayItemSchema(arrayField) {
+  const itemShape = {};
+  for (const field of arrayField.fields) {
+    const validator = getValidatorForField(field);
+    itemShape[field.name] = field.required ? validator : validator.optional();
+  }
+  return zod.z.object(itemShape);
+}
+function buildSchema(fields) {
   const shape = {};
-  for (const item of items) {
-    if (isLayoutBlock(item)) {
-      let childItems = [];
-      if (item.type === 'columns') {
-        for (const column of item.columns) {
-          childItems.push(...column.children);
-        }
-      } else if (item.type === 'section') {
-        childItems = item.children;
+  for (const field of fields) {
+    if (isArrayField(field)) {
+      let arraySchema = zod.z.array(buildArrayItemSchema(field));
+      if (field.minItems !== undefined) {
+        arraySchema = arraySchema.min(field.minItems);
       }
-      if (item.wrapFieldNames && item.name) {
-        shape[item.name] = buildSchema(childItems);
-      } else {
-        const childSchema = buildSchema(childItems);
-        if (childSchema instanceof zod.z.ZodObject) {
-          Object.assign(shape, childSchema.shape);
-        }
+      if (field.maxItems !== undefined) {
+        arraySchema = arraySchema.max(field.maxItems);
       }
+      shape[field.name] = arraySchema;
     } else {
-      const field = item;
       const validator = getValidatorForField(field);
       shape[field.name] = field.required ? validator : validator.optional();
     }
   }
   return zod.z.object(shape);
 }
-function buildDefaultValues(items) {
+function buildArrayItemDefaults(arrayField) {
+  var _a;
+  const item = {};
+  for (const field of arrayField.fields) {
+    item[field.name] = (_a = field.defaultValue) !== null && _a !== void 0 ? _a : '';
+  }
+  return item;
+}
+function buildDefaultValues(fields) {
   var _a;
   const values = {};
-  for (const item of items) {
-    if (isLayoutBlock(item)) {
-      let childItems = [];
-      if (item.type === 'columns') {
-        for (const column of item.columns) {
-          childItems.push(...column.children);
-        }
-      } else if (item.type === 'section') {
-        childItems = item.children;
-      }
-      if (item.wrapFieldNames && item.name) {
-        values[item.name] = buildDefaultValues(childItems);
+  for (const field of fields) {
+    if (isArrayField(field)) {
+      if (field.defaultValue && field.defaultValue.length > 0) {
+        values[field.name] = field.defaultValue;
+      } else if (field.minItems && field.minItems > 0) {
+        values[field.name] = Array.from({
+          length: field.minItems
+        }, () => buildArrayItemDefaults(field));
       } else {
-        Object.assign(values, buildDefaultValues(childItems));
+        values[field.name] = [];
       }
     } else {
-      const field = item;
       values[field.name] = (_a = field.defaultValue) !== null && _a !== void 0 ? _a : '';
     }
   }
   return values;
 }
-function getItemKey(item, index) {
-  if (isLayoutBlock(item)) {
-    return `layout-${item.type}-${index}`;
-  }
-  return item.name;
-}
-function FormGenerator(t0) {
-  const $ = compilerRuntime.c(20);
+
+function FormGenerator(props) {
   const {
     fields,
-    onSubmit,
     defaultValues,
-    schema: userSchema,
     className,
-    submitText: t1,
+    submitText = 'Submit',
     disabled,
-    mode: t2
-  } = t0;
-  const submitText = t1 === undefined ? "Submit" : t1;
-  const mode = t2 === undefined ? "onChange" : t2;
-  let t3;
-  bb0: {
-    if (userSchema) {
-      t3 = userSchema;
-      break bb0;
-    }
-    let t4;
-    if ($[0] !== fields) {
-      t4 = buildSchema(fields);
-      $[0] = fields;
-      $[1] = t4;
-    } else {
-      t4 = $[1];
+    mode = 'onChange',
+    title,
+    description,
+    showReset = false,
+    resetText = 'Reset',
+    children,
+    ref,
+    validateTypes
+  } = props;
+  const onSubmit = props.onSubmit;
+  const formRef = React.useRef(null);
+  React.useMemo(() => {
+    if (validateTypes) {
+      const registeredTypes = getRegisteredFieldTypes();
+      const options = typeof validateTypes === 'object' ? validateTypes : {
+        throwOnError: false,
+        warn: true
+      };
+      validateFieldTypes(fields, registeredTypes, options);
     }
-    t3 = t4;
-  }
-  const schema = t3;
-  let t4;
-  if ($[2] !== defaultValues || $[3] !== fields) {
+  }, [fields, validateTypes]);
+  const schema = React.useMemo(() => buildSchema(fields), [fields]);
+  const mergedDefaultValues = React.useMemo(() => {
     const builtDefaults = buildDefaultValues(fields);
-    t4 = defaultValues ? deepMerge(builtDefaults, defaultValues) : builtDefaults;
-    $[2] = defaultValues;
-    $[3] = fields;
-    $[4] = t4;
-  } else {
-    t4 = $[4];
-  }
-  const mergedDefaultValues = t4;
-  let t5;
-  if ($[5] !== schema) {
-    t5 = a(schema);
-    $[5] = schema;
-    $[6] = t5;
-  } else {
-    t5 = $[6];
-  }
-  let t6;
-  if ($[7] !== mergedDefaultValues || $[8] !== mode || $[9] !== t5) {
-    t6 = {
-      resolver: t5,
+    return defaultValues ? deepMerge(builtDefaults, defaultValues) : builtDefaults;
+  }, [fields, 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,
-      mode
+      form: form
     };
-    $[7] = mergedDefaultValues;
-    $[8] = mode;
-    $[9] = t5;
-    $[10] = t6;
-  } else {
-    t6 = $[10];
+    await onSubmit(data, context);
+  });
+  const handleReset = React.useCallback(() => {
+    form.reset(mergedDefaultValues);
+  }, [form, mergedDefaultValues]);
+  React.useImperativeHandle(ref, () => ({
+    setValues: values => {
+      Object.entries(values).forEach(([key, value]) => {
+        form.setValue(key, value, {
+          shouldValidate: true,
+          shouldDirty: true
+        });
+      });
+    },
+    getValues: () => form.getValues(),
+    reset: values_0 => {
+      if (values_0) {
+        form.reset(deepMerge(mergedDefaultValues, values_0));
+      } else {
+        form.reset(mergedDefaultValues);
+      }
+    },
+    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
+  } = React.useMemo(() => {
+    const regular = [];
+    const arrays = [];
+    fields.forEach(field => {
+      if (isArrayField(field)) {
+        arrays.push(field);
+      } else {
+        regular.push(field);
+      }
+    });
+    return {
+      regularFields: regular,
+      arrayFields: arrays
+    };
+  }, [fields]);
+  const fieldEntries = React.useMemo(() => {
+    const entries = new Map();
+    regularFields.forEach((field_0, index) => {
+      if (!field_0.hidden) {
+        const element = jsxRuntime.jsx(FieldWrapper, {
+          name: field_0.name,
+          type: field_0.type,
+          className: field_0.className,
+          children: jsxRuntime.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 = React.useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
+  const buttons = React.useMemo(() => {
+    const result = {
+      submit: jsxRuntime.jsx(SubmitButton, {
+        disabled: disabled || form.formState.isSubmitting,
+        isSubmitting: form.formState.isSubmitting,
+        children: submitText
+      }, "submit")
+    };
+    if (showReset) {
+      result.reset = jsxRuntime.jsx("button", {
+        type: "button",
+        onClick: handleReset,
+        disabled: disabled,
+        children: resetText
+      }, "reset");
+    }
+    return result;
+  }, [SubmitButton, disabled, form.formState.isSubmitting, submitText, showReset, resetText, handleReset]);
+  const renderField = React.useCallback((field_1, options_0) => {
+    return jsxRuntime.jsx(FieldRenderer, {
+      field: field_1,
+      namePrefix: options_0 === null || options_0 === void 0 ? void 0 : options_0.namePrefix
+    });
+  }, []);
+  if (!children) {
+    return jsxRuntime.jsx(FormProvider, {
+      ...form,
+      children: jsxRuntime.jsx(FieldsProvider, {
+        fields: fields,
+        children: jsxRuntime.jsxs("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: [jsxRuntime.jsxs(FieldsWrapper, {
+            children: [regularFields.map((field_2, index_0) => jsxRuntime.jsx(FieldWrapper, {
+              name: field_2.name,
+              type: field_2.type,
+              className: field_2.className,
+              children: jsxRuntime.jsx(FieldRenderer, {
+                field: field_2
+              })
+            }, field_2.name || `field-${index_0}`)), arrayFields.map(arrayField => jsxRuntime.jsx(FieldWrapper, {
+              name: arrayField.name,
+              type: "array",
+              className: arrayField.className,
+              children: jsxRuntime.jsx(ArrayFieldRenderer, {
+                field: arrayField
+              })
+            }, arrayField.name))]
+          }), jsxRuntime.jsx(SubmitButton, {
+            disabled: disabled || form.formState.isSubmitting,
+            isSubmitting: form.formState.isSubmitting,
+            children: submitText
+          })]
+        })
+      })
+    });
   }
-  const form = useForm(t6);
-  let t7;
-  if ($[11] !== className || $[12] !== disabled || $[13] !== fields || $[14] !== form || $[15] !== onSubmit || $[16] !== submitText) {
-    let t8;
-    if ($[18] !== onSubmit) {
-      t8 = async data => {
-        await onSubmit(data);
+  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 jsxRuntime.jsx(FormProvider, {
+    ...form,
+    children: jsxRuntime.jsx(FieldsProvider, {
+      fields: fields,
+      children: jsxRuntime.jsx("form", {
+        ref: formRef,
+        onSubmit: handleSubmit,
+        className: className,
+        children: renderFn(renderProps)
+      })
+    })
+  });
+}
+
+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 = 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();
+      const options = typeof validateTypes === 'object' ? validateTypes : {
+        throwOnError: false,
+        warn: true
       };
-      $[18] = onSubmit;
-      $[19] = t8;
-    } else {
-      t8 = $[19];
+      validateFieldTypes(fieldsWithRequirements, registeredTypes, options);
     }
-    const handleSubmit = form.handleSubmit(t8);
-    const SubmitButton = getFormComponent("SubmitButton");
-    t7 = jsxRuntime.jsx(FormProvider, {
+  }, [fieldsWithRequirements, validateTypes]);
+  const mergedDefaultValues = React.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 = React.useCallback(() => {
+    form.reset(mergedDefaultValues);
+  }, [form, mergedDefaultValues]);
+  React.useImperativeHandle(ref, () => ({
+    setValues: values => {
+      Object.entries(values).forEach(([key, value]) => {
+        form.setValue(key, value, {
+          shouldValidate: true,
+          shouldDirty: true
+        });
+      });
+    },
+    getValues: () => form.getValues(),
+    reset: values_0 => {
+      if (values_0) {
+        form.reset(deepMerge(mergedDefaultValues, values_0));
+      } else {
+        form.reset(mergedDefaultValues);
+      }
+    },
+    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
+  } = React.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 = React.useMemo(() => {
+    const entries = new Map();
+    regularFields.forEach((field_0, index) => {
+      if (!field_0.hidden) {
+        const element = jsxRuntime.jsx(FieldWrapper, {
+          name: field_0.name,
+          type: field_0.type,
+          className: field_0.className,
+          children: jsxRuntime.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 = React.useMemo(() => createTemplateFields(fieldEntries), [fieldEntries]);
+  const buttons = React.useMemo(() => {
+    const result = {
+      submit: jsxRuntime.jsx(SubmitButton, {
+        disabled: disabled || form.formState.isSubmitting,
+        isSubmitting: form.formState.isSubmitting,
+        children: submitText
+      }, "submit")
+    };
+    if (showReset) {
+      result.reset = jsxRuntime.jsx("button", {
+        type: "button",
+        onClick: handleReset,
+        disabled: disabled,
+        children: resetText
+      }, "reset");
+    }
+    return result;
+  }, [SubmitButton, disabled, form.formState.isSubmitting, submitText, showReset, resetText, handleReset]);
+  const renderField = React.useCallback((field_1, options_0) => {
+    return jsxRuntime.jsx(FieldRenderer, {
+      field: field_1,
+      namePrefix: options_0 === null || options_0 === void 0 ? void 0 : options_0.namePrefix
+    });
+  }, []);
+  if (!children) {
+    return jsxRuntime.jsx(FormProvider, {
       ...form,
-      children: jsxRuntime.jsxs("form", {
-        onSubmit: handleSubmit,
-        className,
-        children: [fields.map(_temp), jsxRuntime.jsx(SubmitButton, {
-          disabled: disabled || form.formState.isSubmitting,
-          isSubmitting: form.formState.isSubmitting,
-          children: submitText
-        })]
+      children: jsxRuntime.jsx(FieldsProvider, {
+        fields: fieldsWithRequirements,
+        children: jsxRuntime.jsxs("form", {
+          ref: formRef,
+          onSubmit: handleSubmit,
+          className: className,
+          children: [jsxRuntime.jsxs(FieldsWrapper, {
+            children: [regularFields.map((field_2, index_0) => jsxRuntime.jsx(FieldWrapper, {
+              name: field_2.name,
+              type: field_2.type,
+              className: field_2.className,
+              children: jsxRuntime.jsx(FieldRenderer, {
+                field: field_2
+              })
+            }, field_2.name || `field-${index_0}`)), arrayFields.map(arrayField => jsxRuntime.jsx(FieldWrapper, {
+              name: arrayField.name,
+              type: "array",
+              className: arrayField.className,
+              children: jsxRuntime.jsx(ArrayFieldRenderer, {
+                field: arrayField
+              })
+            }, arrayField.name))]
+          }), jsxRuntime.jsx(SubmitButton, {
+            disabled: disabled || form.formState.isSubmitting,
+            isSubmitting: form.formState.isSubmitting,
+            children: submitText
+          })]
+        })
       })
     });
-    $[11] = className;
-    $[12] = disabled;
-    $[13] = fields;
-    $[14] = form;
-    $[15] = onSubmit;
-    $[16] = submitText;
-    $[17] = t7;
-  } else {
-    t7 = $[17];
   }
-  return t7;
+  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 jsxRuntime.jsx(FormProvider, {
+    ...form,
+    children: jsxRuntime.jsx(FieldsProvider, {
+      fields: fieldsWithRequirements,
+      children: jsxRuntime.jsx("form", {
+        ref: formRef,
+        onSubmit: handleSubmit,
+        className: className,
+        children: renderFn(renderProps)
+      })
+    })
+  });
 }
-function _temp(item, index) {
-  return jsxRuntime.jsx(FormItemRenderer, {
-    item
-  }, getItemKey(item, index));
+function createFieldFactory(_schema) {
+  return field => field;
 }
 
 Object.defineProperty(exports, "z", {
     enumerable: true,
     get: function () { return zod.z; }
 });
+exports.ArrayFieldRenderer = ArrayFieldRenderer;
 exports.Controller = Controller;
 exports.FieldRenderer = FieldRenderer;
+exports.FieldsProvider = FieldsProvider;
 exports.FormGenerator = FormGenerator;
 exports.FormProvider = FormProvider;
+exports.StrictFormGenerator = StrictFormGenerator;
+exports.analyzeSchema = analyzeSchema;
 exports.clearAllRegistries = clearAllRegistries;
 exports.clearFieldRegistry = clearFieldRegistry;
 exports.clearFormComponentRegistry = clearFormComponentRegistry;
-exports.clearLayoutRegistry = clearLayoutRegistry;
+exports.createArrayField = createArrayField;
+exports.createField = createField;
+exports.createFieldFactory = createFieldFactory;
+exports.getDateConstraints = getDateConstraints;
 exports.getFieldComponent = getFieldComponent;
 exports.getFormComponent = getFormComponent;
 exports.getFormComponents = getFormComponents;
-exports.getLayoutComponent = getLayoutComponent;
+exports.getNumberConstraints = getNumberConstraints;
 exports.getRegisteredFieldTypes = getRegisteredFieldTypes;
+exports.getSchemaRequirements = getSchemaRequirements;
+exports.getSchemaTypeName = getSchemaTypeName;
+exports.getStringConstraints = getStringConstraints;
 exports.hasFieldType = hasFieldType;
 exports.hasFormComponent = hasFormComponent;
-exports.hasLayoutComponent = hasLayoutComponent;
-exports.isLayoutBlock = isLayoutBlock;
+exports.isArrayField = isArrayField;
+exports.isSchemaRequired = isSchemaRequired;
+exports.mergeSchemaConstraints = mergeSchemaConstraints;
+exports.mergeSchemaRequirements = mergeSchemaRequirements;
 exports.registerField = registerField;
 exports.registerFields = registerFields;
 exports.registerFormComponent = registerFormComponent;
 exports.registerFormComponents = registerFormComponents;
-exports.registerLayoutComponent = registerLayoutComponent;
-exports.registerLayoutComponents = registerLayoutComponents;
 exports.resetFormComponentRegistry = resetFormComponentRegistry;
+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.useWatch = useWatch;
+exports.validateFieldType = validateFieldType;
+exports.validateFieldTypes = validateFieldTypes;
 //# sourceMappingURL=index.js.map