pythonnative 0.23.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

pythonnative/hot_reload.py

@@ -576,7 +576,10 @@ class ModuleReloader:
             if getattr(vnode, "element", None) is not None:
                 rewrite_element_tree(vnode.element)
             rendered = getattr(vnode, "_rendered", None)
-            if rendered is not None:
+            if isinstance(rendered, (list, tuple)):
+                for rendered_el in rendered:
+                    rewrite_element_tree(rendered_el)
+            elif rendered is not None:
                 rewrite_element_tree(rendered)
             for child in getattr(vnode, "children", []) or []:
                 visit(child)
@@ -598,6 +601,11 @@ class ModuleReloader:
         if not replacement_map:
             return False
         rewrites = ModuleReloader.swap_components_in_tree(reconciler, replacement_map)
+        if rewrites > 0 and hasattr(reconciler, "reset_hook_signatures"):
+            # New component bodies may legitimately call a different
+            # hook sequence; forget the recorded signatures so the
+            # dev-mode order guard doesn't flag the refresh itself.
+            reconciler.reset_hook_signatures()
         return rewrites > 0
 
     @staticmethod

pythonnative/native_views/android.py

@@ -1073,7 +1073,7 @@ class ButtonHandler(AndroidViewHandler):
 
         class ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
             def onClick(self, view: Any) -> None:
-                _fire(view, "on_click")
+                _fire(view, "on_press")
 
         btn.setOnClickListener(ClickProxy())
         return btn
@@ -2094,6 +2094,81 @@ class ModalHandler(AndroidViewHandler):
                 pass
 
 
+# ======================================================================
+# Portal: floats its children over the screen in a top-level overlay
+# ======================================================================
+
+
+class PortalHandler(AndroidViewHandler):
+    """Overlay container hosting [`Portal`][pythonnative.Portal] children.
+
+    The portal's native view is a full-size, non-clickable
+    ``FrameLayout`` added directly to the screen's fragment container
+    (the same parent as the screen root, so portal coordinates equal
+    viewport coordinates). It is appended last, which stacks it above
+    the main content; because the overlay itself never consumes
+    touches, taps on empty areas fall through to the screen below
+    while the portal's own children stay interactive.
+
+    The overlay attaches lazily on the first child insert and re-homes
+    itself if the fragment container was rebuilt (e.g. after popping
+    back to a previously mounted screen).
+    """
+
+    def _build(self, props: Dict[str, Any]) -> Any:
+        overlay = jclass("android.widget.FrameLayout")(_ctx())
+        overlay.setClickable(False)
+        return overlay
+
+    def _apply(self, overlay: Any, props: Dict[str, Any], initial: bool) -> None:
+        _apply_common_visual(overlay, props)
+        if not initial:
+            self._ensure_attached(overlay)
+
+    def _ensure_attached(self, overlay: Any) -> None:
+        try:
+            from ..utils import get_android_fragment_container
+
+            container = get_android_fragment_container()
+        except Exception:
+            return
+        try:
+            parent = overlay.getParent()
+            if parent is not None and _java_id(parent) == _java_id(container):
+                overlay.bringToFront()
+                return
+            if parent is not None:
+                parent.removeView(overlay)
+            LayoutParams = jclass("android.view.ViewGroup$LayoutParams")
+            lp = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+            container.addView(overlay, lp)
+        except Exception:
+            pass
+
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+        self._ensure_attached(parent)
+        _insert_view(parent, child, index)
+
+    def remove_child(self, parent: Any, child: Any) -> None:
+        try:
+            parent.removeView(child)
+        except Exception:
+            pass
+
+    def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
+        # The overlay fills its container via MATCH_PARENT layout params;
+        # the engine frames only the portal's children.
+        return
+
+    def _teardown(self, overlay: Any) -> None:
+        try:
+            parent = overlay.getParent()
+            if parent is not None:
+                parent.removeView(overlay)
+        except Exception:
+            pass
+
+
 class SliderHandler(AndroidViewHandler):
     def _build(self, props: Dict[str, Any]) -> Any:
         sb = jclass("android.widget.SeekBar")(_ctx())
@@ -3211,6 +3286,7 @@ def register_handlers(registry: Any) -> None:
     registry.register("Spacer", SpacerHandler())
     registry.register("SafeAreaView", SafeAreaViewHandler())
     registry.register("Modal", ModalHandler())
+    registry.register("Portal", PortalHandler())
     registry.register("Slider", SliderHandler())
     registry.register("TabBar", TabBarHandler())
     registry.register("Pressable", PressableHandler())
@@ -3238,6 +3314,7 @@ __all__ = [
     "SpacerHandler",
     "SafeAreaViewHandler",
     "ModalHandler",
+    "PortalHandler",
     "SliderHandler",
     "TabBarHandler",
     "PressableHandler",

pythonnative/native_views/desktop.py

@@ -803,7 +803,7 @@ class TextHandler(DesktopViewHandler):
 class ButtonHandler(DesktopViewHandler):
     def build(self, props: Dict[str, Any]) -> Any:
         button = tk.Button(_master(), highlightthickness=0, takefocus=0)
-        button.configure(command=lambda: _fire(button, "on_click"))
+        button.configure(command=lambda: _fire(button, "on_press"))
         return button
 
     def apply(self, button: Any, props: Dict[str, Any]) -> None:
@@ -1328,6 +1328,42 @@ class ModalHandler(DesktopViewHandler):
         return
 
 
+# ======================================================================
+# Portal
+# ======================================================================
+
+
+class PortalHandler(DesktopViewHandler):
+    """Portal host that floats children over the whole stage.
+
+    Tkinter has no view that can cover the stage without also
+    swallowing clicks, so the portal keeps its own frame unmapped and
+    instead places each child directly against the stage (``_place``
+    with no logical parent targets the root container). The detached
+    layout pass produces viewport coordinates, which is exactly the
+    stage coordinate space, and ``_place`` lifts children above the
+    main content. Empty portal area has no widget at all, so clicks
+    there reach whatever sits underneath.
+    """
+
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+        # No ``_pn_parent``: placement composes against the stage.
+        child._pn_parent = None
+        _register_child(parent, child, index)
+        _place(child)
+
+    def remove_child(self, parent: Any, child: Any) -> None:
+        _unregister_child(parent, child)
+        try:
+            child.place_forget()
+        except Exception:
+            pass
+
+    def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
+        # The portal frame itself stays unmapped; only children render.
+        return
+
+
 # ======================================================================
 # TabBar
 # ======================================================================
@@ -1580,6 +1616,7 @@ def register_handlers(registry: Any) -> None:
     registry.register("ScrollView", ScrollViewHandler())
     registry.register("SafeAreaView", SafeAreaViewHandler())
     registry.register("Modal", ModalHandler())
+    registry.register("Portal", PortalHandler())
     registry.register("Slider", SliderHandler())
     registry.register("TabBar", TabBarHandler())
     registry.register("Pressable", PressableHandler())

pythonnative/native_views/ios.py

@@ -1589,7 +1589,7 @@ class ButtonHandler(IOSViewHandler):
         btn.setTranslatesAutoresizingMaskIntoConstraints_(True)
         btn.retain()
         _pn_retained_views.append(btn)
-        _register_control_action(btn, 1 << 6, lambda: _fire(btn, "on_click"))  # TouchUpInside
+        _register_control_action(btn, 1 << 6, lambda: _fire(btn, "on_press"))  # TouchUpInside
         return btn
 
     def measure_intrinsic(
@@ -3137,6 +3137,174 @@ class ModalHandler(IOSViewHandler):
         _fire(placeholder, "on_dismiss")
 
 
+# ======================================================================
+# Portal: floats its children over the screen in a top-level overlay
+# ======================================================================
+#
+# The overlay is an instance of ``_PNPortalViewCTypes``, a raw libobjc
+# subclass of ``UIView`` overriding ``pointInside:withEvent:`` so the
+# overlay only claims touches that land on one of its subviews. UIKit's
+# default hit-testing skips a view (and its whole subtree) when
+# ``pointInside:`` returns NO, so taps on empty portal area fall
+# through to the screen content below while the portal's own children
+# stay fully interactive. Registered raw (not via rubicon's
+# ``@objc_method``) for the same arm64 FFI reliability reasons as the
+# other delegate classes in this module.
+
+
+class _PNCGPoint(_ct.Structure):
+    _fields_ = [("x", _ct.c_double), ("y", _ct.c_double)]
+
+
+_PORTAL_POINT_INSIDE_TYPE = _ct.CFUNCTYPE(_ct.c_bool, _ct.c_void_p, _ct.c_void_p, _PNCGPoint, _ct.c_void_p)
+
+
+def _portal_point_inside_imp(self_ptr: int, _cmd_ptr: int, point: Any, _event_ptr: int) -> bool:
+    """Return whether ``point`` lands on any visible, interactive subview."""
+    try:
+        view = ObjCInstance(_ct.c_void_p(self_ptr))
+        px = float(point.x)
+        py = float(point.y)
+        # On instances of this raw-registered class rubicon resolves
+        # ``subviews`` as a bound method rather than a property, so it
+        # must be called to get the NSArray.
+        subs = view.subviews
+        if callable(subs):
+            subs = subs()
+        for sub in list(subs or []):
+            try:
+                if bool(sub.isHidden()) or float(sub.alpha) <= 0.01:
+                    continue
+                if not bool(sub.isUserInteractionEnabled()):
+                    continue
+                frame = sub.frame
+                fx = float(frame.origin.x)
+                fy = float(frame.origin.y)
+                fw = float(frame.size.width)
+                fh = float(frame.size.height)
+                if fx <= px <= fx + fw and fy <= py <= fy + fh:
+                    return True
+            except Exception:
+                continue
+        return False
+    except Exception:
+        return False
+
+
+_portal_point_inside_imp_ref = _PORTAL_POINT_INSIDE_TYPE(_portal_point_inside_imp)
+
+_UIVIEW_CLS = _get_cls(b"UIView")
+_PN_PORTAL_VIEW_CLS = _alloc_cls(_UIVIEW_CLS, b"_PNPortalViewCTypes", 0) if _UIVIEW_CLS else None
+if _PN_PORTAL_VIEW_CLS:
+    _add_method(
+        _PN_PORTAL_VIEW_CLS,
+        _sel_reg(b"pointInside:withEvent:"),
+        _ct.cast(_portal_point_inside_imp_ref, _ct.c_void_p),
+        b"c@:{CGPoint=dd}@",
+    )
+    _reg_cls(_PN_PORTAL_VIEW_CLS)
+
+
+class PortalHandler(IOSViewHandler):
+    """Overlay container hosting [`Portal`][pythonnative.Portal] children.
+
+    The portal's native view is a transparent, full-size overlay added
+    to the topmost view controller's view (the same view the screen
+    root is attached to). Its frame mirrors the screen host's root
+    frame (below the top safe-area inset), so portal coordinates equal
+    viewport coordinates. Attachment happens lazily on the first child
+    insert and re-homes itself if the host view changed (e.g. after a
+    native modal closed).
+
+    When the ``_PNPortalViewCTypes`` registration is unavailable the
+    handler degrades to a plain ``UIView`` overlay: portal children
+    still render and receive touches, but empty portal area blocks the
+    content below instead of passing touches through.
+    """
+
+    def _build(self, props: Dict[str, Any]) -> Any:
+        overlay = None
+        if _PN_PORTAL_VIEW_CLS:
+            try:
+                overlay = ObjCClass("_PNPortalViewCTypes").alloc().init()
+            except Exception:
+                overlay = None
+        if overlay is None:
+            overlay = ObjCClass("UIView").alloc().init()
+        overlay.setTranslatesAutoresizingMaskIntoConstraints_(True)
+        overlay.setBackgroundColor_(_uicolor("#00000000"))
+        overlay.retain()
+        _pn_retained_views.append(overlay)
+        return overlay
+
+    def _apply(self, overlay: Any, props: Dict[str, Any], initial: bool) -> None:
+        _apply_common_visual(overlay, props)
+        if not initial:
+            self._ensure_attached(overlay)
+
+    def _ensure_attached(self, overlay: Any) -> None:
+        try:
+            UIApplication = ObjCClass("UIApplication")
+            top = _top_view_controller_for_alert(UIApplication.sharedApplication)
+            host = top.view if top is not None else None
+            if host is None:
+                return
+            current = overlay.superview
+            if current is not None and _objc_ptr(current) == _objc_ptr(host):
+                host.bringSubviewToFront_(overlay)
+                self._sync_overlay_frame(overlay, host)
+                return
+            if current is not None:
+                overlay.removeFromSuperview()
+            host.addSubview_(overlay)
+            self._sync_overlay_frame(overlay, host)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _sync_overlay_frame(overlay: Any, host: Any) -> None:
+        """Mirror the screen host's root frame (see ``_sync_root_frame``)."""
+        try:
+            bounds = host.bounds
+            insets = host.safeAreaInsets
+            top = float(insets.top)
+            left = float(insets.left)
+            right = float(insets.right)
+            w = max(0.0, float(bounds.size.width) - left - right)
+            h = max(0.0, float(bounds.size.height) - top)
+            overlay.setFrame_(((left, top), (w, h)))
+            overlay.setAutoresizingMask_(2 | 16)  # FlexibleWidth | FlexibleHeight
+        except Exception:
+            pass
+
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+        self._ensure_attached(parent)
+        super().insert_child(parent, child, index)
+
+    def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
+        # The overlay frames itself against the host view; the engine
+        # frames only the portal's children.
+        return
+
+    def measure_intrinsic(
+        self,
+        native_view: Any,
+        max_width: float,
+        max_height: float,
+    ) -> Tuple[float, float]:
+        return (0.0, 0.0)
+
+    def _teardown(self, overlay: Any) -> None:
+        try:
+            _pn_retained_views.remove(overlay)
+        except ValueError:
+            pass
+        try:
+            overlay.release()
+        except Exception:
+            pass
+
+
 # ======================================================================
 # StatusBar: global side effect, no view in the tree
 # ======================================================================
@@ -3972,6 +4140,28 @@ def _table_row_height(info: dict, row: int) -> float:
     return float(info.get("row_height", 44.0))
 
 
+def _table_row_start(info: dict, row: int) -> float:
+    """Content-coordinate y where ``row`` begins."""
+    starts = info.get("row_starts")
+    if starts is not None and 0 <= row < len(starts):
+        return float(starts[row])
+    return float(info.get("row_height", 44.0)) * row
+
+
+def _table_set_heights(info: dict, heights: Optional[List[float]]) -> None:
+    """Store per-row heights plus their prefix sums (for row starts)."""
+    info["row_heights"] = heights
+    if not heights:
+        info["row_starts"] = None
+        return
+    starts = [0.0] * len(heights)
+    acc = 0.0
+    for i, h in enumerate(heights):
+        starts[i] = acc
+        acc += float(h)
+    info["row_starts"] = starts
+
+
 def _table_num_sections_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int) -> int:
     return 1
 
@@ -4041,7 +4231,37 @@ def _table_cell_imp(self_ptr: int, cmd_ptr: int, tv_ptr: int, ip_ptr: int) -> in
         except Exception:
             pass
 
-        if info is not None:
+        # Only rows in (or near) the visible content window get a
+        # mounted subtree. UITableView's accessibility container calls
+        # ``cellForRowAtIndexPath:`` for *every* row whenever an
+        # accessibility client (VoiceOver, XCUITest / UI-test drivers)
+        # snapshots the hierarchy, no matter the estimated heights.
+        # Mounting those would defeat virtualization -- a 10k-row list
+        # would mount 10k Python subtrees on the first snapshot -- and
+        # the never-displayed cells would sit stacked at the table
+        # origin where tests read them as visible. Off-window requests
+        # get an empty accessibility-hidden placeholder; when the row
+        # really scrolls on screen UIKit asks again and the content
+        # window has moved, so the real subtree mounts.
+        try:
+            offset_y = float(tv.contentOffset.y)
+        except Exception:
+            offset_y = 0.0
+        try:
+            viewport_h = float(tv.bounds.size.height)
+        except Exception:
+            viewport_h = 0.0
+        row_start = _table_row_start(info, row) if info else 0.0
+        margin = viewport_h if viewport_h > 0 else 800.0
+        in_window = (row_start + row_h >= offset_y - margin) and (
+            row_start <= offset_y + max(viewport_h, row_h) + margin
+        )
+        try:
+            cell.setAccessibilityElementsHidden_(not in_window)
+        except Exception:
+            pass
+
+        if in_window and info is not None:
             render_row = info.get("render_row")
             pool = info.get("pool")
             if render_row is not None and pool is not None:
@@ -4195,7 +4415,19 @@ class VirtualListHandler(IOSViewHandler):
         tv.setTranslatesAutoresizingMaskIntoConstraints_(True)
         tv.setSeparatorStyle_(0)  # none by default; rows draw their own
         try:
-            tv.setEstimatedRowHeight_(0.0)  # force exact heightForRow
+            # A *nonzero* estimate keeps UITableView lazy: with
+            # ``estimatedRowHeight = 0`` modern UIKit builds cells for
+            # every row up front to size its content, which mounts a
+            # Python subtree per row (defeating virtualization) and
+            # leaves the never-displayed cells visible to the
+            # accessibility tree. ``heightForRowAtIndexPath:`` still
+            # returns exact heights for the rows that do come on screen.
+            heights = props.get("row_heights")
+            if heights:
+                estimate = sum(float(h) for h in heights) / max(1, len(heights))
+            else:
+                estimate = float(props.get("row_height", 44.0) or 44.0)
+            tv.setEstimatedRowHeight_(max(1.0, estimate))
         except Exception:
             pass
         tv.retain()
@@ -4205,14 +4437,15 @@ class VirtualListHandler(IOSViewHandler):
         if source_ptr == 0:
             raise RuntimeError("[VirtualList][iOS] dataSource alloc returned NULL")
 
-        _pn_table_state[source_ptr] = {
+        state = {
             "count": int(props.get("count", 0) or 0),
             "row_height": float(props.get("row_height", 44.0) or 44.0),
-            "row_heights": props.get("row_heights"),
             "render_row": props.get("render_row"),
             "pool": RowHostPool(),
             "tv": tv,
         }
+        _table_set_heights(state, props.get("row_heights"))
+        _pn_table_state[source_ptr] = state
 
         _objc_msgSend.restype = None
         _objc_msgSend.argtypes = [_ct.c_void_p, _ct.c_void_p, _ct.c_void_p]
@@ -4220,7 +4453,6 @@ class VirtualListHandler(IOSViewHandler):
         _objc_msgSend(tv_ptr, _SEL_SET_DATA_SOURCE, _ct.c_void_p(source_ptr))
         _objc_msgSend(tv_ptr, _SEL_SET_DELEGATE, _ct.c_void_p(source_ptr))
 
-        state = _pn_table_state[source_ptr]
         state["source_ptr"] = source_ptr
         return tv
 
@@ -4245,7 +4477,7 @@ class VirtualListHandler(IOSViewHandler):
             info["row_height"] = float(props["row_height"])
             data_changed = True
         if "row_heights" in props:
-            info["row_heights"] = props.get("row_heights")
+            _table_set_heights(info, props.get("row_heights"))
             data_changed = True
         if "render_row" in props:
             info["render_row"] = props.get("render_row")
@@ -4350,6 +4582,7 @@ def register_handlers(registry: Any) -> None:
     registry.register("ScrollView", ScrollViewHandler())
     registry.register("SafeAreaView", SafeAreaViewHandler())
     registry.register("Modal", ModalHandler())
+    registry.register("Portal", PortalHandler())
     registry.register("Slider", SliderHandler())
     registry.register("TabBar", TabBarHandler())
     registry.register("Pressable", PressableHandler())
@@ -4377,6 +4610,7 @@ __all__ = [
     "SpacerHandler",
     "SafeAreaViewHandler",
     "ModalHandler",
+    "PortalHandler",
     "SliderHandler",
     "TabBarHandler",
     "PressableHandler",

pythonnative/navigation.py

@@ -45,11 +45,12 @@ Example:
     ```
 """
 
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, TypedDict, Union
 
 from .element import Element
 from .hooks import (
     Provider,
+    Ref,
     _NavigationContext,
     component,
     create_context,
@@ -60,6 +61,29 @@ from .hooks import (
     use_state,
 )
 
+
+class ScreenOptions(TypedDict, total=False):
+    """Typed per-screen options accepted by ``Screen(..., options=...)``.
+
+    All keys are optional. Navigators ignore keys they don't use.
+
+    Attributes:
+        title: Human-readable screen title. Stack navigators forward it
+            to the host's native navigation bar; tab and drawer
+            navigators use it as the item label.
+        tab_bar_icon: Native system icon identifier for tab items. A
+            string is used on every platform; a dict like
+            ``{"ios": "house.fill", "android": "ic_menu_home"}``
+            selects per platform. iOS values are resolved via
+            SF Symbols (``UIImage.systemImageNamed_``); Android values
+            are resolved against ``android.R.drawable.<name>``. Names
+            that don't resolve fall back to text-only.
+    """
+
+    title: str
+    tab_bar_icon: Union[str, Dict[str, str]]
+
+
 # ======================================================================
 # Focus context
 # ======================================================================
@@ -85,14 +109,14 @@ class _ScreenDef:
         name: Route name used by `navigate(name, ...)`.
         component: A `@component` function rendered when this screen is
             active.
-        options: Free-form per-screen options (e.g., `title` for the
-            tab bar, `headerShown`, etc.). Interpretation is up to the
-            specific navigator implementation.
+        options: Per-screen [`ScreenOptions`][pythonnative.ScreenOptions]
+            (e.g., `title`, `tab_bar_icon`). Interpretation is up to
+            the specific navigator implementation.
     """
 
     __slots__ = ("name", "component", "options")
 
-    def __init__(self, name: str, component_fn: Any, options: Optional[Dict[str, Any]] = None) -> None:
+    def __init__(self, name: str, component_fn: Any, options: Optional[ScreenOptions] = None) -> None:
         self.name = name
         self.component = component_fn
         self.options = options or {}
@@ -450,10 +474,10 @@ def _stack_navigator_impl(screens: Any = None, initial_route: Optional[str] = No
     stack, set_stack = use_state(lambda: [_RouteEntry(first_route, first_params)])
 
     stack_ref = use_ref(None)
-    stack_ref["current"] = stack
+    stack_ref.current = stack
 
     handle = use_memo(
-        lambda: _DeclarativeNavHandle(screen_map, lambda: stack_ref["current"], set_stack, parent=parent_nav), []
+        lambda: _DeclarativeNavHandle(screen_map, lambda: stack_ref.current, set_stack, parent=parent_nav), []
     )
     handle._screen_map = screen_map
     handle._parent = parent_nav
@@ -505,7 +529,7 @@ def create_stack_navigator() -> Any:
 
     class _StackNavigator:
         @staticmethod
-        def Screen(name: str, *, component: Any, options: Optional[Dict[str, Any]] = None) -> "_ScreenDef":
+        def Screen(name: str, *, component: Any, options: Optional[ScreenOptions] = None) -> "_ScreenDef":
             """Define a screen within this stack navigator.
 
             Args:
@@ -556,8 +580,8 @@ def _tab_navigator_impl(screens: Any = None, initial_route: Optional[str] = None
     active_tab, set_active_tab = use_state(first_route)
     tab_params, set_tab_params = use_state(lambda: {first_route: {}})
 
-    params_ref = use_ref(None)
-    params_ref["current"] = tab_params
+    params_ref: Ref[Dict[str, Dict[str, Any]]] = use_ref(None)
+    params_ref.current = tab_params
 
     def switch_tab(name: str, params: Optional[Dict[str, Any]] = None) -> None:
         set_active_tab(name)
@@ -565,7 +589,7 @@ def _tab_navigator_impl(screens: Any = None, initial_route: Optional[str] = None
             set_tab_params(lambda p: {**p, name: params})
 
     def get_stack() -> List[_RouteEntry]:
-        p = params_ref["current"] or {}
+        p = params_ref.current or {}
         return [_RouteEntry(active_tab, p.get(active_tab, {}))]
 
     handle = use_memo(lambda: _TabNavHandle(screen_map, get_stack, lambda _: None, switch_tab, parent=parent_nav), [])
@@ -643,7 +667,7 @@ def create_tab_navigator() -> Any:
 
     class _TabNavigator:
         @staticmethod
-        def Screen(name: str, *, component: Any, options: Optional[Dict[str, Any]] = None) -> "_ScreenDef":
+        def Screen(name: str, *, component: Any, options: Optional[ScreenOptions] = None) -> "_ScreenDef":
             """Define a screen within this tab navigator.
 
             Args:
@@ -704,8 +728,8 @@ def _drawer_navigator_impl(screens: Any = None, initial_route: Optional[str] = N
     drawer_open, set_drawer_open = use_state(False)
     screen_params, set_screen_params = use_state(lambda: {first_route: {}})
 
-    params_ref = use_ref(None)
-    params_ref["current"] = screen_params
+    params_ref: Ref[Dict[str, Dict[str, Any]]] = use_ref(None)
+    params_ref.current = screen_params
 
     def switch_screen(name: str, params: Optional[Dict[str, Any]] = None) -> None:
         set_active_screen(name)
@@ -713,7 +737,7 @@ def _drawer_navigator_impl(screens: Any = None, initial_route: Optional[str] = N
             set_screen_params(lambda p: {**p, name: params})
 
     def get_stack() -> List[_RouteEntry]:
-        p = params_ref["current"] or {}
+        p = params_ref.current or {}
         return [_RouteEntry(active_screen, p.get(active_screen, {}))]
 
     handle = use_memo(
@@ -763,7 +787,7 @@ def _drawer_navigator_impl(screens: Any = None, initial_route: Optional[str] = N
                 return _select
 
             menu_items.append(
-                Element("Button", {"title": label, "on_click": make_select(item_name)}, [], key=f"__drawer_{item_name}")
+                Element("Button", {"title": label, "on_press": make_select(item_name)}, [], key=f"__drawer_{item_name}")
             )
 
         drawer_panel = Element(
@@ -813,7 +837,7 @@ def create_drawer_navigator() -> Any:
 
     class _DrawerNavigator:
         @staticmethod
-        def Screen(name: str, *, component: Any, options: Optional[Dict[str, Any]] = None) -> "_ScreenDef":
+        def Screen(name: str, *, component: Any, options: Optional[ScreenOptions] = None) -> "_ScreenDef":
             """Define a screen within this drawer navigator.
 
             Args: