reflex 0.7.14a5__py3-none-any.whl → 0.8.0a1__py3-none-any.whl

reflex/components/props.py

@@ -2,17 +2,280 @@
 
 from __future__ import annotations
 
-from pydantic import ValidationError
+from collections.abc import Callable
+from dataclasses import _MISSING_TYPE, MISSING
+from typing import Any, TypeVar, get_args, get_origin
 
-from reflex.base import Base
+from typing_extensions import dataclass_transform
+
+from reflex.components.field import BaseField, FieldBasedMeta
 from reflex.utils import format
 from reflex.utils.exceptions import InvalidPropValueError
+from reflex.utils.serializers import serializer
+from reflex.utils.types import is_union
 from reflex.vars.object import LiteralObjectVar
 
+PROPS_FIELD_TYPE = TypeVar("PROPS_FIELD_TYPE")
+
+
+def _get_props_subclass(field_type: Any) -> type | None:
+    """Extract the Props subclass from a field type annotation.
+
+    Args:
+        field_type: The type annotation to check.
+
+    Returns:
+        The Props subclass if found, None otherwise.
+    """
+    from reflex.utils.types import typehint_issubclass
+
+    # For direct class types, we can return them directly if they're Props subclasses
+    if isinstance(field_type, type):
+        return field_type if typehint_issubclass(field_type, PropsBase) else None
+
+    # For Union types, check each union member
+    if is_union(field_type):
+        for arg in get_args(field_type):
+            result = _get_props_subclass(arg)
+            if result is not None:
+                return result
+
+    return None
+
+
+def _find_props_in_list_annotation(field_type: Any) -> type | None:
+    """Find Props subclass within a list type annotation.
+
+    Args:
+        field_type: The type annotation to check (e.g., list[SomeProps] or list[SomeProps] | None).
+
+    Returns:
+        The Props subclass if found in a list annotation, None otherwise.
+    """
+    origin = get_origin(field_type)
+    if origin is list:
+        args = get_args(field_type)
+        if args:
+            return _get_props_subclass(args[0])
+
+    # Handle Union types - check if any union member is a list
+    if is_union(field_type):
+        for arg in get_args(field_type):
+            if arg is not type(None):  # Skip None from Optional
+                list_element = _find_props_in_list_annotation(arg)
+                if list_element is not None:
+                    return list_element
+
+    return None
+
+
+class PropsField(BaseField[PROPS_FIELD_TYPE]):
+    """A field for a props class."""
+
+    def __init__(
+        self,
+        default: PROPS_FIELD_TYPE | _MISSING_TYPE = MISSING,
+        default_factory: Callable[[], PROPS_FIELD_TYPE] | None = None,
+        annotated_type: type[Any] | _MISSING_TYPE = MISSING,
+    ) -> None:
+        """Initialize the field.
+
+        Args:
+            default: The default value for the field.
+            default_factory: The default factory for the field.
+            annotated_type: The annotated type for the field.
+        """
+        super().__init__(default, default_factory, annotated_type)
+        self._name: str = ""  # Will be set by metaclass
+
+    @property
+    def required(self) -> bool:
+        """Check if the field is required (for Pydantic compatibility).
+
+        Returns:
+            True if the field has no default value or factory.
+        """
+        return self.default is MISSING and self.default_factory is None
+
+    @property
+    def name(self) -> str | None:
+        """Field name (for Pydantic compatibility).
+
+        Note: This is set by the metaclass when processing fields.
+
+        Returns:
+            The field name if set, None otherwise.
+        """
+        return getattr(self, "_name", None)
+
+    def get_default(self) -> Any:
+        """Get the default value (for Pydantic compatibility).
+
+        Returns:
+            The default value for the field, or None if required.
+        """
+        try:
+            return self.default_value()
+        except ValueError:
+            # Field is required (no default)
+            return None
+
+    def __repr__(self) -> str:
+        """Represent the field in a readable format.
+
+        Returns:
+            The string representation of the field.
+        """
+        annotated_type_str = (
+            f", annotated_type={self.annotated_type!r}"
+            if self.annotated_type is not MISSING
+            else ""
+        )
+        if self.default is not MISSING:
+            return f"PropsField(default={self.default!r}{annotated_type_str})"
+        return (
+            f"PropsField(default_factory={self.default_factory!r}{annotated_type_str})"
+        )
+
+
+def props_field(
+    default: PROPS_FIELD_TYPE | _MISSING_TYPE = MISSING,
+    default_factory: Callable[[], PROPS_FIELD_TYPE] | None = None,
+) -> PROPS_FIELD_TYPE:
+    """Create a field for a props class.
+
+    Args:
+        default: The default value for the field.
+        default_factory: The default factory for the field.
+
+    Returns:
+        The field for the props class.
+
+    Raises:
+        ValueError: If both default and default_factory are specified.
+    """
+    if default is not MISSING and default_factory is not None:
+        msg = "cannot specify both default and default_factory"
+        raise ValueError(msg)
+    return PropsField(  # pyright: ignore [reportReturnType]
+        default=default,
+        default_factory=default_factory,
+        annotated_type=MISSING,
+    )
+
 
-class PropsBase(Base):
+@dataclass_transform(field_specifiers=(props_field,))
+class PropsBaseMeta(FieldBasedMeta):
+    """Meta class for PropsBase."""
+
+    @classmethod
+    def _process_annotated_fields(
+        cls,
+        namespace: dict[str, Any],
+        annotations: dict[str, Any],
+        inherited_fields: dict[str, PropsField],
+    ) -> dict[str, PropsField]:
+        own_fields: dict[str, PropsField] = {}
+
+        for key, annotation in annotations.items():
+            value = namespace.get(key, MISSING)
+
+            if value is MISSING:
+                # Field with only annotation, no default value
+                field = PropsField(annotated_type=annotation, default=None)
+            elif not isinstance(value, PropsField):
+                # Field with default value
+                field = PropsField(annotated_type=annotation, default=value)
+            else:
+                # Field is already a PropsField, update annotation
+                field = PropsField(
+                    annotated_type=annotation,
+                    default=value.default,
+                    default_factory=value.default_factory,
+                )
+
+            own_fields[key] = field
+
+        return own_fields
+
+    @classmethod
+    def _create_field(
+        cls,
+        annotated_type: Any,
+        default: Any = MISSING,
+        default_factory: Callable[[], Any] | None = None,
+    ) -> PropsField:
+        return PropsField(
+            annotated_type=annotated_type,
+            default=default,
+            default_factory=default_factory,
+        )
+
+    @classmethod
+    def _finalize_fields(
+        cls,
+        namespace: dict[str, Any],
+        inherited_fields: dict[str, PropsField],
+        own_fields: dict[str, PropsField],
+    ) -> None:
+        # Call parent implementation
+        super()._finalize_fields(namespace, inherited_fields, own_fields)
+
+        # Add Pydantic compatibility
+        namespace["__fields__"] = namespace["_fields"]
+
+
+class PropsBase(metaclass=PropsBaseMeta):
     """Base for a class containing props that can be serialized as a JS object."""
 
+    def __init__(self, **kwargs):
+        """Initialize the props with field values.
+
+        Args:
+            **kwargs: The field values to set.
+        """
+        # Set field values from kwargs with nested object instantiation
+        for key, value in kwargs.items():
+            field_info = self.get_fields().get(key)
+            if field_info:
+                field_type = field_info.annotated_type
+
+                # Check if this field expects a specific Props type and we got a dict
+                if isinstance(value, dict):
+                    props_class = _get_props_subclass(field_type)
+                    if props_class is not None:
+                        value = props_class(**value)
+
+                # Check if this field expects a list of Props and we got a list of dicts
+                elif isinstance(value, list):
+                    element_type = _find_props_in_list_annotation(field_type)
+                    if element_type is not None:
+                        # Convert each dict in the list to the appropriate Props class
+                        value = [
+                            element_type(**item) if isinstance(item, dict) else item
+                            for item in value
+                        ]
+
+            setattr(self, key, value)
+
+        # Set default values for fields not provided
+        for field_name, field in self.get_fields().items():
+            if field_name not in kwargs:
+                if field.default is not MISSING:
+                    setattr(self, field_name, field.default)
+                elif field.default_factory is not None:
+                    setattr(self, field_name, field.default_factory())
+                # Note: Fields with no default and no factory remain unset (required fields)
+
+    @classmethod
+    def get_fields(cls) -> dict[str, Any]:
+        """Get the fields of the object.
+
+        Returns:
+            The fields of the object.
+        """
+        return getattr(cls, "_fields", {})
+
     def json(self) -> str:
         """Convert the object to a json-like string.
 
@@ -27,31 +290,117 @@ class PropsBase(Base):
             {format.to_camel_case(key): value for key, value in self.dict().items()}
         ).json()
 
-    def dict(self, *args, **kwargs):
+    def dict(
+        self,
+        exclude_none: bool = True,
+        include: set[str] | None = None,
+        exclude: set[str] | None = None,
+        **kwargs,
+    ):
         """Convert the object to a dictionary.
 
         Keys will be converted to camelCase.
         By default, None values are excluded (exclude_none=True).
 
         Args:
-            *args: Arguments to pass to the parent class.
-            **kwargs: Keyword arguments to pass to the parent class.
+            exclude_none: Whether to exclude None values.
+            include: Fields to include in the output.
+            exclude: Fields to exclude from the output.
+            **kwargs: Additional keyword arguments (for compatibility).
 
         Returns:
             The object as a dictionary.
         """
-        kwargs.setdefault("exclude_none", True)
-        return {
-            format.to_camel_case(key): value
-            for key, value in super().dict(*args, **kwargs).items()
-        }
+        result = {}
 
+        for field_name in self.get_fields():
+            if hasattr(self, field_name):
+                value = getattr(self, field_name)
 
-class NoExtrasAllowedProps(Base):
+                # Apply include/exclude filters
+                if include is not None and field_name not in include:
+                    continue
+                if exclude is not None and field_name in exclude:
+                    continue
+
+                # Apply exclude_none logic
+                if exclude_none and value is None:
+                    continue
+
+                # Recursively convert nested structures
+                value = self._convert_to_camel_case(
+                    value, exclude_none, include, exclude
+                )
+
+                # Convert key to camelCase
+                camel_key = format.to_camel_case(field_name)
+                result[camel_key] = value
+
+        return result
+
+    def _convert_to_camel_case(
+        self,
+        value: Any,
+        exclude_none: bool = True,
+        include: set[str] | None = None,
+        exclude: set[str] | None = None,
+    ) -> Any:
+        """Recursively convert nested dictionaries and lists to camelCase.
+
+        Args:
+            value: The value to convert.
+            exclude_none: Whether to exclude None values.
+            include: Fields to include in the output.
+            exclude: Fields to exclude from the output.
+
+        Returns:
+            The converted value with camelCase keys.
+        """
+        if isinstance(value, PropsBase):
+            # Convert nested PropsBase objects
+            return value.dict(
+                exclude_none=exclude_none, include=include, exclude=exclude
+            )
+        if isinstance(value, dict):
+            # Convert dictionary keys to camelCase
+            return {
+                format.to_camel_case(k): self._convert_to_camel_case(
+                    v, exclude_none, include, exclude
+                )
+                for k, v in value.items()
+                if not (exclude_none and v is None)
+            }
+        if isinstance(value, (list, tuple)):
+            # Convert list/tuple items recursively
+            return [
+                self._convert_to_camel_case(item, exclude_none, include, exclude)
+                for item in value
+            ]
+        # Return primitive values as-is
+        return value
+
+
+@serializer(to=dict)
+def serialize_props_base(value: PropsBase) -> dict:
+    """Serialize a PropsBase instance.
+
+    Unlike serialize_base, this preserves callables (lambdas) since they're
+    needed for AG Grid and other components that process them on the frontend.
+
+    Args:
+        value: The PropsBase instance to serialize.
+
+    Returns:
+        Dictionary representation of the PropsBase instance.
+    """
+    return value.dict()
+
+
+class NoExtrasAllowedProps(PropsBase):
     """A class that holds props to be passed or applied to a component with no extra props allowed."""
 
     def __init__(self, component_name: str | None = None, **kwargs):
-        """Initialize the props.
+        """Initialize the props with validation.
 
         Args:
             component_name: The custom name of the component.
@@ -61,17 +410,17 @@ class NoExtrasAllowedProps(Base):
             InvalidPropValueError: If invalid props are passed on instantiation.
         """
         component_name = component_name or type(self).__name__
-        try:
-            super().__init__(**kwargs)
-        except ValidationError as e:
-            invalid_fields = ", ".join([error["loc"][0] for error in e.errors()])  # pyright: ignore [reportCallIssue, reportArgumentType]
-            supported_props_str = ", ".join(f'"{field}"' for field in self.get_fields())
-            msg = f"Invalid prop(s) {invalid_fields} for {component_name!r}. Supported props are {supported_props_str}"
-            raise InvalidPropValueError(msg) from None
-
-    class Config:  # pyright: ignore [reportIncompatibleVariableOverride]
-        """Pydantic config."""
-
-        arbitrary_types_allowed = True
-        use_enum_values = True
-        extra = "forbid"
+
+        # Validate fields BEFORE setting them
+        known_fields = set(self.__class__.get_fields().keys())
+        provided_fields = set(kwargs.keys())
+        invalid_fields = provided_fields - known_fields
+
+        if invalid_fields:
+            invalid_fields_str = ", ".join(invalid_fields)
+            supported_props_str = ", ".join(f'"{field}"' for field in known_fields)
+            msg = f"Invalid prop(s) {invalid_fields_str} for {component_name!r}. Supported props are {supported_props_str}"
+            raise InvalidPropValueError(msg)
+
+        # Use parent class initialization after validation
+        super().__init__(**kwargs)

reflex/components/radix/primitives/accordion.py

@@ -334,7 +334,11 @@ class AccordionHeader(AccordionComponent):
         Returns:
             The style of the component.
         """
-        return {"display": "flex"}
+        return {
+            "display": "flex",
+            # Reset some values to ensure consistent styling without tailwind reset.
+            "margin": "0",
+        }
 
 
 class AccordionTrigger(AccordionComponent):
@@ -399,6 +403,9 @@ class AccordionTrigger(AccordionComponent):
                     "color": "var(--accent-contrast)",
                 },
             },
+            # Reset some values to ensure consistent styling without tailwind reset.
+            "background": "none",
+            "border": "none",
         }
 
 

reflex/components/radix/primitives/accordion.pyi

@@ -10,7 +10,7 @@ from reflex.components.component import Component, ComponentNamespace
 from reflex.components.core.breakpoints import Breakpoints
 from reflex.components.lucide.icon import Icon
 from reflex.components.radix.primitives.base import RadixPrimitiveComponent
-from reflex.event import EventType
+from reflex.event import EventType, PointerEventInfo
 from reflex.vars.base import Var
 
 LiteralAccordionType = Literal["single", "multiple"]
@@ -102,9 +102,9 @@ class AccordionComponent(RadixPrimitiveComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -115,6 +115,7 @@ class AccordionComponent(RadixPrimitiveComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> AccordionComponent:
@@ -239,9 +240,9 @@ class AccordionRoot(AccordionComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -252,6 +253,7 @@ class AccordionRoot(AccordionComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         on_value_change: EventType[()] | EventType[str | list[str]] | None = None,
         **props,
@@ -373,9 +375,9 @@ class AccordionItem(AccordionComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -386,6 +388,7 @@ class AccordionItem(AccordionComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> AccordionItem:
@@ -496,9 +499,9 @@ class AccordionHeader(AccordionComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -509,6 +512,7 @@ class AccordionHeader(AccordionComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> AccordionHeader:
@@ -615,9 +619,9 @@ class AccordionTrigger(AccordionComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -628,6 +632,7 @@ class AccordionTrigger(AccordionComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> AccordionTrigger:
@@ -672,9 +677,9 @@ class AccordionIcon(Icon):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -685,6 +690,7 @@ class AccordionIcon(Icon):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> AccordionIcon:
@@ -788,9 +794,9 @@ class AccordionContent(AccordionComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -801,6 +807,7 @@ class AccordionContent(AccordionComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> AccordionContent:

reflex/components/radix/primitives/base.pyi

@@ -8,7 +8,7 @@ from typing import Any, overload
 
 from reflex.components.component import Component
 from reflex.components.core.breakpoints import Breakpoints
-from reflex.event import EventType
+from reflex.event import EventType, PointerEventInfo
 from reflex.vars.base import Var
 
 class RadixPrimitiveComponent(Component):
@@ -30,9 +30,9 @@ class RadixPrimitiveComponent(Component):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -43,6 +43,7 @@ class RadixPrimitiveComponent(Component):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> RadixPrimitiveComponent:
@@ -83,9 +84,9 @@ class RadixPrimitiveComponentWithClassName(RadixPrimitiveComponent):
         autofocus: bool | None = None,
         custom_attrs: dict[str, Var | Any] | None = None,
         on_blur: EventType[()] | None = None,
-        on_click: EventType[()] | None = None,
-        on_context_menu: EventType[()] | None = None,
-        on_double_click: EventType[()] | None = None,
+        on_click: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
+        on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -96,6 +97,7 @@ class RadixPrimitiveComponentWithClassName(RadixPrimitiveComponent):
         on_mouse_over: EventType[()] | None = None,
         on_mouse_up: EventType[()] | None = None,
         on_scroll: EventType[()] | None = None,
+        on_scroll_end: EventType[()] | None = None,
         on_unmount: EventType[()] | None = None,
         **props,
     ) -> RadixPrimitiveComponentWithClassName: