litestar-vite 0.9.0__tar.gz → 0.11.0__tar.gz

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: litestar-vite
-Version: 0.9.0
+Version: 0.11.0
 Summary: Vite plugin for Litestar
 Project-URL: Changelog, https://cofin.github.io/litestar-vite/latest/changelog
 Project-URL: Discord, https://discord.gg/X3FJqy8d2j
@@ -53,6 +53,8 @@ from pathlib import Path
 from litestar import Controller, get, Litestar
 from litestar.response import Template
 from litestar.status_codes import HTTP_200_OK
+from litestar.template.config import TemplateConfig
+from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar_vite import ViteConfig, VitePlugin
 
 class WebController(Controller):
@@ -64,9 +66,9 @@ class WebController(Controller):
     async def index(self) -> Template:
         return Template(template_name="index.html.j2")
 
-
-vite = VitePlugin(config=ViteConfig(template_dir='templates/'))
-app = Litestar(plugins=[vite], route_handlers=[WebController])
+template_config = TemplateConfig(engine=JinjaTemplateEngine(directory='templates/'))
+vite = VitePlugin(config=ViteConfig())
+app = Litestar(plugins=[vite], template_config=template_config, route_handlers=[WebController])
 
 ```
 

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/README.md

@@ -18,6 +18,8 @@ from pathlib import Path
 from litestar import Controller, get, Litestar
 from litestar.response import Template
 from litestar.status_codes import HTTP_200_OK
+from litestar.template.config import TemplateConfig
+from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar_vite import ViteConfig, VitePlugin
 
 class WebController(Controller):
@@ -29,9 +31,9 @@ class WebController(Controller):
     async def index(self) -> Template:
         return Template(template_name="index.html.j2")
 
-
-vite = VitePlugin(config=ViteConfig(template_dir='templates/'))
-app = Litestar(plugins=[vite], route_handlers=[WebController])
+template_config = TemplateConfig(engine=JinjaTemplateEngine(directory='templates/'))
+vite = VitePlugin(config=ViteConfig())
+app = Litestar(plugins=[vite], template_config=template_config, route_handlers=[WebController])
 
 ```
 

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/pyproject.toml

@@ -25,7 +25,7 @@ license = { text = "MIT" }
 name = "litestar-vite"
 readme = "README.md"
 requires-python = ">=3.8"
-version = "0.9.0"
+version = "0.11.0"
 
 [project.urls]
 Changelog = "https://cofin.github.io/litestar-vite/latest/changelog"
@@ -85,7 +85,7 @@ test = [
 allow_dirty = true
 commit = true
 commit_args = "--no-verify"
-current_version = "0.9.0"
+current_version = "0.11.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -267,6 +267,8 @@ lint.select = ["ALL"]
 lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 src = ["src/py/litestar_vite", "src/py/tests"]
 target-version = "py38"
+unsafe-fixes = true
+
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

litestar_vite-0.11.0/src/py/litestar_vite/__init__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from litestar_vite import inertia
+from litestar_vite.config import ViteConfig
+from litestar_vite.loader import ViteAssetLoader
+from litestar_vite.plugin import VitePlugin
+
+__all__ = ("ViteAssetLoader", "ViteConfig", "VitePlugin", "inertia")

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/litestar_vite/cli.py

@@ -113,8 +113,8 @@ def vite_init(
     )
     from rich.prompt import Confirm
 
+    from litestar_vite import VitePlugin
     from litestar_vite.commands import execute_command, init_vite
-    from litestar_vite.plugin import VitePlugin
 
     if callable(ctx.obj):
         ctx.obj = ctx.obj()

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/litestar_vite/commands.py

@@ -14,7 +14,7 @@ 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.9.0",
+    "litestar-vite-plugin": "^0.11.0",
     "@types/node": "^22.10.1",
 }
 DEFAULT_DEPENDENCIES: dict[str, str] = {"axios": "^1.7.2"}

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/litestar_vite/config.py

@@ -2,21 +2,9 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass, field
-from functools import cached_property
-from inspect import isclass
 from pathlib import Path
-from typing import TYPE_CHECKING, cast
 
-from litestar.exceptions import ImproperlyConfiguredException
-from litestar.template import TemplateConfig
-from litestar.template.config import EngineType
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from litestar.types import PathType
-
-__all__ = ("ViteConfig", "ViteTemplateConfig")
+__all__ = ("ViteConfig",)
 TRUE_VALUES = {"True", "true", "1", "yes", "Y", "T"}
 
 
@@ -39,8 +27,6 @@ class ViteConfig:
 
     In a standalone Vue or React application, this would be equivalent to the ``./src`` directory.
     """
-    template_dir: Path | str | None = field(default="templates")
-    """Location of the Jinja2 template file."""
     public_dir: Path | str = field(default="public")
     """The optional public directory Vite serves assets from.
 
@@ -113,8 +99,6 @@ class ViteConfig:
             self.root_dir = Path(self.root_dir)
         elif self.root_dir is None:
             self.root_dir = Path()
-        if self.template_dir is not None and isinstance(self.template_dir, str):
-            self.template_dir = Path(self.template_dir)
         if self.public_dir and isinstance(self.public_dir, str):
             self.public_dir = Path(self.public_dir)
         if isinstance(self.resource_dir, str):
@@ -123,53 +107,3 @@ class ViteConfig:
             self.bundle_dir = Path(self.bundle_dir)
         if isinstance(self.ssr_output_dir, str):
             self.ssr_output_dir = Path(self.ssr_output_dir)
-
-
-@dataclass
-class ViteTemplateConfig(TemplateConfig[EngineType]):
-    """Configuration for Templating.
-
-    To enable templating, pass an instance of this class to the
-    :class:`Litestar <litestar.app.Litestar>` constructor using the
-    'template_config' key.
-    """
-
-    config: ViteConfig = field(default_factory=lambda: ViteConfig())
-    """A a config for the vite engine`."""
-    engine: type[EngineType] | EngineType | None = field(default=None)
-    """A template engine adhering to the :class:`TemplateEngineProtocol <litestar.template.TemplateEngineProtocol>`."""
-    directory: PathType | list[PathType] | None = field(default=None)
-    """A directory or list of directories from which to serve templates."""
-    engine_callback: Callable[[EngineType], None] | None = field(default=None)
-    """A callback function that allows modifying the instantiated templating
-    protocol."""
-
-    instance: EngineType | None = field(default=None)
-    """An instance of the templating protocol."""
-
-    def __post_init__(self) -> None:
-        """Ensure that directory is set if engine is a class."""
-        if isclass(self.engine) and not self.directory:  # pyright: ignore[reportUnknownMemberType,reportUnknownArgumentType]
-            msg = "directory is a required kwarg when passing a template engine class"
-            raise ImproperlyConfiguredException(msg)
-        """Ensure that directory is not set if instance is."""
-        if self.instance is not None and self.directory is not None:  # pyright: ignore[reportUnknownMemberType]
-            msg = "directory cannot be set if instance is"
-            raise ImproperlyConfiguredException(msg)
-
-    def to_engine(self) -> EngineType:
-        """Instantiate the template engine."""
-        template_engine = cast(
-            "EngineType",
-            self.engine(directory=self.directory, config=self.config, engine_instance=None)  # pyright: ignore[reportUnknownMemberType,reportCallIssue]
-            if isclass(self.engine)  # pyright: ignore[reportUnknownMemberType,reportUnknownArgumentType]
-            else self.engine,  # pyright: ignore[reportUnknownMemberType,reportUnknownArgumentType]
-        )
-        if callable(self.engine_callback):
-            self.engine_callback(template_engine)  # pyright: ignore[reportUnknownMemberType,reportUnknownArgumentType]
-        return template_engine
-
-    @cached_property
-    def engine_instance(self) -> EngineType:
-        """Return the template engine instance."""
-        return self.to_engine() if self.instance is None else self.instance

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/litestar_vite/inertia/middleware.py

@@ -26,8 +26,7 @@ async def redirect_on_asset_version_mismatch(request: Request[UserT, AuthT, Stat
         return None
 
     vite_plugin = request.app.plugins.get(VitePlugin)
-    template_engine = vite_plugin.template_config.to_engine()
-    if inertia_version == template_engine.asset_loader.version_id:
+    if inertia_version == vite_plugin.asset_loader.version_id:
         return None
     return InertiaRedirect(request, redirect_to=str(request.url))
 

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/litestar_vite/inertia/response.py

@@ -245,7 +245,7 @@ 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)
-        template_engine = vite_plugin.template_config.to_engine()
+        template_engine = request.app.template_engine  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
         headers.update(
             {"Vary": "Accept", **get_headers(InertiaHeaderType(enabled=True))},
         )
@@ -254,13 +254,13 @@ class InertiaResponse(Response[T]):
         page_props = PageProps[T](
             component=request.inertia.route_component,  # type: ignore[attr-defined] # pyright: ignore[reportUnknownArgumentType,reportUnknownMemberType,reportAttributeAccessIssue]
             props=shared_props,  # pyright: ignore[reportArgumentType]
-            version=template_engine.asset_loader.version_id,
+            version=vite_plugin.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(
+            return ASGIResponse(  # pyright: ignore[reportUnknownMemberType]
                 background=self.background or background,
                 body=body,
                 cookies=cookies,
@@ -290,17 +290,16 @@ class InertiaResponse(Response[T]):
                 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)
+            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
-            # 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)
+            template = template_engine.get_template(template_name)  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            body = template.render(**context).encode(self.encoding)  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
 
-        return ASGIResponse(
+        return ASGIResponse(  # pyright: ignore[reportUnknownMemberType]
             background=self.background or background,
-            body=body,
+            body=body,  # pyright: ignore[reportUnknownArgumentType]
             cookies=cookies,
             encoded_headers=encoded_headers,
             encoding=self.encoding,

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/litestar_vite/loader.py

@@ -4,11 +4,61 @@ import json
 from functools import cached_property
 from pathlib import Path
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar, Mapping, cast
 from urllib.parse import urljoin
 
+import markupsafe
+from litestar.exceptions import ImproperlyConfiguredException
+
 if TYPE_CHECKING:
+    from litestar.connection import Request
+
     from litestar_vite.config import ViteConfig
+    from litestar_vite.plugin import VitePlugin
+
+
+def _get_request_from_context(context: Mapping[str, Any]) -> Request[Any, Any, Any]:
+    """Get the request from the template context.
+
+    Args:
+        context: The template context.
+
+    Returns:
+        The request object.
+    """
+    return cast("Request[Any, Any, Any]", context["request"])
+
+
+def render_hmr_client(context: Mapping[str, Any], /) -> markupsafe.Markup:
+    """Render the HMR client.
+
+    Args:
+        context: The template context.
+
+    Returns:
+        The HMR client.
+    """
+    return cast(
+        "VitePlugin", _get_request_from_context(context).app.plugins.get("VitePlugin")
+    ).asset_loader.render_hmr_client()
+
+
+def render_asset_tag(
+    context: Mapping[str, Any], /, path: str | list[str], scripts_attrs: dict[str, str] | None = None
+) -> markupsafe.Markup:
+    """Render an asset tag.
+
+    Args:
+        context: The template context.
+        path: The path to the asset.
+        scripts_attrs: The attributes for the script tag.
+
+    Returns:
+        The asset tag.
+    """
+    return cast(
+        "VitePlugin", _get_request_from_context(context).app.plugins.get("VitePlugin")
+    ).asset_loader.render_asset_tag(path, scripts_attrs)
 
 
 class ViteAssetLoader:
@@ -39,6 +89,19 @@ class ViteAssetLoader:
             return str(hash(self.manifest_content))
         return "1.0"
 
+    def render_hmr_client(self) -> markupsafe.Markup:
+        """Generate the script tag for the Vite WS client for HMR."""
+        return markupsafe.Markup(
+            f"{self.generate_react_hmr_tags()}{self.generate_ws_client_tags()}",
+        )
+
+    def render_asset_tag(self, path: str | list[str], scripts_attrs: dict[str, str] | None = None) -> markupsafe.Markup:
+        """Generate all assets include tags for the file in argument."""
+        path = [str(p) for p in path] if isinstance(path, list) else [str(path)]
+        return markupsafe.Markup(
+            "".join([self.generate_asset_tags(p, scripts_attrs=scripts_attrs) for p in path]),
+        )
+
     def parse_manifest(self) -> None:
         """Parse the Vite manifest file.
 
@@ -151,7 +214,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 after an update?"
-            raise RuntimeError(
+            raise ImproperlyConfiguredException(
                 msg,
                 path,
                 Path(f"{self._config.bundle_dir}/{self._config.manifest_name}"),
@@ -159,7 +222,7 @@ class ViteAssetLoader:
 
         tags: list[str] = []
         manifest_entry: dict[str, Any] = {}
-        manifest_entry.update({p: self._manifest[p] for p in path})
+        manifest_entry.update({p: self._manifest[p] for p in path if p})
         if not scripts_attrs:
             scripts_attrs = {"type": "module", "async": "", "defer": ""}
         for manifest in manifest_entry.values():

litestar_vite-0.11.0/src/py/litestar_vite/plugin.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import os
+import signal
+import threading
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator, cast
+
+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]
+
+if TYPE_CHECKING:
+    from click import Group
+    from litestar import Litestar
+    from litestar.config.app import AppConfig
+
+    from litestar_vite.config import ViteConfig
+    from litestar_vite.loader import ViteAssetLoader
+
+
+def set_environment(config: ViteConfig) -> None:
+    """Configure environment for easier integration"""
+    os.environ.setdefault("ASSET_URL", config.asset_url)
+    os.environ.setdefault("VITE_ALLOW_REMOTE", str(True))
+    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", f"http://localhost:{os.environ.get('LITESTAR_PORT', 8000)}")
+    if config.dev_mode:
+        os.environ.setdefault("VITE_DEV_MODE", str(config.dev_mode))
+
+
+class ViteProcess:
+    """Manages the Vite process."""
+
+    def __init__(self) -> None:
+        self.process: threading.Thread | None = None
+        self._lock = threading.Lock()
+
+    def start(self, command: list[str], cwd: Path | str | None) -> None:
+        """Start the Vite process."""
+        from litestar.cli._utils import console
+
+        from litestar_vite.commands import execute_command
+
+        try:
+            with self._lock:
+                if self.process and self.process.is_alive():
+                    return
+
+                self.process = threading.Thread(
+                    name="vite",
+                    target=execute_command,
+                    args=[],
+                    kwargs={"command_to_run": command, "cwd": cwd},
+                    daemon=True,  # Make thread daemon so it exits when main thread exits
+                )
+                console.print(f"Starting Vite process with command: {command}")
+                self.process.start()
+        except Exception as e:
+            console.print(f"[red]Failed to start Vite process: {e!s}[/]")
+            raise
+
+    def stop(self, timeout: float = 5.0) -> None:
+        """Stop the Vite process."""
+        from litestar.cli._utils import console
+
+        try:
+            with self._lock:
+                if self.process and self.process.is_alive():
+                    # Send SIGTERM to child process
+                    if hasattr(signal, "SIGTERM") and self.process.ident is not None:
+                        os.kill(self.process.ident, signal.SIGTERM)
+                    self.process.join(timeout=timeout)
+
+                    # Force kill if still alive
+                    if self.process.is_alive():
+                        if hasattr(signal, "SIGKILL") and self.process.ident is not None:
+                            os.kill(self.process.ident, signal.SIGKILL)
+                        self.process.join(timeout=1.0)
+                console.print("Stopping Vite process")
+        except Exception as e:
+            console.print(f"[red]Failed to stop Vite process: {e!s}[/]")
+            raise
+
+
+class VitePlugin(InitPluginProtocol, CLIPlugin):
+    """Vite plugin."""
+
+    __slots__ = ("_asset_loader", "_config", "_vite_process")
+
+    def __init__(self, config: ViteConfig | None = None, asset_loader: ViteAssetLoader | 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.
+        """
+        from litestar_vite.config import ViteConfig
+
+        if config is None:
+            config = ViteConfig()
+        self._config = config
+        self._asset_loader = asset_loader
+        self._vite_process = ViteProcess()
+
+    @property
+    def config(self) -> ViteConfig:
+        return self._config
+
+    @property
+    def asset_loader(self) -> ViteAssetLoader:
+        from litestar_vite.loader import ViteAssetLoader
+
+        if self._asset_loader is None:
+            self._asset_loader = ViteAssetLoader.initialize_loader(config=self._config)
+        return self._asset_loader
+
+    def on_cli_init(self, cli: Group) -> None:
+        from litestar_vite.cli import vite_group
+
+        cli.add_command(vite_group)
+
+    def on_app_init(self, app_config: AppConfig) -> AppConfig:
+        """Configure application for use with Vite.
+
+        Args:
+            app_config: The :class:`AppConfig <litestar.config.app.AppConfig>` instance.
+        """
+        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 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},
+                ),
+            )
+        return app_config
+
+    @contextmanager
+    def server_lifespan(self, app: Litestar) -> Iterator[None]:
+        """Manage Vite server process lifecycle."""
+        from litestar.cli._utils import console
+
+        if self._config.use_server_lifespan and self._config.dev_mode:
+            command_to_run = self._config.run_command if self._config.hot_reload else self._config.build_watch_command
+
+            if self.config.hot_reload:
+                console.rule("[yellow]Starting Vite process with HMR Enabled[/]", align="left")
+            else:
+                console.rule("[yellow]Starting Vite watch and build process[/]", align="left")
+
+            if self._config.set_environment:
+                set_environment(config=self._config)
+
+            try:
+                self._vite_process.start(command_to_run, self._config.root_dir)
+                yield
+            finally:
+                self._vite_process.stop()
+                console.print("[yellow]Vite process stopped.[/]")
+        else:
+            manifest_path = Path(f"{self._config.bundle_dir}/{self._config.manifest_name}")
+            if manifest_path.exists():
+                console.rule(f"[yellow]Serving assets using manifest at `{manifest_path!s}`.[/]", align="left")
+            else:
+                console.rule(f"[yellow]Serving assets without manifest at `{manifest_path!s}`.[/]", align="left")
+            yield

litestar_vite-0.11.0/src/py/tests/conftest.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Generator
+
+import pytest
+from litestar.contrib.jinja import JinjaTemplateEngine
+from litestar.template.config import TemplateConfig
+
+from litestar_vite.config import ViteConfig
+
+pytestmark = pytest.mark.anyio
+here = Path(__file__).parent
+
+
+@pytest.fixture
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+@pytest.fixture
+def test_app_path() -> Generator[Path, None, None]:
+    yield Path(here / "test_app" / "web")
+
+
+@pytest.fixture
+def template_config(test_app_path: Path) -> TemplateConfig[JinjaTemplateEngine]:
+    return TemplateConfig(engine=JinjaTemplateEngine(directory=test_app_path / "templates"))
+
+
+# Define a fixture for ViteConfig
+@pytest.fixture
+def vite_config(test_app_path: Path) -> ViteConfig:
+    # Mock the ViteConfig with necessary attributes for testing
+    return ViteConfig(
+        bundle_dir=test_app_path / "public",
+        resource_dir=test_app_path / "resources",
+        hot_reload=True,
+    )

{litestar_vite-0.9.0 → litestar_vite-0.11.0}/src/py/tests/test_app/app.py

@@ -3,17 +3,23 @@ from __future__ import annotations
 from pathlib import Path
 
 from litestar import Litestar
+from litestar.contrib.jinja import JinjaTemplateEngine
+from litestar.template.config import TemplateConfig
 
 from litestar_vite import ViteConfig, VitePlugin
 
 here = Path(__file__).parent
 
+template_config = TemplateConfig(
+    engine=JinjaTemplateEngine(
+        directory=Path(here / "web" / "templates"),
+    )
+)
 vite = VitePlugin(
     config=ViteConfig(
         bundle_dir=Path(here / "web" / "public"),
         resource_dir=Path(here / "web" / "resources"),
-        template_dir=Path(here / "web" / "templates"),
         hot_reload=True,
     ),
 )
-app = Litestar(plugins=[vite])
+app = Litestar(plugins=[vite], template_config=template_config)