codeforms 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

codeforms/__init__.py

@@ -12,6 +12,7 @@ from codeforms.fields import (
     FormStep,
     HiddenField,
     ListField,
+    ObjectListField,
     NumberField,
     RadioField,
     SelectField,
@@ -63,6 +64,7 @@ __all__ = [
     "UrlField",
     "TextareaField",
     "ListField",
+    "ObjectListField",
     "FieldGroup",
     "FormStep",
     # Form

codeforms/export.py

@@ -12,6 +12,7 @@ from codeforms.fields import (
     FormStep,
     HiddenField,
     ListField,
+    ObjectListField,
     NumberField,
     RadioField,
     SelectField,
@@ -485,6 +486,26 @@ _LIST_ITEM_TYPE_MAP: Dict[str, str] = {
 }
 
 
+def _object_list_item_schema(field: ObjectListField) -> Dict[str, Any]:
+    properties: Dict[str, Any] = {}
+    required = []
+
+    for subfield in field.fields:
+        properties[subfield.name] = _field_to_json_schema_property(subfield)
+        if subfield.required:
+            required.append(subfield.name)
+
+    item_schema: Dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+        "additionalProperties": False,
+    }
+    if required:
+        item_schema["required"] = required
+
+    return item_schema
+
+
 def _field_to_json_schema_property(field: FormFieldBase) -> Dict[str, Any]:
     """Convert a single form field to a JSON Schema property definition."""
     prop: Dict[str, Any] = {}
@@ -570,6 +591,14 @@ def _field_to_json_schema_property(field: FormFieldBase) -> Dict[str, Any]:
         if field.max_items is not None:
             prop["maxItems"] = field.max_items
 
+    elif isinstance(field, ObjectListField):
+        prop["type"] = "array"
+        prop["items"] = _object_list_item_schema(field)
+        if field.min_items is not None:
+            prop["minItems"] = field.min_items
+        if field.max_items is not None:
+            prop["maxItems"] = field.max_items
+
     elif isinstance(field, TextField):
         prop["type"] = "string"
         if field.minlength is not None:

codeforms/fields.py

@@ -30,6 +30,7 @@ class FieldType(str, Enum):
     HIDDEN = "hidden"
     URL = "url"
     LIST = "list"
+    OBJECT_LIST = "object-list"
 
 
 class ValidationRule(BaseModel):
@@ -279,7 +280,7 @@ class TextareaField(FormFieldBase):
 
 
 class ListField(FormFieldBase):
-    """Campo para listas de valores (ej: lista de participantes)"""
+    """Campo para listas de valores primitivos (ej: lista de participantes)."""
 
     field_type: FieldType = FieldType.LIST
     min_items: Optional[int] = None
@@ -287,6 +288,32 @@ class ListField(FormFieldBase):
     item_type: str = "text"  # Tipo de cada item en la lista
 
 
+class ObjectListField(FormFieldBase):
+    """Campo para listas de objetos homogéneos validados por subcampos."""
+
+    field_type: FieldType = FieldType.OBJECT_LIST
+    min_items: Optional[int] = None
+    max_items: Optional[int] = None
+    fields: List[Any] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    @classmethod
+    def resolve_object_fields(cls, data: Any) -> Any:
+        if isinstance(data, dict) and "fields" in data:
+            from codeforms.registry import resolve_content_item
+
+            data = data.copy()
+            data["fields"] = [resolve_content_item(item) for item in data["fields"]]
+        return data
+
+    @model_validator(mode="after")
+    def validate_object_fields(self) -> "ObjectListField":
+        names = [field.name for field in self.fields]
+        if len(names) != len(set(names)):
+            raise ValueError(t("form.unique_field_names_in_group", title=self.label or self.name))
+        return self
+
+
 class FieldGroup(BaseModel):
     """Representa un grupo de campos en un formulario para organización en secciones"""
 

codeforms/forms.py

@@ -191,8 +191,22 @@ class Form(BaseModel):
                             "message": t("checkbox_group.invalid_options"),
                         }
                     )
+            elif isinstance(field, ListField):
+                value, field_errors = _validate_list_field_value(field, field_value)
+                if field_errors:
+                    errors.extend(field_errors)
+                else:
+                    validated_data[field.name] = value
+            elif isinstance(field, ObjectListField):
+                value, field_errors = _validate_object_list_field_value(
+                    field, field_value
+                )
+                if field_errors:
+                    errors.extend(field_errors)
+                else:
+                    validated_data[field.name] = value
 
-            if not errors:
+            if not errors and field.name not in validated_data:
                 validated_data[field.name] = field_value
 
         return {
@@ -324,6 +338,10 @@ class FormDataModel(BaseModel):
                 fields[field.name] = (float, ... if field.required else None)
             elif isinstance(field, DateField):
                 fields[field.name] = (date, ... if field.required else None)
+            elif isinstance(field, ListField):
+                fields[field.name] = (List[Any], ... if field.required else [])
+            elif isinstance(field, ObjectListField):
+                fields[field.name] = (List[Dict[str, Any]], ... if field.required else [])
             else:
                 fields[field.name] = (str, ... if field.required else None)
 
@@ -426,6 +444,10 @@ class FormDataValidator:
                 field_type = float
             elif isinstance(field, DateField):
                 field_type = date
+            elif isinstance(field, ListField):
+                field_type = List[Any]
+            elif isinstance(field, ObjectListField):
+                field_type = List[Dict[str, Any]]
             else:
                 field_type = str
 
@@ -434,7 +456,7 @@ class FormDataValidator:
                 fields[field.name] = Field(..., description=field.help_text)
             else:
                 default_value = None
-                if field_type == List[str]:
+                if field_type in (List[str], List[Any], List[Dict[str, Any]]):
                     default_value = []
                 fields[field.name] = Field(
                     default=default_value, description=field.help_text
@@ -460,223 +482,126 @@ class FormDataValidator:
         return model
 
 
+def _make_error(field_name: str, message: str) -> dict:
+    return {"field": field_name, "message": message}
+
+
+def _validate_primitive_list_item(item_type: str, value: Any) -> tuple[Any, Optional[str]]:
+    if item_type == "number":
+        try:
+            return float(value), None
+        except (TypeError, ValueError):
+            return None, t("number.invalid")
+
+    if item_type == "email":
+        if not re.match(r"[^@]+@[^@]+\.[^@]+", str(value)):
+            return None, t("email.invalid")
+        return str(value), None
+
+    if item_type == "url":
+        if not isinstance(value, str) or not value.startswith(("http://", "https://")):
+            return None, t("url.invalid_scheme")
+        return value, None
+
+    if item_type == "date":
+        try:
+            return date.fromisoformat(str(value)).isoformat(), None
+        except (TypeError, ValueError):
+            return None, t("date.invalid_format")
+
+    if not isinstance(value, str):
+        value = str(value)
+    return value, None
+
+
+def _validate_list_field_value(field: ListField, field_value: Any, field_path: Optional[str] = None) -> tuple[Any, List[dict]]:
+    field_name = field_path or field.name
+    if isinstance(field_value, str):
+        field_value = [field_value]
+
+    if not isinstance(field_value, list):
+        return None, [_make_error(field_name, t("select.value_must_be_list"))]
+
+    if field.min_items is not None and len(field_value) < field.min_items:
+        return None, [_make_error(field_name, f"Expected at least {field.min_items} items")]
+
+    if field.max_items is not None and len(field_value) > field.max_items:
+        return None, [_make_error(field_name, f"Expected at most {field.max_items} items")]
+
+    validated_items = []
+    errors = []
+    for index, item in enumerate(field_value):
+        validated_item, error_message = _validate_primitive_list_item(field.item_type, item)
+        if error_message:
+            errors.append(_make_error(f"{field_name}[{index}]", error_message))
+        else:
+            validated_items.append(validated_item)
+
+    return (validated_items if not errors else None), errors
+
+
+def _validate_object_list_field_value(field: ObjectListField, field_value: Any, field_path: Optional[str] = None) -> tuple[Any, List[dict]]:
+    field_name = field_path or field.name
+    if not isinstance(field_value, list):
+        return None, [_make_error(field_name, t("select.value_must_be_list"))]
+
+    if field.min_items is not None and len(field_value) < field.min_items:
+        return None, [_make_error(field_name, f"Expected at least {field.min_items} items")]
+
+    if field.max_items is not None and len(field_value) > field.max_items:
+        return None, [_make_error(field_name, f"Expected at most {field.max_items} items")]
+
+    allowed_fields = {subfield.name for subfield in field.fields}
+    validated_items = []
+    errors = []
+
+    for index, item in enumerate(field_value):
+        item_path = f"{field_name}[{index}]"
+        if not isinstance(item, dict):
+            errors.append(_make_error(item_path, "Each item must be an object"))
+            continue
+
+        extra_fields = sorted(set(item.keys()) - allowed_fields)
+        if extra_fields:
+            errors.append(_make_error(item_path, f"Unknown fields: {', '.join(extra_fields)}"))
+
+        validated_item = {}
+        item_errors = []
+        for subfield in field.fields:
+            subvalue = item.get(subfield.name)
+            validated_value, suberrors = _validate_field_value(
+                subfield,
+                subvalue,
+                item,
+                field_path=f"{item_path}.{subfield.name}",
+            )
+            if suberrors:
+                item_errors.extend(suberrors)
+            elif validated_value is not None:
+                validated_item[subfield.name] = validated_value
+
+        if item_errors:
+            errors.extend(item_errors)
+        else:
+            validated_items.append(validated_item)
+
+    return (validated_items if not errors else None), errors
+
+
 def validate_form_data(form: Form, data: Dict[str, Any]) -> Dict[str, Any]:
     try:
         validated_data = {}
         for field in form.fields:
             field_value = data.get(field.name)
-
-            # Si no hay valor, usar el valor por defecto
-            if field_value is None:
-                field_value = field.default_value
-
-            # Validar campo requerido después de considerar el valor por defecto
-            if field.required and field_value is None:
+            value, errors = _validate_field_value(field, field_value, data)
+            if errors:
                 return {
                     "success": False,
-                    "errors": [
-                        {
-                            "field": field.name,
-                            "message": t("field.required_named", name=field.name),
-                        }
-                    ],
+                    "errors": errors,
                     "message": t("form.data_validation_error"),
                 }
-
-            # Procesar valores específicos por tipo
-            if field_value is not None:
-                # Select validation (debe ir antes de otros tipos)
-                if field.field_type == FieldType.SELECT:
-                    valid_options = [opt.value for opt in field.options]
-                    if field.multiple:
-                        # Asegurar que field_value sea una lista
-                        if isinstance(field_value, str):
-                            field_value = [field_value]
-                        if not isinstance(field_value, list):
-                            return {
-                                "success": False,
-                                "errors": [
-                                    {
-                                        "field": field.name,
-                                        "message": t("select.value_must_be_list"),
-                                    }
-                                ],
-                                "message": t("form.data_validation_error"),
-                            }
-                        # Validar cada valor en la lista
-                        invalid_values = [
-                            v for v in field_value if v not in valid_options
-                        ]
-                        if invalid_values:
-                            return {
-                                "success": False,
-                                "errors": [
-                                    {
-                                        "field": field.name,
-                                        "message": t(
-                                            "select.invalid_values",
-                                            values=str(invalid_values),
-                                        ),
-                                    }
-                                ],
-                                "message": t("form.data_validation_error"),
-                            }
-                    else:
-                        # Validar valor único
-                        if field_value not in valid_options:
-                            return {
-                                "success": False,
-                                "errors": [
-                                    {
-                                        "field": field.name,
-                                        "message": t(
-                                            "select.invalid_option_value",
-                                            value=field_value,
-                                            valid=str(valid_options),
-                                        ),
-                                    }
-                                ],
-                                "message": t("form.data_validation_error"),
-                            }
-                    validated_data[field.name] = field_value
-
-                # Email validation
-                elif field.field_type == FieldType.EMAIL:
-                    try:
-                        if not re.match(r"[^@]+@[^@]+\.[^@]+", field_value):
-                            raise ValueError("Invalid email format")
-                        validated_data[field.name] = field_value
-                    except ValueError:
-                        return {
-                            "success": False,
-                            "errors": [
-                                {"field": field.name, "message": t("email.invalid")}
-                            ],
-                            "message": t("form.data_validation_error"),
-                        }
-
-                # Checkbox group validation
-                elif field.field_type == FieldType.CHECKBOX and hasattr(
-                    field, "options"
-                ):
-                    valid_options = [opt.value for opt in field.options]
-
-                    # Ensure field_value is a list
-                    if isinstance(field_value, str):
-                        field_value = [field_value]
-
-                    if not isinstance(field_value, list):
-                        return {
-                            "success": False,
-                            "errors": [
-                                {
-                                    "field": field.name,
-                                    "message": t("select.value_must_be_list"),
-                                }
-                            ],
-                            "message": t("form.data_validation_error"),
-                        }
-
-                    # Check if all values are valid options
-                    invalid_values = [v for v in field_value if v not in valid_options]
-                    if invalid_values:
-                        return {
-                            "success": False,
-                            "errors": [
-                                {
-                                    "field": field.name,
-                                    "message": t(
-                                        "select.invalid_values",
-                                        values=str(invalid_values),
-                                    ),
-                                }
-                            ],
-                            "message": t("form.data_validation_error"),
-                        }
-                    validated_data[field.name] = field_value
-
-                # Single checkbox validation
-                elif field.field_type == FieldType.CHECKBOX and not hasattr(
-                    field, "options"
-                ):
-                    # Convertir a booleano si es necesario
-                    validated_data[field.name] = bool(field_value)
-
-                # Radio validation
-                elif field.field_type == FieldType.RADIO:
-                    valid_options = [opt.value for opt in field.options]
-                    if field_value not in valid_options:
-                        return {
-                            "success": False,
-                            "errors": [
-                                {
-                                    "field": field.name,
-                                    "message": t("radio.invalid_option"),
-                                }
-                            ],
-                            "message": t("form.data_validation_error"),
-                        }
-                    validated_data[field.name] = field_value
-
-                # Number validation
-                elif field.field_type == FieldType.NUMBER:
-                    try:
-                        num_value = float(field_value)
-                        if hasattr(field, "min_value") and field.min_value is not None:
-                            if num_value < field.min_value:
-                                raise ValueError(
-                                    t("number.min_value", min=field.min_value)
-                                )
-                        if hasattr(field, "max_value") and field.max_value is not None:
-                            if num_value > field.max_value:
-                                raise ValueError(
-                                    t("number.max_value", max=field.max_value)
-                                )
-                        validated_data[field.name] = num_value
-                    except ValueError as e:
-                        return {
-                            "success": False,
-                            "errors": [{"field": field.name, "message": str(e)}],
-                            "message": t("form.data_validation_error"),
-                        }
-
-                # Text validation
-                elif field.field_type == FieldType.TEXT:
-                    if not isinstance(field_value, str):
-                        field_value = str(field_value)
-                    if hasattr(field, "minlength") and field.minlength is not None:
-                        if len(field_value) < field.minlength:
-                            return {
-                                "success": False,
-                                "errors": [
-                                    {
-                                        "field": field.name,
-                                        "message": t(
-                                            "text.minlength", min=field.minlength
-                                        ),
-                                    }
-                                ],
-                                "message": t("form.data_validation_error"),
-                            }
-                    if hasattr(field, "maxlength") and field.maxlength is not None:
-                        if len(field_value) > field.maxlength:
-                            return {
-                                "success": False,
-                                "errors": [
-                                    {
-                                        "field": field.name,
-                                        "message": t(
-                                            "text.maxlength", max=field.maxlength
-                                        ),
-                                    }
-                                ],
-                                "message": t("form.data_validation_error"),
-                            }
-                    validated_data[field.name] = field_value
-
-                # Default validation for other types
-                else:
-                    validated_data[field.name] = field_value
+            if value is not None:
+                validated_data[field.name] = value
 
         return {
             "success": True,
@@ -740,26 +665,25 @@ def evaluate_visibility(field: FormFieldBase, data: Dict[str, Any]) -> bool:
 
 
 def _validate_field_value(
-    field: FormFieldBase, field_value: Any, data: Dict[str, Any]
-) -> tuple:
+    field: FormFieldBase, field_value: Any, data: Dict[str, Any], field_path: Optional[str] = None
+) -> tuple[Any, List[dict]]:
     """Valida un campo individual y retorna (validated_value, error_dict_or_None).
 
     Lógica de validación compartida entre validate_form_data y
     validate_form_data_dynamic. No modifica la función legacy.
     """
+    field_name = field_path or field.name
+
     # Si no hay valor, usar el valor por defecto
     if field_value is None:
         field_value = field.default_value
 
     # Validar campo requerido
     if field.required and field_value is None:
-        return None, {
-            "field": field.name,
-            "message": t("field.required_named", name=field.name),
-        }
+        return None, [_make_error(field_name, t("field.required_named", name=field.name))]
 
     if field_value is None:
-        return field_value, None
+        return field_value, []
 
     # Select validation
     if field.field_type == FieldType.SELECT:
@@ -768,33 +692,32 @@ def _validate_field_value(
             if isinstance(field_value, str):
                 field_value = [field_value]
             if not isinstance(field_value, list):
-                return None, {
-                    "field": field.name,
-                    "message": t("select.value_must_be_list"),
-                }
+                return None, [_make_error(field_name, t("select.value_must_be_list"))]
             invalid_values = [v for v in field_value if v not in valid_options]
             if invalid_values:
-                return None, {
-                    "field": field.name,
-                    "message": t("select.invalid_values", values=str(invalid_values)),
-                }
+                return None, [_make_error(field_name, t("select.invalid_values", values=str(invalid_values)))]
         else:
             if field_value not in valid_options:
-                return None, {
-                    "field": field.name,
-                    "message": t(
+                return None, [_make_error(field_name, t(
                         "select.invalid_option_value",
                         value=field_value,
                         valid=str(valid_options),
-                    ),
-                }
-        return field_value, None
+                    ))]
+        return field_value, []
+
+    # Primitive list validation
+    if field.field_type == FieldType.LIST:
+        return _validate_list_field_value(field, field_value, field_name)
+
+    # Object list validation
+    if field.field_type == FieldType.OBJECT_LIST:
+        return _validate_object_list_field_value(field, field_value, field_name)
 
     # Email validation
     if field.field_type == FieldType.EMAIL:
         if not re.match(r"[^@]+@[^@]+\.[^@]+", str(field_value)):
-            return None, {"field": field.name, "message": t("email.invalid")}
-        return field_value, None
+            return None, [_make_error(field_name, t("email.invalid"))]
+        return field_value, []
 
     # Checkbox group validation
     if field.field_type == FieldType.CHECKBOX and hasattr(field, "options"):
@@ -802,17 +725,11 @@ def _validate_field_value(
         if isinstance(field_value, str):
             field_value = [field_value]
         if not isinstance(field_value, list):
-            return None, {
-                "field": field.name,
-                "message": t("select.value_must_be_list"),
-            }
+            return None, [_make_error(field_name, t("select.value_must_be_list"))]
         invalid_values = [v for v in field_value if v not in valid_options]
         if invalid_values:
-            return None, {
-                "field": field.name,
-                "message": t("select.invalid_values", values=str(invalid_values)),
-            }
-        return field_value, None
+            return None, [_make_error(field_name, t("select.invalid_values", values=str(invalid_values)))]
+        return field_value, []
 
     # Single checkbox validation
     if field.field_type == FieldType.CHECKBOX and not hasattr(field, "options"):
@@ -822,8 +739,8 @@ def _validate_field_value(
     if field.field_type == FieldType.RADIO:
         valid_options = [opt.value for opt in field.options]
         if field_value not in valid_options:
-            return None, {"field": field.name, "message": t("radio.invalid_option")}
-        return field_value, None
+            return None, [_make_error(field_name, t("radio.invalid_option"))]
+        return field_value, []
 
     # Number validation
     if field.field_type == FieldType.NUMBER:
@@ -831,19 +748,13 @@ def _validate_field_value(
             num_value = float(field_value)
             if hasattr(field, "min_value") and field.min_value is not None:
                 if num_value < field.min_value:
-                    return None, {
-                        "field": field.name,
-                        "message": t("number.min_value", min=field.min_value),
-                    }
+                    return None, [_make_error(field_name, t("number.min_value", min=field.min_value))]
             if hasattr(field, "max_value") and field.max_value is not None:
                 if num_value > field.max_value:
-                    return None, {
-                        "field": field.name,
-                        "message": t("number.max_value", max=field.max_value),
-                    }
+                    return None, [_make_error(field_name, t("number.max_value", max=field.max_value))]
             return num_value, None
         except (ValueError, TypeError):
-            return None, {"field": field.name, "message": t("number.invalid")}
+            return None, [_make_error(field_name, t("number.invalid"))]
 
     # Text validation
     if field.field_type == FieldType.TEXT:
@@ -851,20 +762,14 @@ def _validate_field_value(
             field_value = str(field_value)
         if hasattr(field, "minlength") and field.minlength is not None:
             if len(field_value) < field.minlength:
-                return None, {
-                    "field": field.name,
-                    "message": t("text.minlength", min=field.minlength),
-                }
+                return None, [_make_error(field_name, t("text.minlength", min=field.minlength))]
         if hasattr(field, "maxlength") and field.maxlength is not None:
             if len(field_value) > field.maxlength:
-                return None, {
-                    "field": field.name,
-                    "message": t("text.maxlength", max=field.maxlength),
-                }
-        return field_value, None
+                return None, [_make_error(field_name, t("text.maxlength", max=field.maxlength))]
+        return field_value, []
 
     # Default: pasar el valor sin validación adicional
-    return field_value, None
+    return field_value, []
 
 
 def validate_form_data_dynamic(
@@ -923,10 +828,10 @@ def validate_form_data_dynamic(
                 continue  # Campo oculto, no validar
 
             field_value = data.get(field.name)
-            value, error = _validate_field_value(field, field_value, data)
+            value, field_errors = _validate_field_value(field, field_value, data)
 
-            if error:
-                errors.append(error)
+            if field_errors:
+                errors.extend(field_errors)
             elif value is not None:
                 validated_data[field.name] = value
 

codeforms/registry.py

@@ -69,6 +69,7 @@ def _init_builtin_types() -> None:
         FileField,
         HiddenField,
         ListField,
+        ObjectListField,
         NumberField,
         RadioField,
         SelectField,
@@ -91,6 +92,7 @@ def _init_builtin_types() -> None:
         UrlField,
         TextareaField,
         ListField,
+        ObjectListField,
     ]:
         _register_class(cls)
 

{codeforms-0.2.1.dist-info → codeforms-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeforms
-Version: 0.2.1
+Version: 0.2.2
 Summary: Python library for creating, validating, and rendering web forms using Pydantic
 License-Expression: MIT
 License-File: LICENSE
@@ -100,6 +100,69 @@ All fields inherit from `FormFieldBase` and share these common attributes:
   - `accept`: Accepted file types (e.g. `"image/*,.pdf"`).
   - `multiple`: Allow multiple file uploads.
 - **`HiddenField`** — Hidden field (`<input type="hidden">`).
+- **`ListField`** — Array of primitive values.
+  - `item_type`: Primitive type for each item (`text`, `number`, `email`, `url`, `date`).
+  - `min_items`, `max_items`: List size limits.
+- **`ObjectListField`** — Array of homogeneous objects validated against nested subfields.
+  - `fields`: List of subfields that define each object shape.
+  - `min_items`, `max_items`: List size limits.
+
+### `ObjectListField`
+
+Use `ObjectListField` when a form needs a repeatable list of structured rows, such as parallel approvers, attendees with roles, or line items.
+
+```python
+from codeforms import Form, ObjectListField, TextField, CheckboxField
+
+form = Form(
+    name="parallel_approvers",
+    fields=[
+        ObjectListField(
+            name="parallel_approvals",
+            label="Aprobadores",
+            required=True,
+            min_items=1,
+            max_items=5,
+            fields=[
+                TextField(name="approver_email", label="Email", required=True),
+                TextField(name="label", label="Etiqueta", required=True),
+                CheckboxField(name="required", label="Obligatorio"),
+            ],
+        )
+    ],
+)
+```
+
+Expected submitted value:
+
+```json
+{
+  "parallel_approvals": [
+    {
+      "approver_email": "ana@empresa.com",
+      "label": "Compras",
+      "required": true
+    },
+    {
+      "approver_email": "luis@empresa.com",
+      "label": "Finanzas"
+    }
+  ]
+}
+```
+
+Validation behavior:
+
+- The top-level field must be a JSON array.
+- Each item must be a JSON object.
+- Unknown keys inside items are rejected.
+- Required nested subfields are enforced.
+- Validation errors include nested paths like `parallel_approvals[0].label`.
+
+Current limitation:
+
+- `ObjectListField` is fully supported in backend validation and JSON Schema export.
+- Rich repeatable HTML UI generation is not implemented yet. If you need an interactive editor, prefer consuming the exported `json_schema` from your frontend.
 
 ## Data Validation
 
@@ -284,9 +347,38 @@ Output:
 | `UrlField` | `string` (`format: "uri"`) | `minLength`, `maxLength` |
 | `TextareaField` | `string` | `minLength`, `maxLength` |
 | `ListField` | `array` | `minItems`, `maxItems` |
+| `ObjectListField` | `array` of `object` | nested `properties`, nested `required`, `minItems`, `maxItems` |
 
 Field annotations like `label`, `help_text`, `default_value`, and `readonly` map to the JSON Schema keywords `title`, `description`, `default`, and `readOnly` respectively.
 
+Example `ObjectListField` schema:
+
+```json
+{
+  "type": "array",
+  "minItems": 1,
+  "items": {
+    "type": "object",
+    "properties": {
+      "approver_email": {
+        "type": "string",
+        "title": "Email"
+      },
+      "label": {
+        "type": "string",
+        "title": "Etiqueta"
+      },
+      "required": {
+        "type": "boolean",
+        "title": "Obligatorio"
+      }
+    },
+    "required": ["approver_email", "label"],
+    "additionalProperties": false
+  }
+}
+```
+
 Fields inside `FieldGroup` and `FormStep` containers are flattened into the top-level `properties` automatically.
 
 ## Internationalization (i18n)

codeforms-0.2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+codeforms/__init__.py,sha256=fwftisOnA1dFLFoEDKMPpYBYlVBI7vFwxY-ThP21ERU,1735
+codeforms/export.py,sha256=PBfKHtsaXrQsIalQKE-MR6m_-LUKpbrAlc958DbpEAE,21265
+codeforms/fields.py,sha256=dt4sGL1XKhCiCGUrgHzwiymjP9c4CptsY9QFKjZKDSM,13803
+codeforms/forms.py,sha256=qWHF5TjmYuJU_Iw4eQ94_QTI-rbd8RTi20MbiH4jt_8,33692
+codeforms/i18n.py,sha256=VK0n3d8UaD-q31ggrlIiJ4NSjagoYLoz200YFCXKuKU,10392
+codeforms/registry.py,sha256=COYMIK0dtOdUwvNKBLhmUJEHC2ErSuJE8PU-jwZVt7U,6670
+codeforms-0.2.2.dist-info/METADATA,sha256=KjHK2PpzKmqG9voez5We5vDknH9CO3KsQ9mamX8Krzs,20284
+codeforms-0.2.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+codeforms-0.2.2.dist-info/licenses/LICENSE,sha256=U9D6cQ9DZJQrT03MMDJcq-aOuoB_Bn8HJlzcTTN7PfM,1074
+codeforms-0.2.2.dist-info/RECORD,,

{codeforms-0.2.1.dist-info → codeforms-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any

codeforms-0.2.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-codeforms/__init__.py,sha256=ozi9bHDT22B7kkh6fjCOm7Y6suJwWaHFWKR8S6kZlW0,1691
-codeforms/export.py,sha256=QuzllibvfFYv8nuG0WfUld4uzL-mnxZ51-CRYRYxhTE,20398
-codeforms/fields.py,sha256=LcDKiDX4lJ2OLT02eTYj-BSNKXq-CE6IE_Yb8MEDs1I,12793
-codeforms/forms.py,sha256=VM80L5fQyHJxwiCslFqlcsD2UvPDGVE_bnw_23XP-gY,38442
-codeforms/i18n.py,sha256=VK0n3d8UaD-q31ggrlIiJ4NSjagoYLoz200YFCXKuKU,10392
-codeforms/registry.py,sha256=Qwd-9-yXhzqJiG7loDPgFrCmLjZ_zOU4_vAfTV7zdzc,6620
-codeforms-0.2.1.dist-info/METADATA,sha256=2HG7D1OdTSFihxfDe2FftDAIyXXNJPsTymvpeOdwFH8,17746
-codeforms-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-codeforms-0.2.1.dist-info/licenses/LICENSE,sha256=U9D6cQ9DZJQrT03MMDJcq-aOuoB_Bn8HJlzcTTN7PfM,1074
-codeforms-0.2.1.dist-info/RECORD,,