flet 0.85.1__tar.gz → 0.85.3.dev0__tar.gz

{flet-0.85.1 → flet-0.85.3.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet
-Version: 0.85.1
+Version: 0.85.3.dev0
 Summary: Flet for Python - easily build interactive multi-platform apps in Python
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,23 +9,23 @@ Project-URL: Repository, https://github.com/flet-dev/flet
 Project-URL: Documentation, https://flet.dev/docs/
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: flet-cli==0.85.1; extra == "cli"
-Requires-Dist: flet-web==0.85.1; extra == "web"
+Requires-Dist: flet-cli==0.85.3.dev0; extra == "cli"
+Requires-Dist: flet-web==0.85.3.dev0; extra == "web"
 Requires-Dist: oauthlib>=3.2.2; platform_system != "Emscripten"
 Requires-Dist: httpx>=0.28.1; platform_system != "Emscripten"
 Requires-Dist: repath>=0.9.0
 Requires-Dist: msgpack>=1.1.0
 Requires-Dist: typing-extensions; python_version < "3.11"
 Provides-Extra: all
-Requires-Dist: flet-cli==0.85.1; extra == "all"
-Requires-Dist: flet-web==0.85.1; extra == "all"
-Requires-Dist: flet-desktop==0.85.1; extra == "all"
+Requires-Dist: flet-cli==0.85.3.dev0; extra == "all"
+Requires-Dist: flet-web==0.85.3.dev0; extra == "all"
+Requires-Dist: flet-desktop==0.85.3.dev0; extra == "all"
 Provides-Extra: cli
-Requires-Dist: flet-cli==0.85.1; extra == "cli"
+Requires-Dist: flet-cli==0.85.3.dev0; extra == "cli"
 Provides-Extra: desktop
-Requires-Dist: flet-desktop==0.85.1; extra == "desktop"
+Requires-Dist: flet-desktop==0.85.3.dev0; extra == "desktop"
 Provides-Extra: web
-Requires-Dist: flet-web==0.85.1; extra == "web"
+Requires-Dist: flet-web==0.85.3.dev0; extra == "web"
 
 <p align="center">
   <a href="https://flet.dev"><img src="https://raw.githubusercontent.com/flet-dev/flet/refs/heads/main/media/logo/flet-logo.svg" height="150" alt="Flet logo"></a>

{flet-0.85.1 → flet-0.85.3.dev0}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "flet"
-version = "0.85.1"
+version = "0.85.3.dev0"
 description = "Flet for Python - easily build interactive multi-platform apps in Python"
 authors = [{name = "Appveyor Systems Inc.", email = "hello@flet.dev"}]
 license = "Apache-2.0"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "flet-cli==0.85.1; extra == 'cli'",
-    "flet-web==0.85.1; extra == 'web'",
+    "flet-cli==0.85.3.dev0; extra == 'cli'",
+    "flet-web==0.85.3.dev0; extra == 'web'",
     "oauthlib >=3.2.2; platform_system != 'Emscripten'",
     "httpx >=0.28.1; platform_system != 'Emscripten'",
     "repath >=0.9.0",
@@ -23,15 +23,15 @@ Documentation = "https://flet.dev/docs/"
 
 [project.optional-dependencies]
 all = [
-    "flet-cli==0.85.1",
-    "flet-web==0.85.1",
-    "flet-desktop==0.85.1",
+    "flet-cli==0.85.3.dev0",
+    "flet-web==0.85.3.dev0",
+    "flet-desktop==0.85.3.dev0",
 ]
-cli = ["flet-cli==0.85.1"]
+cli = ["flet-cli==0.85.3.dev0"]
 desktop = [
-    "flet-desktop==0.85.1",
+    "flet-desktop==0.85.3.dev0",
 ]
-web = ["flet-web==0.85.1"]
+web = ["flet-web==0.85.3.dev0"]
 
 [project.scripts]
 flet = "flet.cli:main"

{flet-0.85.1 → flet-0.85.3.dev0}/src/flet/components/router.py

@@ -47,30 +47,55 @@ class Route:
     """
     Defines a single route in the route tree.
 
-    Routes can be nested via ``children`` to create layout hierarchies.
-    A route with ``component`` and ``children`` acts as a layout route — its
+    Routes can be nested via `children` to create layout hierarchies.
+    A route with `component` and `children` acts as a layout route — its
     component should call :func:`~flet.use_route_outlet` to render the
     matched child.
 
     Args:
-        path: Relative path segment. Supports dynamic segments (``:name``),
-            optional segments (``:name?``), splats (``:name*``), and custom
-            regex constraints (``:name(\\\\d+)``). ``None`` for pathless
+        path: Relative path segment. Supports dynamic segments (`:name`),
+            optional segments (`:name?`), splats (`:name*`), and custom
+            regex constraints (`:name(\\\\d+)`). `None` for pathless
             layout routes.
-        index: When ``True``, this route matches when the parent path
+        index: When `True`, this route matches when the parent path
             matches exactly (no further segments). Index routes must not
-            have ``path`` or ``children``.
-        component: A ``@component`` function to render when this route
+            have `path` or `children`.
+        component: A `@component` function to render when this route
             matches.
         children: Nested child routes.
         loader: Optional data loader function. Called with the matched
             params dict when the route matches. Result is available via
             :func:`~flet.use_route_loader_data`.
-        outlet: When ``True`` and ``manage_views=True``, this route acts
+        outlet: When `True` and `manage_views=True`, this route acts
             as a layout that wraps its matched child via
             :func:`~flet.use_route_outlet` within a single
             :class:`~flet.View`, instead of each child becoming a separate
             :class:`~flet.View`.
+        modal: When `True` and `manage_views=True`, the route's View
+            is rendered as a modal overlay on top of the existing stack
+            instead of replacing it. The route's component should set
+            `fullscreen_dialog=True` on its returned :class:`~flet.View`
+            so Flutter renders the slide-up presentation and a close (X)
+            icon. Placement controls the base stack:
+
+            * Declared at the **top level**: a *global* modal. The base
+              stack is rebuilt from the last non-modal location the
+              Router saw (defaults to `"/"` on first render).
+            * Declared as a **child** of a non-modal route: a *local*
+              modal. The base stack is the chain above the modal in the
+              route tree, so deep-link works from the URL alone.
+
+            On pop, the Router navigates to the resolved URL of the
+            non-modal parent — never to `views[-2].route` — so a
+            modal close is always a real navigation back to the
+            base location.
+        recursive: When `True`, the route can match itself as its own
+            descendant — one matched `_RouteMatch` per consumed segment.
+            Useful for tree-shaped URLs with unbounded depth
+            (e.g. `/folder/a/b/c`) where each segment should become its
+            own stack entry. Non-recursive children are tried before
+            self-recursion at every depth so a more specific sibling
+            (e.g. `example/:gp*`) wins over the recursive `:slug`.
     """
 
     path: str | None = None
@@ -79,6 +104,8 @@ class Route:
     children: list[Route] | None = field(default=None)
     loader: Callable[..., Any] | None = None
     outlet: bool = False
+    modal: bool = False
+    recursive: bool = False
 
 
 @dataclass
@@ -87,9 +114,9 @@ class LocationInfo:
     Describes the current location parsed from the page route.
 
     Args:
-        pathname: URL path portion (e.g. ``/products/42``).
-        search: Query string portion without leading ``?``.
-        hash: Fragment portion without leading ``#``.
+        pathname: URL path portion (e.g. `/products/42`).
+        search: Query string portion without leading `?`.
+        hash: Fragment portion without leading `#`.
     """
 
     pathname: str
@@ -142,7 +169,7 @@ def _match_routes(
     Match pathname against route tree.
 
     Returns a chain of matched routes from outermost to innermost,
-    or ``None`` if no route matches.
+    or `None` if no route matches.
     """
     for route in routes:
         result = _try_match(route, pathname, parent_path)
@@ -192,6 +219,43 @@ def _try_match(
     if not full_path:
         full_path = "/"
 
+    if route.recursive:
+        # Recursive routes consume one matched segment per recursion and
+        # try non-recursive children before self-recursing — so a more
+        # specific sibling (e.g. `example/:gp*`) wins over the
+        # recursive `:slug` at every depth without duplicate
+        # declarations.
+        prefix_pattern = repath.pattern(full_path, end=False)
+        prefix_m = re.match(prefix_pattern, pathname)
+        if not prefix_m:
+            return None
+        consumed = prefix_m.group(0)
+        head = _RouteMatch(
+            route=route,
+            params=prefix_m.groupdict(),
+            full_path=full_path,
+            resolved_path=consumed,
+        )
+        # Fully consumed → this is the leaf. Accept either an exact
+        # match or a trailing "/" remainder (so /folder/a and
+        # /folder/a/ both terminate cleanly).
+        remainder = pathname[len(consumed) :]
+        if not remainder or remainder == "/":
+            return [head]
+        # 1) Try non-recursive children first (more specific match).
+        for child in route.children or []:
+            if child is route:
+                continue
+            child_result = _try_match(child, pathname, consumed)
+            if child_result is not None:
+                return [head] + child_result
+        # 2) Fall back to self-recursion with the consumed prefix as
+        #    the parent path.
+        recurse = _try_match(route, pathname, consumed)
+        if recurse is None:
+            return None
+        return [head] + recurse
+
     if route.children:
         # Parent route — try prefix match to extract params, then match children
         parent_params: dict[str, str] = {}
@@ -298,7 +362,7 @@ def use_route_location() -> str:
     Returns an empty string if called outside a Router tree.
 
     Returns:
-        The current URL pathname (e.g. ``"/products/42"``).
+        The current URL pathname (e.g. `"/products/42"`).
     """
     loc = use_context(_location_context)
     if not _is_inside_router(loc):
@@ -311,17 +375,17 @@ def use_view_path() -> str:
     Returns the resolved URL for the current view level.
 
     This differs from :func:`use_route_location` which returns the full
-    current URL.  ``use_view_path`` returns the URL up to the current
-    view level (the leaf route of the view in ``manage_views=True`` mode).
+    current URL.  `use_view_path` returns the URL up to the current
+    view level (the leaf route of the view in `manage_views=True` mode).
 
-    Useful as the ``route`` value for :class:`~flet.View` to produce a
+    Useful as the `route` value for :class:`~flet.View` to produce a
     unique Navigator key per view in the stack.
 
     Must be called inside a component rendered by a :class:`~flet.Router`.
     Returns an empty string if called outside a Router tree.
 
     Returns:
-        The resolved URL for this view level (e.g. ``"/products/42"``).
+        The resolved URL for this view level (e.g. `"/products/42"`).
     """
     value = use_context(_view_path_context)
     if not _is_inside_router(value):
@@ -335,10 +399,10 @@ def use_route_outlet() -> Control:
 
     Used inside layout route components to render the active child route.
     Must be called inside a component rendered by a :class:`~flet.Router`.
-    Returns ``None`` if called outside a Router tree.
+    Returns `None` if called outside a Router tree.
 
     Returns:
-        The rendered child component, or ``None`` if no child matches.
+        The rendered child component, or `None` if no child matches.
     """
     value = use_context(_outlet_context)
     if not _is_inside_router(value):
@@ -350,10 +414,10 @@ def use_route_loader_data():
     """
     Returns the data from the current route's loader function.
 
-    Must be called inside a component whose route has a ``loader`` defined.
+    Must be called inside a component whose route has a `loader` defined.
 
     Returns:
-        The return value of the route's loader function, or ``None``.
+        The return value of the route's loader function, or `None`.
     """
     value = use_context(_loader_data_context)
     if not _is_inside_router(value):
@@ -369,12 +433,12 @@ def is_route_active(path: str, exact: bool = False) -> bool:
 
     Args:
         path: Path to check against the current location.
-        exact: If ``True``, requires an exact match. If ``False`` (default),
-            a prefix match is used (e.g. ``"/products"`` matches
-            ``"/products/42"``).
+        exact: If `True`, requires an exact match. If `False` (default),
+            a prefix match is used (e.g. `"/products"` matches
+            `"/products/42"`).
 
     Returns:
-        ``True`` if the path matches the current location.
+        `True` if the path matches the current location.
     """
     loc = use_context(_location_context)
     if not _is_inside_router(loc):
@@ -443,7 +507,7 @@ def _split_chain_into_view_levels(
     """
     Split matched chain into layout wrappers and view entries.
 
-    Only **pathless** routes (no ``path``, not ``index``) with a component
+    Only **pathless** routes (no `path`, not `index`) with a component
     are treated as layouts that wrap every View.  All other routes with
     a component become their own View in the stack.
 
@@ -451,7 +515,7 @@ def _split_chain_into_view_levels(
         A tuple of (layouts, view_entries) where:
         - layouts: pathless routes with components that wrap every View
         - view_entries: path-bearing routes, each becoming its own View.
-          Each entry is ``(match, accumulated_path)``.
+          Each entry is `(match, accumulated_path)`.
     """
     layouts: list[_RouteMatch] = []
     view_entries: list[tuple[_RouteMatch, str]] = []
@@ -543,7 +607,7 @@ def Router(
     Navigation is done via :meth:`~flet.Page.push_route` or
     :meth:`~flet.Page.navigate`.
 
-    When ``manage_views`` is ``True``, the Router returns a list of
+    When `manage_views` is `True`, the Router returns a list of
     :class:`~flet.View` objects (one per path level) instead of a single
     component tree. This enables swipe-back gestures, system back button,
     and :class:`~flet.AppBar` implicit back button on mobile.
@@ -552,10 +616,10 @@ def Router(
     Args:
         routes: List of top-level :class:`~flet.Route` definitions.
         not_found: Optional component to render when no route matches (404).
-        manage_views: When ``True``, produce a list of
+        manage_views: When `True`, produce a list of
             :class:`~flet.View` objects (one per path level) instead of a
             single component tree. Route components should return
-            :class:`~flet.View` instances with ``route`` and ``appbar``
+            :class:`~flet.View` instances with `route` and `appbar`
             set. Use with :meth:`~flet.Page.render_views`.
 
     Example:
@@ -576,6 +640,22 @@ def Router(
     location, set_location = use_state(page.route or "/")
     prev_route_handler_ref = use_ref(None)
     prev_pop_handler_ref = use_ref(None)
+    # Last non-modal location the Router saw. Used as the base for
+    # global modal routes (declared at the top level) — when the user
+    # navigates from /apps/X to /settings (modal=True), the modal is
+    # rendered ON TOP OF the chain matched against /apps/X, so closing
+    # it reveals the original stack instead of rebuilding it.
+    prev_non_modal_location_ref = use_ref(None)
+    # Snapshot of the chain emitted for the current location. Used by
+    # the default pop handler to compute the parent URL structurally
+    # (`chain[-2].resolved_path`), which survives shared `view.route`
+    # keys (e.g. an app that uses the same route key for two sibling
+    # tab roots to suppress switch animations).
+    current_chain_ref = use_ref(None)
+    # URL to navigate to when popping the topmost view, IF the current
+    # chain ends in a modal route. `None` otherwise. Set whenever a
+    # modal route matches.
+    current_modal_pop_to_ref = use_ref(None)
 
     # Subscribe to route changes on mount
     def setup_listeners():
@@ -590,13 +670,45 @@ def Router(
             prev_pop_handler_ref.current = page.on_view_pop
 
             def on_view_pop(e):
-                from flet.components.public_utils import unwrap_component
-
-                views_list = unwrap_component(page.views)
-                if isinstance(views_list, list) and len(views_list) > 1:
-                    prev_view = unwrap_component(views_list[-2])
-                    if prev_view is not None:
-                        page.navigate(prev_view.route)
+                # If the app installed its own `page.on_view_pop` before
+                # the Router mounted, delegate to it. Apps can still
+                # override entirely (e.g. for a stack visualisation or
+                # confirmation flow).
+                prev = prev_pop_handler_ref.current
+                if prev is not None:
+                    prev(e)
+                    return
+
+                # Modal pop: navigate to the base URL stamped at emit
+                # time. Same logic for global and local modals — the
+                # base URL was resolved when the modal was matched.
+                if current_modal_pop_to_ref.current is not None:
+                    page.navigate(current_modal_pop_to_ref.current)
+                    return
+
+                # Non-modal pop: navigate to the previous *view entry*'s
+                # resolved URL rather than `chain[-2]` or
+                # `views[-2].route`. Classifying into view entries skips
+                # `outlet=True` layouts and componentless grouping routes
+                # — otherwise `chain[-2]` can point at a layout whose URL
+                # equals the current view's URL, making the pop navigate
+                # to where we already are (a no-op that strands the URL).
+                # Staying route-tree-structural also survives shared view
+                # keys like a tab-root layout emitting `route="/"` for
+                # multiple sibling sections.
+                chain_now = current_chain_ref.current
+                if chain_now:
+                    _, view_entries = _split_chain_into_view_levels(chain_now)
+                    if len(view_entries) > 1:
+                        parent_match = view_entries[-2][0]
+                        target = (
+                            parent_match.resolved_path or parent_match.full_path or "/"
+                        )
+                        page.navigate(target)
+                        return
+
+                # Stack of length 1 — nothing to pop to. (Flutter's
+                # `Navigator.canPop` is False here anyway.)
 
             page.on_view_pop = on_view_pop
 
@@ -621,10 +733,66 @@ def Router(
             if manage_views:
                 from flet.controls.core.view import View
 
+                # Reset state so a stale modal pop_to doesn't leak into
+                # a 404'd location.
+                current_chain_ref.current = None
+                current_modal_pop_to_ref.current = None
                 return [View(route=pathname, controls=[not_found()])]
             return not_found()
         return None
 
+    # Detect modal routes in the chain. `modal_idx` is the index of
+    # the first route in the chain with `modal=True`; `-1` means
+    # the chain is fully non-modal.
+    modal_idx = -1
+    for i, m in enumerate(chain):
+        if m.route.modal:
+            modal_idx = i
+            break
+
+    # For a *global* modal (`modal_idx == 0` — the chain starts at a
+    # modal with no non-modal parents) we want the visible stack to be
+    # the chain of the previously visited non-modal location +
+    # the modal's own chain. This way the underlying stack stays mounted
+    # underneath the modal — closing the modal reveals it without a
+    # rebuild.
+    if manage_views and modal_idx == 0:
+        base_location = prev_non_modal_location_ref.current or "/"
+        base_pathname = _normalize_path(urlparse(base_location).path or "/")
+        base_chain = _match_routes(routes, base_pathname) or []
+        # If the base path also resolves to a modal (shouldn't happen
+        # in practice — non-modal navigations are the only ones that
+        # update prev_non_modal_location_ref), fall back to no base.
+        if any(b.route.modal for b in base_chain):
+            base_chain = []
+        # Combine: base lives below, modal sits on top.
+        chain = base_chain + chain
+        # Re-locate the modal index in the combined chain.
+        modal_idx = len(base_chain)
+
+    # Track refs that downstream consumers (default pop handler, etc.)
+    # read. `current_chain_ref` always reflects the chain we're
+    # actually emitting. `current_modal_pop_to_ref` is set only when
+    # the chain ends in a modal — non-modal navigations clear it.
+    current_chain_ref.current = chain
+    if modal_idx == -1:
+        # Non-modal navigation — remember it as the next base.
+        prev_non_modal_location_ref.current = location
+        current_modal_pop_to_ref.current = None
+    else:
+        # Modal route — the URL to pop to is the resolved URL of the
+        # last non-modal entry in the chain.
+        if modal_idx > 0:
+            parent = chain[modal_idx - 1]
+            current_modal_pop_to_ref.current = (
+                parent.resolved_path or parent.full_path or "/"
+            )
+        else:
+            # No non-modal parent in the chain (rare — would require a
+            # deep-link to a top-level modal with no remembered base
+            # AND an empty default match). Fall back to "/".
+            current_modal_pop_to_ref.current = "/"
+
     # Merge all params from the chain
     all_params: dict[str, str] = {}
     for m in chain:
@@ -640,7 +808,8 @@ def Router(
     loc = LocationInfo(pathname=pathname, search=search, hash=hash_val)
 
     if not manage_views:
-        # Single-view mode (existing behavior)
+        # Single-view mode (existing behavior). `modal` is ignored
+        # here — it only affects stack composition in multi-view mode.
         return _location_context(
             loc,
             lambda: _params_context(
@@ -653,47 +822,81 @@ def Router(
     # route, etc.).  The Router sets route and can_pop on each View
     # after the component body executes (via the patch walk).
     # Used with page.render_views(App).
-    layouts, view_entries = _split_chain_into_view_levels(chain)
+    #
+    # If the chain contains a modal route, split into two independent
+    # sub-chains at the modal boundary. Each sub-chain is classified
+    # into layouts vs. view entries SEPARATELY so that an outlet route
+    # that would be a leaf view in its own sub-chain doesn't get
+    # re-classified as a layout just because there's more chain after
+    # the boundary. `modal_idx` already points to the modal route in
+    # the (possibly combined) chain.
+    # `modal_idx <= 0` covers both the no-modal case (`-1`) and a
+    # degenerate modal chain with no base (`0`) — neither is split.
+    sub_chains = [chain] if modal_idx <= 0 else [chain[:modal_idx], chain[modal_idx:]]
+
+    # Each sub-chain's views see their own URL via the location
+    # context. The base sub-chain (when there's a modal split) sees the
+    # remembered non-modal location it was matched against — so
+    # `is_route_active("/gallery")` inside a base view stays True
+    # while a global `/settings` modal is open over Gallery.
+    base_sub_loc = LocationInfo(pathname=pathname, search=search, hash=hash_val)
+    if modal_idx > 0:
+        base_loc_str = prev_non_modal_location_ref.current or "/"
+        base_parsed = urlparse(base_loc_str)
+        base_sub_loc = LocationInfo(
+            pathname=_normalize_path(base_parsed.path or "/"),
+            search=base_parsed.query or "",
+            hash=base_parsed.fragment or "",
+        )
 
     results = []
-    for match, _ in view_entries:
-        # Params accumulated up to this view level
-        level_params: dict[str, str] = {}
-        for m in chain:
-            level_params.update(m.params)
-            if m is match:
-                break
-
-        # LocationInfo.pathname is the actual URL (not the route template),
-        # so is_route_active() and use_route_location() work consistently.
-        level_loc = LocationInfo(pathname=pathname, search=search, hash=hash_val)
-        # Per-view resolved URL — unique per view level for Navigator keying.
-        level_view_path = match.resolved_path or match.full_path or "/"
-        _match = match
-        # Only apply layouts that appear before this view entry in the chain
-        match_idx = chain.index(match)
-        _layouts = [lm for lm in layouts if chain.index(lm) < match_idx]
-
-        def build_view_content(
-            _match=_match,
-            _layouts=_layouts,
-            _level_params=level_params,
-            _level_loc=level_loc,
-            _level_view_path=level_view_path,
-        ):
-            return _view_path_context(
-                _level_view_path,
-                lambda: _location_context(
-                    _level_loc,
-                    lambda: _params_context(
-                        _level_params,
-                        lambda: _build_view_level(
-                            _layouts, _match, loader_results, chain
+    for sub_chain_idx, sub_chain in enumerate(sub_chains):
+        layouts, view_entries = _split_chain_into_view_levels(sub_chain)
+        # The base sub-chain (everything before the modal) is rendered
+        # "as if" the user is at the previous non-modal URL; the modal
+        # sub-chain is rendered at the modal URL.
+        sub_loc = base_sub_loc if (modal_idx > 0 and sub_chain_idx == 0) else loc
+        for match, _ in view_entries:
+            # Params accumulated up to this view level — within the
+            # combined chain so a local modal view still sees its
+            # parents' captures.
+            level_params: dict[str, str] = {}
+            for m in chain:
+                level_params.update(m.params)
+                if m is match:
+                    break
+
+            # Per-view resolved URL — unique per view level for
+            # Navigator keying.
+            level_view_path = match.resolved_path or match.full_path or "/"
+            _match = match
+            # Only apply layouts that appear before this view entry IN
+            # THE SAME SUB-CHAIN. A modal view never inherits the
+            # base's layouts (and vice versa).
+            match_idx = sub_chain.index(match)
+            _layouts = [lm for lm in layouts if sub_chain.index(lm) < match_idx]
+
+            def build_view_content(
+                _match=_match,
+                _layouts=_layouts,
+                _level_params=level_params,
+                _level_loc=sub_loc,
+                _level_view_path=level_view_path,
+                _sub_chain=sub_chain,
+            ):
+                return _view_path_context(
+                    _level_view_path,
+                    lambda: _location_context(
+                        _level_loc,
+                        lambda: _params_context(
+                            _level_params,
+                            lambda: _build_view_level(
+                                _layouts, _match, loader_results, _sub_chain
+                            ),
                         ),
                     ),
-                ),
-            )
+                )
 
-        results.append(build_view_content())
+            results.append(build_view_content())
 
     return results

{flet-0.85.1 → flet-0.85.3.dev0}/src/flet/controls/core/icon.py

@@ -28,7 +28,7 @@ class Icon(LayoutControl):
     The icon to display, selected from a predefined icon set.
 
     You can explore available icons using the
-    [Flet Icons Browser](https://examples.flet.dev/icons_browser/).
+    [Flet Icons Browser](https://flet.app/gallery/run/apps/icons_browser/).
     """
 
     color: Optional[ColorValue] = None

{flet-0.85.1 → flet-0.85.3.dev0}/src/flet/controls/keys.py

@@ -10,7 +10,7 @@ __all__ = [
 
 
 def _lazy_value(cls=None, **kwargs):
-    """Deferred proxy for ``value`` to avoid circular import with base_control."""
+    """Deferred proxy for `value` to avoid circular import with base_control."""
     from flet.controls.base_control import value as _v
 
     if cls is not None:

{flet-0.85.1 → flet-0.85.3.dev0}/src/flet/controls/material/radio_group.py

@@ -21,8 +21,8 @@ class RadioGroup(Control):
     """
     The content of the RadioGroup.
 
-    Typically a list of `Radio` controls nested in a container control, e.g. `Column`,
-    `Row`.
+    Typically a list of :class:`~flet.Radio` controls nested in a container control,
+    e.g. `Column`, `Row`.
 
     Raises:
         ValueError: If :attr:`content` is not visible.

{flet-0.85.1 → flet-0.85.3.dev0}/src/flet/controls/page.py

@@ -947,8 +947,8 @@ class Page(BasePage):
         """
         Navigate to a new route (sync convenience wrapper).
 
-        Equivalent to ``asyncio.create_task(page.push_route(route, **kwargs))``.
-        Use this in synchronous callbacks (e.g. ``on_click``) where awaiting
+        Equivalent to `asyncio.create_task(page.push_route(route, **kwargs))`.
+        Use this in synchronous callbacks (e.g. `on_click`) where awaiting
         is not possible.
 
         Args:

{flet-0.85.1 → flet-0.85.3.dev0}/src/flet/controls/types.py

@@ -1307,7 +1307,7 @@ Represents a color and can be:
 - a material color from the :class:`~flet.Colors` enum,
 - or a Cupertino color from the :class:`~flet.CupertinoColors` enum.
 
-More information [here](https://flet.dev/docs/cookbook/cookbook/cookbook/colors).
+More information [here](https://flet.dev/docs/cookbook/colors).
 """
 
 # Icons