Change star pattern to {NAME:any}

Author: Archmonger

.gitignore

@@ -4,7 +4,7 @@ docs/site
 
 # --- JAVASCRIPT BUNDLES ---
 
-src/reactpy_router/bundle.js
+src/reactpy_router/static/bundle.js
 
 # --- PYTHON IGNORE FILES ----
 

docs/examples/python/basic-routing-more-routes.py

@@ -7,7 +7,7 @@ def root():
     return browser_router(
         route("/", html.h1("Home Page 🏠")),
         route("/messages", html.h1("Messages 💬")),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/basic-routing.py

@@ -6,7 +6,7 @@
 def root():
     return browser_router(
         route("/", html.h1("Home Page 🏠")),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/nested-routes.py

@@ -26,7 +26,7 @@ def root():
             route("/with/Alice", messages_with("Alice")),
             route("/with/Alice-Bob", messages_with("Alice", "Bob")),
         ),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/route-links.py

@@ -7,7 +7,7 @@ def root():
     return browser_router(
         route("/", home()),
         route("/messages", html.h1("Messages 💬")),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/examples/python/route-parameters.py

@@ -25,7 +25,7 @@ def root():
             all_messages(),
             route("/with/{names}", messages_with()),  # note the path param
         ),
-        route("*", html.h1("Missing Link 🔗‍💥")),
+        route("{404:any}", html.h1("Missing Link 🔗‍💥")),
     )
 
 

docs/src/learn/routers-routes-and-links.md

@@ -19,7 +19,7 @@ Here's a basic example showing how to use `#!python browser_router` with two rou
     {% include "../../examples/python/basic-routing.py" %}
     ```
 
-Here we'll note some special syntax in the route path for the second route. The `#!python "*"` is a wildcard that will match any path. This is useful for creating a "404" page that will be shown when no other route matches.
+Here we'll note some special syntax in the route path for the second route. The `#!python "any"` type is a wildcard that will match any path. This is useful for creating a default page or error page such as "404 NOT FOUND".
 
 ### Browser Router
 
@@ -34,11 +34,13 @@ In this case, `#!python param` is the name of the route parameter and the option
 
 | Type | Pattern |
 | --- | --- |
-| `#!python str` (default) | `#!python [^/]+` |
 | `#!python int` | `#!python \d+` |
-| `#!python float` | `#!python \d+(\.\d+)?` |
+| `#!python str` (default) | `#!python [^/]+` |
 | `#!python uuid` | `#!python [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}` |
+| `#!python slug` | `#!python [-a-zA-Z0-9_]+` |
 | `#!python path` | `#!python .+` |
+| `#!python float` | `#!python \d+(\.\d+)?` |
+| `#!python any` | `#!python .*` |
 
 So in practice these each might look like:
 

src/reactpy_router/converters.py

@@ -29,5 +29,9 @@
         "regex": r"\d+(\.\d+)?",
         "func": float,
     },
+    "any": {
+        "regex": r".*",
+        "func": str,
+    },
 }
 """The conversion types supported by the default Resolver. You can add more types if needed."""

src/reactpy_router/core.py

@@ -65,10 +65,7 @@ def router_component(
     if match:
         route_elements = [
             _route_state_context(
-                html.div(
-                    element,  # type: ignore
-                    key=f"{location.pathname}{select}{params}{element}{id(element)}",
-                ),
+                element,
                 value=_RouteState(set_location, params),
             )
             for element, params in match

src/reactpy_router/resolvers.py

@@ -16,47 +16,63 @@ def __init__(
         self,
         route: Route,
         param_pattern=r"{(?P<name>\w+)(?P<type>:\w+)?}",
-        match_any_identifier=r"\*$",
         converters: dict[str, ConversionInfo] | None = None,
     ) -> None:
         self.element = route.element
-        self.pattern, self.converter_mapping = self.parse_path(route.path)
         self.registered_converters = converters or CONVERTERS
-        self.key = self.pattern.pattern
+        self.converter_mapping: ConverterMapping = {}
+        # self.match_any_indentifier = match_any_identifier
         self.param_regex = re.compile(param_pattern)
-        self.match_any = match_any_identifier
+        self.pattern = self.parse_path(route.path)
+        self.key = self.pattern.pattern  # Unique identifier for ReactPy rendering
 
-    def parse_path(self, path: str) -> tuple[re.Pattern[str], ConverterMapping]:
+    def parse_path(self, path: str) -> re.Pattern[str]:
         # Convert path to regex pattern, then interpret using registered converters
         pattern = "^"
         last_match_end = 0
-        converter_mapping: ConverterMapping = {}
+
+        # Iterate through matches of the parameter pattern
         for match in self.param_regex.finditer(path):
-            param_name = match.group("name")
+            # Extract parameter name and type
+            name = match.group("name")
+            if name[0].isnumeric():
+                name = f"_numeric_{name}"
             param_type = (match.group("type") or "str").strip(":")
+
+            # Check if a converter exists for the type
             try:
-                param_conv = self.registered_converters[param_type]
+                conversion_info = self.registered_converters[param_type]
             except KeyError as e:
                 raise ValueError(
                     f"Unknown conversion type {param_type!r} in {path!r}"
                 ) from e
+
+            # Add the string before the match to the pattern
             pattern += re.escape(path[last_match_end : match.start()])
-            pattern += f"(?P<{param_name}>{param_conv['regex']})"
-            converter_mapping[param_name] = param_conv["func"]
+
+            # Add the match to the pattern
+            pattern += f"(?P<{name}>{conversion_info['regex']})"
+
+            # Keep a local mapping of parameter names to conversion functions.
+            self.converter_mapping[name] = conversion_info["func"]
+
+            # Update the last match end
             last_match_end = match.end()
-        pattern += f"{re.escape(path[last_match_end:])}$"
 
-        # Replace "match anything" pattern with regex, if it's at the end of the path
-        if pattern.endswith(self.match_any):
-            pattern = f"{pattern[:-3]}.*$"
+        # Add the string after the last match
+        pattern += f"{re.escape(path[last_match_end:])}$"
 
-        return re.compile(pattern), converter_mapping
+        return re.compile(pattern)
 
     def resolve(self, path: str) -> tuple[Any, dict[str, Any]] | None:
         match = self.pattern.match(path)
         if match:
-            return (
-                self.element,
-                {k: self.converter_mapping[k](v) for k, v in match.groupdict().items()},
-            )
+            # Convert the matched groups to the correct types
+            params = {
+                parameter_name.strip("_numeric_"): self.converter_mapping[
+                    parameter_name
+                ](value)
+                for parameter_name, value in match.groupdict().items()
+            }
+            return (self.element, params)
         return None