litestar-vite 0.1.22__py3-none-any.whl → 0.2.0__py3-none-any.whl

litestar_vite/inertia/response.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+import itertools
+from collections import defaultdict
+from functools import lru_cache
+from mimetypes import guess_type
+from pathlib import PurePath
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Mapping, TypeVar, cast
+from urllib.parse import quote
+
+from litestar import Litestar, MediaType, Request, Response
+from litestar.datastructures.cookie import Cookie
+from litestar.exceptions import ImproperlyConfiguredException
+from litestar.response import Redirect
+from litestar.response.base import ASGIResponse
+from litestar.serialization import get_serializer
+from litestar.status_codes import HTTP_200_OK, HTTP_303_SEE_OTHER, HTTP_307_TEMPORARY_REDIRECT, HTTP_409_CONFLICT
+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 litestar_vite.inertia._utils import get_headers
+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.routes import Routes
+
+    from .plugin import InertiaPlugin
+
+T = TypeVar("T")
+
+
+def share(
+    connection: ASGIConnection[Any, Any, Any, Any],
+    key: str,
+    value: Any,
+) -> None:
+    connection.session.setdefault("_shared", {}).update({key: value})
+
+
+def error(
+    connection: ASGIConnection[Any, Any, Any, Any],
+    key: str,
+    message: str,
+) -> None:
+    connection.session.setdefault("_errors", {}).update({key: message})
+
+
+def get_shared_props(request: ASGIConnection[Any, Any, Any, Any]) -> Dict[str, Any]:  # noqa: UP006
+    """Return shared session props for a request
+
+
+    Be sure to call this before `self.create_template_context` if you would like to include the `flash` message details.
+    """
+    error_bag = request.headers.get("X-Inertia-Error-Bag", None)
+    errors = request.session.pop("_errors", {})
+    props = request.session.pop("_shared", {})
+    flash: dict[str, list[str]] = defaultdict(list)
+    for message in 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_page_props)
+    props["csrf_token"] = value_or_default(ScopeState.from_scope(request.scope).csrf_token, "")
+    props["flash"] = flash
+    props["errors"] = {error_bag: errors} if error_bag is not None else errors
+    return props
+
+
+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]):
+    """Inertia Response"""
+
+    def __init__(
+        self,
+        content: T,
+        *,
+        template_name: str | None = None,
+        template_str: str | None = None,
+        background: BackgroundTask | BackgroundTasks | None = None,
+        context: dict[str, Any] | None = None,
+        cookies: ResponseCookies | None = None,
+        encoding: str = "utf-8",
+        headers: ResponseHeaders | None = None,
+        media_type: MediaType | str | None = None,
+        status_code: int = HTTP_200_OK,
+        type_encoders: TypeEncodersMap | None = None,
+    ) -> None:
+        """Handle the rendering of a given template into a bytes string.
+
+        Args:
+            content: A value for the response body that will be rendered into bytes string.
+            template_name: Path-like name for the template to be rendered, e.g. ``index.html``.
+            template_str: A string representing the template, e.g. ``tmpl = "Hello <strong>World</strong>"``.
+            background: A :class:`BackgroundTask <.background_tasks.BackgroundTask>` instance or
+                :class:`BackgroundTasks <.background_tasks.BackgroundTasks>` to execute after the response is finished.
+                Defaults to ``None``.
+            context: A dictionary of key/value pairs to be passed to the temple engine's render method.
+            cookies: A list of :class:`Cookie <.datastructures.Cookie>` instances to be set under the response
+                ``Set-Cookie`` header.
+            encoding: Content encoding
+            headers: A string keyed dictionary of response headers. Header keys are insensitive.
+            media_type: A string or member of the :class:`MediaType <.enums.MediaType>` enum. If not set, try to infer
+                the media type based on the template name. If this fails, fall back to ``text/plain``.
+            status_code: A value for the response HTTP status code.
+            type_encoders: A mapping of types to callables that transform them into types supported for serialization.
+        """
+        if template_name and template_str:
+            msg = "Either template_name or template_str must be provided, not both."
+            raise ValueError(msg)
+        self.content = content
+        self.background = background
+        self.cookies: list[Cookie] = (
+            [Cookie(key=key, value=value) for key, value in cookies.items()]
+            if isinstance(cookies, Mapping)
+            else list(cookies or [])
+        )
+        self.encoding = encoding
+        self.headers: dict[str, Any] = (
+            dict(headers) if isinstance(headers, Mapping) else {h.name: h.value for h in headers or {}}
+        )
+        self.media_type = media_type
+        self.status_code = status_code
+        self.response_type_encoders = {**(self.type_encoders or {}), **(type_encoders or {})}
+        self.context = context or {}
+        self.template_name = template_name
+        self.template_str = template_str
+
+    def create_template_context(
+        self,
+        request: Request[UserT, AuthT, StateT],
+        page_props: PageProps[T],
+        type_encoders: TypeEncodersMap | None = None,
+    ) -> dict[str, Any]:
+        """Create a context object for the template.
+
+        Args:
+            request: A :class:`Request <.connection.Request>` instance.
+            page_props: A formatted object to return the inertia configuration.
+            type_encoders: A mapping of types to callables that transform them into types supported for serialization.
+
+        Returns:
+            A dictionary holding the template context
+        """
+        csrf_token = value_or_default(ScopeState.from_scope(request.scope).csrf_token, "")
+        inertia_props = self.render(page_props, MediaType.JSON, get_serializer(type_encoders)).decode()
+        return {
+            **self.context,
+            "inertia": inertia_props,
+            "js_routes": js_routes_script(request.app.state.js_routes),
+            "request": request,
+            "csrf_input": f'<input type="hidden" name="_csrf_token" value="{csrf_token}" />',
+        }
+
+    def to_asgi_response(
+        self,
+        app: Litestar | None,
+        request: Request[UserT, AuthT, StateT],
+        *,
+        background: BackgroundTask | BackgroundTasks | None = None,
+        cookies: Iterable[Cookie] | None = None,
+        encoded_headers: Iterable[tuple[bytes, bytes]] | None = None,
+        headers: dict[str, str] | None = None,
+        is_head_response: bool = False,
+        media_type: MediaType | str | None = None,
+        status_code: int | None = None,
+        type_encoders: TypeEncodersMap | None = None,
+    ) -> ASGIResponse:
+        if app is not None:
+            warn_deprecation(
+                version="2.1",
+                deprecated_name="app",
+                kind="parameter",
+                removal_in="3.0.0",
+                alternative="request.app",
+            )
+        inertia_enabled = getattr(request, "inertia_enabled", False) or getattr(request, "is_inertia", False)
+        is_inertia = getattr(request, "is_inertia", False)
+
+        headers = {**headers, **self.headers} if headers is not None else self.headers
+        cookies = self.cookies if cookies is None else itertools.chain(self.cookies, cookies)
+        type_encoders = (
+            {**type_encoders, **(self.response_type_encoders or {})} if type_encoders else self.response_type_encoders
+        )
+        if not inertia_enabled:
+            media_type = get_enum_string_value(self.media_type or media_type or MediaType.JSON)
+            return ASGIResponse(
+                background=self.background or background,
+                body=self.render(self.content, media_type, get_serializer(type_encoders)),
+                cookies=cookies,
+                encoded_headers=encoded_headers,
+                encoding=self.encoding,
+                headers=headers,
+                is_head_response=is_head_response,
+                media_type=media_type,
+                status_code=self.status_code or status_code,
+            )
+        vite_plugin = request.app.plugins.get(VitePlugin)
+        template_engine = vite_plugin.template_config.to_engine()
+        headers.update(
+            {"Vary": "Accept", **get_headers(InertiaHeaderType(enabled=True))},
+        )
+        shared_props = get_shared_props(request)
+        page_props = PageProps[T](
+            component=request.inertia.route_component,  # type: ignore[attr-defined] # pyright: ignore[reportUnknownArgumentType,reportUnknownMemberType,reportAttributeAccessIssue]
+            props={"content": self.content, **shared_props},  # pyright: ignore[reportArgumentType]
+            version=template_engine.asset_loader.version_id,
+            url=request.url.path,
+        )
+        if is_inertia:
+            media_type = get_enum_string_value(self.media_type or media_type or MediaType.JSON)
+            body = self.render(page_props, media_type, get_serializer(type_encoders))
+            return ASGIResponse(
+                background=self.background or background,
+                body=body,
+                cookies=cookies,
+                encoded_headers=encoded_headers,
+                encoding=self.encoding,
+                headers=headers,
+                is_head_response=is_head_response,
+                media_type=media_type,
+                status_code=self.status_code or status_code,
+            )
+
+        if not template_engine:
+            msg = "Template engine is not configured"
+            raise ImproperlyConfiguredException(msg)
+        # it should default to HTML at this point unless the user specified something
+        media_type = media_type or MediaType.HTML
+        if not media_type:
+            if self.template_name:
+                suffixes = PurePath(self.template_name).suffixes
+                for suffix in suffixes:
+                    if _type := guess_type(f"name{suffix}")[0]:
+                        media_type = _type
+                        break
+                else:
+                    media_type = MediaType.TEXT
+            else:
+                media_type = MediaType.HTML
+        context = self.create_template_context(request, page_props, type_encoders)  # pyright: ignore[reportUnknownMemberType]
+        if self.template_str is not None:
+            body = template_engine.render_string(self.template_str, context).encode(self.encoding)
+        else:
+            inertia_plugin = cast("InertiaPlugin", request.app.plugins.get("InertiaPlugin"))
+            template_name = self.template_name or inertia_plugin.config.root_template
+            # cast to str b/c we know that either template_name cannot be None if template_str is None
+            template = template_engine.get_template(template_name)
+            body = template.render(**context).encode(self.encoding)
+
+        return ASGIResponse(
+            background=self.background or background,
+            body=body,
+            cookies=cookies,
+            encoded_headers=encoded_headers,
+            encoding=self.encoding,
+            headers=headers,
+            is_head_response=is_head_response,
+            media_type=media_type,
+            status_code=self.status_code or status_code,
+        )
+
+
+class InertiaExternalRedirect(Response[Any]):
+    """Client side redirect."""
+
+    def __init__(
+        self,
+        request: Request[Any, Any, Any],
+        redirect_to: str,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize external redirect, Set status code to 409 (required by Inertia),
+        and pass redirect url.
+        """
+        super().__init__(
+            content=kwargs.get("content", ""),
+            status_code=HTTP_409_CONFLICT,
+            headers={"X-Inertia": "true", "X-Inertia-Location": quote(redirect_to, safe="/#%[]=:;$&()+,!?*@'~")},
+            cookies=request.cookies,
+            **kwargs,
+        )
+
+
+class InertiaRedirect(Redirect):
+    """Client side redirect."""
+
+    def __init__(
+        self,
+        request: Request[Any, Any, Any],
+        redirect_to: str,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize external redirect, Set status code to 409 (required by Inertia),
+        and pass redirect url.
+        """
+        super().__init__(
+            path=redirect_to,
+            status_code=HTTP_307_TEMPORARY_REDIRECT if request.method == "GET" else HTTP_303_SEE_OTHER,
+            cookies=request.cookies,
+            **kwargs,
+        )
+
+
+class InertiaBack(Redirect):
+    """Client side redirect."""
+
+    def __init__(
+        self,
+        request: Request[Any, Any, Any],
+        **kwargs: Any,
+    ) -> None:
+        """Initialize external redirect, Set status code to 409 (required by Inertia),
+        and pass redirect url.
+        """
+        super().__init__(
+            path=request.headers["Referer"],
+            status_code=HTTP_307_TEMPORARY_REDIRECT if request.method == "GET" else HTTP_303_SEE_OTHER,
+            cookies=request.cookies,
+            **kwargs,
+        )

litestar_vite/inertia/routes.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from litestar.app import DEFAULT_OPENAPI_CONFIG
+from litestar.cli._utils import (
+    remove_default_schema_routes,
+    remove_routes_with_patterns,
+)
+from litestar.routes import ASGIRoute, WebSocketRoute
+from litestar.serialization import encode_json
+
+if TYPE_CHECKING:
+    from litestar import Litestar
+
+
+@dataclass(frozen=True)
+class Routes:
+    routes: dict[str, str]
+
+    @cached_property
+    def formatted_routes(self) -> str:
+        return encode_json(self.routes).decode(encoding="utf-8")
+
+
+EXCLUDED_METHODS = {"HEAD", "OPTIONS", "TRACE"}
+
+
+def generate_js_routes(
+    app: Litestar,
+    exclude: tuple[str, ...] | None = None,
+    schema: bool = False,
+) -> Routes:
+    sorted_routes = sorted(app.routes, key=lambda r: r.path)
+    if not schema:
+        openapi_config = app.openapi_config or DEFAULT_OPENAPI_CONFIG
+        sorted_routes = remove_default_schema_routes(sorted_routes, openapi_config)
+    if exclude is not None:
+        sorted_routes = remove_routes_with_patterns(sorted_routes, exclude)
+    route_list: dict[str, str] = {}
+    for route in sorted_routes:
+        if isinstance(route, (ASGIRoute, WebSocketRoute)):
+            route_name = route.route_handler.name or route.route_handler.handler_name
+            if len(route.methods.difference(EXCLUDED_METHODS)) > 0:
+                route_list[route_name] = route.path
+        else:
+            for handler in route.route_handlers:
+                route_name = handler.name or handler.handler_name
+                if handler.http_methods.isdisjoint(EXCLUDED_METHODS):
+                    route_list[route_name] = route.path
+
+    return Routes(routes=route_list)

litestar_vite/inertia/types.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Generic, TypedDict, TypeVar
+
+__all__ = (
+    "InertiaHeaderType",
+    "PageProps",
+)
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class PageProps(Generic[T]):
+    """Inertia Page Props Type."""
+
+    component: str
+    url: str
+    version: str
+    props: dict[str, Any]
+
+
+@dataclass
+class InertiaProps(Generic[T]):
+    """Inertia Props Type."""
+
+    page: PageProps[T]
+
+
+class InertiaHeaderType(TypedDict, total=False):
+    """Type for inertia_headers parameter in get_headers()."""
+
+    enabled: bool | None
+    version: str | None
+    location: str | None
+    partial_data: str | None
+    partial_component: str | None

litestar_vite/loader.py

@@ -1,17 +1,15 @@
 from __future__ import annotations
 
 import json
+from functools import cached_property
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, ClassVar
 from urllib.parse import urljoin
 
-from litestar.template import TemplateEngineProtocol
-
 if TYPE_CHECKING:
     from litestar_vite.config import ViteConfig
 
-T = TypeVar("T", bound=TemplateEngineProtocol)
-
 
 class ViteAssetLoader:
     """Vite  manifest loader.
@@ -24,6 +22,7 @@ class ViteAssetLoader:
     def __init__(self, config: ViteConfig) -> None:
         self._config = config
         self._manifest: dict[str, Any] = {}
+        self._manifest_content: str = ""
         self._vite_base_path: str | None = None
 
     @classmethod
@@ -34,6 +33,12 @@ class ViteAssetLoader:
             cls._instance.parse_manifest()
         return cls._instance
 
+    @cached_property
+    def version_id(self) -> str:
+        if self._manifest_content != "":
+            return str(hash(self.manifest_content))
+        return "1.0"
+
     def parse_manifest(self) -> None:
         """Read and parse the Vite manifest file.
 
@@ -76,11 +81,11 @@ class ViteAssetLoader:
             try:
                 if manifest_path.exists():
                     with manifest_path.open() as manifest_file:
-                        manifest_content = manifest_file.read()
-                        self._manifest = json.loads(manifest_content)
+                        self.manifest_content = manifest_file.read()
+                        self._manifest = json.loads(self.manifest_content)
                 else:
                     self._manifest = {}
-            except Exception as exc:  # noqa: BLE001
+            except Exception as exc:
                 msg = "There was an issue reading the Vite manifest file at  %s. Did you forget to build your assets?"
                 raise RuntimeError(
                     msg,
@@ -111,7 +116,7 @@ class ViteAssetLoader:
             str: The script tag or an empty string.
         """
         if self._config.is_react and self._config.hot_reload and self._config.dev_mode:
-            return f"""
+            return dedent(f"""
                 <script type="module">
                 import RefreshRuntime from '{self._vite_server_url()}@react-refresh'
                 RefreshRuntime.injectIntoGlobalHook(window)
@@ -119,7 +124,7 @@ class ViteAssetLoader:
                 window.$RefreshSig$ = () => (type) => type
                 window.__vite_plugin_react_preamble_installed__=true
                 </script>
-                """
+                """)
         return ""
 
     def generate_asset_tags(self, path: str | list[str], scripts_attrs: dict[str, str] | None = None) -> str:
@@ -133,7 +138,9 @@ class ViteAssetLoader:
         if self._config.hot_reload and self._config.dev_mode:
             return "".join(
                 [
-                    self._script_tag(
+                    self._style_tag(self._vite_server_url(p))
+                    if p.endswith(".css")
+                    else self._script_tag(
                         self._vite_server_url(p),
                         {"type": "module", "async": "", "defer": ""},
                     )
@@ -142,7 +149,7 @@ class ViteAssetLoader:
             )
 
         if any(p for p in path if p not in self._manifest):
-            msg = "Cannot find %s in Vite manifest at %s.  Did you forget to build your assets?"
+            msg = "Cannot find %s in Vite manifest at %s.  Did you forget to build your assets after an update?"
             raise RuntimeError(
                 msg,
                 path,
@@ -150,30 +157,33 @@ class ViteAssetLoader:
             )
 
         tags: list[str] = []
-        for p in path:
-            manifest_entry: dict = self._manifest[p]
+        manifest_entry: dict[str, Any] = {}
+        manifest_entry.update({p: self._manifest[p] for p in path})
         if not scripts_attrs:
             scripts_attrs = {"type": "module", "async": "", "defer": ""}
-
-        # Add dependent CSS
-        if "css" in manifest_entry:
-            tags.extend(
-                self._style_tag(urljoin(self._config.asset_url, css_path)) for css_path in manifest_entry.get("css", {})
-            )
-        # Add dependent "vendor"
-        if "imports" in manifest_entry:
-            tags.extend(
-                self.generate_asset_tags(vendor_path, scripts_attrs=scripts_attrs)
-                for vendor_path in manifest_entry.get("imports", {})
-            )
-        # Add the script by itself
-        tags.append(
-            self._script_tag(
-                urljoin(self._config.asset_url, manifest_entry["file"]),
-                attrs=scripts_attrs,
-            ),
-        )
-
+        for manifest in manifest_entry.values():
+            if "css" in manifest:
+                tags.extend(
+                    self._style_tag(urljoin(self._config.asset_url, css_path)) for css_path in manifest.get("css", {})
+                )
+            # Add dependent "vendor"
+            if "imports" in manifest:
+                tags.extend(
+                    self.generate_asset_tags(vendor_path, scripts_attrs=scripts_attrs)
+                    for vendor_path in manifest.get("imports", {})
+                )
+            # Add the script by itself
+            if manifest.get("file").endswith(".css"):
+                tags.append(
+                    self._style_tag(urljoin(self._config.asset_url, manifest["file"])),
+                )
+            else:
+                tags.append(
+                    self._script_tag(
+                        urljoin(self._config.asset_url, manifest["file"]),
+                        attrs=scripts_attrs,
+                    ),
+                )
         return "".join(tags)
 
     def _vite_server_url(self, path: str | None = None) -> str:
@@ -193,7 +203,9 @@ class ViteAssetLoader:
 
     def _script_tag(self, src: str, attrs: dict[str, str] | None = None) -> str:
         """Generate an HTML script tag."""
-        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()]) if attrs is not None else ""
+        if attrs is None:
+            attrs = {}
+        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
         return f'<script {attrs_str} src="{src}"></script>'
 
     def _style_tag(self, href: str) -> str:

litestar_vite/plugin.py

@@ -6,7 +6,9 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Iterator, cast
 
 from litestar.plugins import CLIPlugin, InitPluginProtocol
-from litestar.static_files import create_static_files_router
+from litestar.static_files import (
+    create_static_files_router,  # pyright: ignore[reportUnknownVariableType]
+)
 
 from litestar_vite.config import ViteConfig
 
@@ -15,6 +17,9 @@ if TYPE_CHECKING:
     from litestar import Litestar
     from litestar.config.app import AppConfig
 
+    from litestar_vite.config import ViteTemplateConfig
+    from litestar_vite.template_engine import ViteTemplateEngine
+
 
 def set_environment(config: ViteConfig) -> None:
     """Configure environment for easier integration"""
@@ -23,6 +28,7 @@ def set_environment(config: ViteConfig) -> None:
     os.environ.setdefault("VITE_PORT", str(config.port))
     os.environ.setdefault("VITE_HOST", config.host)
     os.environ.setdefault("VITE_PROTOCOL", config.protocol)
+    os.environ.setdefault("APP_URL", "http://localhost:8000")
     if config.dev_mode:
         os.environ.setdefault("VITE_DEV_MODE", str(config.dev_mode))
 
@@ -46,11 +52,21 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
     def config(self) -> ViteConfig:
         return self._config
 
+    @property
+    def template_config(self) -> ViteTemplateConfig[ViteTemplateEngine]:
+        from litestar_vite.config import ViteTemplateConfig
+        from litestar_vite.template_engine import ViteTemplateEngine
+
+        return ViteTemplateConfig[ViteTemplateEngine](
+            engine=ViteTemplateEngine,
+            config=self._config,
+            directory=self._config.template_dir,
+        )
+
     def on_cli_init(self, cli: Group) -> None:
         from litestar_vite.cli import vite_group
 
         cli.add_command(vite_group)
-        return super().on_cli_init(cli)
 
     def on_app_init(self, app_config: AppConfig) -> AppConfig:
         """Configure application for use with Vite.
@@ -59,15 +75,8 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
             app_config: The :class:`AppConfig <.config.app.AppConfig>` instance.
         """
 
-        from litestar_vite.config import ViteTemplateConfig
-        from litestar_vite.template_engine import ViteTemplateEngine
-
         if self._config.template_dir is not None:
-            app_config.template_config = ViteTemplateConfig[ViteTemplateEngine](  # type: ignore[assignment]
-                engine=ViteTemplateEngine,
-                config=self._config,
-                directory=self._config.template_dir,
-            )
+            app_config.template_config = self.template_config
 
         if self._config.set_static_folders:
             static_dirs = [Path(self._config.bundle_dir), Path(self._config.resource_dir)]
@@ -115,7 +124,7 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
                 yield
             finally:
                 if vite_thread.is_alive():
-                    vite_thread.join()
+                    vite_thread.join(timeout=5)
                 console.print("[yellow]Vite process stopped.[/]")
 
         else: