litestar-vite 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

litestar_vite/__init__.py

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

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/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/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/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/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/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/plugin.py

@@ -1,24 +1,24 @@
 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]
-)
-
-from litestar_vite.config import ViteConfig
+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 ViteTemplateConfig
-    from litestar_vite.template_engine import ViteTemplateEngine
+    from litestar_vite.config import ViteConfig
+    from litestar_vite.loader import ViteAssetLoader
 
 
 def set_environment(config: ViteConfig) -> None:
@@ -28,40 +28,96 @@ 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", f"http://localhost:{os.environ.get('LITESTAR_PORT',8000)}")
+    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__ = ("_config",)
+    __slots__ = ("_asset_loader", "_config", "_vite_process")
 
-    def __init__(self, config: ViteConfig | None = None) -> None:
+    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 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 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
@@ -72,12 +128,24 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
         """Configure application for use with Vite.
 
         Args:
-            app_config: The :class:`AppConfig <.config.app.AppConfig>` instance.
+            app_config: The :class:`AppConfig <litestar.config.app.AppConfig>` instance.
         """
-
-        if self._config.template_dir is not None:
-            app_config.template_config = self.template_config
-
+        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:
@@ -99,34 +167,26 @@ class VitePlugin(InitPluginProtocol, CLIPlugin):
 
     @contextmanager
     def server_lifespan(self, app: Litestar) -> Iterator[None]:
-        import threading
-
+        """Manage Vite server process lifecycle."""
         from litestar.cli._utils import console
 
-        from litestar_vite.commands import execute_command
-
         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)
-            vite_thread = threading.Thread(
-                name="vite",
-                target=execute_command,
-                args=[],
-                kwargs={"command_to_run": command_to_run, "cwd": self._config.root_dir},
-            )
+
             try:
-                vite_thread.start()
+                self._vite_process.start(command_to_run, self._config.root_dir)
                 yield
             finally:
-                if vite_thread.is_alive():
-                    vite_thread.join(timeout=5)
+                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():

{litestar_vite-0.9.0.dist-info → litestar_vite-0.11.0.dist-info}/METADATA

@@ -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.dist-info → litestar_vite-0.11.0.dist-info}/RECORD

@@ -1,20 +1,19 @@
-litestar_vite/__init__.py,sha256=S2zgWHas3O16FhXukd1j3tGCMP9skj7Rp-BvMQA7sd8,402
+litestar_vite/__init__.py,sha256=OioNGhH88mdivQlFz9JlbJV8R6wyjSYE3c8C-RIM4Ls,277
 litestar_vite/__metadata__.py,sha256=_Wo-vNQuj5co9J4FwJAB2rRafbFo8ztTHrXmEPrYrV8,514
-litestar_vite/cli.py,sha256=iRJlHa72ch9IPtu88BsalrqzDGXI3F78b2ug8JT5UWA,10756
-litestar_vite/commands.py,sha256=pszP0xdLL8fRDb8PQuilfpqLa2jpqprfZ0XDHTqxg7U,5227
-litestar_vite/config.py,sha256=IA5MU6TOxXPYrCehGoBK_dFniu2PrYvOGwQPV7XkX5I,7756
-litestar_vite/loader.py,sha256=gK0RlenM-enNV_pS-jEwW9hanAmq053m2P75rfQuGCg,8227
-litestar_vite/plugin.py,sha256=p4VPKYdWw5qIYZ1OwfdMRcwM_Q-vfoDEmIbu3IyF7oI,5166
+litestar_vite/cli.py,sha256=CBSRohDLU9cDeKMAfSbFiw1x8OE_b15ZlUaxji9Rdw8,10749
+litestar_vite/commands.py,sha256=aGpSmrRfArSg4hkpL6GTuKZPRyZm1y-qhon0P5mUoEQ,5228
+litestar_vite/config.py,sha256=cZWIwTwNnBYScCty8OxxPaOL8cELx57dm7JQeV8og3Y,4565
+litestar_vite/loader.py,sha256=nrXL2txXoBZEsdLZnysgBYZSreMXQ7ckLuNcu7MqnSM,10277
+litestar_vite/plugin.py,sha256=XZ1RxyRS9aX3coJis02Uv2AMB2frI2eqKSlK_zZWwSY,8091
 litestar_vite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-litestar_vite/template_engine.py,sha256=lFFJsD-sgf3LIaFDoD1NysRUg49WV-ELE53SHiBDeeA,3837
 litestar_vite/inertia/__init__.py,sha256=Fab61KXbBnyub2Nx-2AHYv2U6QiYUIrqhEZia_f9xik,863
 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/middleware.py,sha256=NEDcAoT7GMWA9hEGvANZ3MG5_p3MmZX57RF95T71les,1716
+litestar_vite/inertia/middleware.py,sha256=23HfQ8D2wNGXUXt_isuGfZ8AFKrr1d_498qGFLynocs,1650
 litestar_vite/inertia/plugin.py,sha256=OgXmmvjl7KWlt4KEkYhS3mU2EY4iYN9JtJ20S3Qlht8,2349
 litestar_vite/inertia/request.py,sha256=Ogt_ikauWrsgKafaip7IL1YhbybwjdBAQ0PQS7cImoQ,3848
-litestar_vite/inertia/response.py,sha256=Au7jQnqjY3wJAHNmiwteCZxKTKGCpnkjMTSzBVRwkXs,15927
+litestar_vite/inertia/response.py,sha256=drOn8wdxEhoffPJLBpLGqEX1UJVgSOL-qbsTR3bJG2M,16222
 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
@@ -24,7 +23,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.9.0.dist-info/METADATA,sha256=VY0pL6yNgte4PGdsQ_Lm4LNtCkop7ILu5TarD-BjcyY,6022
-litestar_vite-0.9.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-litestar_vite-0.9.0.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
-litestar_vite-0.9.0.dist-info/RECORD,,
+litestar_vite-0.11.0.dist-info/METADATA,sha256=vwSng0cRQYYu4oWOP7a0auIl2p7kLiaxUCOS3TT5fAA,6222
+litestar_vite-0.11.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+litestar_vite-0.11.0.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
+litestar_vite-0.11.0.dist-info/RECORD,,

litestar_vite/template_engine.py

@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Mapping, TypeVar
-
-import markupsafe
-from litestar.contrib.jinja import JinjaTemplateEngine
-from litestar.template.base import TemplateEngineProtocol
-
-from litestar_vite.loader import ViteAssetLoader
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-    from jinja2 import Environment
-    from jinja2 import Template as JinjaTemplate
-
-    from litestar_vite.config import ViteConfig
-
-T = TypeVar("T", bound=TemplateEngineProtocol["JinjaTemplate", Mapping[str, Any]])
-
-
-class ViteTemplateEngine(JinjaTemplateEngine):
-    """Jinja Template Engine with Vite Integration.
-
-    This class extends :class:`litestar.contrib.jinja.JinjaTemplateEngine` to provide Vite asset integration
-    and hot module reloading support.
-
-    Raises:
-        TemplateNotFoundException: If template is not found.
-    """
-
-    def __init__(
-        self,
-        directory: Path | list[Path] | None = None,
-        engine_instance: Environment | None = None,
-        config: ViteConfig | None = None,
-    ) -> None:
-        """Jinja2 based TemplateEngine.
-
-        Args:
-            directory: Direct path or list of directory paths from which to serve templates.
-            engine_instance: A jinja Environment instance.
-            config: Vite config
-        """
-        super().__init__(directory=directory, engine_instance=engine_instance)
-        if config is None:
-            msg = "Please configure the `ViteConfig` instance."
-            raise ValueError(msg)
-        self.config = config
-        self.asset_loader = ViteAssetLoader.initialize_loader(config=self.config)
-        self.engine.globals.update({"vite_hmr": self.get_hmr_client, "vite": self.get_asset_tag})  # pyright: ignore[reportCallIssue,reportUnknownMemberType,reportArgumentType]
-
-    def get_hmr_client(self) -> markupsafe.Markup:
-        """Generate the script tag for the Vite WS client for HMR.
-
-        Only used when hot module reloading is enabled, in production this method returns an empty string.
-
-        Returns:
-            markupsafe.Markup: The script tag or an empty string.
-        """
-        return markupsafe.Markup(
-            f"{self.asset_loader.generate_react_hmr_tags()}{self.asset_loader.generate_ws_client_tags()}",
-        )
-
-    def get_asset_tag(
-        self,
-        path: str | list[str],
-        scripts_attrs: dict[str, str] | None = None,
-        **_: Any,
-    ) -> markupsafe.Markup:
-        """Generate all assets include tags for the file in argument.
-
-        Generates all scripts tags for this file and all its dependencies
-        (JS and CSS) by reading the manifest file (for production only).
-        In development Vite imports all dependencies by itself.
-        Place this tag in <head> section of your page.
-
-        Args:
-            path: Path to a Vite asset to include.
-            scripts_attrs: Dictionary of attributes to add to script tags.
-            **_: Additional keyword arguments (ignored).
-
-        Returns:
-            markupsafe.Markup: HTML markup containing all required asset tags.
-        """
-        if isinstance(path, str):
-            path = [path]
-        return markupsafe.Markup(
-            "".join([self.asset_loader.generate_asset_tags(p, scripts_attrs=scripts_attrs) for p in path]),
-        )
-
-    @classmethod
-    def from_environment(cls, config: ViteConfig, jinja_environment: Environment) -> ViteTemplateEngine:  # type: ignore[override]
-        """Create a JinjaTemplateEngine from an existing jinja Environment instance.
-
-        Args:
-            config: Vite config
-            jinja_environment (jinja2.environment.Environment): A jinja Environment instance.
-
-        Returns:
-            JinjaTemplateEngine instance
-        """
-        return cls(directory=None, config=config, engine_instance=jinja_environment)