flet-routing 1.0.0__py3-none-any.whl

flet_routing/__init__.py

@@ -0,0 +1,28 @@
+from .router import FletRouter, FletRouterError
+from .types import (
+    AuthChecker,
+    Middleware,
+    MiddlewareContext,
+    Params,
+    Route,
+    RouteEntry,
+    ViewFactory,
+)
+from .components import BaseView, MiddlewareBase
+from .builtin import build_not_auth_view, build_not_found_view
+
+__all__ = [
+    "FletRouter",
+    "FletRouterError",
+    "AuthChecker",
+    "Middleware",
+    "MiddlewareContext",
+    "MiddlewareBase",
+    "Params",
+    "Route",
+    "RouteEntry",
+    "ViewFactory",
+    "BaseView",
+    "build_not_auth_view",
+    "build_not_found_view",
+]

flet_routing/builtin/__init__.py

@@ -0,0 +1,9 @@
+from .views.not_found import build_not_found_view
+from .views.not_auth import build_not_auth_view
+from .middlewares.logger import LoggerMiddleware
+
+__all__ = [
+    "build_not_found_view",
+    "build_not_auth_view",
+    "LoggerMiddleware"
+]

flet_routing/builtin/middlewares/logger.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from ...types.types import MiddlewareContext
+from ...components import MiddlewareBase
+
+class LoggerMiddleware(MiddlewareBase):
+    def __call__(self, ctx: 'MiddlewareContext'):
+        print("-----------------------------------")
+        print(f"[LOG]: Route -> {ctx.route}")
+        print(f"[LOG]: Private -> {ctx.private}")
+        print(f"[LOG]: Path -> {ctx.path}")
+        print(f"[LOG]: Params -> {ctx.params}")
+        print(f"[LOG]: Full Path -> {ctx.full_path}")
+        print(f"[LOG]: Router -> {ctx.router}")
+        print("-----------------------------------")
+        return True

flet_routing/builtin/views/not_auth.py

@@ -0,0 +1,35 @@
+from flet import (
+    Column,
+    Colors,
+    Container,
+    CrossAxisAlignment,
+    FontWeight,
+    Icon,
+    Icons,
+    MainAxisAlignment,
+    Text,
+    View,
+    alignment,
+)
+
+def build_not_auth_view() -> View:
+    return View(
+        route="/401",
+        controls=[
+            Container(
+                content=Column(
+                    controls=[
+                        Icon(Icons.LOCK, size=80, color=Colors.RED_400),
+                        Text("401 - Unauthorized", size=30, weight=FontWeight.BOLD),
+                        Text("You don't have permission to access this page.", size=16),
+                    ],
+                    horizontal_alignment=CrossAxisAlignment.CENTER,
+                    spacing=20,
+                ),
+                alignment=alignment.center,
+                expand=True,
+            ),
+        ],
+        horizontal_alignment=CrossAxisAlignment.CENTER,
+        vertical_alignment=MainAxisAlignment.CENTER,
+    )

flet_routing/builtin/views/not_found.py

@@ -0,0 +1,35 @@
+from flet import (
+    View,
+    Container,
+    Column,
+    Icon,
+    Icons,
+    Colors,
+    Text,
+    CrossAxisAlignment,
+    FontWeight,
+    MainAxisAlignment,
+    alignment
+)
+
+def build_not_found_view() -> View:
+    return View(
+        route="/404",
+        controls=[
+            Container(
+                content=Column(
+                    controls=[
+                        Icon(Icons.ERROR_OUTLINE, size=80, color=Colors.RED_400),
+                        Text("404 - Page Not Found", size=30, weight=FontWeight.BOLD),
+                        Text("The page you're looking for doesn't exist.", size=16),
+                    ],
+                    horizontal_alignment=CrossAxisAlignment.CENTER,
+                    spacing=20,
+                ),
+                alignment=alignment.center,
+                expand=True,
+            ),
+        ],
+        horizontal_alignment=CrossAxisAlignment.CENTER,
+        vertical_alignment=MainAxisAlignment.CENTER,
+    )

flet_routing/components/__init__.py

@@ -0,0 +1,7 @@
+from .base_view import BaseView
+from .middleware import MiddlewareBase
+
+__all__ = [
+    "BaseView",
+    "MiddlewareBase",
+]

flet_routing/components/base_view.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+from flet import (
+    AppBar,
+    BottomAppBar,
+    ColorValue,
+    Colors,
+    Control,
+    ControlEvent,
+    CupertinoAppBar,
+    CupertinoNavigationBar,
+    FloatingActionButton,
+    FloatingActionButtonLocation,
+    Icon,
+    IconButton,
+    Icons,
+    MainAxisAlignment,
+    NavigationBar,
+    NavigationDrawer,
+    OffsetValue,
+    OptionalControlEventCallable,
+    OptionalEventCallable,
+    OptionalNumber,
+    OnScrollEvent,
+    PaddingValue,
+    ScrollMode,
+    Text,
+    View,
+)
+from flet import *
+
+
+class BaseView(View):
+    def __init__(
+        self,
+        router: Optional['FletRouter'] = None,
+        route: str | None = None,
+        controls: Sequence[Control] | None = None,
+        appbar: AppBar | CupertinoAppBar | None = None,
+        bottom_appbar: BottomAppBar | None = None,
+        floating_action_button: FloatingActionButton | None = None,
+        floating_action_button_location: OffsetValue | FloatingActionButtonLocation = None,
+        navigation_bar: NavigationBar | CupertinoNavigationBar | None = None,
+        drawer: NavigationDrawer | None = None,
+        end_drawer: NavigationDrawer | None = None,
+        vertical_alignment: MainAxisAlignment | None = None,
+        horizontal_alignment: CrossAxisAlignment | None = None,
+        spacing: OptionalNumber = None,
+        padding: PaddingValue | None = None,
+        bgcolor: ColorValue | None = None,
+        decoration: BoxDecoration | None = None,
+        foreground_decoration: BoxDecoration | None = None,
+        can_pop: bool | None = None,
+        on_confirm_pop: OptionalControlEventCallable = None,
+        scroll: ScrollMode | None = None,
+        auto_scroll: bool | None = None,
+        fullscreen_dialog: bool | None = None,
+        on_scroll_interval: OptionalNumber = None,
+        on_scroll: OptionalEventCallable[OnScrollEvent] = None,
+        adaptive: bool | None = None
+    ):
+        super().__init__(
+            route=route,
+            controls=controls,
+            appbar=appbar,
+            bottom_appbar=bottom_appbar,
+            floating_action_button=floating_action_button,
+            floating_action_button_location=floating_action_button_location,
+            navigation_bar=navigation_bar,
+            drawer=drawer,
+            end_drawer=end_drawer,
+            vertical_alignment=vertical_alignment,
+            horizontal_alignment=horizontal_alignment,
+            spacing=spacing,
+            padding=padding,
+            bgcolor=bgcolor,
+            decoration=decoration,
+            foreground_decoration=foreground_decoration,
+            can_pop=can_pop,
+            on_confirm_pop=on_confirm_pop,
+            scroll=scroll,
+            auto_scroll=auto_scroll,
+            fullscreen_dialog=fullscreen_dialog,
+            on_scroll_interval=on_scroll_interval,
+            on_scroll=on_scroll,
+            adaptive=adaptive,
+        )
+        self.__router = router
+        
+    def build(self):
+        if not self.appbar:
+            self.appbar = AppBar(
+                leading=IconButton(
+                    icon=Icons.ARROW_BACK,
+                    on_click=self.pop,
+                    visible=bool(self.page.views)
+                ),
+                title=Text(self.route.replace("/", "") or "App")
+            )
+        return super().build()
+
+    @property
+    def router(self) -> 'FletRouter':
+        return self.__router 
+    
+    @router.setter
+    def router(self, new: 'FletRouter') -> None:
+        self.__router = new

flet_routing/components/middleware.py

@@ -0,0 +1,3 @@
+from .middleware_base import MiddlewareBase
+
+__all__ = ["MiddlewareBase"]

flet_routing/components/middleware_base.py

@@ -0,0 +1,13 @@
+from ..types import MiddlewareContext
+
+
+class MiddlewareBase:
+    """Base class for class‑based middlewares.
+
+    Subclass this and implement ``__call__(self, ctx: MiddlewareContext) -> bool``.
+    Instances of the subclass can be registered with :meth:`use` just like a
+    plain callable middleware.
+    """
+
+    def __call__(self, ctx: 'MiddlewareContext') -> bool:  # pragma: no cover
+        raise NotImplementedError("MiddlewareBase subclasses must implement __call__")