litestar-vite 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

litestar_vite/commands.py

@@ -13,11 +13,11 @@ VITE_INIT_TEMPLATES: set[str] = {"package.json.j2", "tsconfig.json.j2", "vite.co
 DEFAULT_RESOURCES: set[str] = {"styles.css.j2", "main.ts.j2"}
 DEFAULT_DEV_DEPENDENCIES: dict[str, str] = {
     "typescript": "^5.7.2",
-    "vite": "^6.0.3",
-    "litestar-vite-plugin": "^0.12.0",
-    "@types/node": "^22.10.1",
+    "vite": "^6.0.6",
+    "litestar-vite-plugin": "^0.13.0",
+    "@types/node": "^22.10.2",
 }
-DEFAULT_DEPENDENCIES: dict[str, str] = {"axios": "^1.7.2"}
+DEFAULT_DEPENDENCIES: dict[str, str] = {"axios": "^1.7.9"}
 
 
 def to_json(value: Any) -> str:

litestar_vite/inertia/__init__.py

@@ -1,17 +1,17 @@
-from .config import InertiaConfig
-from .exception_handler import create_inertia_exception_response, exception_to_http_response
-from .middleware import InertiaMiddleware
-from .plugin import InertiaPlugin
-from .request import InertiaDetails, InertiaHeaders, InertiaRequest
-from .response import (
+from litestar_vite.inertia import helpers
+from litestar_vite.inertia.config import InertiaConfig
+from litestar_vite.inertia.exception_handler import create_inertia_exception_response, exception_to_http_response
+from litestar_vite.inertia.helpers import error, get_shared_props, js_routes_script, lazy, share
+from litestar_vite.inertia.middleware import InertiaMiddleware
+from litestar_vite.inertia.plugin import InertiaPlugin
+from litestar_vite.inertia.request import InertiaDetails, InertiaHeaders, InertiaRequest
+from litestar_vite.inertia.response import (
     InertiaBack,
     InertiaExternalRedirect,
     InertiaRedirect,
     InertiaResponse,
-    error,
-    get_shared_props,
-    share,
 )
+
 from .routes import generate_js_routes
 
 __all__ = (
@@ -30,5 +30,8 @@ __all__ = (
     "exception_to_http_response",
     "generate_js_routes",
     "get_shared_props",
+    "helpers",
+    "js_routes_script",
+    "lazy",
     "share",
 )

litestar_vite/inertia/exception_handler.py

@@ -35,7 +35,8 @@ from litestar.status_codes import (
     HTTP_500_INTERNAL_SERVER_ERROR,
 )
 
-from litestar_vite.inertia.response import InertiaBack, InertiaRedirect, InertiaResponse, error
+from litestar_vite.inertia.helpers import error
+from litestar_vite.inertia.response import InertiaBack, InertiaRedirect, InertiaResponse
 
 if TYPE_CHECKING:
     from litestar.connection import Request

litestar_vite/inertia/helpers.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import inspect
+from collections import defaultdict
+from collections.abc import Mapping
+from contextlib import contextmanager
+from functools import lru_cache
+from textwrap import dedent
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    TypeVar,
+    cast,
+    overload,
+)
+
+from anyio.from_thread import BlockingPortal, start_blocking_portal
+from litestar.exceptions import ImproperlyConfiguredException
+from litestar.utils.empty import value_or_default
+from litestar.utils.scope.state import ScopeState
+from markupsafe import Markup
+from typing_extensions import ParamSpec, TypeGuard
+
+if TYPE_CHECKING:
+    from litestar.connection import ASGIConnection
+
+    from litestar_vite.inertia.plugin import InertiaPlugin
+    from litestar_vite.inertia.routes import Routes
+
+T = TypeVar("T")
+T_ParamSpec = ParamSpec("T_ParamSpec")
+PropKeyT = TypeVar("PropKeyT", bound=str)
+StaticT = TypeVar("StaticT", bound=object)
+
+
+@overload
+def lazy(key: str, value_or_callable: None) -> StaticProp[str, None]: ...
+
+
+@overload
+def lazy(key: str, value_or_callable: T) -> StaticProp[str, T]: ...
+
+
+@overload
+def lazy(key: str, value_or_callable: Callable[..., None] = ...) -> DeferredProp[str, None]: ...
+
+
+@overload
+def lazy(key: str, value_or_callable: Callable[..., Coroutine[Any, Any, None]] = ...) -> DeferredProp[str, None]: ...
+
+
+@overload
+def lazy(
+    key: str,
+    value_or_callable: Callable[..., T | Coroutine[Any, Any, T]] = ...,  # pyright: ignore[reportInvalidTypeVarUse]
+) -> DeferredProp[str, T]: ...
+
+
+def lazy(
+    key: str,
+    value_or_callable: None
+    | Callable[T_ParamSpec, None | Coroutine[Any, Any, None]]
+    | T
+    | Callable[T_ParamSpec, T | Coroutine[Any, Any, T]] = None,
+) -> StaticProp[str, None] | StaticProp[str, T] | DeferredProp[str, T] | DeferredProp[str, None]:
+    """Wrap an async function to return a DeferredProp."""
+    if value_or_callable is None:
+        return StaticProp[str, None](key=key, value=None)
+
+    if not callable(value_or_callable):
+        return StaticProp[str, T](key=key, value=value_or_callable)
+
+    return DeferredProp[str, T](key=key, value=cast("Callable[..., T | Coroutine[Any, Any, T]]", value_or_callable))
+
+
+class StaticProp(Generic[PropKeyT, StaticT]):
+    """A wrapper for static property evaluation."""
+
+    def __init__(self, key: PropKeyT, value: StaticT) -> None:
+        self._key = key
+        self._result = value
+
+    @property
+    def key(self) -> PropKeyT:
+        return self._key
+
+    def render(self, portal: BlockingPortal | None = None) -> StaticT:
+        return self._result
+
+
+class DeferredProp(Generic[PropKeyT, T]):
+    """A wrapper for deferred property evaluation."""
+
+    def __init__(
+        self, key: PropKeyT, value: Callable[..., None | T | Coroutine[Any, Any, T | None]] | None = None
+    ) -> None:
+        self._key = key
+        self._value = value
+        self._evaluated = False
+        self._result: T | None = None
+
+    @property
+    def key(self) -> PropKeyT:
+        return self._key
+
+    @contextmanager
+    def with_portal(self, portal: BlockingPortal | None = None) -> Generator[BlockingPortal, None, None]:
+        if portal is None:
+            with start_blocking_portal() as p:
+                yield p
+        else:
+            yield portal
+
+    @staticmethod
+    def _is_awaitable(
+        v: Callable[..., T | Coroutine[Any, Any, T]],
+    ) -> TypeGuard[Coroutine[Any, Any, T]]:
+        return inspect.iscoroutinefunction(v)
+
+    def render(self, portal: BlockingPortal | None = None) -> T | None:
+        if self._evaluated:
+            return self._result
+        if self._value is None or not callable(self._value):
+            self._result = self._value
+            self._evaluated = True
+            return self._result
+        if not self._is_awaitable(cast("Callable[..., T]", self._value)):
+            self._result = cast("T", self._value())
+            self._evaluated = True
+            return self._result
+        with self.with_portal(portal) as p:
+            self._result = p.call(cast("Callable[..., T]", self._value))
+            self._evaluated = True
+            return self._result
+
+
+def is_lazy_prop(value: Any) -> TypeGuard[DeferredProp[Any, Any]]:
+    """Check if value is a deferred property.
+
+    Args:
+        value: Any value to check
+
+    Returns:
+        bool: True if value is a deferred property
+    """
+    return isinstance(value, (DeferredProp, StaticProp))
+
+
+def should_render(value: Any, partial_data: set[str] | None = None) -> bool:
+    """Check if value should be rendered.
+
+    Args:
+        value: Any value to check
+        partial_data: Optional set of keys for partial rendering
+
+    Returns:
+        bool: True if value should be rendered
+    """
+    partial_data = partial_data or set()
+    if is_lazy_prop(value):
+        return value.key in partial_data
+    return True
+
+
+def is_or_contains_lazy_prop(value: Any) -> bool:
+    """Check if value is or contains a deferred property.
+
+    Args:
+        value: Any value to check
+
+    Returns:
+        bool: True if value is or contains a deferred property
+    """
+    if is_lazy_prop(value):
+        return True
+    if isinstance(value, str):
+        return False
+    if isinstance(value, Mapping):
+        return any(is_or_contains_lazy_prop(v) for v in cast("Mapping[str, Any]", value).values())
+    if isinstance(value, Iterable):
+        return any(is_or_contains_lazy_prop(v) for v in cast("Iterable[Any]", value))
+    return False
+
+
+def lazy_render(value: T, partial_data: set[str] | None = None, portal: BlockingPortal | None = None) -> T:
+    """Filter deferred properties from the value based on partial data.
+
+    Args:
+        value: The value to filter
+        partial_data: Keys for partial rendering
+        portal: Optional portal to use for async rendering
+    Returns:
+        The filtered value
+    """
+    partial_data = partial_data or set()
+    if isinstance(value, str):
+        return cast("T", value)
+    if isinstance(value, Mapping):
+        return cast(
+            "T",
+            {
+                k: lazy_render(v, partial_data, portal)
+                for k, v in cast("Mapping[str, Any]", value).items()
+                if should_render(v, partial_data)
+            },
+        )
+
+    if isinstance(value, (list, tuple)):
+        filtered = [
+            lazy_render(v, partial_data, portal) for v in cast("Iterable[Any]", value) if should_render(v, partial_data)
+        ]
+        return cast("T", type(value)(filtered))  # pyright: ignore[reportUnknownArgumentType]
+
+    if is_lazy_prop(value) and should_render(value, partial_data):
+        return cast("T", value.render(portal))
+
+    return cast("T", value)
+
+
+def get_shared_props(
+    request: ASGIConnection[Any, Any, Any, Any],
+    partial_data: set[str] | None = None,
+) -> dict[str, Any]:
+    """Return shared session props for a request.
+
+    Args:
+        request: The ASGI connection.
+        partial_data: Optional set of keys for partial rendering.
+        portal: Optional portal to use for async rendering
+    Returns:
+        Dict[str, Any]: The shared props.
+
+    Note:
+        Be sure to call this before `self.create_template_context` if you would like to include the `flash` message details.
+    """
+    props: dict[str, Any] = {}
+    flash: dict[str, list[str]] = defaultdict(list)
+    errors: dict[str, Any] = {}
+    error_bag = request.headers.get("X-Inertia-Error-Bag", None)
+
+    try:
+        errors = request.session.pop("_errors", {})
+        shared_props = cast("Dict[str,Any]", request.session.pop("_shared", {}))
+        inertia_plugin = cast("InertiaPlugin", request.app.plugins.get("InertiaPlugin"))
+
+        # Handle deferred props
+        for key, value in shared_props.items():
+            if is_lazy_prop(value) and should_render(value, partial_data):
+                props[key] = value.render(inertia_plugin.portal)
+                continue
+            if should_render(value, partial_data):
+                props[key] = value
+
+        for message in cast("List[Dict[str,Any]]", request.session.pop("_messages", [])):
+            flash[message["category"]].append(message["message"])
+
+        props.update(inertia_plugin.config.extra_static_page_props)
+        for session_prop in inertia_plugin.config.extra_session_page_props:
+            if session_prop not in props and session_prop in request.session:
+                props[session_prop] = request.session.get(session_prop)
+
+    except (AttributeError, ImproperlyConfiguredException):
+        msg = "Unable to generate all shared props.  A valid session was not found for this request."
+        request.logger.warning(msg)
+
+    props["flash"] = flash
+    props["errors"] = {error_bag: errors} if error_bag is not None else errors
+    props["csrf_token"] = value_or_default(ScopeState.from_scope(request.scope).csrf_token, "")
+    return props
+
+
+def share(
+    connection: ASGIConnection[Any, Any, Any, Any],
+    key: str,
+    value: Any,
+) -> None:
+    """Share a value in the session.
+
+    Args:
+        connection: The ASGI connection.
+        key: The key to store the value under.
+        value: The value to store.
+    """
+    try:
+        connection.session.setdefault("_shared", {}).update({key: value})
+    except (AttributeError, ImproperlyConfiguredException):
+        msg = "Unable to set `share` session state.  A valid session was not found for this request."
+        connection.logger.warning(msg)
+
+
+def error(
+    connection: ASGIConnection[Any, Any, Any, Any],
+    key: str,
+    message: str,
+) -> None:
+    """Set an error message in the session.
+
+    Args:
+        connection: The ASGI connection.
+        key: The key to store the error under.
+        message: The error message.
+    """
+    try:
+        connection.session.setdefault("_errors", {}).update({key: message})
+    except (AttributeError, ImproperlyConfiguredException):
+        msg = "Unable to set `error` session state.  A valid session was not found for this request."
+        connection.logger.warning(msg)
+
+
+def js_routes_script(js_routes: Routes) -> Markup:
+    @lru_cache
+    def _markup_safe_json_dumps(js_routes: str) -> Markup:
+        js = js_routes.replace("<", "\\u003c").replace(">", "\\u003e").replace("&", "\\u0026").replace("'", "\\u0027")
+        return Markup(js)
+
+    return Markup(
+        dedent(f"""
+        <script type="module">
+        globalThis.routes = JSON.parse('{_markup_safe_json_dumps(js_routes.formatted_routes)}')
+        </script>
+        """),
+    )

litestar_vite/inertia/plugin.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, AsyncGenerator
 
-from anyio.from_thread import BlockingPortalProvider
+from anyio.from_thread import start_blocking_portal
 from litestar.plugins import InitPluginProtocol
 
 if TYPE_CHECKING:
+    from anyio.from_thread import BlockingPortal
     from litestar import Litestar
     from litestar.config.app import AppConfig
 
@@ -23,7 +25,7 @@ def set_js_routes(app: Litestar) -> None:
 class InertiaPlugin(InitPluginProtocol):
     """Inertia plugin."""
 
-    __slots__ = ("config", "portal")
+    __slots__ = ("_portal", "config")
 
     def __init__(self, config: InertiaConfig) -> None:
         """Initialize ``Inertia``.
@@ -33,10 +35,18 @@ class InertiaPlugin(InitPluginProtocol):
         """
         self.config = config
 
-        self.portal = BlockingPortalProvider()
+    @asynccontextmanager
+    async def lifespan(self, app: Litestar) -> AsyncGenerator[None, None]:
+        """Lifespan to ensure the event loop is available."""
 
-    def get_portal(self) -> BlockingPortalProvider:
-        return self.portal
+        with start_blocking_portal() as portal:
+            self._portal = portal
+            yield
+
+    @property
+    def portal(self) -> BlockingPortal:
+        """Get the portal."""
+        return self._portal
 
     def on_app_init(self, app_config: AppConfig) -> AppConfig:
         """Configure application for use with Vite.
@@ -52,9 +62,10 @@ class InertiaPlugin(InitPluginProtocol):
         from litestar.utils.predicates import is_class_and_subclass
 
         from litestar_vite.inertia.exception_handler import exception_to_http_response
+        from litestar_vite.inertia.helpers import DeferredProp, StaticProp
         from litestar_vite.inertia.middleware import InertiaMiddleware
         from litestar_vite.inertia.request import InertiaRequest
-        from litestar_vite.inertia.response import DeferredProp, InertiaBack, InertiaResponse, StaticProp
+        from litestar_vite.inertia.response import InertiaBack, InertiaResponse
 
         for mw in app_config.middleware:
             if isinstance(mw, DefineMiddleware) and is_class_and_subclass(
@@ -81,4 +92,5 @@ class InertiaPlugin(InitPluginProtocol):
             (lambda x: x is DeferredProp, lambda t, v: t(v)),
             *(app_config.type_decoders or []),
         ]
+        app_config.lifespan.append(self.lifespan)  # pyright: ignore[reportUnknownMemberType]
         return app_config

litestar_vite/inertia/response.py

@@ -1,31 +1,18 @@
 from __future__ import annotations
 
-import inspect
 import itertools
-from collections import defaultdict
 from collections.abc import Mapping
-from contextlib import contextmanager
-from functools import lru_cache
 from mimetypes import guess_type
 from pathlib import PurePath
-from textwrap import dedent
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Coroutine,
-    Dict,
-    Generator,
-    Generic,
     Iterable,
-    List,
     TypeVar,
     cast,
-    overload,
 )
 from urllib.parse import quote, urlparse, urlunparse
 
-from anyio.from_thread import BlockingPortal, start_blocking_portal
 from litestar import Litestar, MediaType, Request, Response
 from litestar.datastructures.cookie import Cookie
 from litestar.exceptions import ImproperlyConfiguredException
@@ -37,308 +24,27 @@ from litestar.utils.deprecation import warn_deprecation
 from litestar.utils.empty import value_or_default
 from litestar.utils.helpers import get_enum_string_value
 from litestar.utils.scope.state import ScopeState
-from markupsafe import Markup
-from typing_extensions import ParamSpec, TypeGuard
 
 from litestar_vite.inertia._utils import get_headers
+from litestar_vite.inertia.helpers import (
+    get_shared_props,
+    is_or_contains_lazy_prop,
+    js_routes_script,
+    lazy_render,
+    should_render,
+)
+from litestar_vite.inertia.plugin import InertiaPlugin
 from litestar_vite.inertia.types import InertiaHeaderType, PageProps
 from litestar_vite.plugin import VitePlugin
 
 if TYPE_CHECKING:
     from litestar.app import Litestar
     from litestar.background_tasks import BackgroundTask, BackgroundTasks
-    from litestar.connection import ASGIConnection
     from litestar.connection.base import AuthT, StateT, UserT
     from litestar.types import ResponseCookies, ResponseHeaders, TypeEncodersMap
 
-    from litestar_vite.inertia.plugin import InertiaPlugin
-    from litestar_vite.inertia.routes import Routes
 
 T = TypeVar("T")
-T_ParamSpec = ParamSpec("T_ParamSpec")
-PropKeyT = TypeVar("PropKeyT", bound=str)
-StaticT = TypeVar("StaticT", bound=object)
-
-
-@overload
-def lazy(key: str, value_or_callable: None) -> StaticProp[str, None]: ...
-
-
-@overload
-def lazy(key: str, value_or_callable: T) -> StaticProp[str, T]: ...
-
-
-@overload
-def lazy(
-    key: str,
-    value_or_callable: Callable[..., None] = ...,
-) -> DeferredProp[str, None]: ...
-
-
-@overload
-def lazy(
-    key: str,
-    value_or_callable: Callable[T_ParamSpec, T | Coroutine[Any, Any, T]] = ...,  # pyright: ignore[reportInvalidTypeVarUse]
-) -> DeferredProp[str, T]: ...
-
-
-def lazy(  # type: ignore[misc]
-    key: str,
-    value_or_callable: T | Callable[T_ParamSpec, T | Coroutine[Any, Any, T]],  # pyright: ignore[reportInvalidTypeVarUse]
-) -> StaticProp[str, None] | StaticProp[str, T] | DeferredProp[str, T] | DeferredProp[str, None]:
-    """Wrap an async function to return a DeferredProp."""
-    if value_or_callable is None:
-        return StaticProp[str, None](key=key, value=None)
-
-    if not callable(value_or_callable):
-        return StaticProp[str, T](key=key, value=value_or_callable)
-
-    return DeferredProp[str, T](key=key, value=value_or_callable)  # pyright: ignore[reportArgumentType]
-
-
-class StaticProp(Generic[PropKeyT, StaticT]):
-    """A wrapper for static property evaluation."""
-
-    def __init__(self, key: PropKeyT, value: StaticT) -> None:
-        self._key = key
-        self._result = value
-
-    @property
-    def key(self) -> PropKeyT:
-        return self._key
-
-    def render(self, portal: BlockingPortal | None = None) -> StaticT:
-        return self._result
-
-
-class DeferredProp(Generic[PropKeyT, T]):
-    """A wrapper for deferred property evaluation."""
-
-    def __init__(self, key: PropKeyT, value: Callable[T_ParamSpec, T | Coroutine[Any, Any, T]] | None = None) -> None:
-        self._key = key
-        self._value = value
-        self._evaluated = False
-        self._result: T | None = None
-
-    @property
-    def key(self) -> PropKeyT:
-        return self._key
-
-    @staticmethod
-    def _is_awaitable(
-        v: Callable[T_ParamSpec, T | Coroutine[Any, Any, T]],
-    ) -> TypeGuard[Coroutine[Any, Any, T]]:
-        return inspect.iscoroutinefunction(v)
-
-    @staticmethod
-    @contextmanager
-    def _with_portal(portal: BlockingPortal | None = None) -> Generator[BlockingPortal, None, None]:
-        if portal is None:
-            with start_blocking_portal() as new_portal:
-                yield new_portal
-        else:
-            yield portal
-
-    def render(self, portal: BlockingPortal | None = None) -> T | None:
-        if self._evaluated:
-            return self._result
-        if self._value is None or not callable(self._value):
-            self._result = self._value
-        elif not self._is_awaitable(self._value):
-            self._result = self._value()  # type: ignore[call-arg,assignment,unused-ignore]
-        else:
-            with self._with_portal(portal) as bp:
-                self._result = bp.call(self._value)  # type: ignore[call-overload]
-        self._evaluated = True
-        return self._result  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
-
-
-def is_lazy_prop(value: Any) -> TypeGuard[DeferredProp[Any, Any]]:
-    """Check if value is a deferred property.
-
-    Args:
-        value: Any value to check
-
-    Returns:
-        bool: True if value is a deferred property
-    """
-    return isinstance(value, (DeferredProp, StaticProp))
-
-
-def should_render(value: Any, partial_data: set[str] | None = None) -> bool:
-    """Check if value should be rendered.
-
-    Args:
-        value: Any value to check
-        partial_data: Optional set of keys for partial rendering
-
-    Returns:
-        bool: True if value should be rendered
-    """
-    partial_data = partial_data or set()
-    if is_lazy_prop(value):
-        return value.key in partial_data
-    return True
-
-
-def is_or_contains_lazy_prop(value: Any) -> bool:
-    """Check if value is or contains a deferred property.
-
-    Args:
-        value: Any value to check
-
-    Returns:
-        bool: True if value is or contains a deferred property
-    """
-    if is_lazy_prop(value):
-        return True
-    if isinstance(value, str):
-        return False
-    if isinstance(value, Mapping):
-        return any(is_or_contains_lazy_prop(v) for v in cast("Mapping[str, Any]", value).values())
-    if isinstance(value, Iterable):
-        return any(is_or_contains_lazy_prop(v) for v in cast("Iterable[Any]", value))
-    return False
-
-
-def lazy_render(value: T, partial_data: set[str] | None = None, portal: BlockingPortal | None = None) -> T:
-    """Filter deferred properties from the value based on partial data.
-
-    Args:
-        value: The value to filter
-        partial_data: Keys for partial rendering
-        portal: Optional portal to use for async rendering
-    Returns:
-        The filtered value
-    """
-    partial_data = partial_data or set()
-    if isinstance(value, str):
-        return cast("T", value)
-    if isinstance(value, Mapping):
-        return cast(
-            "T",
-            {
-                k: lazy_render(v, partial_data)
-                for k, v in cast("Mapping[str, Any]", value).items()
-                if should_render(v, partial_data)
-            },
-        )
-
-    if isinstance(value, (list, tuple)):
-        filtered = [
-            lazy_render(v, partial_data) for v in cast("Iterable[Any]", value) if should_render(v, partial_data)
-        ]
-        return cast("T", type(value)(filtered))  # pyright: ignore[reportUnknownArgumentType]
-
-    if is_lazy_prop(value) and should_render(value, partial_data):
-        return cast("T", value.render())
-
-    return cast("T", value)
-
-
-def get_shared_props(
-    request: ASGIConnection[Any, Any, Any, Any],
-    partial_data: set[str] | None = None,
-) -> dict[str, Any]:
-    """Return shared session props for a request.
-
-    Args:
-        request: The ASGI connection.
-        partial_data: Optional set of keys for partial rendering.
-
-    Returns:
-        Dict[str, Any]: The shared props.
-
-    Note:
-        Be sure to call this before `self.create_template_context` if you would like to include the `flash` message details.
-    """
-    props: dict[str, Any] = {}
-    flash: dict[str, list[str]] = defaultdict(list)
-    errors: dict[str, Any] = {}
-    error_bag = request.headers.get("X-Inertia-Error-Bag", None)
-
-    try:
-        errors = request.session.pop("_errors", {})
-        shared_props = cast("Dict[str,Any]", request.session.pop("_shared", {}))
-
-        # Handle deferred props
-        for key, value in shared_props.items():
-            if is_lazy_prop(value) and should_render(value, partial_data):
-                props[key] = value.render()
-                continue
-            if should_render(value, partial_data):
-                props[key] = value
-
-        for message in cast("List[Dict[str,Any]]", request.session.pop("_messages", [])):
-            flash[message["category"]].append(message["message"])
-
-        inertia_plugin = cast("InertiaPlugin", request.app.plugins.get("InertiaPlugin"))
-        props.update(inertia_plugin.config.extra_static_page_props)
-        for session_prop in inertia_plugin.config.extra_session_page_props:
-            if session_prop not in props and session_prop in request.session:
-                props[session_prop] = request.session.get(session_prop)
-
-    except (AttributeError, ImproperlyConfiguredException):
-        msg = "Unable to generate all shared props.  A valid session was not found for this request."
-        request.logger.warning(msg)
-
-    props["flash"] = flash
-    props["errors"] = {error_bag: errors} if error_bag is not None else errors
-    props["csrf_token"] = value_or_default(ScopeState.from_scope(request.scope).csrf_token, "")
-    return props
-
-
-def share(
-    connection: ASGIConnection[Any, Any, Any, Any],
-    key: str,
-    value: Any,
-) -> None:
-    """Share a value in the session.
-
-    Args:
-        connection: The ASGI connection.
-        key: The key to store the value under.
-        value: The value to store.
-    """
-    try:
-        connection.session.setdefault("_shared", {}).update({key: value})
-    except (AttributeError, ImproperlyConfiguredException):
-        msg = "Unable to set `share` session state.  A valid session was not found for this request."
-        connection.logger.warning(msg)
-
-
-def error(
-    connection: ASGIConnection[Any, Any, Any, Any],
-    key: str,
-    message: str,
-) -> None:
-    """Set an error message in the session.
-
-    Args:
-        connection: The ASGI connection.
-        key: The key to store the error under.
-        message: The error message.
-    """
-    try:
-        connection.session.setdefault("_errors", {}).update({key: message})
-    except (AttributeError, ImproperlyConfiguredException):
-        msg = "Unable to set `error` session state.  A valid session was not found for this request."
-        connection.logger.warning(msg)
-
-
-def js_routes_script(js_routes: Routes) -> Markup:
-    @lru_cache
-    def _markup_safe_json_dumps(js_routes: str) -> Markup:
-        js = js_routes.replace("<", "\\u003c").replace(">", "\\u003e").replace("&", "\\u0026").replace("'", "\\u0027")
-        return Markup(js)
-
-    return Markup(
-        dedent(f"""
-        <script type="module">
-        globalThis.routes = JSON.parse('{_markup_safe_json_dumps(js_routes.formatted_routes)}')
-        </script>
-        """),
-    )
 
 
 class InertiaResponse(Response[T]):
@@ -473,13 +179,21 @@ class InertiaResponse(Response[T]):
         is_partial_render = cast("bool", getattr(request, "is_partial_render", False))
         partial_keys = cast("set[str]", getattr(request, "partial_keys", {}))
         vite_plugin = request.app.plugins.get(VitePlugin)
+        inertia_plugin = request.app.plugins.get(InertiaPlugin)
         template_engine = request.app.template_engine  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
         headers.update(
             {"Vary": "Accept", **get_headers(InertiaHeaderType(enabled=True))},
         )
-        shared_props = get_shared_props(request, partial_data=partial_keys if is_partial_render else None)
+        shared_props = get_shared_props(
+            request,
+            partial_data=partial_keys if is_partial_render else None,
+        )
         if is_or_contains_lazy_prop(self.content):
-            filtered_content = lazy_render(self.content, partial_keys if is_partial_render else None)
+            filtered_content = lazy_render(
+                self.content,
+                partial_keys if is_partial_render else None,
+                inertia_plugin.portal,
+            )
             if filtered_content is not None:
                 shared_props["content"] = filtered_content
         elif should_render(self.content, partial_keys):
@@ -526,7 +240,6 @@ class InertiaResponse(Response[T]):
         if self.template_str is not None:
             body = template_engine.render_string(self.template_str, context).encode(self.encoding)  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
         else:
-            inertia_plugin = cast("InertiaPlugin", request.app.plugins.get("InertiaPlugin"))
             template_name = self.template_name or inertia_plugin.config.root_template
             template = template_engine.get_template(template_name)  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
             body = template.render(**context).encode(self.encoding)  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]

litestar_vite/plugin.py

@@ -6,12 +6,12 @@ import signal
 import subprocess
 import threading
 from contextlib import contextmanager
+from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, cast
+from typing import TYPE_CHECKING, Any, Iterator, Sequence
 
 from litestar.cli._utils import console
 from litestar.contrib.jinja import JinjaTemplateEngine
-from litestar.exceptions import ImproperlyConfiguredException
 from litestar.plugins import CLIPlugin, InitPluginProtocol
 from litestar.static_files import create_static_files_router  # pyright: ignore[reportUnknownVariableType]
 
@@ -19,6 +19,16 @@ if TYPE_CHECKING:
     from click import Group
     from litestar import Litestar
     from litestar.config.app import AppConfig
+    from litestar.datastructures import CacheControlHeader
+    from litestar.openapi.spec import SecurityRequirement
+    from litestar.types import (
+        AfterRequestHookHandler,  # pyright: ignore[reportUnknownVariableType]
+        AfterResponseHookHandler,  # pyright: ignore[reportUnknownVariableType]
+        BeforeRequestHookHandler,  # pyright: ignore[reportUnknownVariableType]
+        ExceptionHandlersMap,
+        Guard,  # pyright: ignore[reportUnknownVariableType]
+        Middleware,
+    )
 
     from litestar_vite.config import ViteConfig
     from litestar_vite.loader import ViteAssetLoader
@@ -36,6 +46,20 @@ def set_environment(config: ViteConfig) -> None:
         os.environ.setdefault("VITE_DEV_MODE", str(config.dev_mode))
 
 
+@dataclass
+class StaticFilesConfig:
+    after_request: AfterRequestHookHandler | None = None
+    after_response: AfterResponseHookHandler | None = None
+    before_request: BeforeRequestHookHandler | None = None
+    cache_control: CacheControlHeader | None = None
+    exception_handlers: ExceptionHandlersMap | None = None
+    guards: list[Guard] | None = None
+    middleware: Sequence[Middleware] | None = None
+    opt: dict[str, Any] | None = None
+    security: Sequence[SecurityRequirement] | None = None
+    tags: Sequence[str] | None = None
+
+
 class ViteProcess:
     """Manages the Vite process."""
 
@@ -86,14 +110,20 @@ class ViteProcess:
 class VitePlugin(InitPluginProtocol, CLIPlugin):
     """Vite plugin."""
 
-    __slots__ = ("_asset_loader", "_config", "_vite_process")
+    __slots__ = ("_asset_loader", "_config", "_static_files_config", "_vite_process")
 
-    def __init__(self, config: ViteConfig | None = None, asset_loader: ViteAssetLoader | None = None) -> None:
+    def __init__(
+        self,
+        config: ViteConfig | None = None,
+        asset_loader: ViteAssetLoader | None = None,
+        static_files_config: StaticFilesConfig | None = None,
+    ) -> None:
         """Initialize ``Vite``.
 
         Args:
             config: configuration to use for starting Vite.  The default configuration will be used if it is not provided.
             asset_loader: an initialized asset loader to use for rendering asset tags.
+            static_files_config: optional configuration dictionary for the static files router.
         """
         from litestar_vite.config import ViteConfig
 
@@ -102,6 +132,7 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
         self._config = config
         self._asset_loader = asset_loader
         self._vite_process = ViteProcess()
+        self._static_files_config: dict[str, Any] = static_files_config.__dict__ if static_files_config else {}
 
     @property
     def config(self) -> ViteConfig:
@@ -128,37 +159,29 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
         """
         from litestar_vite.loader import render_asset_tag, render_hmr_client
 
-        if app_config.template_config is None:  # pyright: ignore[reportUnknownMemberType]
-            msg = "A template configuration is required for Vite."
-            raise ImproperlyConfiguredException(msg)
-        if not isinstance(app_config.template_config.engine_instance, JinjaTemplateEngine):  # pyright: ignore[reportUnknownMemberType]
-            msg = "Jinja2 template engine is required for Vite."
-            raise ImproperlyConfiguredException(msg)
-        app_config.template_config.engine_instance.register_template_callable(  # pyright: ignore[reportUnknownMemberType]
-            key="vite_hmr",
-            template_callable=render_hmr_client,
-        )
-        app_config.template_config.engine_instance.register_template_callable(  # pyright: ignore[reportUnknownMemberType]
-            key="vite",
-            template_callable=render_asset_tag,
-        )
+        if app_config.template_config and isinstance(app_config.template_config.engine_instance, JinjaTemplateEngine):  # pyright: ignore[reportUnknownMemberType]
+            app_config.template_config.engine_instance.register_template_callable(  # pyright: ignore[reportUnknownMemberType]
+                key="vite_hmr",
+                template_callable=render_hmr_client,
+            )
+            app_config.template_config.engine_instance.register_template_callable(  # pyright: ignore[reportUnknownMemberType]
+                key="vite",
+                template_callable=render_asset_tag,
+            )
         if self._config.set_static_folders:
             static_dirs = [Path(self._config.bundle_dir), Path(self._config.resource_dir)]
             if Path(self._config.public_dir).exists() and self._config.public_dir != self._config.bundle_dir:
                 static_dirs.append(Path(self._config.public_dir))
-            app_config.route_handlers.append(
-                create_static_files_router(
-                    directories=cast(  # type: ignore[arg-type]
-                        "list[Path]",
-                        static_dirs if self._config.dev_mode else [Path(self._config.bundle_dir)],
-                    ),
-                    path=self._config.asset_url,
-                    name="vite",
-                    html_mode=False,
-                    include_in_schema=False,
-                    opt={"exclude_from_auth": True},
-                ),
-            )
+            base_config = {
+                "directories": static_dirs if self._config.dev_mode else [Path(self._config.bundle_dir)],
+                "path": self._config.asset_url,
+                "name": "vite",
+                "html_mode": False,
+                "include_in_schema": False,
+                "opt": {"exclude_from_auth": True},
+            }
+            static_files_config: dict[str, Any] = {**base_config, **self._static_files_config}
+            app_config.route_handlers.append(create_static_files_router(**static_files_config))
         return app_config
 
     @contextmanager

{litestar_vite-0.12.0.dist-info → litestar_vite-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: litestar-vite
-Version: 0.12.0
+Version: 0.13.0
 Summary: Vite plugin for Litestar
 Project-URL: Changelog, https://cofin.github.io/litestar-vite/latest/changelog
 Project-URL: Discord, https://discord.gg/X3FJqy8d2j

{litestar_vite-0.12.0.dist-info → litestar_vite-0.13.0.dist-info}/RECORD

@@ -1,19 +1,20 @@
 litestar_vite/__init__.py,sha256=OioNGhH88mdivQlFz9JlbJV8R6wyjSYE3c8C-RIM4Ls,277
 litestar_vite/__metadata__.py,sha256=_Wo-vNQuj5co9J4FwJAB2rRafbFo8ztTHrXmEPrYrV8,514
 litestar_vite/cli.py,sha256=CBSRohDLU9cDeKMAfSbFiw1x8OE_b15ZlUaxji9Rdw8,10749
-litestar_vite/commands.py,sha256=JTRBvpR_3ddFb2o4-AJSELegw-ZGDsJ_yMaT5FVdp4w,5228
+litestar_vite/commands.py,sha256=NFRTA_VoeFuZVk6bOINJTdP9DGGSAIZRVsM-SlDykNk,5228
 litestar_vite/config.py,sha256=cZWIwTwNnBYScCty8OxxPaOL8cELx57dm7JQeV8og3Y,4565
 litestar_vite/loader.py,sha256=nrXL2txXoBZEsdLZnysgBYZSreMXQ7ckLuNcu7MqnSM,10277
-litestar_vite/plugin.py,sha256=2ypzvlW5TaOeXTWPa2yHXzkPUf4okRBDl9YHo2qg-cM,8043
+litestar_vite/plugin.py,sha256=nglizc45_CBG1gqZRDxyGo8cc_KZ1yOJfAS0XiSadpg,9119
 litestar_vite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-litestar_vite/inertia/__init__.py,sha256=Fab61KXbBnyub2Nx-2AHYv2U6QiYUIrqhEZia_f9xik,863
+litestar_vite/inertia/__init__.py,sha256=KGvxCZhnOw06Pqx5_qjUxj0WWsCR3BR0cVnuNMT7sKQ,1136
 litestar_vite/inertia/_utils.py,sha256=ijO9Lgka7ZPIAHkby9szbTGoSg0nDShC2bqWT9cDxi0,1956
 litestar_vite/inertia/config.py,sha256=0Je9SLg0acv0eRvudk3aJLj5k1DjPxULoVOwAfpjnUc,1232
-litestar_vite/inertia/exception_handler.py,sha256=0FiW8jVib0xT453BzMPOeJa7bRwnxkOUdJ91kiFHPIo,5308
+litestar_vite/inertia/exception_handler.py,sha256=BU7vOK7C2iW52_J5xGJZMjYX3EqIg1OpAF3PgbaLSZ4,5349
+litestar_vite/inertia/helpers.py,sha256=9XVQUAqmiXOTUGVLgxPWPgftkRCx99jr6LXPiD35YJE,10571
 litestar_vite/inertia/middleware.py,sha256=23HfQ8D2wNGXUXt_isuGfZ8AFKrr1d_498qGFLynocs,1650
-litestar_vite/inertia/plugin.py,sha256=f2oFwlEDt9WZ8zt-AqiCIRPlkHIyzLtPYYo8WJZX-tI,3186
+litestar_vite/inertia/plugin.py,sha256=iVF1c8E7M6IdZK_S1nZW8ZTi7vfIllMAnIUX0pVdrFQ,3686
 litestar_vite/inertia/request.py,sha256=Ogt_ikauWrsgKafaip7IL1YhbybwjdBAQ0PQS7cImoQ,3848
-litestar_vite/inertia/response.py,sha256=CY-qziEPc9FZ4oXxtgO0Iipg1Hz4x-fiUeLK04Br8kM,23425
+litestar_vite/inertia/response.py,sha256=YjfabkYkGxDwbuo-WLgbUAHcCi0jgZYM_qdnUbI6Pas,13767
 litestar_vite/inertia/routes.py,sha256=QksJm2RUfL-WbuhOieYnPXXWO5GYnPtmsYEm6Ef8Yeo,1782
 litestar_vite/inertia/types.py,sha256=tLp0pm1N__hcWC875khf6wH1nuFlKS9-VjDqgsRkXnw,702
 litestar_vite/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,7 +24,7 @@ litestar_vite/templates/package.json.j2,sha256=0JWgdTuaSZ25EmCltF_zbqDdpxfvCLeYu
 litestar_vite/templates/styles.css.j2,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 litestar_vite/templates/tsconfig.json.j2,sha256=q1REIuVyXUHCy4Zi2kgTkmrhdT98vyY89k-WTrImOj8,843
 litestar_vite/templates/vite.config.ts.j2,sha256=bF5kOPFafYMkhhV0VkIwetN-_zoVMGVM1jEMX_wKoNc,1037
-litestar_vite-0.12.0.dist-info/METADATA,sha256=0Nv7ZBioTYS6JTE0KzPht82kwBhcBGH7W1cBRB8vgCM,6244
-litestar_vite-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-litestar_vite-0.12.0.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
-litestar_vite-0.12.0.dist-info/RECORD,,
+litestar_vite-0.13.0.dist-info/METADATA,sha256=qxVk_WT5C6YZaPsDHfPaoauTTXJQh9dL_6BUCVrUeCY,6244
+litestar_vite-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+litestar_vite-0.13.0.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
+litestar_vite-0.13.0.dist-info/RECORD,,