litestar-vite 0.15.0__py3-none-any.whl → 0.15.0rc2__py3-none-any.whl

litestar_vite/deploy.py

@@ -8,13 +8,13 @@ DeployConfig is defined in litestar_vite.config and passed into ViteDeployer.
 
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
+from importlib.util import find_spec
 from pathlib import Path
 from typing import Any, cast
 
 from litestar.exceptions import SerializationException
 from litestar.serialization import decode_json
 
-from litestar_vite.config import FSSPEC_INSTALLED
 from litestar_vite.config import DeployConfig as _DeployConfig
 from litestar_vite.exceptions import MissingDependencyError
 
@@ -51,7 +51,7 @@ def _import_fsspec(storage_backend: "str | None") -> tuple[Any, Callable[..., tu
     Raises:
         MissingDependencyError: If fsspec is not installed.
     """
-    if not FSSPEC_INSTALLED:
+    if find_spec("fsspec") is None:
         msg = "fsspec"
         raise MissingDependencyError(msg, install_package=_suggest_install_extra(storage_backend))
 
@@ -110,18 +110,7 @@ class ViteDeployer:
             raise ValueError(msg)
 
         self.bundle_dir = bundle_dir
-        manifest_rel = Path(manifest_name)
-        manifest_path = bundle_dir / manifest_rel
-        if (
-            not manifest_path.exists()
-            and not manifest_rel.is_absolute()
-            and (not manifest_rel.parts or manifest_rel.parts[0] != ".vite")
-        ):
-            vite_manifest = bundle_dir / ".vite" / manifest_rel
-            if vite_manifest.exists():
-                manifest_path = vite_manifest
-
-        self.manifest_path = manifest_path
+        self.manifest_path = bundle_dir / manifest_name
         self.config = deploy_config
         self._fs, self.remote_path = self._init_filesystem(fs, remote_path)
 

litestar_vite/doctor.py

@@ -421,10 +421,8 @@ class ViteDoctor:
             A dictionary representing the expected bridge configuration.
         """
         types = self.config.types if isinstance(self.config.types, TypeGenConfig) else None
-        deploy = self.config.deploy_config
         return {
             "assetUrl": self.config.asset_url,
-            "deployAssetUrl": deploy.asset_url if deploy is not None and deploy.asset_url else None,
             "bundleDir": str(self.config.bundle_dir),
             "hotFile": self.config.hot_file,
             "resourceDir": str(self.config.resource_dir),
@@ -434,6 +432,7 @@ class ViteDoctor:
             "proxyMode": self.config.proxy_mode,
             "port": self.config.port,
             "host": self.config.host,
+            "ssrEnabled": self.config.ssr_enabled,
             "ssrOutDir": str(self.config.ssr_output_dir) if self.config.ssr_output_dir else None,
             "types": (
                 {
@@ -966,14 +965,13 @@ class ViteDoctor:
         if self.config.is_dev_mode:
             return
 
-        candidates = self.config.candidate_manifest_paths()
-        if not any(path.exists() for path in candidates):
-            manifest_locations = " or ".join(str(path) for path in candidates)
+        manifest_path = self._resolve_to_root(self.config.bundle_dir) / self.config.manifest_name
+        if not manifest_path.exists():
             self.issues.append(
                 DoctorIssue(
                     check="Manifest Missing",
                     severity="warning",
-                    message=f"Manifest not found at {manifest_locations} (expected in production; ok during dev)",
+                    message=f"Manifest not found at {manifest_path} (expected in production; ok during dev)",
                     fix_hint="Run `litestar assets build` before starting in production",
                     auto_fixable=False,
                 )
@@ -1021,9 +1019,8 @@ class ViteDoctor:
             "VITE_HOST": self.config.host,
             "VITE_PROXY_MODE": self.config.proxy_mode,
             "VITE_PROTOCOL": self.config.protocol,
+            "VITE_BASE_URL": self.config.base_url or self.config.asset_url,
         }
-        if self.config.base_url:
-            comparisons["VITE_BASE_URL"] = self.config.base_url
 
         for key, expected in comparisons.items():
             actual = os.getenv(key)
@@ -1063,6 +1060,7 @@ class ViteDoctor:
             "dev_mode": self.config.is_dev_mode,
             "host": self.config.host,
             "port": self.config.port,
+            "ssr_enabled": self.config.ssr_enabled,
             "executor": self.config.runtime.executor,
             "set_environment": self.config.set_environment,
             "types_enabled": isinstance(self.config.types, TypeGenConfig),

litestar_vite/executor.py

@@ -72,22 +72,9 @@ class JSExecutor(ABC):
     def install(self, cwd: Path) -> None:
         """Install dependencies."""
 
-    @abstractmethod
-    def update(self, cwd: Path, *, latest: bool = False) -> None:
-        """Update dependencies.
-
-        Args:
-            cwd: The working directory.
-            latest: If True, update to latest versions (ignoring semver constraints where supported).
-        """
-
     @abstractmethod
     def run(self, args: list[str], cwd: Path) -> "subprocess.Popen[Any]":
-        """Run a command.
-
-        Returns:
-            The result.
-        """
+        """Run a command."""
 
     @abstractmethod
     def execute(self, args: list[str], cwd: Path) -> None:
@@ -155,10 +142,6 @@ class JSExecutor(ABC):
 class CommandExecutor(JSExecutor):
     """Generic command executor."""
 
-    # Subclasses override to customize update behavior
-    update_command: ClassVar[str] = "update"
-    update_latest_flag: ClassVar[str] = "--latest"
-
     def install(self, cwd: Path) -> None:
         executable = self._resolve_executable()
         command = [executable, "install"]
@@ -166,15 +149,6 @@ class CommandExecutor(JSExecutor):
         if process.returncode != 0:
             raise ViteExecutionError(command, process.returncode, "package install failed")
 
-    def update(self, cwd: Path, *, latest: bool = False) -> None:
-        executable = self._resolve_executable()
-        command = [executable, self.update_command]
-        if latest and self.update_latest_flag:
-            command.append(self.update_latest_flag)
-        process = subprocess.run(command, cwd=cwd, shell=platform.system() == "Windows", check=False)
-        if process.returncode != 0:
-            raise ViteExecutionError(command, process.returncode, "package update failed")
-
     def run(self, args: list[str], cwd: Path) -> "subprocess.Popen[Any]":
         executable = self._resolve_executable()
         args = self._apply_silent_flag(args)
@@ -203,8 +177,6 @@ class NodeExecutor(CommandExecutor):
     """Node.js executor."""
 
     bin_name = "npm"
-    # npm doesn't have --latest; use --save to update package.json
-    update_latest_flag: ClassVar[str] = "--save"
 
 
 class BunExecutor(CommandExecutor):
@@ -218,22 +190,15 @@ class DenoExecutor(CommandExecutor):
 
     bin_name = "deno"
     silent_flag: ClassVar[str] = ""
-    update_latest_flag: ClassVar[str] = ""
 
     def install(self, cwd: Path) -> None:
         pass
 
-    def update(self, cwd: Path, *, latest: bool = False) -> None:
-        """Deno doesn't have traditional package management."""
-        del cwd, latest  # unused
-
 
 class YarnExecutor(CommandExecutor):
     """Yarn executor."""
 
     bin_name = "yarn"
-    # yarn uses "upgrade" command (not "update")
-    update_command: ClassVar[str] = "upgrade"
 
 
 class PnpmExecutor(CommandExecutor):
@@ -299,15 +264,6 @@ class NodeenvExecutor(JSExecutor):
         command = [npm_path, "install"]
         subprocess.run(command, cwd=cwd, check=True)
 
-    def update(self, cwd: Path, *, latest: bool = False) -> None:
-        npm_path = self._find_npm_in_venv()
-        command = [npm_path, "update"]
-        if latest:
-            command.append("--save")
-        process = subprocess.run(command, cwd=cwd, shell=platform.system() == "Windows", check=False)
-        if process.returncode != 0:
-            raise ViteExecutionError(command, process.returncode, "package update failed")
-
     def run(self, args: list[str], cwd: Path) -> "subprocess.Popen[Any]":
         npm_path = self._find_npm_in_venv()
         args = self._apply_silent_flag(args)

litestar_vite/handler.py

@@ -0,0 +1,9 @@
+"""SPA mode handler public API.
+
+The SPA handler implementation lives in ``litestar_vite._handler.app``. This module exists as a stable import
+location for users and tests.
+"""
+
+from litestar_vite._handler.app import AppHandler
+
+__all__ = ("AppHandler",)

litestar_vite/html_transform.py

@@ -91,8 +91,7 @@ def _escape_attr(value: str) -> str:
         The escaped value safe for use in HTML attribute values.
     """
     return (
-        value
-        .replace("&", "&")
+        value.replace("&", "&")
         .replace('"', """)
         .replace("'", "'")
         .replace("<", "&lt;")
@@ -136,14 +135,13 @@ def _set_inner_html_replacer(match: re.Match[str], *, content: str) -> str:
     return match.group(1) + content + match.group(5)
 
 
-def inject_head_script(html: str, script: str, *, escape: bool = True, nonce: str | None = None) -> str:
+def inject_head_script(html: str, script: str, *, escape: bool = True) -> str:
     """Inject a script tag before the closing </head> tag.
 
     Args:
         html: The HTML document.
         script: The JavaScript code to inject (without <script> tags).
         escape: Whether to escape the script content. Default True.
-        nonce: Optional CSP nonce to add to the injected ``<script>`` tag.
 
     Returns:
         The HTML with the injected script. If ``</head>`` is not found,
@@ -160,8 +158,7 @@ def inject_head_script(html: str, script: str, *, escape: bool = True, nonce: st
     if escape:
         script = _escape_script(script)
 
-    nonce_attr = f' nonce="{_escape_attr(nonce)}"' if nonce else ""
-    script_tag = f"<script{nonce_attr}>{script}</script>\n"
+    script_tag = f"<script>{script}</script>\n"
 
     head_end_match = _HEAD_END_PATTERN.search(html)
     if head_end_match:
@@ -303,55 +300,7 @@ def set_element_inner_html(html: str, selector: str, content: str) -> str:
     return pattern.sub(replacer, html, count=1)
 
 
-def inject_page_script(html: str, json_data: str, *, nonce: str | None = None, script_id: str = "app_page") -> str:
-    r"""Inject page data as a JSON script element before ``</body>``.
-
-    This is an Inertia.js v2.3+ optimization that embeds page data in a
-    ``<script type="application/json">`` element instead of a ``data-page`` attribute.
-    This provides ~37% payload reduction for large pages by avoiding HTML entity escaping.
-
-    The script element is inserted before ``</body>`` with:
-    - ``type="application/json"`` (non-executable, just data)
-    - ``id="app_page"`` (Inertia's expected ID for useScriptElementForInitialPage)
-    - Optional ``nonce`` for CSP compliance
-
-    Args:
-        html: The HTML document.
-        json_data: Pre-serialized JSON string (page props).
-        nonce: Optional CSP nonce to add to the script element.
-        script_id: The script element ID (default "app_page" per Inertia protocol).
-
-    Returns:
-        The HTML with the script element injected before ``</body>``.
-        Falls back to appending at the end if no ``</body>`` tag is found.
-
-    Note:
-        The JSON content is escaped to prevent XSS via ``</script>`` injection.
-        Sequences like ``</`` are replaced with ``<\\/`` (escaped forward slash)
-        which is valid JSON and prevents HTML parser issues.
-
-    Example:
-        html = inject_page_script(html, '{"component":"Home","props":{}}')
-    """
-    if not json_data:
-        return html
-
-    # Escape sequences that could break out of script element
-    # Replace </ with <\/ to prevent premature tag closure (XSS prevention)
-    escaped_json = json_data.replace("</", r"<\/")
-
-    nonce_attr = f' nonce="{_escape_attr(nonce)}"' if nonce else ""
-    script_tag = f'<script type="application/json" id="{script_id}"{nonce_attr}>{escaped_json}</script>\n'
-
-    body_end_match = _BODY_END_PATTERN.search(html)
-    if body_end_match:
-        pos = body_end_match.start()
-        return html[:pos] + script_tag + html[pos:]
-
-    return html + "\n" + script_tag
-
-
-def inject_json_script(html: str, var_name: str, data: dict[str, Any], *, nonce: str | None = None) -> str:
+def inject_json_script(html: str, var_name: str, data: dict[str, Any]) -> str:
     """Inject a script that sets a global JavaScript variable to JSON data.
 
     This is a convenience function for injecting structured data into the page.
@@ -362,7 +311,6 @@ def inject_json_script(html: str, var_name: str, data: dict[str, Any], *, nonce:
         html: The HTML document.
         var_name: The global variable name (e.g., "__LITESTAR_ROUTES__").
         data: The data to serialize as JSON.
-        nonce: Optional CSP nonce to add to the injected ``<script>`` tag.
 
     Returns:
         The HTML with the injected script in the ``<head>`` section. Falls back
@@ -378,98 +326,7 @@ def inject_json_script(html: str, var_name: str, data: dict[str, Any], *, nonce:
     """
     json_data = encode_json(data).decode("utf-8")
     script = f"window.{var_name} = {json_data};"
-    return inject_head_script(html, script, escape=False, nonce=nonce)
-
-
-def inject_vite_dev_scripts(
-    html: str,
-    vite_url: str,
-    *,
-    asset_url: str = "/static/",
-    is_react: bool = False,
-    csp_nonce: str | None = None,
-    resource_dir: str | None = None,
-) -> str:
-    """Inject Vite dev server scripts for HMR support.
-
-    This function injects the necessary scripts for Vite's Hot Module Replacement
-    (HMR) to work when serving HTML from the backend (e.g., in hybrid/Inertia mode).
-    The scripts are injected into the ``<head>`` section.
-
-    For React apps, a preamble script is injected before the Vite client to
-    enable React Fast Refresh.
-
-    Scripts are injected as relative URLs using the ``asset_url`` prefix. This
-    routes them through Litestar's proxy middleware, which forwards to Vite
-    with the correct base path handling.
-
-    When ``resource_dir`` is provided, entry point script URLs are also transformed
-    to include the asset URL prefix (e.g., ``/resources/main.tsx`` becomes
-    ``/static/resources/main.tsx``).
-
-    Args:
-        html: The HTML document.
-        vite_url: The Vite dev server URL (kept for backward compatibility, unused).
-        asset_url: The asset URL prefix (e.g., "/static/"). Scripts are served
-            at ``{asset_url}@vite/client`` etc.
-        is_react: Whether to inject the React Fast Refresh preamble.
-        csp_nonce: Optional CSP nonce to add to injected ``<script>`` tags.
-        resource_dir: Optional resource directory name (e.g., "resources", "src").
-            When provided, script sources starting with ``/{resource_dir}/`` are
-            prefixed with ``asset_url``.
-
-    Returns:
-        The HTML with Vite dev scripts injected. Scripts are inserted before
-        ``</head>`` when present, otherwise before ``</html>`` or at the end.
-
-    Example:
-        html = inject_vite_dev_scripts(html, "", asset_url="/static/", is_react=True)
-    """
-    # Use relative URLs with asset_url prefix so requests go through Litestar's proxy
-    # This ensures proper base path handling (Vite expects /static/@vite/client, not /@vite/client)
-    base = asset_url.rstrip("/")
-    nonce_attr = f' nonce="{_escape_attr(csp_nonce)}"' if csp_nonce else ""
-
-    # Transform entry point script URLs to include the asset URL prefix
-    # This ensures /resources/main.tsx becomes /static/resources/main.tsx
-    if resource_dir:
-        resource_prefix = f"/{resource_dir.strip('/')}/"
-
-        def transform_entry_script(match: re.Match[str]) -> str:
-            prefix = match.group(1)
-            src = match.group(2)
-            suffix = match.group(3)
-            if src.startswith(resource_prefix) and not src.startswith(base):
-                return prefix + base + src + suffix
-            return match.group(0)
-
-        html = _SCRIPT_SRC_PATTERN.sub(transform_entry_script, html)
-
-    scripts: list[str] = []
-
-    if is_react:
-        react_preamble = f"""import RefreshRuntime from '{base}/@react-refresh'
-RefreshRuntime.injectIntoGlobalHook(window)
-window.$RefreshReg$ = () => {{}}
-window.$RefreshSig$ = () => (type) => type
-window.__vite_plugin_react_preamble_installed__ = true"""
-        scripts.append(f'<script type="module"{nonce_attr}>{react_preamble}</script>')
-
-    scripts.append(f'<script type="module" src="{base}/@vite/client"{nonce_attr}></script>')
-
-    script_content = "\n".join(scripts) + "\n"
-
-    head_end_match = _HEAD_END_PATTERN.search(html)
-    if head_end_match:
-        pos = head_end_match.start()
-        return html[:pos] + script_content + html[pos:]
-
-    html_end_match = _HTML_END_PATTERN.search(html)
-    if html_end_match:
-        pos = html_end_match.start()
-        return html[:pos] + script_content + html[pos:]
-
-    return html + "\n" + script_content
+    return inject_head_script(html, script, escape=False)
 
 
 def transform_asset_urls(

litestar_vite/inertia/__init__.py

@@ -2,41 +2,27 @@ from litestar_vite.config import InertiaConfig
 from litestar_vite.inertia import helpers
 from litestar_vite.inertia.exception_handler import create_inertia_exception_response, exception_to_http_response
 from litestar_vite.inertia.helpers import (
-    AlwaysProp,
-    OnceProp,
-    OptionalProp,
     PropFilter,
-    always,
     clear_history,
     defer,
     error,
     except_,
     extract_deferred_props,
     extract_merge_props,
-    extract_once_props,
     flash,
     get_shared_props,
     lazy,
     merge,
-    once,
     only,
-    optional,
     scroll_props,
     share,
 )
 from litestar_vite.inertia.middleware import InertiaMiddleware
 from litestar_vite.inertia.plugin import InertiaPlugin
-from litestar_vite.inertia.precognition import (
-    PrecognitionResponse,
-    create_precognition_exception_handler,
-    normalize_validation_errors,
-    precognition,
-)
 from litestar_vite.inertia.request import InertiaDetails, InertiaHeaders, InertiaRequest
 from litestar_vite.inertia.response import InertiaBack, InertiaExternalRedirect, InertiaRedirect, InertiaResponse
 
 __all__ = (
-    "AlwaysProp",
     "InertiaBack",
     "InertiaConfig",
     "InertiaDetails",
@@ -47,31 +33,21 @@ __all__ = (
     "InertiaRedirect",
     "InertiaRequest",
     "InertiaResponse",
-    "OnceProp",
-    "OptionalProp",
-    "PrecognitionResponse",
     "PropFilter",
-    "always",
     "clear_history",
     "create_inertia_exception_response",
-    "create_precognition_exception_handler",
     "defer",
     "error",
     "except_",
     "exception_to_http_response",
     "extract_deferred_props",
     "extract_merge_props",
-    "extract_once_props",
     "flash",
     "get_shared_props",
     "helpers",
     "lazy",
     "merge",
-    "normalize_validation_errors",
-    "once",
     "only",
-    "optional",
-    "precognition",
     "scroll_props",
     "share",
 )

litestar_vite/inertia/_utils.py

@@ -30,11 +30,6 @@ class InertiaHeaders(str, Enum):
 
     INFINITE_SCROLL_MERGE_INTENT = "X-Inertia-Infinite-Scroll-Merge-Intent"
 
-    # Precognition headers (Laravel Precognition protocol)
-    PRECOGNITION = "Precognition"
-    PRECOGNITION_SUCCESS = "Precognition-Success"
-    PRECOGNITION_VALIDATE_ONLY = "Precognition-Validate-Only"
-
 
 def get_enabled_header(enabled: bool = True) -> "dict[str, Any]":
     """True if inertia is enabled.

litestar_vite/inertia/exception_handler.py

@@ -1,12 +1,12 @@
 import re
 from typing import TYPE_CHECKING, Any, cast
-from urllib.parse import quote, urlparse, urlunparse
 
 from litestar import MediaType
 from litestar.connection import Request
 from litestar.connection.base import AuthT, StateT, UserT
 from litestar.exceptions import (
     HTTPException,
+    ImproperlyConfiguredException,
     InternalServerException,
     NotAuthorizedException,
     NotFoundException,
@@ -16,6 +16,7 @@ from litestar.exceptions.responses import (
     create_debug_response,  # pyright: ignore[reportUnknownVariableType]
     create_exception_response,  # pyright: ignore[reportUnknownVariableType]
 )
+from litestar.plugins.flash import flash
 from litestar.repository.exceptions import (
     ConflictError,  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue]
     NotFoundError,  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue]
@@ -32,7 +33,7 @@ from litestar.status_codes import (
     HTTP_500_INTERNAL_SERVER_ERROR,
 )
 
-from litestar_vite.inertia.helpers import error, flash
+from litestar_vite.inertia.helpers import error
 from litestar_vite.inertia.request import InertiaRequest
 from litestar_vite.inertia.response import InertiaBack, InertiaRedirect, InertiaResponse
 
@@ -132,9 +133,11 @@ def create_inertia_exception_response(request: "Request[UserT, AuthT, StateT]",
     if extras:
         content.update({"extra": extras})
 
-    flash_succeeded = False
-    if detail:
-        flash_succeeded = flash(request, detail, category="error")
+    try:
+        if detail:
+            flash(request, detail, category="error")
+    except (AttributeError, KeyError, RuntimeError, ImproperlyConfiguredException):
+        request.logger.warning("Unable to set flash message", exc_info=True)
 
     if extras and isinstance(extras, (list, tuple)) and len(extras) >= 1:  # pyright: ignore[reportUnknownArgumentType]
         first_extra = extras[0]  # pyright: ignore[reportUnknownVariableType]
@@ -147,28 +150,19 @@ def create_inertia_exception_response(request: "Request[UserT, AuthT, StateT]",
             field = match.group(1) if match else default_field
             error(request, field, error_detail or detail)
 
-    if status_code in {HTTP_422_UNPROCESSABLE_ENTITY, HTTP_400_BAD_REQUEST} or isinstance(
-        exc, PermissionDeniedException
-    ):
+    if status_code in {HTTP_422_UNPROCESSABLE_ENTITY, HTTP_400_BAD_REQUEST}:
+        return InertiaBack(request)
+    if isinstance(exc, PermissionDeniedException):
         return InertiaBack(request)
 
     if inertia_plugin is None:
         return InertiaResponse[Any](media_type=preferred_type, content=content, status_code=status_code)
 
-    is_unauthorized = status_code == HTTP_401_UNAUTHORIZED or isinstance(exc, NotAuthorizedException)
-    redirect_to_login = inertia_plugin.config.redirect_unauthorized_to
-    if is_unauthorized and redirect_to_login is not None:
-        if request.url.path != redirect_to_login:
-            # If flash failed (no session), pass error message via query param
-            if not flash_succeeded and detail:
-                parsed = urlparse(redirect_to_login)
-                error_param = f"error={quote(detail, safe='')}"
-                query = f"{parsed.query}&{error_param}" if parsed.query else error_param
-                redirect_to_login = urlunparse(parsed._replace(query=query))
-            return InertiaRedirect(request, redirect_to=redirect_to_login)
-        # Already on login page - redirect back so Inertia processes flash messages
-        # (Inertia.js shows 4xx responses in a modal instead of updating page state)
-        return InertiaBack(request)
+    if (status_code == HTTP_401_UNAUTHORIZED or isinstance(exc, NotAuthorizedException)) and (
+        inertia_plugin.config.redirect_unauthorized_to is not None
+        and request.url.path != inertia_plugin.config.redirect_unauthorized_to
+    ):
+        return InertiaRedirect(request, redirect_to=inertia_plugin.config.redirect_unauthorized_to)
 
     if status_code in {HTTP_404_NOT_FOUND, HTTP_405_METHOD_NOT_ALLOWED} and (
         inertia_plugin.config.redirect_404 is not None and request.url.path != inertia_plugin.config.redirect_404