reflex 0.7.14a6__py3-none-any.whl → 0.8.0__py3-none-any.whl

reflex/plugins/tailwind_v3.py

@@ -1,12 +1,16 @@
 """Base class for all plugins."""
 
+import dataclasses
 from pathlib import Path
 from types import SimpleNamespace
 
 from reflex.constants.base import Dirs
 from reflex.constants.compiler import Ext, PageNames
-from reflex.plugins.base import Plugin as PluginBase
-from reflex.utils.decorator import once
+from reflex.plugins.shared_tailwind import (
+    TailwindConfig,
+    TailwindPlugin,
+    tailwind_config_js_template,
+)
 
 
 class Constants(SimpleNamespace):
@@ -17,7 +21,7 @@ class Constants(SimpleNamespace):
     # The Tailwind config.
     CONFIG = "tailwind.config.js"
     # Default Tailwind content paths
-    CONTENT = ["./pages/**/*.{js,ts,jsx,tsx}", "./utils/**/*.{js,ts,jsx,tsx}"]
+    CONTENT = [f"./{Dirs.PAGES}/**/*.{{js,ts,jsx,tsx}}", "./utils/**/*.{js,ts,jsx,tsx}"]
     # Relative tailwind style path to root stylesheet in Dirs.STYLES.
     ROOT_STYLE_PATH = "./tailwind.css"
 
@@ -35,90 +39,7 @@ class Constants(SimpleNamespace):
     TAILWIND_CSS = "@import url('./tailwind.css');"
 
 
-@once
-def tailwind_config_js_template():
-    """Get the Tailwind config template.
-
-    Returns:
-        The Tailwind config template.
-    """
-    from reflex.compiler.templates import from_string
-
-    source = r"""
-{# Helper macro to render JS objects and arrays #}
-{% macro render_js(val, indent=2, level=0) -%}
-{%- set space = ' ' * (indent * level) -%}
-{%- set next_space = ' ' * (indent * (level + 1)) -%}
-
-{%- if val is mapping -%}
-{
-{%- for k, v in val.items() %}
-{{ next_space }}{{ k if k is string and k.isidentifier() else k|tojson }}: {{ render_js(v, indent, level + 1) }}{{ "," if not loop.last }}
-{%- endfor %}
-{{ space }}}
-{%- elif val is iterable and val is not string -%}
-[
-{%- for item in val %}
-{{ next_space }}{{ render_js(item, indent, level + 1) }}{{ "," if not loop.last }}
-{%- endfor %}
-{{ space }}]
-{%- else -%}
-{{ val | tojson }}
-{%- endif -%}
-{%- endmacro %}
-
-{# Extract destructured imports from plugin dicts only #}
-{%- set imports = [] %}
-{%- for plugin in plugins if plugin is mapping and plugin.import is defined %}
-  {%- set _ = imports.append(plugin.import) %}
-{%- endfor %}
-
-/** @type {import('tailwindcss').Config} */
-{%- for imp in imports %}
-const { {{ imp.name }} } = require({{ imp.from | tojson }});
-{%- endfor %}
-
-module.exports = {
-  content: {{ render_js(content) }},
-  theme: {{ render_js(theme) }},
-  {% if darkMode is defined %}darkMode: {{ darkMode | tojson }},{% endif %}
-  {% if corePlugins is defined %}corePlugins: {{ render_js(corePlugins) }},{% endif %}
-  {% if important is defined %}important: {{ important | tojson }},{% endif %}
-  {% if prefix is defined %}prefix: {{ prefix | tojson }},{% endif %}
-  {% if separator is defined %}separator: {{ separator | tojson }},{% endif %}
-  {% if presets is defined %}
-  presets: [
-    {% for preset in presets %}
-    require({{ preset | tojson }}){{ "," if not loop.last }}
-    {% endfor %}
-  ],
-  {% endif %}
-  plugins: [
-    {% for plugin in plugins %}
-      {% if plugin is mapping %}
-        {% if plugin.call is defined %}
-          {{ plugin.call }}(
-            {%- if plugin.args is defined -%}
-              {{ render_js(plugin.args) }}
-            {%- endif -%}
-          ){{ "," if not loop.last }}
-        {% else %}
-          require({{ plugin.name | tojson }}){{ "," if not loop.last }}
-        {% endif %}
-      {% else %}
-        require({{ plugin | tojson }}){{ "," if not loop.last }}
-      {% endif %}
-    {% endfor %}
-  ]
-};
-"""
-
-    return from_string(source)
-
-
-def compile_config(
-    config: dict,
-):
+def compile_config(config: TailwindConfig):
     """Compile the Tailwind config.
 
     Args:
@@ -129,6 +50,7 @@ def compile_config(
     """
     return Constants.CONFIG, tailwind_config_js_template().render(
         **config,
+        DEFAULT_CONTENT=Constants.CONTENT,
     )
 
 
@@ -215,7 +137,8 @@ def add_tailwind_to_css_file(css_file_content: str) -> str:
     )
 
 
-class Plugin(PluginBase):
+@dataclasses.dataclass
+class TailwindV3Plugin(TailwindPlugin):
     """Plugin for Tailwind CSS."""
 
     def get_frontend_development_dependencies(self, **context) -> list[str]:
@@ -227,13 +150,10 @@ class Plugin(PluginBase):
         Returns:
             A list of packages required by the plugin.
         """
-        from reflex.config import get_config
-
-        config = get_config()
         return [
-            plugin if isinstance(plugin, str) else plugin.get("name")
-            for plugin in (config.tailwind or {}).get("plugins", [])
-        ] + [Constants.VERSION]
+            *super().get_frontend_development_dependencies(**context),
+            Constants.VERSION,
+        ]
 
     def pre_compile(self, **context):
         """Pre-compile the plugin.
@@ -241,23 +161,10 @@ class Plugin(PluginBase):
         Args:
             context: The context for the plugin.
         """
-        from reflex.config import get_config
-
-        config = get_config().tailwind or {}
-
-        config["content"] = config.get("content", Constants.CONTENT)
-        context["add_save_task"](compile_config, config)
+        context["add_save_task"](compile_config, self.get_unversioned_config())
         context["add_save_task"](compile_root_style)
         context["add_modify_task"](Dirs.POSTCSS_JS, add_tailwind_to_postcss_config)
         context["add_modify_task"](
             str(Path(Dirs.STYLES) / (PageNames.STYLESHEET_ROOT + Ext.CSS)),
             add_tailwind_to_css_file,
         )
-
-    def __repr__(self):
-        """Return a string representation of the plugin.
-
-        Returns:
-            A string representation of the plugin.
-        """
-        return "TailwindV3Plugin()"

reflex/plugins/tailwind_v4.py

@@ -1,123 +1,44 @@
 """Base class for all plugins."""
 
+import dataclasses
 from pathlib import Path
 from types import SimpleNamespace
 
 from reflex.constants.base import Dirs
 from reflex.constants.compiler import Ext, PageNames
-from reflex.plugins.base import Plugin as PluginBase
-from reflex.utils.decorator import once
+from reflex.plugins.shared_tailwind import (
+    TailwindConfig,
+    TailwindPlugin,
+    tailwind_config_js_template,
+)
 
 
 class Constants(SimpleNamespace):
     """Tailwind constants."""
 
     # The Tailwindcss version
-    VERSION = "tailwindcss@4.1.7"
+    VERSION = "tailwindcss@4.1.10"
     # The Tailwind config.
     CONFIG = "tailwind.config.js"
     # Default Tailwind content paths
-    CONTENT = ["./pages/**/*.{js,ts,jsx,tsx}", "./utils/**/*.{js,ts,jsx,tsx}"]
+    CONTENT = [f"./{Dirs.PAGES}/**/*.{{js,ts,jsx,tsx}}", "./utils/**/*.{js,ts,jsx,tsx}"]
     # Relative tailwind style path to root stylesheet in Dirs.STYLES.
     ROOT_STYLE_PATH = "./tailwind.css"
 
     # Content of the style content.
     ROOT_STYLE_CONTENT = """@layer theme, base, components, utilities;
-@config "../tailwind.config.js";
 @import "tailwindcss/theme.css" layer(theme);
 @import "tailwindcss/preflight.css" layer(base);
 @import "{radix_url}" layer(components);
 @import "tailwindcss/utilities.css" layer(utilities);
+@config "../tailwind.config.js";
 """
 
     # The default tailwind css.
     TAILWIND_CSS = "@import url('./tailwind.css');"
 
 
-@once
-def tailwind_config_js_template():
-    """Get the Tailwind config template.
-
-    Returns:
-        The Tailwind config template.
-    """
-    from reflex.compiler.templates import from_string
-
-    source = r"""
-{# Helper macro to render JS objects and arrays #}
-{% macro render_js(val, indent=2, level=0) -%}
-{%- set space = ' ' * (indent * level) -%}
-{%- set next_space = ' ' * (indent * (level + 1)) -%}
-
-{%- if val is mapping -%}
-{
-{%- for k, v in val.items() %}
-{{ next_space }}{{ k if k is string and k.isidentifier() else k|tojson }}: {{ render_js(v, indent, level + 1) }}{{ "," if not loop.last }}
-{%- endfor %}
-{{ space }}}
-{%- elif val is iterable and val is not string -%}
-[
-{%- for item in val %}
-{{ next_space }}{{ render_js(item, indent, level + 1) }}{{ "," if not loop.last }}
-{%- endfor %}
-{{ space }}]
-{%- else -%}
-{{ val | tojson }}
-{%- endif -%}
-{%- endmacro %}
-
-{# Extract destructured imports from plugin dicts only #}
-{%- set imports = [] %}
-{%- for plugin in plugins if plugin is mapping and plugin.import is defined %}
-  {%- set _ = imports.append(plugin.import) %}
-{%- endfor %}
-
-/** @type {import('tailwindcss').Config} */
-{%- for imp in imports %}
-const { {{ imp.name }} } = require({{ imp.from | tojson }});
-{%- endfor %}
-
-module.exports = {
-  content: {{ render_js(content) }},
-  theme: {{ render_js(theme) }},
-  {% if darkMode is defined %}darkMode: {{ darkMode | tojson }},{% endif %}
-  {% if corePlugins is defined %}corePlugins: {{ render_js(corePlugins) }},{% endif %}
-  {% if important is defined %}important: {{ important | tojson }},{% endif %}
-  {% if prefix is defined %}prefix: {{ prefix | tojson }},{% endif %}
-  {% if separator is defined %}separator: {{ separator | tojson }},{% endif %}
-  {% if presets is defined %}
-  presets: [
-    {% for preset in presets %}
-    require({{ preset | tojson }}){{ "," if not loop.last }}
-    {% endfor %}
-  ],
-  {% endif %}
-  plugins: [
-    {% for plugin in plugins %}
-      {% if plugin is mapping %}
-        {% if plugin.call is defined %}
-          {{ plugin.call }}(
-            {%- if plugin.args is defined -%}
-              {{ render_js(plugin.args) }}
-            {%- endif -%}
-          ){{ "," if not loop.last }}
-        {% else %}
-          require({{ plugin.name | tojson }}){{ "," if not loop.last }}
-        {% endif %}
-      {% else %}
-        require({{ plugin | tojson }}){{ "," if not loop.last }}
-      {% endif %}
-    {% endfor %}
-  ]
-};
-"""
-
-    return from_string(source)
-
-
-def compile_config(
-    config: dict,
-):
+def compile_config(config: TailwindConfig):
     """Compile the Tailwind config.
 
     Args:
@@ -128,6 +49,7 @@ def compile_config(
     """
     return Constants.CONFIG, tailwind_config_js_template().render(
         **config,
+        DEFAULT_CONTENT=Constants.CONTENT,
     )
 
 
@@ -218,7 +140,8 @@ def add_tailwind_to_css_file(css_file_content: str) -> str:
     )
 
 
-class Plugin(PluginBase):
+@dataclasses.dataclass
+class TailwindV4Plugin(TailwindPlugin):
     """Plugin for Tailwind CSS."""
 
     def get_frontend_development_dependencies(self, **context) -> list[str]:
@@ -230,13 +153,11 @@ class Plugin(PluginBase):
         Returns:
             A list of packages required by the plugin.
         """
-        from reflex.config import get_config
-
-        config = get_config()
         return [
-            plugin if isinstance(plugin, str) else plugin.get("name")
-            for plugin in (config.tailwind or {}).get("plugins", [])
-        ] + [Constants.VERSION, "@tailwindcss/postcss@4.1.7"]
+            *super().get_frontend_development_dependencies(**context),
+            Constants.VERSION,
+            "@tailwindcss/postcss@4.1.10",
+        ]
 
     def pre_compile(self, **context):
         """Pre-compile the plugin.
@@ -244,23 +165,10 @@ class Plugin(PluginBase):
         Args:
             context: The context for the plugin.
         """
-        from reflex.config import get_config
-
-        config = get_config().tailwind or {}
-
-        config["content"] = config.get("content", Constants.CONTENT)
-        context["add_save_task"](compile_config, config)
+        context["add_save_task"](compile_config, self.get_unversioned_config())
         context["add_save_task"](compile_root_style)
         context["add_modify_task"](Dirs.POSTCSS_JS, add_tailwind_to_postcss_config)
         context["add_modify_task"](
             str(Path(Dirs.STYLES) / (PageNames.STYLESHEET_ROOT + Ext.CSS)),
             add_tailwind_to_css_file,
         )
-
-    def __repr__(self):
-        """Return a string representation of the plugin.
-
-        Returns:
-            A string representation of the plugin.
-        """
-        return "TailwindV4Plugin()"

reflex/reflex.py

@@ -204,6 +204,7 @@ def _run(
     args = (frontend,)
     kwargs = {
         "check_if_schema_up_to_date": True,
+        "prerender_routes": env == constants.Env.PROD,
     }
 
     # Granian fails if the app is already imported.

reflex/route.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Callable
 
 from reflex import constants
 
@@ -16,15 +17,40 @@ def verify_route_validity(route: str) -> None:
     Raises:
         ValueError: If the route is invalid.
     """
-    pattern = catchall_in_route(route)
-    if pattern and not route.endswith(pattern):
-        msg = f"Catch-all must be the last part of the URL: {route}"
-        raise ValueError(msg)
-    if route == "api" or route.startswith("api/"):
-        msg = (
-            f"Cannot have a route prefixed with 'api/': {route} (conflicts with NextJS)"
-        )
-        raise ValueError(msg)
+    route_parts = route.removeprefix("/").split("/")
+    for i, part in enumerate(route_parts):
+        if constants.RouteRegex.SLUG.fullmatch(part):
+            continue
+        if not part.startswith("[") or not part.endswith("]"):
+            msg = (
+                f"Route part `{part}` is not valid. Reflex only supports "
+                "alphabetic characters, underscores, and hyphens in route parts. "
+            )
+            raise ValueError(msg)
+        if part.startswith(("[[...", "[...")):
+            if part != constants.RouteRegex.SPLAT_CATCHALL:
+                msg = f"Catchall pattern `{part}` is not valid. Only `{constants.RouteRegex.SPLAT_CATCHALL}` is allowed."
+                raise ValueError(msg)
+            if i != len(route_parts) - 1:
+                msg = f"Catchall pattern `{part}` must be at the end of the route."
+                raise ValueError(msg)
+            continue
+        if part.startswith("[["):
+            if constants.RouteRegex.OPTIONAL_ARG.fullmatch(part):
+                continue
+            msg = (
+                f"Route part `{part}` with optional argument is not valid. "
+                "Reflex only supports optional arguments that start with an alphabetic character or underscore, "
+                "followed by alphanumeric characters or underscores."
+            )
+            raise ValueError(msg)
+        if not constants.RouteRegex.ARG.fullmatch(part):
+            msg = (
+                f"Route part `{part}` with argument is not valid. "
+                "Reflex only supports argument names that start with an alphabetic character or underscore, "
+                "followed by alphanumeric characters or underscores."
+            )
+            raise ValueError(msg)
 
 
 def get_route_args(route: str) -> dict[str, str]:
@@ -38,103 +64,159 @@ def get_route_args(route: str) -> dict[str, str]:
     """
     args = {}
 
-    def add_route_arg(match: re.Match[str], type_: str):
-        """Add arg from regex search result.
-
-        Args:
-            match: Result of a regex search
-            type_: The assigned type for this arg
-
-        Raises:
-            ValueError: If the route is invalid.
-        """
-        arg_name = match.groups()[0]
+    def _add_route_arg(arg_name: str, type_: str):
         if arg_name in args:
-            msg = f"Arg name [{arg_name}] is used more than once in this URL"
+            msg = (
+                f"Arg name `{arg_name}` is used more than once in the route `{route}`."
+            )
             raise ValueError(msg)
         args[arg_name] = type_
 
     # Regex to check for route args.
-    check = constants.RouteRegex.ARG
-    check_strict_catchall = constants.RouteRegex.STRICT_CATCHALL
-    check_opt_catchall = constants.RouteRegex.OPT_CATCHALL
+    argument_regex = constants.RouteRegex.ARG
+    optional_argument_regex = constants.RouteRegex.OPTIONAL_ARG
 
     # Iterate over the route parts and check for route args.
     for part in route.split("/"):
-        match_opt = check_opt_catchall.match(part)
-        if match_opt:
-            add_route_arg(match_opt, constants.RouteArgType.LIST)
+        if part == constants.RouteRegex.SPLAT_CATCHALL:
+            _add_route_arg("splat", constants.RouteArgType.LIST)
             break
 
-        match_strict = check_strict_catchall.match(part)
-        if match_strict:
-            add_route_arg(match_strict, constants.RouteArgType.LIST)
-            break
+        optional_argument = optional_argument_regex.match(part)
+        if optional_argument:
+            _add_route_arg(optional_argument.group(1), constants.RouteArgType.SINGLE)
+            continue
+
+        argument = argument_regex.match(part)
+        if argument:
+            _add_route_arg(argument.group(1), constants.RouteArgType.SINGLE)
+            continue
 
-        match = check.match(part)
-        if match:
-            # Add the route arg to the list.
-            add_route_arg(match, constants.RouteArgType.SINGLE)
     return args
 
 
-def catchall_in_route(route: str) -> str:
-    """Extract the catchall part from a route.
+def replace_brackets_with_keywords(input_string: str) -> str:
+    """Replace brackets and everything inside it in a string with a keyword.
+
+    Example:
+        >>> replace_brackets_with_keywords("/posts")
+        '/posts'
+        >>> replace_brackets_with_keywords("/posts/[slug]")
+        '/posts/__SINGLE_SEGMENT__'
+        >>> replace_brackets_with_keywords("/posts/[slug]/comments")
+        '/posts/__SINGLE_SEGMENT__/comments'
+        >>> replace_brackets_with_keywords("/posts/[[slug]]")
+        '/posts/__DOUBLE_SEGMENT__'
+        >>> replace_brackets_with_keywords("/posts/[[...splat]]")
+        '/posts/__DOUBLE_CATCHALL_SEGMENT__'
 
     Args:
-        route: the route from which to extract
+        input_string: String to replace.
 
     Returns:
-        str: the catchall part of the URI
+        new string containing keywords.
     """
-    match_ = constants.RouteRegex.CATCHALL.search(route)
-    return match_.group() if match_ else ""
+    # Replace [<slug>] with __SINGLE_SEGMENT__
+    return constants.RouteRegex.ARG.sub(
+        constants.RouteRegex.SINGLE_SEGMENT,
+        # Replace [[slug]] with __DOUBLE_SEGMENT__
+        constants.RouteRegex.OPTIONAL_ARG.sub(
+            constants.RouteRegex.DOUBLE_SEGMENT,
+            # Replace [[...splat]] with __DOUBLE_CATCHALL_SEGMENT__
+            input_string.replace(
+                constants.RouteRegex.SPLAT_CATCHALL,
+                constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT,
+            ),
+        ),
+    )
 
 
-def catchall_prefix(route: str) -> str:
-    """Extract the prefix part from a route that contains a catchall.
+def route_specifity(keyworded_route: str) -> tuple[int, int, int]:
+    """Get the specificity of a route with keywords.
+
+    The smaller the number, the more specific the route is.
 
     Args:
-        route: the route from which to extract
+        keyworded_route: The route with keywords.
 
     Returns:
-        str: the prefix part of the URI
+        A tuple containing the counts of double catchall segments,
+        double segments, and single segments in the route.
     """
-    pattern = catchall_in_route(route)
-    return route.replace(pattern, "") if pattern else ""
+    return (
+        keyworded_route.count(constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT),
+        keyworded_route.count(constants.RouteRegex.DOUBLE_SEGMENT),
+        keyworded_route.count(constants.RouteRegex.SINGLE_SEGMENT),
+    )
 
 
-def replace_brackets_with_keywords(input_string: str) -> str:
-    """Replace brackets and everything inside it in a string with a keyword.
+def get_route_regex(keyworded_route: str) -> re.Pattern:
+    """Get the regex pattern for a route with keywords.
 
     Args:
-        input_string: String to replace.
+        keyworded_route: The route with keywords.
 
     Returns:
-        new string containing keywords.
+        A compiled regex pattern for the route.
     """
-    # /posts -> /post
-    # /posts/[slug] -> /posts/__SINGLE_SEGMENT__
-    # /posts/[slug]/comments -> /posts/__SINGLE_SEGMENT__/comments
-    # /posts/[[slug]] -> /posts/__DOUBLE_SEGMENT__
-    # / posts/[[...slug2]]-> /posts/__DOUBLE_CATCHALL_SEGMENT__
-    # /posts/[...slug3]-> /posts/__SINGLE_CATCHALL_SEGMENT__
-
-    # Replace [[...<slug>]] with __DOUBLE_CATCHALL_SEGMENT__
-    output_string = re.sub(
-        r"\[\[\.\.\..+?\]\]",
-        constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT,
-        input_string,
-    )
-    # Replace [...<slug>] with __SINGLE_CATCHALL_SEGMENT__
-    output_string = re.sub(
-        r"\[\.\.\..+?\]",
-        constants.RouteRegex.SINGLE_CATCHALL_SEGMENT,
-        output_string,
-    )
-    # Replace [[<slug>]] with __DOUBLE_SEGMENT__
-    output_string = re.sub(
-        r"\[\[.+?\]\]", constants.RouteRegex.DOUBLE_SEGMENT, output_string
+    if keyworded_route == "index":
+        return re.compile(re.escape("/"))
+    path_parts = keyworded_route.split("/")
+    regex_parts = []
+    for part in path_parts:
+        if part == constants.RouteRegex.SINGLE_SEGMENT:
+            # Match a single segment (/slug)
+            regex_parts.append(r"/[^/]*")
+        elif part == constants.RouteRegex.DOUBLE_SEGMENT:
+            # Match a single optional segment (/slug or nothing)
+            regex_parts.append(r"(/[^/]+)?")
+        elif part == constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT:
+            regex_parts.append(".*")
+        else:
+            regex_parts.append(re.escape("/" + part))
+    # Join the regex parts and compile the regex
+    regex_pattern = "".join(regex_parts)
+    regex_pattern = f"^{regex_pattern}/?$"
+    return re.compile(regex_pattern)
+
+
+def get_router(routes: list[str]) -> Callable[[str], str | None]:
+    """Get a function that computes the route for a given path.
+
+    Args:
+        routes: A list of routes to match against.
+
+    Returns:
+        A function that takes a path and returns the first matching route,
+        or None if no match is found.
+    """
+    keyworded_routes = {
+        replace_brackets_with_keywords(route): route for route in routes
+    }
+    sorted_routes_by_specifity = sorted(
+        keyworded_routes.items(),
+        key=lambda item: route_specifity(item[0]),
     )
-    # Replace [<slug>] with __SINGLE_SEGMENT__
-    return re.sub(r"\[.+?\]", constants.RouteRegex.SINGLE_SEGMENT, output_string)
+    regexed_routes = [
+        (get_route_regex(keyworded_route), original_route)
+        for keyworded_route, original_route in sorted_routes_by_specifity
+    ]
+
+    def get_route(path: str) -> str | None:
+        """Get the first matching route for a given path.
+
+        Args:
+            path: The path to match against the routes.
+
+        Returns:
+            The first matching route, or None if no match is found.
+        """
+        path = "/" + path.removeprefix("/").removesuffix("/")
+        if path == "/index":
+            path = "/"
+        for regex, original_route in regexed_routes:
+            if regex.fullmatch(path):
+                return original_route
+        return None
+
+    return get_route