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

litestar_vite/loader.py

@@ -1,284 +0,0 @@
-from __future__ import annotations
-
-import json
-from functools import cached_property
-from pathlib import Path
-from textwrap import dedent
-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:
-    """Vite  manifest loader.
-
-    Please see: https://vitejs.dev/guide/backend-integration.html
-    """
-
-    _instance: ClassVar[ViteAssetLoader | None] = None
-
-    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
-    def initialize_loader(cls, config: ViteConfig) -> ViteAssetLoader:
-        """Singleton manifest loader."""
-        if cls._instance is None:
-            cls._instance = cls(config=config)
-            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 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.
-
-        The manifest file is a JSON file that maps source files to their corresponding output files.
-        Example manifest file structure:
-
-        .. code-block:: json
-
-            {
-                "main.js": {
-                    "file": "assets/main.4889e940.js",
-                    "src": "main.js",
-                    "isEntry": true,
-                    "dynamicImports": ["views/foo.js"],
-                    "css": ["assets/main.b82dbe22.css"],
-                    "assets": ["assets/asset.0ab0f9cd.png"]
-                },
-                "views/foo.js": {
-                    "file": "assets/foo.869aea0d.js",
-                    "src": "views/foo.js",
-                    "isDynamicEntry": true,
-                    "imports": ["_shared.83069a53.js"]
-                },
-                "_shared.83069a53.js": {
-                    "file": "assets/shared.83069a53.js"
-                }
-            }
-
-        The manifest is parsed and stored in memory for asset resolution during template rendering.
-        """
-        if self._config.hot_reload and self._config.dev_mode:
-            hot_file_path = Path(
-                f"{self._config.bundle_dir}/{self._config.hot_file}",
-            )
-            if hot_file_path.exists():
-                with hot_file_path.open() as hot_file:
-                    self._vite_base_path = hot_file.read()
-
-        else:
-            manifest_path = Path(f"{self._config.bundle_dir}/{self._config.manifest_name}")
-            try:
-                if manifest_path.exists():
-                    with manifest_path.open() as manifest_file:
-                        self.manifest_content = manifest_file.read()
-                        self._manifest = json.loads(self.manifest_content)
-                else:
-                    self._manifest = {}
-            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,
-                    manifest_path,
-                ) from exc
-
-    def generate_ws_client_tags(self) -> str:
-        """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:
-            str: The script tag or an empty string.
-        """
-        if self._config.hot_reload and self._config.dev_mode:
-            return self._script_tag(
-                self._vite_server_url("@vite/client"),
-                {"type": "module"},
-            )
-        return ""
-
-    def generate_react_hmr_tags(self) -> str:
-        """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:
-            str: The script tag or an empty string.
-        """
-        if self._config.is_react and self._config.hot_reload and self._config.dev_mode:
-            return dedent(f"""
-                <script type="module">
-                import RefreshRuntime from '{self._vite_server_url()}@react-refresh'
-                RefreshRuntime.injectIntoGlobalHook(window)
-                window.$RefreshReg$ = () => {{}}
-                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:
-        """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 and self._config.dev_mode:
-            return "".join(
-                [
-                    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": ""},
-                    )
-                    for p in path
-                ],
-            )
-
-        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 ImproperlyConfiguredException(
-                msg,
-                path,
-                Path(f"{self._config.bundle_dir}/{self._config.manifest_name}"),
-            )
-
-        tags: list[str] = []
-        manifest_entry: dict[str, Any] = {}
-        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():
-            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:
-        """Generate an URL to and asset served by the Vite development server.
-
-        Keyword Arguments:
-            path: Path to the asset. (default: {None})
-
-        Returns:
-            str: Full URL to the asset.
-        """
-        base_path = self._vite_base_path or f"{self._config.protocol}://{self._config.host}:{self._config.port}"
-        return urljoin(
-            base_path,
-            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."""
-        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:
-        """Generate and HTML <link> stylesheet tag for CSS.
-
-        Args:
-            href: CSS file URL.
-
-        Returns:
-            str: CSS link tag.
-        """
-        return f'<link rel="stylesheet" href="{href}" />'

litestar_vite/plugin.py

@@ -1,191 +0,0 @@
-from __future__ import annotations
-
-import os
-import platform
-import signal
-import subprocess
-import threading
-from contextlib import contextmanager
-from pathlib import Path
-from typing import TYPE_CHECKING, Iterator, cast
-
-from litestar.cli._utils import console
-from litestar.contrib.jinja import JinjaTemplateEngine
-from litestar.exceptions import ImproperlyConfiguredException
-from litestar.plugins import CLIPlugin, InitPluginProtocol
-from litestar.static_files import create_static_files_router  # pyright: ignore[reportUnknownVariableType]
-
-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: subprocess.Popen | None = None  # pyright: ignore[reportUnknownMemberType,reportMissingTypeArgument]
-        self._lock = threading.Lock()
-
-    def start(self, command: list[str], cwd: Path | str | None) -> None:
-        """Start the Vite process."""
-
-        try:
-            with self._lock:
-                if self.process and self.process.poll() is None:  # pyright: ignore[reportUnknownMemberType]
-                    return
-
-                console.print(f"Starting Vite process with command: {command}")
-                self.process = subprocess.Popen(
-                    command,
-                    cwd=cwd,
-                    shell=platform.system() == "Windows",
-                )
-        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."""
-
-        try:
-            with self._lock:
-                if self.process and self.process.poll() is None:  # pyright: ignore[reportUnknownMemberType]
-                    # Send SIGTERM to child process
-                    if hasattr(signal, "SIGTERM"):
-                        self.process.terminate()  # pyright: ignore[reportUnknownMemberType]
-                    try:
-                        self.process.wait(timeout=timeout)  # pyright: ignore[reportUnknownMemberType]
-                    except subprocess.TimeoutExpired:
-                        # Force kill if still alive
-                        if hasattr(signal, "SIGKILL"):
-                            self.process.kill()  # pyright: ignore[reportUnknownMemberType]
-                        self.process.wait(timeout=1.0)  # pyright: ignore[reportUnknownMemberType]
-                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."""
-
-        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/templates/index.html.j2

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<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>
-  {{ vite_hmr() }}
-  {{ vite('resources/main.ts') }}
-</body>
-
-</html>

litestar_vite/templates/main.ts.j2

@@ -1 +0,0 @@
-import "./styles.css"

litestar_vite/templates/package.json.j2

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

litestar_vite/templates/tsconfig.json.j2

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "module": "ES2020",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "jsx": "preserve",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true,
-    "noEmit": true,
-    "composite": true,
-    "allowSyntheticDefaultImports": true,
-    "baseUrl": "{{ resource_path }}",
-    "paths": {
-      "@/*": ["./*"]
-    },
-    "types": ["vite/client"]
-  },
-  "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/vite.config.ts.j2

@@ -1,37 +0,0 @@
-import { defineConfig } from "vite";
-{% if include_vue %}import vue from "@vitejs/plugin-vue";{% endif %}
-{% if include_react %}import react from "@vitejs/plugin-react";{% endif %}
-import litestar from "litestar-vite-plugin";
-
-const ASSET_URL = process.env.ASSET_URL || "{{ asset_url }}";
-const VITE_PORT = process.env.VITE_PORT || "5173";
-const VITE_HOST = process.env.VITE_HOST || "localhost";
-export default defineConfig({
-  base: `${ASSET_URL}`,
-  server: {
-    host: "0.0.0.0",
-    port: +`${VITE_PORT}`,
-    cors: true,
-    hmr: {
-      host: `${VITE_HOST}`,
-    },
-  },
-  plugins: [
-    {% if include_vue %}vue(),{% endif %}
-    {% if include_react %}react(),{% endif %}
-    litestar({
-      input: [
-        {% if entry_point %}"{{ entry_point | join('\", \"') }}"{% endif %}
-      ],
-      assetUrl: `${ASSET_URL}`,
-      bundleDirectory: "{{ bundle_path }}",
-      resourceDirectory: "{{ resource_path }}",
-      hotFile: "{{ hot_file }}"
-    }),
-  ],
-  resolve: {
-    alias: {
-      "@": "{{ resource_path }}"
-    },
-  },
-});

litestar_vite-0.12.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-litestar_vite/__init__.py,sha256=OioNGhH88mdivQlFz9JlbJV8R6wyjSYE3c8C-RIM4Ls,277
-litestar_vite/__metadata__.py,sha256=_Wo-vNQuj5co9J4FwJAB2rRafbFo8ztTHrXmEPrYrV8,514
-litestar_vite/cli.py,sha256=CBSRohDLU9cDeKMAfSbFiw1x8OE_b15ZlUaxji9Rdw8,10749
-litestar_vite/commands.py,sha256=JTRBvpR_3ddFb2o4-AJSELegw-ZGDsJ_yMaT5FVdp4w,5228
-litestar_vite/config.py,sha256=cZWIwTwNnBYScCty8OxxPaOL8cELx57dm7JQeV8og3Y,4565
-litestar_vite/loader.py,sha256=nrXL2txXoBZEsdLZnysgBYZSreMXQ7ckLuNcu7MqnSM,10277
-litestar_vite/plugin.py,sha256=2ypzvlW5TaOeXTWPa2yHXzkPUf4okRBDl9YHo2qg-cM,8043
-litestar_vite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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=23HfQ8D2wNGXUXt_isuGfZ8AFKrr1d_498qGFLynocs,1650
-litestar_vite/inertia/plugin.py,sha256=f2oFwlEDt9WZ8zt-AqiCIRPlkHIyzLtPYYo8WJZX-tI,3186
-litestar_vite/inertia/request.py,sha256=Ogt_ikauWrsgKafaip7IL1YhbybwjdBAQ0PQS7cImoQ,3848
-litestar_vite/inertia/response.py,sha256=CY-qziEPc9FZ4oXxtgO0Iipg1Hz4x-fiUeLK04Br8kM,23425
-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
-litestar_vite/templates/index.html.j2,sha256=Xue1cTl6piEOZkW3UG68SnW80NeL9PxaOp-Xr23kpr4,322
-litestar_vite/templates/main.ts.j2,sha256=Nzr5m_hXMAjeDL_4yQNP3DMCf7Blh3dwg5m-67GJVbY,22
-litestar_vite/templates/package.json.j2,sha256=0JWgdTuaSZ25EmCltF_zbqDdpxfvCLeYuzBjXrziXNw,299
-litestar_vite/templates/styles.css.j2,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-litestar_vite/templates/tsconfig.json.j2,sha256=q1REIuVyXUHCy4Zi2kgTkmrhdT98vyY89k-WTrImOj8,843
-litestar_vite/templates/vite.config.ts.j2,sha256=bF5kOPFafYMkhhV0VkIwetN-_zoVMGVM1jEMX_wKoNc,1037
-litestar_vite-0.12.0.dist-info/METADATA,sha256=0Nv7ZBioTYS6JTE0KzPht82kwBhcBGH7W1cBRB8vgCM,6244
-litestar_vite-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-litestar_vite-0.12.0.dist-info/licenses/LICENSE,sha256=HeTiEfEgvroUXZe_xAmYHxtTBgw--mbXyZLsWDYabHc,1069
-litestar_vite-0.12.0.dist-info/RECORD,,