litestar-vite 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

litestar_vite/cli.py

@@ -1,9 +1,17 @@
 from __future__ import annotations
 
+import sys
+from pathlib import Path
 from typing import TYPE_CHECKING
 
-from click import group, option
-from litestar.cli._utils import LitestarGroup, console
+from click import Context, group, option
+from click import Path as ClickPath
+from litestar.cli._utils import (
+    LitestarEnv,
+    LitestarGroup,
+    console,
+)
+from rich.prompt import Confirm
 
 if TYPE_CHECKING:
     from litestar import Litestar
@@ -14,6 +22,141 @@ def vite_group() -> None:
     """Manage Vite Tasks."""
 
 
+@vite_group.command(  # type: ignore # noqa: PGH003
+    name="init",
+    help="Initialize vite for your project.",
+)
+@option(
+    "--bundle-path",
+    type=ClickPath(dir_okay=True, file_okay=False, path_type=Path),
+    help="The path for the built Vite assets.  This is the where the output of `npm run build` will write files.",
+    default=None,
+    required=False,
+)
+@option(
+    "--resource-path",
+    type=ClickPath(dir_okay=True, file_okay=False, path_type=Path),
+    help="The path to your Javascript/Typescript source and associated assets.  If this were a standalone Vue or React app, this would point to your `src/` folder.",
+    default=None,
+    required=False,
+)
+@option(
+    "--asset-path",
+    type=ClickPath(dir_okay=True, file_okay=False, path_type=Path),
+    help="The path to your Javascript/Typescript source and associated assets.  If this were a standalone Vue or React app, this would point to your `src/` folder.",
+    default=None,
+    required=False,
+)
+@option("--asset-url", type=str, help="Base url to serve assets from.", default=None, required=False)
+@option(
+    "--vite-port",
+    type=int,
+    help="The port to run the vite server against.",
+    default=None,
+    is_flag=True,
+    required=False,
+)
+@option(
+    "--enable-ssr",
+    type=bool,
+    help="Enable SSR Support.",
+    required=False,
+    show_default=False,
+    is_flag=True,
+)
+@option("--overwrite", type=bool, help="Overwrite any files in place.", default=False, is_flag=True)
+@option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
+@option(
+    "--no-prompt",
+    help="Do not prompt for confirmation and use all defaults for initializing the project.",
+    type=bool,
+    default=False,
+    required=False,
+    show_default=True,
+    is_flag=True,
+)
+def vite_init(
+    ctx: Context,
+    vite_port: int | None,
+    enable_ssr: bool | None,
+    asset_url: str | None,
+    asset_path: Path | None,
+    bundle_path: Path | None,
+    resource_path: Path | None,
+    overwrite: bool,
+    verbose: bool,
+    no_prompt: bool,
+) -> None:  # sourcery skip: low-code-quality
+    """Run vite build."""
+    from litestar_vite.commands import init_vite
+    from litestar_vite.plugin import VitePlugin
+
+    if callable(ctx.obj):
+        ctx.obj = ctx.obj()
+    elif verbose:
+        ctx.obj.app.debug = True
+    env: LitestarEnv = ctx.obj
+    plugin = env.app.plugins.get(VitePlugin)
+    config = plugin._config  # noqa: SLF001
+
+    console.rule("[yellow]Initializing Vite[/]", align="left")
+    resource_path = resource_path or config.resource_dir
+    asset_path = asset_path or config.assets_dir
+    bundle_path = bundle_path or config.bundle_dir
+    enable_ssr = enable_ssr or config.ssr_enabled
+    asset_url = asset_url or config.asset_url
+    vite_port = vite_port or config.port
+    hot_file = Path(bundle_path / config.hot_file)
+    root_path = resource_path.parent
+    if any(output_path.exists() for output_path in (asset_path, bundle_path, resource_path)) and not any(
+        [overwrite, no_prompt],
+    ):
+        confirm_overwrite = Confirm.ask(
+            "Files were found in the paths specified.  Are you sure you wish to overwrite the contents?",
+        )
+        if not confirm_overwrite:
+            console.print("Skipping Vite initialization")
+            sys.exit(2)
+    for output_path in (asset_path, bundle_path, resource_path):
+        output_path.mkdir(parents=True, exist_ok=True)
+    enable_ssr = (
+        True
+        if enable_ssr
+        else False
+        if no_prompt
+        else Confirm.ask(
+            "Do you intend to use Litestar with any SSR framework?",
+        )
+    )
+    init_vite(
+        app=env.app,
+        root_path=root_path,
+        enable_ssr=enable_ssr,
+        vite_port=vite_port,
+        asset_url=asset_url,
+        resource_path=resource_path,
+        asset_path=asset_path,
+        bundle_path=bundle_path,
+        hot_file=hot_file,
+        litestar_port=env.port or 8000,
+    )
+
+
+@vite_group.command(  # type: ignore # noqa: PGH003
+    name="install",
+    help="Install frontend packages.",
+)
+@option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
+def vite_install(app: Litestar, verbose: bool) -> None:  # noqa: ARG001
+    """Run vite build."""
+    from litestar_vite.commands import run_vite
+    from litestar_vite.plugin import VitePlugin
+
+    console.rule("[yellow]Starting Vite build process[/]", align="left")
+    plugin = app.plugins.get(VitePlugin)
+    run_vite(" ".join(plugin._config.install_command))  # noqa: SLF001
+
+
 @vite_group.command(  # type: ignore # noqa: PGH003
     name="build",
     help="Building frontend assets with Vite.",
@@ -21,4 +164,24 @@ def vite_group() -> None:
 @option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
 def vite_build(app: Litestar, verbose: bool) -> None:  # noqa: ARG001
     """Run vite build."""
+    from litestar_vite.commands import run_vite
+    from litestar_vite.plugin import VitePlugin
+
     console.rule("[yellow]Starting Vite build process[/]", align="left")
+    plugin = app.plugins.get(VitePlugin)
+    run_vite(" ".join(plugin._config.build_command))  # noqa: SLF001
+
+
+@vite_group.command(  # type: ignore # noqa: PGH003
+    name="serve",
+    help="Serving frontend assets with Vite.",
+)
+@option("--verbose", type=bool, help="Enable verbose output.", default=False, is_flag=True)
+def vite_serve(app: Litestar, verbose: bool) -> None:  # noqa: ARG001
+    """Run vite serve."""
+    from litestar_vite.commands import run_vite
+    from litestar_vite.plugin import VitePlugin
+
+    console.rule("[yellow]Starting Vite process[/]", align="left")
+    plugin = app.plugins.get(VitePlugin)
+    run_vite(" ".join(plugin._config.build_command))  # noqa: SLF001

litestar_vite/commands.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import contextlib
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, MutableMapping
+
+from jinja2 import select_autoescape
+from litestar.serialization import encode_json
+
+if TYPE_CHECKING:
+    from jinja2 import Environment, Template
+    from litestar import Litestar
+
+VITE_INIT_TEMPLATES_PATH = f"{Path(__file__).parent}/templates/init"
+VITE_INIT_TEMPLATES: set[str] = {"package.json.j2", "tsconfig.json.j2", "vite.config.ts.j2"}
+
+DEFAULT_DEV_DEPENDENCIES: dict[str, str] = {
+    "axios": "^1.6.2",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.6",
+    "litestar-vite-plugin": "^0.3.0",
+    "@types/node": "^20.10.3",
+}
+DEFAULT_DEPENDENCIES: dict[str, str] = {}
+
+
+def to_json(value: Any) -> str:
+    """Serialize JSON field values.
+
+    Args:
+        value: Any json serializable value.
+
+    Returns:
+        JSON string.
+    """
+    return encode_json(value).decode("utf-8")
+
+
+def init_vite(
+    app: Litestar,
+    root_path: Path,
+    resource_path: Path,
+    asset_path: Path,
+    asset_url: str,
+    bundle_path: Path,
+    enable_ssr: bool,
+    vite_port: int,
+    hot_file: Path,
+    litestar_port: int,
+) -> None:
+    """Initialize a new vite project."""
+    from jinja2 import Environment, FileSystemLoader
+
+    entry_point: list[str] = []
+    vite_template_env = Environment(
+        loader=FileSystemLoader([VITE_INIT_TEMPLATES_PATH]),
+        autoescape=select_autoescape(),
+    )
+
+    logger = app.get_logger()
+    enabled_templates: set[str] = VITE_INIT_TEMPLATES
+    dependencies: dict[str, str] = DEFAULT_DEPENDENCIES
+    dev_dependencies: dict[str, str] = DEFAULT_DEV_DEPENDENCIES
+    templates: dict[str, Template] = {
+        template_name: get_template(environment=vite_template_env, name=template_name)
+        for template_name in enabled_templates
+    }
+    for template_name, template in templates.items():
+        target_file_name = template_name.removesuffix(".j2")
+        with Path(target_file_name).open(mode="w") as file:
+            logger.info("Writing %s", target_file_name)
+
+            file.write(
+                template.render(
+                    entry_point=entry_point,
+                    enable_ssr=enable_ssr,
+                    asset_url=asset_url,
+                    root_path=str(root_path.relative_to(Path.cwd())),
+                    resource_path=str(resource_path.relative_to(root_path)),
+                    bundle_path=str(bundle_path.relative_to(root_path)),
+                    asset_path=str(asset_path.relative_to(root_path)),
+                    hot_file=str(hot_file.relative_to(root_path)),
+                    vite_port=str(vite_port),
+                    litestar_port=litestar_port,
+                    dependencies=to_json(dependencies),
+                    dev_dependencies=to_json(dev_dependencies),
+                ),
+            )
+
+
+def get_template(
+    environment: Environment,
+    name: str | Template,
+    parent: str | None = None,
+    globals: MutableMapping[str, Any] | None = None,  # noqa: A002
+) -> Template:
+    return environment.get_template(name=name, parent=parent, globals=globals)
+
+
+def run_vite(command_to_run: str) -> None:
+    """Run Vite in a subprocess."""
+
+    import anyio
+
+    with contextlib.suppress(KeyboardInterrupt):
+        anyio.run(_run_vite, command_to_run)
+
+
+async def _run_vite(command_to_run: str) -> None:
+    """Run Vite in a subprocess."""
+
+    from anyio import open_process
+    from anyio.streams.text import TextReceiveStream
+    from litestar.cli._utils import console
+
+    async with await open_process(command_to_run) as vite_process:
+        async for text in TextReceiveStream(vite_process.stdout):  # type: ignore[arg-type]
+            console.print(text)

litestar_vite/config.py

@@ -31,34 +31,66 @@ class ViteConfig:
     'plugins' key.
     """
 
-    static_dir: Path
-    """Location of the manifest file.
+    bundle_dir: Path
+    """Location of the compiled assets from  Vite.
 
-    The path relative to the `static_url` location
+    The manifest file will also be found here.
+    """
+    resource_dir: Path
+    """The directory where all typescript/javascript source are written.
+
+    In a standalone Vue or React application, this would be equivalent to the ``./src`` directory.
+    """
+    assets_dir: Path
+    """These are the assets that Vite will serve when developing.
+
+    This should include any images, CSS, or other media referenced.
+
+    These will be included in the bundle directory on build.
     """
     templates_dir: Path
     """Location of the Jinja2 template file.
     """
     manifest_name: str = "manifest.json"
     """Name of the manifest file."""
+    hot_file: str = "hot"
+    """Name of the hot file.
+
+    This file contains a single line containing the host, protocol, and port the Vite server is running.
+    """
     hot_reload: bool = False
     """Enable HMR for Vite development server."""
+    ssr_enabled: bool = False
+    """Enable SSR."""
+    ssr_output_dir: Path | None = None
+    """SSR Output path"""
+    root_dir: Path | None = None
+    """The is the base path to your application.
+
+   In a standalone Vue or React application, this would be equivalent to the ``./src`` directory.
+
+    """
     is_react: bool = False
     """Enable React components."""
-    static_url: str = "/static/"
+    asset_url: str = "/static/"
     """Base URL to generate for static asset references.
 
-    This should match what you have for the STATIC_URL
+    This URL will be prepended to anything generated from Vite.
     """
     host: str = "localhost"
     """Default host to use for Vite server."""
     protocol: str = "http"
     """Protocol to use for communication"""
-    port: int = 3000
+    port: int = 5173
     """Default port to use for Vite server."""
-    run_command: str = "npm run dev"
+    run_command: list[str] = field(default_factory=lambda: ["npm", "run", "dev"])
     """Default command to use for running Vite."""
-    build_command: str = "npm run build"
+    build_command: list[str] = field(default_factory=lambda: ["npm", "run", "build"])
+    """Default command to use for building with Vite."""
+    install_command: list[str] = field(default_factory=lambda: ["npm", "install"])
+    """Default command to use for installing Vite."""
+    use_server_lifespan: bool = False
+    """Utilize the server lifespan hook to run Vite."""
 
 
 @dataclass
@@ -89,7 +121,10 @@ class ViteTemplateConfig(Generic[T]):
 
     def to_engine(self) -> T:
         """Instantiate the template engine."""
-        template_engine = cast("T", self.engine(self.directory, self.config) if isclass(self.engine) else self.engine)
+        template_engine = cast(
+            "T",
+            self.engine(directory=self.directory, config=self.config) if isclass(self.engine) else self.engine,
+        )
         if callable(self.engine_callback):
             self.engine_callback(template_engine)
         return template_engine

litestar_vite/loader.py

@@ -24,6 +24,7 @@ class ViteAssetLoader:
     def __init__(self, config: ViteConfig) -> None:
         self._config = config
         self._manifest: dict[str, Any] = {}
+        self._vite_base_path: str | None = None
 
     @classmethod
     def initialize_loader(cls, config: ViteConfig) -> ViteAssetLoader:
@@ -62,9 +63,15 @@ class ViteAssetLoader:
         Raises:
             RuntimeError: if cannot load the file or JSON in file is malformed.
         """
-
-        if not self._config.hot_reload:
-            with Path(self._config.static_dir / self._config.manifest_name).open() as manifest_file:
+        if self._config.hot_reload:
+            if _hot_file_found := Path(
+                self._config.bundle_dir / self._config.hot_file,
+            ).exists():
+                with Path(self._config.bundle_dir / self._config.hot_file).open() as hot_file:
+                    self._vite_base_path = hot_file.read()
+
+        else:
+            with Path(self._config.bundle_dir / self._config.manifest_name).open() as manifest_file:
                 manifest_content = manifest_file.read()
             try:
                 self._manifest = json.loads(manifest_content)
@@ -72,7 +79,7 @@ class ViteAssetLoader:
                 msg = "Cannot read Vite manifest file at %s"
                 raise RuntimeError(
                     msg,
-                    Path(self._config.static_dir / self._config.manifest_name),
+                    Path(self._config.bundle_dir / self._config.manifest_name),
                 ) from exc
 
     def generate_ws_client_tags(self) -> str:
@@ -111,36 +118,43 @@ class ViteAssetLoader:
                 """
         return ""
 
-    def generate_asset_tags(self, path: str, scripts_attrs: dict[str, str] | None = None) -> str:
+    def generate_asset_tags(self, path: str | list[str], scripts_attrs: dict[str, str] | None = None) -> str:
         """Generate all assets include tags for the file in argument.
 
         Returns:
             str: All tags to import this asset in your HTML page.
         """
+        if isinstance(path, str):
+            path = [path]
         if self._config.hot_reload:
-            return self._script_tag(
-                self._vite_server_url(path),
-                {"type": "module", "async": "", "defer": ""},
+            return "".join(
+                [
+                    self._script_tag(
+                        self._vite_server_url(p),
+                        {"type": "module", "async": "", "defer": ""},
+                    )
+                    for p in path
+                ],
             )
 
-        if path not in self._manifest:
+        if any(p for p in path if p not in self._manifest):
             msg = "Cannot find %s in Vite manifest at %s"
             raise RuntimeError(
                 msg,
                 path,
-                Path(self._config.static_dir / self._config.manifest_name),
+                Path(self._config.bundle_dir / self._config.manifest_name),
             )
 
         tags: list[str] = []
-        manifest_entry: dict = self._manifest[path]
+        for p in path:
+            manifest_entry: dict = self._manifest[p]
         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.static_url, css_path))
-                for css_path in manifest_entry.get("css", {})
+                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:
@@ -151,7 +165,7 @@ class ViteAssetLoader:
         # Add the script by itself
         tags.append(
             self._script_tag(
-                urljoin(self._config.static_url, manifest_entry["file"]),
+                urljoin(self._config.asset_url, manifest_entry["file"]),
                 attrs=scripts_attrs,
             ),
         )
@@ -167,18 +181,15 @@ class ViteAssetLoader:
         Returns:
             str: Full URL to the asset.
         """
-        base_path = f"{self._config.protocol}://{self._config.host}:{self._config.port}"
+        base_path = self._vite_base_path or f"{self._config.protocol}://{self._config.host}:{self._config.port}"
         return urljoin(
             base_path,
-            urljoin(self._config.static_url, path if path is not None else ""),
+            urljoin(self._config.asset_url, path if path is not None else ""),
         )
 
     def _script_tag(self, src: str, attrs: dict[str, str] | None = None) -> str:
         """Generate an HTML script tag."""
-        attrs_str = ""
-        if attrs is not None:
-            attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
-
+        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()]) if attrs is not None else ""
         return f'<script {attrs_str} src="{src}"></script>'
 
     def _style_tag(self, href: str) -> str:

litestar_vite/plugin.py

@@ -1,20 +1,25 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import multiprocessing
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Iterator
 
-from litestar.plugins import CLIPluginProtocol, InitPluginProtocol
+from litestar.plugins import CLIPlugin, InitPluginProtocol
 
+from litestar_vite.cli import vite_group
+from litestar_vite.commands import run_vite
 from litestar_vite.config import ViteTemplateConfig
 from litestar_vite.template_engine import ViteTemplateEngine
 
 if TYPE_CHECKING:
     from click import Group
+    from litestar import Litestar
     from litestar.config.app import AppConfig
 
     from litestar_vite.config import ViteConfig
 
 
-class VitePlugin(InitPluginProtocol, CLIPluginProtocol):
+class VitePlugin(InitPluginProtocol, CLIPlugin):
     """Vite plugin."""
 
     __slots__ = ("_config",)
@@ -28,8 +33,6 @@ class VitePlugin(InitPluginProtocol, CLIPluginProtocol):
         self._config = config
 
     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)
 
@@ -40,8 +43,25 @@ class VitePlugin(InitPluginProtocol, CLIPluginProtocol):
             app_config: The :class:`AppConfig <.config.app.AppConfig>` instance.
         """
         app_config.template_config = ViteTemplateConfig(  # type: ignore[assignment]
-            directory=self._config.templates_dir,
             engine=ViteTemplateEngine,
             config=self._config,
+            directory=self._config.templates_dir,
         )
         return app_config
+
+    @contextmanager
+    def server_lifespan(self, app: Litestar) -> Iterator[None]:
+        if self._config.use_server_lifespan:
+            command_to_run = self._config.run_command
+
+            vite_process = multiprocessing.Process(
+                target=run_vite,
+                args=[command_to_run],
+            )
+            try:
+                vite_process.start()
+                yield
+            finally:
+                if vite_process.is_alive():
+                    vite_process.terminate()
+                    vite_process.join()

litestar_vite/template_engine.py

@@ -1,23 +1,17 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 import markupsafe
-from jinja2 import TemplateNotFound as JinjaTemplateNotFound
-from jinja2 import pass_context
 from litestar.contrib.jinja import JinjaTemplateEngine
-from litestar.exceptions import TemplateNotFoundException
-from litestar.template.base import (
-    TemplateEngineProtocol,
-)
+from litestar.template.base import TemplateEngineProtocol
 
-from .loader import ViteAssetLoader
+from litestar_vite.loader import ViteAssetLoader
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
     from pathlib import Path
 
-    from jinja2 import Template as JinjaTemplate
+    from jinja2 import Environment
 
     from litestar_vite.config import ViteConfig
 
@@ -27,62 +21,48 @@ T = TypeVar("T", bound=TemplateEngineProtocol)
 class ViteTemplateEngine(JinjaTemplateEngine):
     """Jinja Template Engine with Vite Integration."""
 
-    def __init__(self, directory: Path | list[Path], config: ViteConfig) -> None:
+    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)
+        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["vite_hmr_client"] = self.hmr_client
-        self.engine.globals["vite_asset"] = self.resource
-
-    def get_template(self, template_name: str) -> JinjaTemplate:
-        """Retrieve a template by matching its name (dotted path) with files in the directory or directories provided.
-
-        Args:
-            template_name: A dotted path
-
-        Returns:
-            JinjaTemplate instance
-
-        Raises:
-            TemplateNotFoundException: if no template is found.
-        """
-        try:
-            return self.engine.get_template(name=template_name)
-        except JinjaTemplateNotFound as exc:
-            raise TemplateNotFoundException(template_name=template_name) from exc
 
-    def register_template_callable(self, key: str, template_callable: Callable[[dict[str, Any]], Any]) -> None:
-        """Register a callable on the template engine.
-
-        Args:
-            key: The callable key, i.e. the value to use inside the template to call the callable.
-            template_callable: A callable to register.
-
-        Returns:
-            None
-        """
-        self.engine.globals[key] = pass_context(template_callable)
+        self.asset_loader = ViteAssetLoader.initialize_loader(config=self.config)
+        self.engine.globals.update({"vite_hmr": self.get_hmr_client, "vite": self.get_asset_tag})
 
-    def hmr_client(self) -> markupsafe.Markup:
+    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.
 
+        Arguments:
+            context: The template context.
 
         Returns:
             str: The script tag or an empty string.
         """
-        tags = [self.asset_loader.generate_react_hmr_tags()]
-        tags.append(self.asset_loader.generate_ws_client_tags())
-        return markupsafe.Markup("".join(tags))
-
-    def resource(self, path: str, scripts_attrs: dict[str, str] | None = None) -> markupsafe.Markup:
+        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,
+    ) -> markupsafe.Markup:
         """Generate all assets include tags for the file in argument.
 
         Generates all scripts tags for this file and all its dependencies
@@ -92,6 +72,7 @@ class ViteTemplateEngine(JinjaTemplateEngine):
         (this function marks automatically <script> as "async" and "defer").
 
         Arguments:
+            context: The template context.
             path: Path to a Vite asset to include.
             scripts_attrs: script attributes
 

litestar_vite/templates/init/htmx/main.js.j2

@@ -0,0 +1 @@
+window.htmx = require("htmx.org");

litestar_vite/templates/init/index.html.j2

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html class="h-full">
+  <head>
+    <meta charset="utf-8" />
+    <!--IE compatibility-->
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1.0, maximum-scale=1.0"
+    />
+  </head>
+
+  <body class="font-sans leading-none text-gray-700 antialiased">
+    <div id="app"></div>
+    {{ vite_hmr() }}
+    {{ vite('main.ts') }}
+  </body>
+</html>

litestar_vite/templates/init/package.json.j2

@@ -0,0 +1,10 @@
+{
+    "private": true,
+    "type": "module",
+    "scripts": {
+        "dev": "vite",
+        "build": "vite build{% if enable_ssr %} && vite build --ssr{% endif %}"
+    },
+    "dependencies": {{ dependencies }},
+    "devDependencies": {{ dev_dependencies }}
+}

litestar_vite/templates/init/react/App.tsx.j2

@@ -0,0 +1,9 @@
+const App = () => {
+  return (
+    <div>
+      <h1>Litestar + Vite + React</h1>
+    </div>
+  );
+};
+
+export default App;

litestar_vite/templates/init/react/main.tsx.j2

@@ -0,0 +1,9 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+    <React.StrictMode>
+        <App />
+    </React.StrictMode>
+);

litestar_vite/templates/init/tailwindcss/main.css.j2

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

litestar_vite/templates/init/tailwindcss/postcss.config.ts.j2

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

litestar_vite/templates/init/tailwindcss/tailwind.config.js.j2

@@ -0,0 +1,9 @@
+module.exports = {
+    content: [ "{{ resource_path }}/**/*.{js,jsx,ts,tsx,vue,j2,html}"],
+    theme: {
+        extend: {},
+    },
+    plugins: [
+        require("@tailwindcss/forms"),
+    ],
+};

litestar_vite/templates/init/tsconfig.json.j2

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "jsx": "preserve",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "lib": ["ESNext", "DOM"],
+    "skipLibCheck": true,
+    "noEmit": true,
+    "composite": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "{{ resource_path }}",
+    "paths": {
+      "@/*": ["./*"]
+    },
+    "types": ["vite/client", "node"]
+  },
+  "include": [
+    {% if include_react %}"{{ resource_path }}/**/*.tsx","{{ resource_path }}/**/*.jsx",{% endif %}{% if include_vue %} "{{ resource_path }}/**/*.vue",{% endif %}
+    "**/*.d.ts",
+    "{{ resource_path }}/**/*.js" ,
+    "{{ resource_path }}/**/*.ts" ,
+    "vite.config.ts"
+  ]
+}

litestar_vite/templates/init/vite.config.ts.j2

@@ -0,0 +1,27 @@
+import { defineConfig } from "vite";
+{% if include_vue %}import vue from "@vitejs/plugin-vue";{% endif %}
+{% if include_react %}import vue from "@vitejs/plugin-react";{% endif %}
+import litestar from "litestar-vite-plugin";
+
+export default defineConfig({
+  root: "{{ root_path }}",
+  plugins: [
+    {% if include_vue %}vue(),{% endif %}
+    {% if include_react %}react(),{% endif %}
+    litestar({
+      input: [
+        {% if entry_point %}"{{ entry_point | join(', \"') }}"{% endif %}
+      ],
+      assetUrl: "{{ asset_url }}",
+      assetDirectory: "{{ asset_path }}",
+      bundleDirectory: "{{ bundle_path }}",
+      resourceDirectory: "{{ resource_path }}",
+      hotFile: "{{ hot_file }}"
+    }),
+  ],
+  resolve: {
+    alias: {
+      "@": "{{ resource_path }}"
+    },
+  },
+});

litestar_vite/templates/init/vue/App.vue.j2

@@ -0,0 +1,5 @@
+<template>
+    <div>
+       Hello World
+    </div>
+</template>

{litestar_vite-0.1.3.dist-info → litestar_vite-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: litestar-vite
-Version: 0.1.3
+Version: 0.1.4
 Summary: Vite plugin for Litestar
 Project-URL: Changelog, https://cofin.github.io/litestar-vite/latest/changelog
 Project-URL: Discord, https://discord.gg/X3FJqy8d2j
@@ -30,7 +30,9 @@ Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: litestar[cli,jinja]>=2.0.1
+Requires-Dist: litestar[cli,jinja]>=2.4.0
+Provides-Extra: nodeenv
+Requires-Dist: nodeenv; extra == 'nodeenv'
 Description-Content-Type: text/markdown
 
 # Litestar Vite

litestar_vite-0.1.4.dist-info/RECORD

@@ -0,0 +1,28 @@
+litestar_vite/__init__.py,sha256=9X3i67Q8DJN2lQYAMa9NSPTZGzHASGn8X8yeWJqBvWg,357
+litestar_vite/__metadata__.py,sha256=Eml1c9xezV-GSodmysksrT8jPWqE__x0ENO1wM5g6q0,319
+litestar_vite/cli.py,sha256=1gfzACx48SEKCxMA4Jj-D_r9LExso3oP9HS356sK5nY,6179
+litestar_vite/commands.py,sha256=wkvp5BgE3zPVPO8PedumC9awPk7Vu9Qaz3ExOW4eIPo,3723
+litestar_vite/config.py,sha256=b9J0jakMHiCxNRczp0bfL9Rt7WGx_ngGZa3s7thrF48,4656
+litestar_vite/loader.py,sha256=oft1CTyZWbzSNfFv07Ihvyio42Q-QA-JH3NBie4SckM,7149
+litestar_vite/plugin.py,sha256=yyFZKJzb5BvVV16cK-btG6g_pGEYF_3is4AGEqoArQA,2007
+litestar_vite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+litestar_vite/template_engine.py,sha256=s7fV4Hhi8Sd95ywylims24UpyTBFXmthEcMp4TLaRYg,2962
+litestar_vite/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+litestar_vite/templates/init/index.html.j2,sha256=aW_u8HyZ1t3bAmqWmRDIuymanZ0Ccq5yT9kT5vkY9DY,443
+litestar_vite/templates/init/package.json.j2,sha256=zGs_Dow9SxvggnitJfC1ujYNBBvDBK3sgk_nXphujyU,260
+litestar_vite/templates/init/tsconfig.json.j2,sha256=323T2tsrc5_J5ClfA2ClPzPR02vpj3Jt2LQTCupFHww,832
+litestar_vite/templates/init/vite.config.ts.j2,sha256=BOje1C-G2dRWiw16iLrUyrqW72Koh9hWUEiLE_WQxrs,785
+litestar_vite/templates/init/htmx/main.css.j2,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+litestar_vite/templates/init/htmx/main.js.j2,sha256=Fzic2sDw7QKnEcYtKuXB91rgounuP2FJmtidI0czc1E,35
+litestar_vite/templates/init/react/App.tsx.j2,sha256=mXns5PRkbxOVFevO5CIb6ZTC_MoWSvW3TEk4rAzNB6w,120
+litestar_vite/templates/init/react/main.tsx.j2,sha256=zpzzfSuAVfTQ01HiBjBG1ywO4605FL9kIuMfUyzxfjI,222
+litestar_vite/templates/init/tailwindcss/main.css.j2,sha256=zBp60NAZ3bHTLQ7LWIugrCbOQdhiXdbDZjSLJfg6KOw,59
+litestar_vite/templates/init/tailwindcss/postcss.config.ts.j2,sha256=JR7N3UZyyc9GdUfj3FNd4ArSEp3ybn565yj6TlrEX8U,82
+litestar_vite/templates/init/tailwindcss/tailwind.config.js.j2,sha256=DyP-ShjY06M_i6QenX96jT7yOaUKAhywdx0oU1uMZWY,195
+litestar_vite/templates/init/vanilla/main.css.j2,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+litestar_vite/templates/init/vue/App.vue.j2,sha256=r73CGdnzcg8KTNw1XEgg78nrw7IFyBAADJcAGkMfTT4,63
+litestar_vite/templates/init/vue/main.ts.j2,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+litestar_vite-0.1.4.dist-info/METADATA,sha256=Zm0VuTh4V1J1dz5nakqe97A5_0heGejKL5CyaJhgrtk,2248
+litestar_vite-0.1.4.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+litestar_vite-0.1.4.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
+litestar_vite-0.1.4.dist-info/RECORD,,

litestar_vite-0.1.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-litestar_vite/__init__.py,sha256=9X3i67Q8DJN2lQYAMa9NSPTZGzHASGn8X8yeWJqBvWg,357
-litestar_vite/__metadata__.py,sha256=Eml1c9xezV-GSodmysksrT8jPWqE__x0ENO1wM5g6q0,319
-litestar_vite/cli.py,sha256=8MDS91THfyyWnI_zxANI3rdnGooDsHfVW1cKxpX5eNo,691
-litestar_vite/config.py,sha256=yWGY-Fdbe2OLjfGR65bPL2YJ_BxUJ_dmj_2KVz7GU_c,3303
-litestar_vite/loader.py,sha256=mHvvDD_1ES7E6Ig8AntWrMZTxCPDKp9zmkEUoarzb7Q,6580
-litestar_vite/plugin.py,sha256=h3EiCOXmZpJLMth3Asq8_mZsiYCtMGW1JQFrldHM9dU,1334
-litestar_vite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-litestar_vite/template_engine.py,sha256=2ttxaBvEpXljTxBH1vInVUSdCie4ZPqM063TLiXxADk,3806
-litestar_vite-0.1.3.dist-info/METADATA,sha256=D5tZDFTdU1PLhZJrBY-xcRhSGVdM3A2m9NoAjlhA_0M,2181
-litestar_vite-0.1.3.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
-litestar_vite-0.1.3.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
-litestar_vite-0.1.3.dist-info/RECORD,,