Remove core.py

Author: Archmonger

src/reactpy_router/__init__.py

@@ -2,28 +2,15 @@
 __version__ = "0.1.1"
 
 
-from .converters import CONVERTERS
-from .core import (
-    create_router,
-    link,
-    route,
-    use_params,
-    use_search_params,
-)
-from .resolvers import Resolver
-from .routers import browser_router
-from .types import Route, RouteCompiler, RouteResolver
+from .components import link, route
+from .hooks import use_params, use_search_params
+from .routers import browser_router, create_router
 
 __all__ = (
     "create_router",
     "link",
     "route",
-    "Route",
-    "RouteCompiler",
-    "RouteResolver",
     "browser_router",
     "use_params",
     "use_search_params",
-    "Resolver",
-    "CONVERTERS",
 )

src/reactpy_router/components.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from reactpy import component, html
+from reactpy.backend.types import Location
+from reactpy.core.types import VdomChild, VdomDict
+from reactpy.web.module import export, module_from_file
+
+from reactpy_router.hooks import _use_route_state
+from reactpy_router.types import Route
+
+History = export(
+    module_from_file("reactpy-router", file=Path(__file__).parent / "static" / "bundle.js"),
+    ("History"),
+)
+link_js_content = (Path(__file__).parent / "static" / "link.js").read_text(encoding="utf-8")
+
+
+@component
+def link(*children: VdomChild, to: str, **attributes: Any) -> VdomDict:
+    """A component that renders a link to the given path."""
+    # FIXME: This currently works in a "dumb" way by trusting that ReactPy's script tag \
+    # properly sets the location. When a client-server communication layer is added to a \
+    # future ReactPy release, this component will need to be rewritten to use that instead. \
+    set_location = _use_route_state().set_location
+    uuid = uuid4().hex
+
+    def on_click(_event: dict[str, Any]) -> None:
+        pathname, search = to.split("?", 1) if "?" in to else (to, "")
+        if search:
+            search = f"?{search}"
+        set_location(Location(pathname, search))
+
+    attrs = {
+        **attributes,
+        "href": to,
+        "onClick": on_click,
+        "id": uuid,
+    }
+    return html._(html.a(attrs, *children), html.script(link_js_content.replace("UUID", uuid)))
+
+
+def route(path: str, element: Any | None, *routes: Route) -> Route:
+    """Create a route with the given path, element, and child routes."""
+    return Route(path, element, routes)

src/reactpy_router/core.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+from urllib.parse import parse_qs
+
+from reactpy import (
+    create_context,
+    use_context,
+    use_location,
+)
+from reactpy.backend.types import Location
+from reactpy.types import Context
+
+
+@dataclass
+class _RouteState:
+    set_location: Callable[[Location], None]
+    params: dict[str, Any]
+
+
+def _use_route_state() -> _RouteState:
+    route_state = use_context(_route_state_context)
+    if route_state is None:
+        raise RuntimeError(
+            "ReactPy-Router was unable to find a route context. Are you "
+            "sure this hook/component is being called within a router?"
+        )
+
+    return route_state
+
+
+_route_state_context: Context[_RouteState | None] = create_context(None)
+
+
+def use_params() -> dict[str, Any]:
+    """The `use_params` hook returns an object of key/value pairs of the dynamic parameters \
+    from the current URL that were matched by the `Route`. Child routes inherit all parameters \
+    from their parent routes.
+
+    For example, if you have a `URL_PARAM` defined in the route `/example/<URL_PARAM>/`,
+    this hook will return the URL_PARAM value that was matched."""
+
+    # TODO: Check if this returns all parent params
+    return _use_route_state().params
+
+
+def use_search_params(
+    keep_blank_values: bool = False,
+    strict_parsing: bool = False,
+    errors: str = "replace",
+    max_num_fields: int | None = None,
+    separator: str = "&",
+) -> dict[str, list[str]]:
+    """
+    The `use_search_params` hook is used to read and modify the query string in the URL \
+    for the current location. Like React's own `use_state` hook, `use_search_params` returns \
+    an array of two values: the current location's search parameters and a function that may \
+    be used to update them.
+
+    See `urllib.parse.parse_qs` for info on this hook's parameters."""
+
+    # FIXME: This needs to return a tuple of the search params and a function to update them
+    return parse_qs(
+        use_location().search[1:],
+        keep_blank_values=keep_blank_values,
+        strict_parsing=strict_parsing,
+        errors=errors,
+        max_num_fields=max_num_fields,
+        separator=separator,
+    )

src/reactpy_router/hooks.py

@@ -6,11 +6,13 @@
 from reactpy_router.converters import CONVERTERS
 from reactpy_router.types import ConversionInfo, ConverterMapping, Route
 
-__all__ = ["Resolver"]
+__all__ = ["StarletteResolver"]
 
 
-class Resolver:
-    """A simple route resolver that uses regex to match paths."""
+class StarletteResolver:
+    """URL resolver that matches routes that match the starlette URL routing syntax.
+
+    However, we add a few additional parameter types on top of Starlette's syntax."""
 
     def __init__(
         self,
@@ -21,7 +23,6 @@ def __init__(
         self.element = route.element
         self.registered_converters = converters or CONVERTERS
         self.converter_mapping: ConverterMapping = {}
-        # self.match_any_indentifier = match_any_identifier
         self.param_regex = re.compile(param_pattern)
         self.pattern = self.parse_path(route.path)
         self.key = self.pattern.pattern  # Unique identifier for ReactPy rendering