pythonnative 0.23.0__py3-none-any.whl → 0.25.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_modules/notifications.py

@@ -28,11 +28,16 @@ Example:
 from __future__ import annotations
 
 import asyncio
-from typing import Any
+from typing import Any, Dict
 
 from ..runtime import resolve_future
 from ..utils import IS_ANDROID
 
+# Delayed Android deliveries in flight, keyed by identifier, so
+# ``cancel`` can abort a notification that hasn't posted yet. (iOS
+# delivers delays natively through UNTimeIntervalNotificationTrigger.)
+_android_delayed: Dict[str, "asyncio.Task[Any]"] = {}
+
 
 class Notifications:
     """Local notification interface."""
@@ -82,7 +87,13 @@ class Notifications:
         """
         del options
         if IS_ANDROID:
-            return await asyncio.to_thread(_android_schedule, title, body, delay_seconds, identifier)
+            if delay_seconds > 0:
+                _cancel_android_delayed(identifier)
+                _android_delayed[identifier] = asyncio.ensure_future(
+                    _android_schedule_later(title, body, delay_seconds, identifier)
+                )
+                return True
+            return await asyncio.to_thread(_android_schedule, title, body, identifier)
         return await asyncio.to_thread(_ios_schedule, title, body, delay_seconds, identifier)
 
     @staticmethod
@@ -94,6 +105,7 @@ class Notifications:
                 [`schedule`][pythonnative.native_modules.notifications.Notifications.schedule].
         """
         if IS_ANDROID:
+            _cancel_android_delayed(identifier)
             await asyncio.to_thread(_android_cancel, identifier)
             return
         await asyncio.to_thread(_ios_cancel, identifier)
@@ -104,8 +116,28 @@ class Notifications:
 # ======================================================================
 
 
-def _android_schedule(title: str, body: str, delay_seconds: float, identifier: str) -> bool:
-    del delay_seconds  # Android schedule is fire-and-forget for now.
+def _cancel_android_delayed(identifier: str) -> None:
+    pending = _android_delayed.pop(identifier, None)
+    if pending is not None and not pending.done():
+        pending.cancel()
+
+
+async def _android_schedule_later(title: str, body: str, delay_seconds: float, identifier: str) -> None:
+    """Post an Android notification after ``delay_seconds`` on the framework loop.
+
+    The delay lives in the app process (matching the semantics of
+    ``UNTimeIntervalNotificationTrigger`` closely enough for in-app
+    reminders); notifications whose delay outlives the process need
+    ``AlarmManager``, which is out of scope for the built-in module.
+    """
+    try:
+        await asyncio.sleep(delay_seconds)
+        await asyncio.to_thread(_android_schedule, title, body, identifier)
+    finally:
+        _android_delayed.pop(identifier, None)
+
+
+def _android_schedule(title: str, body: str, identifier: str) -> bool:
     try:
         from java import jclass
 

pythonnative/native_modules/permissions.py

@@ -193,8 +193,31 @@ def _ios_request(permission: str, on_done: Callable[[PermissionStatus], None]) -
 
             AVCaptureDevice.requestAccessForMediaType_completionHandler_(media, Block(_granted, None, bool))
             return
+
+        if permission == "photos":
+            PHPhotoLibrary = ObjCClass("PHPhotoLibrary")
+
+            def _photos_done(status: int) -> None:
+                # 0 notDetermined, 1 restricted, 2 denied, 3 authorized,
+                # 4 limited (counts as granted).
+                on_done({0: UNDETERMINED, 1: BLOCKED, 2: DENIED, 3: GRANTED, 4: GRANTED}.get(int(status), UNDETERMINED))
+
+            PHPhotoLibrary.requestAuthorization_(Block(_photos_done, None, int))
+            return
+
+        if permission == "notifications":
+            center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
+
+            def _notif_done(granted: bool, _error: Any) -> None:
+                on_done(GRANTED if granted else DENIED)
+
+            # 0x07 = badge | sound | alert.
+            center.requestAuthorizationWithOptions_completionHandler_(0x07, Block(_notif_done, None, bool, object))
+            return
     except Exception:
         pass
     # Fall back to reporting the current status for permissions whose
-    # request flow isn't wired up natively.
+    # request flow isn't wired up natively (location needs a
+    # CLLocationManager delegate; use the Location module's own
+    # request path for that).
     on_done(_ios_check(permission))

pythonnative/native_views/android.py

@@ -612,11 +612,16 @@ def _make_end_listener(anim_id: int) -> Any:
     AnimatorListener = jclass("android.animation.Animator$AnimatorListener")
 
     class _EndProxy(dynamic_proxy(AnimatorListener)):
+        # ``onAnimationStart`` / ``onAnimationEnd`` accept an optional
+        # ``isReverse``: API 26 added default two-arg overloads to
+        # ``AnimatorListener``, and ``ValueAnimator`` invokes those, so
+        # the java.lang.reflect.Proxy forwards two arguments here.
+
         def __init__(self) -> None:
             super().__init__()
             self._cancelled = False
 
-        def onAnimationStart(self, animation: Any) -> None:
+        def onAnimationStart(self, animation: Any, isReverse: bool = False) -> None:
             pass
 
         def onAnimationRepeat(self, animation: Any) -> None:
@@ -625,7 +630,7 @@ def _make_end_listener(anim_id: int) -> Any:
         def onAnimationCancel(self, animation: Any) -> None:
             self._cancelled = True
 
-        def onAnimationEnd(self, animation: Any) -> None:
+        def onAnimationEnd(self, animation: Any, isReverse: bool = False) -> None:
             entry = _native_anims.pop(anim_id, None)
             if entry is None:
                 return
@@ -1073,7 +1078,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 +2099,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 +3291,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 +3319,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,185 @@ 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):
+                # Already attached to the right host. Only reorder when
+                # the overlay is not frontmost: reordering the subview
+                # array during an active touch sequence (a re-render can
+                # flush between touch-down and touch-up) can cancel the
+                # touch and leave the portal's controls stuck
+                # highlighted with their action never fired.
+                try:
+                    front = host.subviews.lastObject()
+                    if front is None or _objc_ptr(front) != _objc_ptr(overlay):
+                        host.bringSubviewToFront_(overlay)
+                except Exception:
+                    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 +4151,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 +4242,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 +4426,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 +4448,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 +4464,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 +4488,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 +4593,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 +4621,7 @@ __all__ = [
     "SpacerHandler",
     "SafeAreaViewHandler",
     "ModalHandler",
+    "PortalHandler",
     "SliderHandler",
     "TabBarHandler",
     "PressableHandler",