litestar-vite 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

litestar_vite/inertia/response.py

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

litestar_vite/inertia/routes.py

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

litestar_vite/inertia/types.py

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

litestar_vite/loader.py

@@ -0,0 +1,221 @@
+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
+from urllib.parse import urljoin
+
+if TYPE_CHECKING:
+    from litestar_vite.config import ViteConfig
+
+
+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 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 RuntimeError(
+                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 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}" />'