From 1ecbed86ace75c69c791d5371d0301c280384290 Mon Sep 17 00:00:00 2001
From: Niicck <niicck@users.noreply.github.com>
Date: Mon, 16 Oct 2023 15:15:46 -0700
Subject: [PATCH] enable multi-app configs with DjangoViteAppClient

---
 django_vite/__init__.py                 |    4 +
 django_vite/exceptions.py               |    6 +
 django_vite/loader.py                   | 1032 +++++++++--------------
 django_vite/tag_generator.py            |  915 +-------------------
 django_vite/templatetags/django_vite.py |  804 +-----------------
 pyproject.toml                          |    1 +
 tests/conftest.py                       |   16 +-
 tests/tests/test_asset_loader.py        |   15 +-
 8 files changed, 469 insertions(+), 2324 deletions(-)

diff --git a/django_vite/__init__.py b/django_vite/__init__.py
index e69de29..09f8c32 100644
--- a/django_vite/__init__.py
+++ b/django_vite/__init__.py
@@ -0,0 +1,4 @@
+from .loader import DjangoViteConfig
+
+
+__all__ = ["DjangoViteConfig"]
diff --git a/django_vite/exceptions.py b/django_vite/exceptions.py
index 1030ca8..ec13a28 100644
--- a/django_vite/exceptions.py
+++ b/django_vite/exceptions.py
@@ -8,3 +8,9 @@ class DjangoViteAssetNotFoundError(RuntimeError):
     """Vite Asset could not be found."""
 
     pass
+
+
+class DjangoViteConfigNotFoundError(RuntimeError):
+    """DjangoViteConfig not found in DJANGO_VITE settings."""
+
+    pass
diff --git a/django_vite/loader.py b/django_vite/loader.py
index c1e9956..75bfeb1 100644
--- a/django_vite/loader.py
+++ b/django_vite/loader.py
@@ -1,40 +1,27 @@
 import json
 from pathlib import Path
-from typing import Dict, List, Callable, NamedTuple, Optional, Type, Union
+from typing import Dict, List, Callable, NamedTuple, Optional, Union, Tuple
 from urllib.parse import urljoin
+import warnings
 
-from django import template
 from django.apps import apps
 from django.conf import settings
-from django.utils.safestring import mark_safe
 
-from django_vite.exceptions import DjangoViteAssetNotFoundError, DjangoViteManifestError
+from django_vite.exceptions import (
+    DjangoViteManifestError,
+    DjangoViteAssetNotFoundError,
+    DjangoViteConfigNotFoundError,
+)
+from django_vite.tag_generator import Tag, TagGenerator
 
-DEFAULT_CONFIG_KEY = "default"
-
-register = template.Library()
-
-
-class DjangoViteManifest(NamedTuple):
-    """
-    Represent an entry for a file inside the "manifest.json".
-    """
-
-    file: str
-    src: Optional[str] = None
-    isEntry: Optional[bool] = False
-    css: Optional[List[str]] = []
-    imports: Optional[List[str]] = []
+DEFAULT_APP_NAME = "default"
 
 
 class DjangoViteConfig(NamedTuple):
     """
-    Represent the Django Vite configuration structure.
+    The arguments for a DjangoViteAppClient.
     """
 
-    # Location of Vite compiled assets (only used in Vite production mode).
-    assets_path: Union[Path, str]
-
     # If using in development or production mode.
     dev_mode: bool = False
 
@@ -47,75 +34,201 @@ class DjangoViteConfig(NamedTuple):
     # Default Vite server port.
     dev_server_port: int = 3000
 
-    # Default Vite server path to HMR script.
-    ws_client_url: str = "@vite/client"
-
     # Prefix for STATIC_URL.
     static_url_prefix: str = ""
 
+    # Path to your manifest file generated by Vite.
+    manifest_path: Optional[Union[Path, str]] = None
+
     # Motif in the "manifest.json" to find the polyfills generated by Vite.
     legacy_polyfills_motif: str = "legacy-polyfills"
 
-    # Path to your manifest file generated by Vite.
-    manifest_path: Union[Path, str] = ""
+    # Default Vite server path to HMR script.
+    ws_client_url: str = "@vite/client"
 
     # Default Vite server path to React RefreshRuntime for @vitejs/plugin-react.
     react_refresh_url: str = "@react-refresh"
 
-    @property
-    def static_url(self) -> str:
-        url = urljoin(settings.STATIC_URL, self.static_url_prefix)
-        if not url.endswith("/"):
-            url += "/"
-        return url
 
-    @property
-    def static_root(self) -> Path:
+class ManifestEntry(NamedTuple):
+    """
+    Represent an entry for a file inside the "manifest.json".
+    """
+
+    file: str
+    src: Optional[str] = None
+    isEntry: Optional[bool] = False
+    css: Optional[List[str]] = []
+    imports: Optional[List[str]] = []
+
+
+class ManifestClient:
+    """
+    A client for accessing entries in the compiled vite config's "manifest.json".
+    Only parses manifest.json if dev_mode=False.
+
+    Public Methods:
+        get(path: str) -- return the ManifestEntry for the given path.
+    """
+
+    def __init__(self, config: DjangoViteConfig):
+        self._config = config
+
+        self.dev_mode = config.dev_mode
+        self.manifest_path = self._clean_manifest_path()
+        self.legacy_polyfills_motif = config.legacy_polyfills_motif
+
+        self._entries: Dict[str, ManifestEntry] = {}
+        self.legacy_polyfills_entry: Optional[ManifestEntry] = None
+
+        if not self.dev_mode:
+            self._entries, self.legacy_polyfills_entry = self._parse_manifest()
+
+    def _clean_manifest_path(self) -> Path:
         """
-        Compute the static root URL of assets.
+        Get the manifest_path from the config.
+        If it wasn't provided, set the default location to
+        STATIC_ROOT / static_url_prefix / "manifest.json".
 
         Returns:
-            Union[Path, str] -- Static root URL.
+            Path -- the path to the vite config's manifest.json
+        """
+        initial_manifest_path = self._config.manifest_path
+        if not initial_manifest_path:
+            return (
+                Path(settings.STATIC_ROOT)
+                / self._config.static_url_prefix
+                / "manifest.json"
+            )
+        elif not isinstance(initial_manifest_path, Path):
+            return Path(initial_manifest_path)
+        else:
+            return initial_manifest_path
+
+    def _parse_manifest(self) -> Tuple[Dict[str, ManifestEntry], ManifestEntry]:
         """
+        Read and parse the Vite manifest file.
 
-        return (
-            Path(self.assets_path)
-            if self.dev_mode
-            else Path(settings.STATIC_ROOT) / self.static_url_prefix
-        )
+        Returns:
+            entries {Dict[str, ManifestEntry]} -- All entries within the manifest
 
-    def get_computed_manifest_path(self) -> Union[Path, str]:
+            legacy_polyfills_entry {ManifestEntry} -- The manifest entry for legacy
+                polyfills, if it exists within the manifest.json
+
+        Raises:
+            DjangoViteManifestError: if cannot load the file or JSON in file is
+                malformed.
         """
-        Compute the path to the "manifest.json".
+        entries: Dict[str, ManifestEntry] = {}
+        legacy_polyfills_entry: Optional[ManifestEntry] = None
+
+        try:
+            with open(self.manifest_path, "r") as manifest_file:
+                manifest_content = manifest_file.read()
+                manifest_json = json.loads(manifest_content)
+
+                for path, manifest_entry_data in manifest_json.items():
+                    manifest_entry = ManifestEntry(**manifest_entry_data)
+                    entries[path] = manifest_entry
+                    if self.legacy_polyfills_motif in path:
+                        legacy_polyfills_entry = manifest_entry
+
+                return (entries, legacy_polyfills_entry)
+
+        except Exception as error:
+            raise DjangoViteManifestError(
+                f"Cannot read Vite manifest file at "
+                f"{self.manifest_path} : {str(error)}"
+            ) from error
+
+    def get(self, path: str) -> ManifestEntry:
+        """
+        Gets the manifest_entry for given path.
 
         Returns:
-            Union[Path, str] -- Path to the "manifest.json".
+            ManifestEntry -- the ManifestEntry for your path
+
+        Raises:
+            DjangoViteAssetNotFoundError: if cannot find the file path in the manifest
+                or if manifest was never parsed due to dev_mode=True.
         """
+        if path not in self._entries:
+            raise DjangoViteAssetNotFoundError(
+                f"Cannot find {path} in Vite manifest " f"at {self.manifest_path}"
+            )
 
-        return (
-            self.manifest_path
-            if self.manifest_path
-            else self.static_root / "manifest.json"
-        )
+        return self._entries[path]
 
 
-class DjangoViteAssetLoader:
+class DjangoViteAppClient:
     """
-    Class handling Vite asset loading.
+    An interface for generating assets and urls from one vite app.
+    DjangoViteConfig provides the arguments for the client.
     """
 
-    _instance = None
+    def __init__(self, config: DjangoViteConfig) -> None:
+        self._config = config
 
-    _configs = Dict[str, Type[DjangoViteConfig]]
-    _manifests: Dict[str, Type[DjangoViteManifest]]
+        self.dev_mode = config.dev_mode
+        self.dev_server_protocol = config.dev_server_protocol
+        self.dev_server_host = config.dev_server_host
+        self.dev_server_port = config.dev_server_port
+        self.static_url_prefix = config.static_url_prefix
+        self.ws_client_url = config.ws_client_url
+        self.react_refresh_url = config.react_refresh_url
 
-    def __init__(self) -> None:
-        raise RuntimeError("Use the instance() method instead.")
+        self.manifest = ManifestClient(config)
+
+    def _get_dev_server_url(
+        self,
+        path: str,
+    ) -> str:
+        """
+        Generates an URL to an asset served by the Vite development server.
+
+        Keyword Arguments:
+            path {str} -- Path to the asset.
+
+        Returns:
+            str -- Full URL to the asset.
+        """
+        static_url_base = urljoin(settings.STATIC_URL, self.static_url_prefix)
+        if not static_url_base.endswith("/"):
+            static_url_base += "/"
+
+        return urljoin(
+            f"{self.dev_server_protocol}://"
+            f"{self.dev_server_host}:{self.dev_server_port}",
+            urljoin(static_url_base, path),
+        )
+
+    def _get_production_server_url(self, path: str) -> str:
+        """
+        Generates an URL to an asset served during production.
+
+        Keyword Arguments:
+            path {str} -- Path to the asset.
+
+        Returns:
+            str -- Full URL to the asset.
+        """
+
+        production_server_url = path
+        if prefix := self.static_url_prefix:
+            if not prefix.endswith("/"):
+                prefix += "/"
+            production_server_url = urljoin(prefix, path)
+
+        if apps.is_installed("django.contrib.staticfiles"):
+            from django.contrib.staticfiles.storage import staticfiles_storage
+
+            return staticfiles_storage.url(production_server_url)
+
+        return production_server_url
 
     def generate_vite_asset(
         self,
         path: str,
-        config_key: str,
         **kwargs: Dict[str, str],
     ) -> str:
         """
@@ -127,7 +240,6 @@ def generate_vite_asset(
 
         Arguments:
             path {str} -- Path to a Vite JS/TS asset to include.
-            config_key {str} -- Key of the configuration to use.
 
         Returns:
             str -- All tags to import this file in your HTML page.
@@ -136,44 +248,30 @@ def generate_vite_asset(
             **kwargs {Dict[str, str]} -- Adds new attributes to generated
                 script tags.
 
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the file path in the
-                manifest (only in production).
-
         Returns:
             str -- The <script> tag and all <link> tags to import
                 this asset in your page.
         """
 
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return DjangoViteAssetLoader._generate_script_tag(
-                DjangoViteAssetLoader._generate_vite_server_url(path, config),
-                {"type": "module", **kwargs},
-            )
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
+        if self.dev_mode:
+            url = self._get_dev_server_url(path)
+            return TagGenerator.script(
+                url,
+                attrs={"type": "module", **kwargs},
             )
 
-        manifest_entry = manifest[path]
-        tags = []
+        tags: List[Tag] = []
+        manifest_entry = self.manifest.get(path)
         scripts_attrs = {"type": "module", "crossorigin": "", **kwargs}
 
         # Add dependent CSS
-        tags.extend(self._load_css_files_of_asset(path, config_key))
+        tags.extend(self._load_css_files_of_asset(path))
 
         # Add the script by itself
+        url = self._get_production_server_url(manifest_entry.file)
         tags.append(
-            DjangoViteAssetLoader._generate_script_tag(
-                DjangoViteAssetLoader._generate_production_server_url(
-                    manifest_entry.file, config.static_url_prefix
-                ),
+            TagGenerator.script(
+                url,
                 attrs=scripts_attrs,
             )
         )
@@ -187,13 +285,11 @@ def generate_vite_asset(
         }
 
         for dep in manifest_entry.imports:
-            dep_manifest_entry = manifest[dep]
+            dep_manifest_entry = self.manifest.get(dep)
             dep_file = dep_manifest_entry.file
-            url = DjangoViteAssetLoader._generate_production_server_url(
-                dep_file, config.static_url_prefix
-            )
+            url = self._get_production_server_url(dep_file)
             tags.append(
-                DjangoViteAssetLoader._generate_preload_tag(
+                TagGenerator.preload(
                     url,
                     attrs=preload_attrs,
                 )
@@ -204,45 +300,29 @@ def generate_vite_asset(
     def preload_vite_asset(
         self,
         path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
     ) -> str:
         """
         Generates a <link modulepreload> tag for this JS/TS asset, a
         <link preload> tag for all of its CSS dependencies,
         and a <link modulepreload> for the js dependencies.
         In development this template tag renders nothing,
-        since files aren't compiled yet"
+        since files aren't compiled yet.
 
         Arguments:
             path {str} -- Path to a Vite JS/TS asset to preload.
-            config_key {str} -- Key of the configuration to use.
 
         Returns:
             str -- All tags to preload this file in your HTML page.
 
-        Raises:
-            DjangoViteAssetNotFoundError: if cannot find the file path in the
-                manifest.
-
         Returns:
             str -- all <link> tags to preload
                 this asset.
         """
-        tags = []
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
+        if self.dev_mode:
             return ""
 
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
+        tags: List[Tag] = []
+        manifest_entry = self.manifest.get(path)
 
         # Add the script by itself
         script_attrs = {
@@ -253,28 +333,24 @@ def preload_vite_asset(
         }
 
         manifest_file = manifest_entry.file
-        url = DjangoViteAssetLoader._generate_production_server_url(
-            manifest_file, config.static_url_prefix
-        )
+        url = self._get_production_server_url(manifest_file)
         tags.append(
-            DjangoViteAssetLoader._generate_preload_tag(
+            TagGenerator.preload(
                 url,
                 attrs=script_attrs,
             )
         )
 
         # Add dependent CSS
-        tags.extend(self._preload_css_files_of_asset(path, config_key))
+        tags.extend(self._preload_css_files_of_asset(path))
 
         # Preload imports
         for dep in manifest_entry.imports:
-            dep_manifest_entry = manifest[dep]
+            dep_manifest_entry = self.manifest.get(dep)
             dep_file = dep_manifest_entry.file
-            url = DjangoViteAssetLoader._generate_production_server_url(
-                dep_file, config.static_url_prefix
-            )
+            url = self._get_production_server_url(dep_file)
             tags.append(
-                DjangoViteAssetLoader._generate_preload_tag(
+                TagGenerator.preload(
                     url,
                     attrs=script_attrs,
                 )
@@ -285,34 +361,27 @@ def preload_vite_asset(
     def _preload_css_files_of_asset(
         self,
         path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
+    ) -> List[Tag]:
         return self._generate_css_files_of_asset(
             path,
-            [],
-            DjangoViteAssetLoader._generate_stylesheet_preload_tag,
-            config_key,
-        )
+            tag_generator=TagGenerator.stylesheet_preload,
+        )[0]
 
     def _load_css_files_of_asset(
         self,
         path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
+    ) -> List[Tag]:
         return self._generate_css_files_of_asset(
             path,
-            [],
-            DjangoViteAssetLoader._generate_stylesheet_tag,
-            config_key,
-        )
+            tag_generator=TagGenerator.stylesheet,
+        )[0]
 
     def _generate_css_files_of_asset(
         self,
         path: str,
-        already_processed: List[str],
-        tag_generator: Callable,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
+        already_processed: Optional[List[str]] = None,
+        tag_generator: Callable[[str], Tag] = TagGenerator.stylesheet,
+    ) -> Tuple[List[Tag], List[str]]:
         """
         Generates all CSS tags for dependencies of an asset.
 
@@ -322,71 +391,50 @@ def _generate_css_files_of_asset(
             already_processed {list} -- List of already processed CSS file.
 
         Returns:
-            list -- List of CSS tags.
+            tags -- List of CSS tags.
+            already_processed -- List of already processed css paths
         """
-
-        tags = []
-        config = self._get_config(config_key)
-        manifest = self._get_manifest(config_key)
-        manifest_entry = manifest[path]
+        already_processed = already_processed or []
+        tags: List[Tag] = []
+        manifest_entry = self.manifest.get(path)
 
         for import_path in manifest_entry.imports:
-            tags.extend(
-                self._generate_css_files_of_asset(
-                    import_path, already_processed, tag_generator, config_key
-                )
+            new_tags, new_already_processed = self._generate_css_files_of_asset(
+                import_path, already_processed, tag_generator
             )
+            tags.extend(new_tags)
+            already_processed.extend(new_already_processed)
 
         for css_path in manifest_entry.css:
             if css_path not in already_processed:
-                url = DjangoViteAssetLoader._generate_production_server_url(
-                    css_path, config.static_url_prefix
-                )
+                url = self._get_production_server_url(css_path)
                 tags.append(tag_generator(url))
 
             already_processed.append(css_path)
 
-        return tags
+        return (tags, already_processed)
 
-    def generate_vite_asset_url(self, path: str, config_key: str) -> str:
+    def generate_vite_asset_url(self, path: str) -> str:
         """
         Generates only the URL of an asset managed by ViteJS.
         Warning, this function does not generate URLs for dependant assets.
 
         Arguments:
             path {str} -- Path to a Vite asset.
-            config_key {str} -- Key of the configuration to use.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the asset path in the
-                manifest (only in production).
 
         Returns:
             str -- The URL of this asset.
         """
 
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return DjangoViteAssetLoader._generate_vite_server_url(path, config)
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
+        if self.dev_mode:
+            return self._get_dev_server_url(path)
 
-        manifest_entry = manifest[path]
+        manifest_entry = self.manifest.get(path)
 
-        return DjangoViteAssetLoader._generate_production_server_url(
-            manifest_entry.file, config.static_url_prefix
-        )
+        return self._get_production_server_url(manifest_entry.file)
 
     def generate_vite_legacy_polyfills(
         self,
-        config_key: str,
         **kwargs: Dict[str, str],
     ) -> str:
         """
@@ -395,47 +443,40 @@ def generate_vite_legacy_polyfills(
         This tag must be included at end of the <body> before
         including other legacy scripts.
 
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
         Keyword Arguments:
             **kwargs {Dict[str, str]} -- Adds new attributes to generated
                 script tags.
 
         Raises:
             DjangoViteAssetNotFoundError: If polyfills path not found inside
-                the 'manifest.json' (only in production).
+                the 'manifest.json'.
 
         Returns:
             str -- The script tag to the polyfills.
         """
 
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
+        if self.dev_mode:
             return ""
 
-        manifest = self._get_manifest(config_key)
-        scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
+        polyfills_manifest_entry = self.manifest.legacy_polyfills_entry
 
-        for path, manifest_entry in manifest.items():
-            if config.legacy_polyfills_motif in path:
-                return DjangoViteAssetLoader._generate_script_tag(
-                    DjangoViteAssetLoader._generate_production_server_url(
-                        manifest_entry.file, config.static_url_prefix
-                    ),
-                    attrs=scripts_attrs,
-                )
+        if not polyfills_manifest_entry:
+            raise DjangoViteAssetNotFoundError(
+                f"Vite legacy polyfills not found in manifest "
+                f"at {self.manifest.manifest_path}"
+            )
+
+        scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
+        url = self._get_production_server_url(polyfills_manifest_entry.file)
 
-        raise DjangoViteAssetNotFoundError(
-            f"Vite legacy polyfills not found in manifest "
-            f"at {config.get_computed_manifest_path()}"
+        return TagGenerator.script(
+            url,
+            attrs=scripts_attrs,
         )
 
     def generate_vite_legacy_asset(
         self,
         path: str,
-        config_key: str,
         **kwargs: Dict[str, str],
     ) -> str:
         """
@@ -446,7 +487,6 @@ def generate_vite_legacy_asset(
         Arguments:
             path {str} -- Path to a Vite asset to include
                 (must contains '-legacy' in its name).
-            config_key {str} -- Key of the configuration to use.
 
         Keyword Arguments:
             **kwargs {Dict[str, str]} -- Adds new attributes to generated
@@ -460,166 +500,24 @@ def generate_vite_legacy_asset(
             str -- The script tag of this legacy asset .
         """
 
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
+        if self.dev_mode:
             return ""
 
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
+        manifest_entry = self.manifest.get(path)
         scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
+        url = self._get_production_server_url(manifest_entry.file)
 
-        url = DjangoViteAssetLoader._generate_production_server_url(
-            manifest[path].file, config.static_url_prefix
-        )
-        return DjangoViteAssetLoader._generate_script_tag(
+        return TagGenerator.script(
             url,
             attrs=scripts_attrs,
         )
 
-    def _get_config(self, config_key: str) -> Type[DjangoViteConfig]:
-        """
-        Get configuration object registered with the key passed in
-        parameter.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to retrieve.
-
-        Raises:
-            RuntimeError: If no configuration exists for this key.
-
-        Returns:
-            Type[DjangoViteConfig] -- The configuration.
-        """
-
-        if config_key not in self._configs:
-            raise RuntimeError(f'Cannot find "{config_key}" configuration')
-
-        return self._configs[config_key]
-
-    def _parse_manifest(self, config_key: str) -> Dict[str, Type[DjangoViteManifest]]:
-        """
-        Read and parse the Vite manifest file.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Raises:
-            DjangoViteManifestError: if cannot load the file or JSON in file is
-            malformed.
-        """
-
-        config = self._get_config(config_key)
-
-        try:
-            with open(config.get_computed_manifest_path(), "r") as manifest_file:
-                manifest_content = manifest_file.read()
-                manifest_json = json.loads(manifest_content)
-
-                return {k: DjangoViteManifest(**v) for k, v in manifest_json.items()}
-
-        except Exception as error:
-            raise DjangoViteManifestError(
-                f"Cannot read Vite manifest file at "
-                f"{config.get_computed_manifest_path()} : {str(error)}"
-            ) from error
-
-    def _get_manifest(self, config_key: str) -> Dict[str, Type[DjangoViteManifest]]:
-        """
-        Load if needed and parse the "manifest.json" of the specified
-        configuration.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            Dict[str, Type[DjangoViteManifest]] -- Parsed content of
-                the "manifest.json"
-        """
-
-        if config_key not in self._manifests:
-            self._manifests[config_key] = self._parse_manifest(config_key)
-
-        return self._manifests[config_key]
-
-    @classmethod
-    def instance(cls):
-        """
-        Singleton.
-        Uses singleton to keep parsed manifests in memory after
-        the first time they are loaded.
-
-        Returns:
-            DjangoViteAssetLoader -- only instance of the class.
-        """
-
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-            cls._instance._configs = {}
-            cls._instance._manifests = {}
-
-            if hasattr(settings, "DJANGO_VITE"):
-                config = getattr(settings, "DJANGO_VITE")
-
-                for config_key, config_values in config.items():
-                    if isinstance(config_values, DjangoViteConfig):
-                        cls._instance._configs[config_key] = config_values
-                    elif isinstance(config_values, dict):
-                        cls._instance._configs[config_key] = DjangoViteConfig(
-                            **config_values
-                        )
-                    else:
-                        raise RuntimeError(
-                            f"Cannot read configuration for key '{config_key}'"
-                        )
-            else:
-                # Warning : This branch will be remove in further
-                # releases. Please use new way of handling configuration.
-
-                _config_keys = {
-                    "DJANGO_VITE_DEV_MODE": "dev_mode",
-                    "DJANGO_VITE_DEV_SERVER_PROTOCOL": "dev_server_protocol",
-                    "DJANGO_VITE_DEV_SERVER_HOST": "dev_server_host",
-                    "DJANGO_VITE_DEV_SERVER_PORT": "dev_server_port",
-                    "DJANGO_VITE_WS_CLIENT_URL": "ws_client_url",
-                    "DJANGO_VITE_ASSETS_PATH": "assets_path",
-                    "DJANGO_VITE_STATIC_URL_PREFIX": "static_url_prefix",
-                    "DJANGO_VITE_MANIFEST_PATH": "manifest_path",
-                    "DJANGO_VITE_LEGACY_POLYFILLS_MOTIF": "legacy_polyfills_motif",
-                    "DJANGO_VITE_REACT_REFRESH_URL": "react_refresh_url",
-                }
-
-                config = {
-                    _config_keys[setting_key]: getattr(settings, setting_key)
-                    for setting_key in dir(settings)
-                    if setting_key in _config_keys.keys()
-                }
-
-                cls._instance._configs[DEFAULT_CONFIG_KEY] = DjangoViteConfig(**config)
-
-                # Manifest is only used in production.
-                if not cls._instance._configs[DEFAULT_CONFIG_KEY].dev_mode:
-                    cls._instance._parse_manifest(DEFAULT_CONFIG_KEY)
-
-        return cls._instance
-
-    def generate_vite_ws_client(
-        self, config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-    ) -> str:
+    def generate_vite_ws_client(self, **kwargs: Dict[str, str]) -> str:
         """
         Generates the script tag for the Vite WS client for HMR.
         Only used in development, in production this method returns
         an empty string.
 
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
         Returns:
             str -- The script tag or an empty string.
 
@@ -628,94 +526,17 @@ def generate_vite_ws_client(
                 script tags.
         """
 
-        config = self._get_config(config_key)
-
-        if not config.dev_mode:
+        if not self.dev_mode:
             return ""
 
-        return self._generate_script_tag(
-            self._generate_vite_server_url(config.ws_client_url, config),
-            {"type": "module", **kwargs},
-        )
-
-    @staticmethod
-    def _generate_script_tag(src: str, attrs: Dict[str, str]) -> str:
-        """
-        Generates an HTML script tag.
-
-        Arguments:
-            src {str} -- Source of the script.
-
-        Keyword Arguments:
-            attrs {Dict[str, str]} -- List of custom attributes
-                for the tag.
-
-        Returns:
-            str -- The script tag.
-        """
-
-        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
-
-        return f'<script {attrs_str} src="{src}"></script>'
-
-    @staticmethod
-    def _generate_stylesheet_tag(href: str) -> str:
-        """
-        Generates an HTML <link> stylesheet tag for CSS.
-
-        Arguments:
-            href {str} -- CSS file URL.
-
-        Returns:
-            str -- CSS link tag.
-        """
-
-        return f'<link rel="stylesheet" href="{href}" />'
+        url = self._get_dev_server_url(self.ws_client_url)
 
-    def _generate_stylesheet_preload_tag(href: str) -> str:
-        """
-        Generates an HTML <link> preload tag for CSS.
-
-        Arguments:
-            href {str} -- CSS file URL.
-
-        Returns:
-            str -- CSS link tag.
-        """
-
-        return f'<link rel="preload" href="{href}" as="style" />'
-
-    @staticmethod
-    def _generate_preload_tag(href: str, attrs: Dict[str, str]) -> str:
-        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
-
-        return f'<link href="{href}" {attrs_str} />'
-
-    @staticmethod
-    def _generate_vite_server_url(
-        path: str,
-        config: Type[DjangoViteConfig],
-    ) -> str:
-        """
-        Generates an URL to and asset served by the Vite development server.
-
-        Keyword Arguments:
-            path {str} -- Path to the asset.
-            config {Type[DjangoViteConfig]} -- Config object to use.
-
-        Returns:
-            str -- Full URL to the asset.
-        """
-
-        return urljoin(
-            f"{config.dev_server_protocol}://"
-            f"{config.dev_server_host}:{config.dev_server_port}",
-            urljoin(config.static_url, path),
+        return TagGenerator.script(
+            url,
+            attrs={"type": "module", **kwargs},
         )
 
-    def generate_vite_react_refresh_url(
-        self, config_key: str = DEFAULT_CONFIG_KEY
-    ) -> str:
+    def generate_vite_react_refresh_url(self) -> str:
         """
         Generates the script for the Vite React Refresh for HMR.
         Only used in development, in production this method returns
@@ -725,234 +546,217 @@ def generate_vite_react_refresh_url(
             str -- The script or an empty string.
             config_key {str} -- Key of the configuration to use.
         """
-        config = self._get_config(config_key)
 
-        if not config.dev_mode:
+        if not self.dev_mode:
             return ""
 
+        url = self._get_dev_server_url(self.react_refresh_url)
+
         return f"""<script type="module">
-            import RefreshRuntime from \
-            '{self._generate_vite_server_url(config.react_refresh_url, config)}'
+            import RefreshRuntime from '{url}'
             RefreshRuntime.injectIntoGlobalHook(window)
             window.$RefreshReg$ = () => {{}}
             window.$RefreshSig$ = () => (type) => type
             window.__vite_plugin_react_preamble_installed__ = true
         </script>"""
 
-    @staticmethod
-    def _generate_production_server_url(path: str, static_url_prefix="") -> str:
-        """
-        Generates an URL to an asset served during production.
-
-        Keyword Arguments:
-            path {str} -- Path to the asset.
-
-        Returns:
-            str -- Full URL to the asset.
-        """
-
-        production_server_url = path
-        if prefix := static_url_prefix:
-            if not static_url_prefix.endswith("/"):
-                prefix += "/"
-            production_server_url = urljoin(prefix, path)
-
-        if apps.is_installed("django.contrib.staticfiles"):
-            from django.contrib.staticfiles.storage import staticfiles_storage
-
-            return staticfiles_storage.url(production_server_url)
-
-        return production_server_url
-
 
-@register.simple_tag
-@mark_safe
-def vite_hmr_client(
-    config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-) -> str:
-    """
-    Generates the script tag for the Vite WS client for HMR.
-    Only used in development, in production this method returns
-    an empty string.
-
-    Arguments:
-        config {str} -- Configuration to use.
-
-    Returns:
-        str -- The script tag or an empty string.
-
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
-    """
-
-    return DjangoViteAssetLoader.instance().generate_vite_ws_client(
-        config_key, **kwargs
-    )
-
-
-@register.simple_tag
-@mark_safe
-def vite_asset(
-    path: str,
-    config_key: str = DEFAULT_CONFIG_KEY,
-    **kwargs: Dict[str, str],
-) -> str:
+class DjangoViteAssetLoader:
     """
-    Generates a <script> tag for this JS/TS asset, a <link> tag for
-    all of its CSS dependencies, and a <link rel="modulepreload">
-    for all js dependencies, as listed in the manifest file
-    In development Vite loads all by itself.
-
-    Arguments:
-        path {str} -- Path to a Vite JS/TS asset to include.
-        config {str} -- Configuration to use.
-
-    Returns:
-        str -- All tags to import this file in your HTML page.
-
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
-
-    Raises:
-        RuntimeError: If cannot find the file path in the
-            manifest (only in production).
+    Class handling Vite asset loading.
 
-    Returns:
-        str -- The <script> tag and all <link> tags to import this
-            asset in your page.
+    Routes asset and url generation to the proper DjangoViteAppClient.
     """
 
-    assert path is not None
-    assert config_key is not None
-
-    return DjangoViteAssetLoader.instance().generate_vite_asset(
-        path, config_key, **kwargs
-    )
+    _instance = None
+    _apps: Dict[str, DjangoViteAppClient]
+
+    DJANGO_VITE = "DJANGO_VITE"
+
+    LEGACY_DJANGO_VITE_SETTINGS: Dict[str, Optional[str]] = {
+        "DJANGO_VITE_DEV_MODE": "dev_mode",
+        "DJANGO_VITE_DEV_SERVER_PROTOCOL": "dev_server_protocol",
+        "DJANGO_VITE_DEV_SERVER_HOST": "dev_server_host",
+        "DJANGO_VITE_DEV_SERVER_PORT": "dev_server_port",
+        "DJANGO_VITE_STATIC_URL_PREFIX": "static_url_prefix",
+        "DJANGO_VITE_MANIFEST_PATH": "manifest_path",
+        "DJANGO_VITE_LEGACY_POLYFILLS_MOTIF": "legacy_polyfills_motif",
+        "DJANGO_VITE_WS_CLIENT_URL": "ws_client_url",
+        "DJANGO_VITE_REACT_REFRESH_URL": "react_refresh_url",
+        "DJANGO_VITE_ASSETS_PATH": None,
+    }
 
+    def __init__(self) -> None:
+        raise RuntimeError("Use the instance() method instead.")
 
-@register.simple_tag
-@mark_safe
-def vite_preload_asset(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
-    """
-    Generates preloadmodule tag for this JS/TS asset and preloads
-    all of its CSS and JS dependencies by reading the manifest
-    file (for production only).
-    In development does nothing.
+    @classmethod
+    def instance(cls):
+        """
+        Singleton.
+        Uses singleton to keep parsed manifests in memory after
+        the first time they are loaded.
 
-    Arguments:
-        path {str} -- Path to a Vite JS/TS asset to include.
+        Returns:
+            DjangoViteAssetLoader -- only instance of the class.
+        """
 
-    Returns:
-        str -- All tags to import this file in your HTML page.
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+            cls._instance._apps = {}
 
-    Raises:
-        RuntimeError: If cannot find the file path in the
-            manifest (only in production).
+            cls._apply_django_vite_settings()
+            cls._apply_legacy_django_vite_settings()
+            cls._apply_default_fallback()
 
-    """
-    assert path is not None
+        return cls._instance
 
-    return DjangoViteAssetLoader.instance().preload_vite_asset(path, config_key)
+    @classmethod
+    def _apply_django_vite_settings(cls):
+        """
+        Takes DjangoViteConfigs from the DJANGO_VITE setting, and plugs them into
+        DjangoViteAppClients.
+        """
 
+        django_vite_settings = getattr(settings, cls.DJANGO_VITE, None)
 
-@register.simple_tag
-def vite_asset_url(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
-    """
-    Generates only the URL of an asset managed by ViteJS.
-    Warning, this function does not generate URLs for dependant assets.
+        if not django_vite_settings:
+            return
 
-    Arguments:
-        path {str} -- Path to a Vite asset.
-        config {str} -- Configuration to use.
+        for app_name, config in django_vite_settings.items():
+            if not isinstance(config, DjangoViteConfig):
+                config = DjangoViteConfig(**config)
+            cls._instance._apps[app_name] = DjangoViteAppClient(config)
 
-    Raises:
-        RuntimeError: If cannot find the asset path in the
-            manifest (only in production).
+    @classmethod
+    def _apply_legacy_django_vite_settings(cls):
+        """
+        If the project hasn't yet migrated to the new way of configuring django-vite,
+        then plug values from the legacy settings into an app named "default".
+        """
+
+        applied_settings = dir(settings)
+        legacy_settings_keys = cls.LEGACY_DJANGO_VITE_SETTINGS.keys()
+        applied_legacy_settings = [
+            key for key in legacy_settings_keys if key in applied_settings
+        ]
+
+        if not applied_legacy_settings:
+            return
+
+        # If there are both new DJANGO_VITE settings as well as legacy settings, then
+        # allow _apply_django_vite_settings to apply only the DJANGO_VITE configs and
+        # ignore the legacy settings.
+        if cls.DJANGO_VITE in applied_settings:
+            warnings.warn(
+                f"You're mixing the new {cls.DJANGO_VITE} setting with these "
+                f"legacy settings: [{applied_legacy_settings.join(',')}]. Those legacy "
+                f"settings will be ignored since you have a {cls.DJANGO_VITE}"
+                " setting configured. Please remove those legacy django-vite settings.",
+                DeprecationWarning,
+            )
+            return
+
+        # Apply legacy settings, with a warning.
+        warnings.warn(
+            f"The settings [{', '.join(applied_legacy_settings)}] will be removed "
+            "in future releases of django-vite. Please switch to defining your "
+            f'settings as {cls.DJANGO_VITE} = {{"default": {{...}},}}.',
+            DeprecationWarning,
+        )
 
-    Returns:
-        str -- The URL of this asset.
-    """
-    assert path is not None
-    return DjangoViteAssetLoader.instance().generate_vite_asset_url(path, config_key)
+        legacy_config = {}
+        for legacy_setting in applied_legacy_settings:
+            new_config_name = cls.LEGACY_DJANGO_VITE_SETTINGS[legacy_setting]
+            if new_config_name:
+                legacy_config[new_config_name] = getattr(settings, legacy_setting)
 
+        legacy_config = DjangoViteConfig(**legacy_config)
+        cls._instance._apps[DEFAULT_APP_NAME] = DjangoViteAppClient(legacy_config)
 
-@register.simple_tag
-@mark_safe
-def vite_legacy_polyfills(
-    config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-) -> str:
-    """
-    Generates a <script> tag to the polyfills generated
-    by '@vitejs/plugin-legacy' if used.
-    This tag must be included at end of the <body> before including
-    other legacy scripts.
+    @classmethod
+    def _apply_default_fallback(cls):
+        """
+        If no settings at all were provided (and no DjangoViteAppClient were
+        instantiated), we can create a "default" DjangoViteAppClient using the default
+        values of DjangoViteConfig.
+        """
 
-    Arguments:
-        config_key {str} -- Configuration to use.
+        if not cls._instance._apps:
+            default_config = DjangoViteConfig()
+            cls._instance._apps[DEFAULT_APP_NAME] = DjangoViteAppClient(default_config)
 
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
+    def _get_app_client(self, app: str) -> DjangoViteAppClient:
+        """
+        Gets the DjangoViteAppClient for given app.
 
-    Raises:
-        RuntimeError: If polyfills path not found inside
-            the 'manifest.json' (only in production).
+        Returns:
+            DjangoViteAppClient -- the client for your app
 
-    Returns:
-        str -- The script tag to the polyfills.
-    """
-    return DjangoViteAssetLoader.instance().generate_vite_legacy_polyfills(
-        config_key, **kwargs
-    )
-
-
-@register.simple_tag
-@mark_safe
-def vite_legacy_asset(
-    path: str,
-    config_key: str = DEFAULT_CONFIG_KEY,
-    **kwargs: Dict[str, str],
-) -> str:
-    """
-    Generates a <script> tag for legacy assets JS/TS
-    generated by '@vitejs/plugin-legacy'
-    (in production only, in development do nothing).
+        Raises:
+            DjangoViteConfigNotFoundError: If app was not found in DJANGO_VITE
+                settings.
+        """
 
-    Arguments:
-        path {str} -- Path to a Vite asset to include
-            (must contains '-legacy' in its name).
-        config_key {str} -- Configuration to use.
+        if app not in self._apps:
+            raise DjangoViteConfigNotFoundError(
+                f"Cannot find {app} in {self.DJANGO_VITE} settings."
+            )
 
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
+        return self._apps[app]
 
-    Raises:
-        RuntimeError: If cannot find the asset path in
-            the manifest (only in production).
+    def generate_vite_asset(
+        self,
+        path: str,
+        app: str = DEFAULT_APP_NAME,
+        **kwargs: Dict[str, str],
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.generate_vite_asset(path, **kwargs)
 
-    Returns:
-        str -- The script tag of this legacy asset.
-    """
+    def preload_vite_asset(
+        self,
+        path: str,
+        app: str = DEFAULT_APP_NAME,
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.preload_vite_asset(path)
 
-    assert path is not None
+    def generate_vite_asset_url(
+        self,
+        path: str,
+        app: str = DEFAULT_APP_NAME,
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.generate_vite_asset_url(path)
 
-    return DjangoViteAssetLoader.instance().generate_vite_legacy_asset(
-        path, config_key, **kwargs
-    )
+    def generate_vite_legacy_polyfills(
+        self,
+        app: str = DEFAULT_APP_NAME,
+        **kwargs: Dict[str, str],
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.generate_vite_legacy_polyfills(**kwargs)
 
+    def generate_vite_legacy_asset(
+        self,
+        path: str,
+        app: str = DEFAULT_APP_NAME,
+        **kwargs: Dict[str, str],
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.generate_vite_legacy_asset(path, **kwargs)
 
-@register.simple_tag
-@mark_safe
-def vite_react_refresh(config_key: str = DEFAULT_CONFIG_KEY) -> str:
-    """
-    Generates the script for the Vite React Refresh for HMR.
-    Only used in development, in production this method returns
-    an empty string.
+    def generate_vite_ws_client(
+        self,
+        app: str = DEFAULT_APP_NAME,
+        **kwargs: Dict[str, str],
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.generate_vite_ws_client(**kwargs)
 
-    Returns:
-        str -- The script or an empty string.
-    """
-    return DjangoViteAssetLoader.instance().generate_vite_react_refresh_url(config_key)
+    def generate_vite_react_refresh_url(
+        self,
+        app: str = DEFAULT_APP_NAME,
+    ) -> str:
+        app_client = self._get_app_client(app)
+        return app_client.generate_vite_react_refresh_url()
diff --git a/django_vite/tag_generator.py b/django_vite/tag_generator.py
index c1e9956..f9f3c8f 100644
--- a/django_vite/tag_generator.py
+++ b/django_vite/tag_generator.py
@@ -1,645 +1,11 @@
-import json
-from pathlib import Path
-from typing import Dict, List, Callable, NamedTuple, Optional, Type, Union
-from urllib.parse import urljoin
+from typing import Dict
 
-from django import template
-from django.apps import apps
-from django.conf import settings
-from django.utils.safestring import mark_safe
+Tag = str
 
-from django_vite.exceptions import DjangoViteAssetNotFoundError, DjangoViteManifestError
-
-DEFAULT_CONFIG_KEY = "default"
-
-register = template.Library()
-
-
-class DjangoViteManifest(NamedTuple):
-    """
-    Represent an entry for a file inside the "manifest.json".
-    """
-
-    file: str
-    src: Optional[str] = None
-    isEntry: Optional[bool] = False
-    css: Optional[List[str]] = []
-    imports: Optional[List[str]] = []
-
-
-class DjangoViteConfig(NamedTuple):
-    """
-    Represent the Django Vite configuration structure.
-    """
-
-    # Location of Vite compiled assets (only used in Vite production mode).
-    assets_path: Union[Path, str]
-
-    # If using in development or production mode.
-    dev_mode: bool = False
-
-    # Default Vite server protocol (http or https)
-    dev_server_protocol: str = "http"
-
-    # Default vite server hostname.
-    dev_server_host: str = "localhost"
-
-    # Default Vite server port.
-    dev_server_port: int = 3000
-
-    # Default Vite server path to HMR script.
-    ws_client_url: str = "@vite/client"
-
-    # Prefix for STATIC_URL.
-    static_url_prefix: str = ""
-
-    # Motif in the "manifest.json" to find the polyfills generated by Vite.
-    legacy_polyfills_motif: str = "legacy-polyfills"
-
-    # Path to your manifest file generated by Vite.
-    manifest_path: Union[Path, str] = ""
-
-    # Default Vite server path to React RefreshRuntime for @vitejs/plugin-react.
-    react_refresh_url: str = "@react-refresh"
-
-    @property
-    def static_url(self) -> str:
-        url = urljoin(settings.STATIC_URL, self.static_url_prefix)
-        if not url.endswith("/"):
-            url += "/"
-        return url
-
-    @property
-    def static_root(self) -> Path:
-        """
-        Compute the static root URL of assets.
-
-        Returns:
-            Union[Path, str] -- Static root URL.
-        """
-
-        return (
-            Path(self.assets_path)
-            if self.dev_mode
-            else Path(settings.STATIC_ROOT) / self.static_url_prefix
-        )
-
-    def get_computed_manifest_path(self) -> Union[Path, str]:
-        """
-        Compute the path to the "manifest.json".
-
-        Returns:
-            Union[Path, str] -- Path to the "manifest.json".
-        """
-
-        return (
-            self.manifest_path
-            if self.manifest_path
-            else self.static_root / "manifest.json"
-        )
-
-
-class DjangoViteAssetLoader:
-    """
-    Class handling Vite asset loading.
-    """
-
-    _instance = None
-
-    _configs = Dict[str, Type[DjangoViteConfig]]
-    _manifests: Dict[str, Type[DjangoViteManifest]]
-
-    def __init__(self) -> None:
-        raise RuntimeError("Use the instance() method instead.")
-
-    def generate_vite_asset(
-        self,
-        path: str,
-        config_key: str,
-        **kwargs: Dict[str, str],
-    ) -> str:
-        """
-        Generates a <script> tag for this JS/TS asset, a <link> tag for
-        all of its CSS dependencies, and a <link modulepreload>
-        for the js dependencies, as listed in the manifest file
-        (for production only).
-        In development Vite loads all by itself.
-
-        Arguments:
-            path {str} -- Path to a Vite JS/TS asset to include.
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            str -- All tags to import this file in your HTML page.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the file path in the
-                manifest (only in production).
-
-        Returns:
-            str -- The <script> tag and all <link> tags to import
-                this asset in your page.
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return DjangoViteAssetLoader._generate_script_tag(
-                DjangoViteAssetLoader._generate_vite_server_url(path, config),
-                {"type": "module", **kwargs},
-            )
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
-        tags = []
-        scripts_attrs = {"type": "module", "crossorigin": "", **kwargs}
-
-        # Add dependent CSS
-        tags.extend(self._load_css_files_of_asset(path, config_key))
-
-        # Add the script by itself
-        tags.append(
-            DjangoViteAssetLoader._generate_script_tag(
-                DjangoViteAssetLoader._generate_production_server_url(
-                    manifest_entry.file, config.static_url_prefix
-                ),
-                attrs=scripts_attrs,
-            )
-        )
-
-        # Preload imports
-        preload_attrs = {
-            "type": "text/javascript",
-            "crossorigin": "anonymous",
-            "rel": "modulepreload",
-            "as": "script",
-        }
-
-        for dep in manifest_entry.imports:
-            dep_manifest_entry = manifest[dep]
-            dep_file = dep_manifest_entry.file
-            url = DjangoViteAssetLoader._generate_production_server_url(
-                dep_file, config.static_url_prefix
-            )
-            tags.append(
-                DjangoViteAssetLoader._generate_preload_tag(
-                    url,
-                    attrs=preload_attrs,
-                )
-            )
-
-        return "\n".join(tags)
-
-    def preload_vite_asset(
-        self,
-        path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> str:
-        """
-        Generates a <link modulepreload> tag for this JS/TS asset, a
-        <link preload> tag for all of its CSS dependencies,
-        and a <link modulepreload> for the js dependencies.
-        In development this template tag renders nothing,
-        since files aren't compiled yet"
-
-        Arguments:
-            path {str} -- Path to a Vite JS/TS asset to preload.
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            str -- All tags to preload this file in your HTML page.
-
-        Raises:
-            DjangoViteAssetNotFoundError: if cannot find the file path in the
-                manifest.
-
-        Returns:
-            str -- all <link> tags to preload
-                this asset.
-        """
-        tags = []
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return ""
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
-
-        # Add the script by itself
-        script_attrs = {
-            "type": "text/javascript",
-            "crossorigin": "anonymous",
-            "rel": "modulepreload",
-            "as": "script",
-        }
-
-        manifest_file = manifest_entry.file
-        url = DjangoViteAssetLoader._generate_production_server_url(
-            manifest_file, config.static_url_prefix
-        )
-        tags.append(
-            DjangoViteAssetLoader._generate_preload_tag(
-                url,
-                attrs=script_attrs,
-            )
-        )
-
-        # Add dependent CSS
-        tags.extend(self._preload_css_files_of_asset(path, config_key))
-
-        # Preload imports
-        for dep in manifest_entry.imports:
-            dep_manifest_entry = manifest[dep]
-            dep_file = dep_manifest_entry.file
-            url = DjangoViteAssetLoader._generate_production_server_url(
-                dep_file, config.static_url_prefix
-            )
-            tags.append(
-                DjangoViteAssetLoader._generate_preload_tag(
-                    url,
-                    attrs=script_attrs,
-                )
-            )
-
-        return "\n".join(tags)
-
-    def _preload_css_files_of_asset(
-        self,
-        path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
-        return self._generate_css_files_of_asset(
-            path,
-            [],
-            DjangoViteAssetLoader._generate_stylesheet_preload_tag,
-            config_key,
-        )
-
-    def _load_css_files_of_asset(
-        self,
-        path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
-        return self._generate_css_files_of_asset(
-            path,
-            [],
-            DjangoViteAssetLoader._generate_stylesheet_tag,
-            config_key,
-        )
-
-    def _generate_css_files_of_asset(
-        self,
-        path: str,
-        already_processed: List[str],
-        tag_generator: Callable,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
-        """
-        Generates all CSS tags for dependencies of an asset.
-
-        Arguments:
-            path {str} -- Path to an asset in the 'manifest.json'.
-            config_key {str} -- Key of the configuration to use.
-            already_processed {list} -- List of already processed CSS file.
-
-        Returns:
-            list -- List of CSS tags.
-        """
-
-        tags = []
-        config = self._get_config(config_key)
-        manifest = self._get_manifest(config_key)
-        manifest_entry = manifest[path]
-
-        for import_path in manifest_entry.imports:
-            tags.extend(
-                self._generate_css_files_of_asset(
-                    import_path, already_processed, tag_generator, config_key
-                )
-            )
-
-        for css_path in manifest_entry.css:
-            if css_path not in already_processed:
-                url = DjangoViteAssetLoader._generate_production_server_url(
-                    css_path, config.static_url_prefix
-                )
-                tags.append(tag_generator(url))
-
-            already_processed.append(css_path)
-
-        return tags
-
-    def generate_vite_asset_url(self, path: str, config_key: str) -> str:
-        """
-        Generates only the URL of an asset managed by ViteJS.
-        Warning, this function does not generate URLs for dependant assets.
-
-        Arguments:
-            path {str} -- Path to a Vite asset.
-            config_key {str} -- Key of the configuration to use.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the asset path in the
-                manifest (only in production).
-
-        Returns:
-            str -- The URL of this asset.
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return DjangoViteAssetLoader._generate_vite_server_url(path, config)
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
-
-        return DjangoViteAssetLoader._generate_production_server_url(
-            manifest_entry.file, config.static_url_prefix
-        )
-
-    def generate_vite_legacy_polyfills(
-        self,
-        config_key: str,
-        **kwargs: Dict[str, str],
-    ) -> str:
-        """
-        Generates a <script> tag to the polyfills
-        generated by '@vitejs/plugin-legacy' if used.
-        This tag must be included at end of the <body> before
-        including other legacy scripts.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If polyfills path not found inside
-                the 'manifest.json' (only in production).
-
-        Returns:
-            str -- The script tag to the polyfills.
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return ""
-
-        manifest = self._get_manifest(config_key)
-        scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
-
-        for path, manifest_entry in manifest.items():
-            if config.legacy_polyfills_motif in path:
-                return DjangoViteAssetLoader._generate_script_tag(
-                    DjangoViteAssetLoader._generate_production_server_url(
-                        manifest_entry.file, config.static_url_prefix
-                    ),
-                    attrs=scripts_attrs,
-                )
-
-        raise DjangoViteAssetNotFoundError(
-            f"Vite legacy polyfills not found in manifest "
-            f"at {config.get_computed_manifest_path()}"
-        )
-
-    def generate_vite_legacy_asset(
-        self,
-        path: str,
-        config_key: str,
-        **kwargs: Dict[str, str],
-    ) -> str:
-        """
-        Generates a <script> tag for legacy assets JS/TS
-        generated by '@vitejs/plugin-legacy'
-        (in production only, in development do nothing).
-
-        Arguments:
-            path {str} -- Path to a Vite asset to include
-                (must contains '-legacy' in its name).
-            config_key {str} -- Key of the configuration to use.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the asset path in the
-                manifest (only in production).
-
-        Returns:
-            str -- The script tag of this legacy asset .
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return ""
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
-
-        url = DjangoViteAssetLoader._generate_production_server_url(
-            manifest[path].file, config.static_url_prefix
-        )
-        return DjangoViteAssetLoader._generate_script_tag(
-            url,
-            attrs=scripts_attrs,
-        )
-
-    def _get_config(self, config_key: str) -> Type[DjangoViteConfig]:
-        """
-        Get configuration object registered with the key passed in
-        parameter.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to retrieve.
-
-        Raises:
-            RuntimeError: If no configuration exists for this key.
-
-        Returns:
-            Type[DjangoViteConfig] -- The configuration.
-        """
-
-        if config_key not in self._configs:
-            raise RuntimeError(f'Cannot find "{config_key}" configuration')
-
-        return self._configs[config_key]
-
-    def _parse_manifest(self, config_key: str) -> Dict[str, Type[DjangoViteManifest]]:
-        """
-        Read and parse the Vite manifest file.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Raises:
-            DjangoViteManifestError: if cannot load the file or JSON in file is
-            malformed.
-        """
-
-        config = self._get_config(config_key)
-
-        try:
-            with open(config.get_computed_manifest_path(), "r") as manifest_file:
-                manifest_content = manifest_file.read()
-                manifest_json = json.loads(manifest_content)
-
-                return {k: DjangoViteManifest(**v) for k, v in manifest_json.items()}
-
-        except Exception as error:
-            raise DjangoViteManifestError(
-                f"Cannot read Vite manifest file at "
-                f"{config.get_computed_manifest_path()} : {str(error)}"
-            ) from error
-
-    def _get_manifest(self, config_key: str) -> Dict[str, Type[DjangoViteManifest]]:
-        """
-        Load if needed and parse the "manifest.json" of the specified
-        configuration.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            Dict[str, Type[DjangoViteManifest]] -- Parsed content of
-                the "manifest.json"
-        """
-
-        if config_key not in self._manifests:
-            self._manifests[config_key] = self._parse_manifest(config_key)
-
-        return self._manifests[config_key]
-
-    @classmethod
-    def instance(cls):
-        """
-        Singleton.
-        Uses singleton to keep parsed manifests in memory after
-        the first time they are loaded.
-
-        Returns:
-            DjangoViteAssetLoader -- only instance of the class.
-        """
-
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-            cls._instance._configs = {}
-            cls._instance._manifests = {}
-
-            if hasattr(settings, "DJANGO_VITE"):
-                config = getattr(settings, "DJANGO_VITE")
-
-                for config_key, config_values in config.items():
-                    if isinstance(config_values, DjangoViteConfig):
-                        cls._instance._configs[config_key] = config_values
-                    elif isinstance(config_values, dict):
-                        cls._instance._configs[config_key] = DjangoViteConfig(
-                            **config_values
-                        )
-                    else:
-                        raise RuntimeError(
-                            f"Cannot read configuration for key '{config_key}'"
-                        )
-            else:
-                # Warning : This branch will be remove in further
-                # releases. Please use new way of handling configuration.
-
-                _config_keys = {
-                    "DJANGO_VITE_DEV_MODE": "dev_mode",
-                    "DJANGO_VITE_DEV_SERVER_PROTOCOL": "dev_server_protocol",
-                    "DJANGO_VITE_DEV_SERVER_HOST": "dev_server_host",
-                    "DJANGO_VITE_DEV_SERVER_PORT": "dev_server_port",
-                    "DJANGO_VITE_WS_CLIENT_URL": "ws_client_url",
-                    "DJANGO_VITE_ASSETS_PATH": "assets_path",
-                    "DJANGO_VITE_STATIC_URL_PREFIX": "static_url_prefix",
-                    "DJANGO_VITE_MANIFEST_PATH": "manifest_path",
-                    "DJANGO_VITE_LEGACY_POLYFILLS_MOTIF": "legacy_polyfills_motif",
-                    "DJANGO_VITE_REACT_REFRESH_URL": "react_refresh_url",
-                }
-
-                config = {
-                    _config_keys[setting_key]: getattr(settings, setting_key)
-                    for setting_key in dir(settings)
-                    if setting_key in _config_keys.keys()
-                }
-
-                cls._instance._configs[DEFAULT_CONFIG_KEY] = DjangoViteConfig(**config)
-
-                # Manifest is only used in production.
-                if not cls._instance._configs[DEFAULT_CONFIG_KEY].dev_mode:
-                    cls._instance._parse_manifest(DEFAULT_CONFIG_KEY)
-
-        return cls._instance
-
-    def generate_vite_ws_client(
-        self, config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-    ) -> str:
-        """
-        Generates the script tag for the Vite WS client for HMR.
-        Only used in development, in production this method returns
-        an empty string.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            str -- The script tag or an empty string.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-        """
-
-        config = self._get_config(config_key)
-
-        if not config.dev_mode:
-            return ""
-
-        return self._generate_script_tag(
-            self._generate_vite_server_url(config.ws_client_url, config),
-            {"type": "module", **kwargs},
-        )
 
+class TagGenerator:
     @staticmethod
-    def _generate_script_tag(src: str, attrs: Dict[str, str]) -> str:
+    def script(src: str, attrs: Dict[str, str]) -> Tag:
         """
         Generates an HTML script tag.
 
@@ -659,7 +25,7 @@ def _generate_script_tag(src: str, attrs: Dict[str, str]) -> str:
         return f'<script {attrs_str} src="{src}"></script>'
 
     @staticmethod
-    def _generate_stylesheet_tag(href: str) -> str:
+    def stylesheet(href: str) -> Tag:
         """
         Generates an HTML <link> stylesheet tag for CSS.
 
@@ -672,7 +38,8 @@ def _generate_stylesheet_tag(href: str) -> str:
 
         return f'<link rel="stylesheet" href="{href}" />'
 
-    def _generate_stylesheet_preload_tag(href: str) -> str:
+    @staticmethod
+    def stylesheet_preload(href: str) -> Tag:
         """
         Generates an HTML <link> preload tag for CSS.
 
@@ -686,273 +53,7 @@ def _generate_stylesheet_preload_tag(href: str) -> str:
         return f'<link rel="preload" href="{href}" as="style" />'
 
     @staticmethod
-    def _generate_preload_tag(href: str, attrs: Dict[str, str]) -> str:
+    def preload(href: str, attrs: Dict[str, str]) -> Tag:
         attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
 
         return f'<link href="{href}" {attrs_str} />'
-
-    @staticmethod
-    def _generate_vite_server_url(
-        path: str,
-        config: Type[DjangoViteConfig],
-    ) -> str:
-        """
-        Generates an URL to and asset served by the Vite development server.
-
-        Keyword Arguments:
-            path {str} -- Path to the asset.
-            config {Type[DjangoViteConfig]} -- Config object to use.
-
-        Returns:
-            str -- Full URL to the asset.
-        """
-
-        return urljoin(
-            f"{config.dev_server_protocol}://"
-            f"{config.dev_server_host}:{config.dev_server_port}",
-            urljoin(config.static_url, path),
-        )
-
-    def generate_vite_react_refresh_url(
-        self, config_key: str = DEFAULT_CONFIG_KEY
-    ) -> str:
-        """
-        Generates the script for the Vite React Refresh for HMR.
-        Only used in development, in production this method returns
-        an empty string.
-
-        Returns:
-            str -- The script or an empty string.
-            config_key {str} -- Key of the configuration to use.
-        """
-        config = self._get_config(config_key)
-
-        if not config.dev_mode:
-            return ""
-
-        return f"""<script type="module">
-            import RefreshRuntime from \
-            '{self._generate_vite_server_url(config.react_refresh_url, config)}'
-            RefreshRuntime.injectIntoGlobalHook(window)
-            window.$RefreshReg$ = () => {{}}
-            window.$RefreshSig$ = () => (type) => type
-            window.__vite_plugin_react_preamble_installed__ = true
-        </script>"""
-
-    @staticmethod
-    def _generate_production_server_url(path: str, static_url_prefix="") -> str:
-        """
-        Generates an URL to an asset served during production.
-
-        Keyword Arguments:
-            path {str} -- Path to the asset.
-
-        Returns:
-            str -- Full URL to the asset.
-        """
-
-        production_server_url = path
-        if prefix := static_url_prefix:
-            if not static_url_prefix.endswith("/"):
-                prefix += "/"
-            production_server_url = urljoin(prefix, path)
-
-        if apps.is_installed("django.contrib.staticfiles"):
-            from django.contrib.staticfiles.storage import staticfiles_storage
-
-            return staticfiles_storage.url(production_server_url)
-
-        return production_server_url
-
-
-@register.simple_tag
-@mark_safe
-def vite_hmr_client(
-    config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-) -> str:
-    """
-    Generates the script tag for the Vite WS client for HMR.
-    Only used in development, in production this method returns
-    an empty string.
-
-    Arguments:
-        config {str} -- Configuration to use.
-
-    Returns:
-        str -- The script tag or an empty string.
-
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
-    """
-
-    return DjangoViteAssetLoader.instance().generate_vite_ws_client(
-        config_key, **kwargs
-    )
-
-
-@register.simple_tag
-@mark_safe
-def vite_asset(
-    path: str,
-    config_key: str = DEFAULT_CONFIG_KEY,
-    **kwargs: Dict[str, str],
-) -> str:
-    """
-    Generates a <script> tag for this JS/TS asset, a <link> tag for
-    all of its CSS dependencies, and a <link rel="modulepreload">
-    for all js dependencies, as listed in the manifest file
-    In development Vite loads all by itself.
-
-    Arguments:
-        path {str} -- Path to a Vite JS/TS asset to include.
-        config {str} -- Configuration to use.
-
-    Returns:
-        str -- All tags to import this file in your HTML page.
-
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
-
-    Raises:
-        RuntimeError: If cannot find the file path in the
-            manifest (only in production).
-
-    Returns:
-        str -- The <script> tag and all <link> tags to import this
-            asset in your page.
-    """
-
-    assert path is not None
-    assert config_key is not None
-
-    return DjangoViteAssetLoader.instance().generate_vite_asset(
-        path, config_key, **kwargs
-    )
-
-
-@register.simple_tag
-@mark_safe
-def vite_preload_asset(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
-    """
-    Generates preloadmodule tag for this JS/TS asset and preloads
-    all of its CSS and JS dependencies by reading the manifest
-    file (for production only).
-    In development does nothing.
-
-    Arguments:
-        path {str} -- Path to a Vite JS/TS asset to include.
-
-    Returns:
-        str -- All tags to import this file in your HTML page.
-
-    Raises:
-        RuntimeError: If cannot find the file path in the
-            manifest (only in production).
-
-    """
-    assert path is not None
-
-    return DjangoViteAssetLoader.instance().preload_vite_asset(path, config_key)
-
-
-@register.simple_tag
-def vite_asset_url(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
-    """
-    Generates only the URL of an asset managed by ViteJS.
-    Warning, this function does not generate URLs for dependant assets.
-
-    Arguments:
-        path {str} -- Path to a Vite asset.
-        config {str} -- Configuration to use.
-
-    Raises:
-        RuntimeError: If cannot find the asset path in the
-            manifest (only in production).
-
-    Returns:
-        str -- The URL of this asset.
-    """
-    assert path is not None
-    return DjangoViteAssetLoader.instance().generate_vite_asset_url(path, config_key)
-
-
-@register.simple_tag
-@mark_safe
-def vite_legacy_polyfills(
-    config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-) -> str:
-    """
-    Generates a <script> tag to the polyfills generated
-    by '@vitejs/plugin-legacy' if used.
-    This tag must be included at end of the <body> before including
-    other legacy scripts.
-
-    Arguments:
-        config_key {str} -- Configuration to use.
-
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
-
-    Raises:
-        RuntimeError: If polyfills path not found inside
-            the 'manifest.json' (only in production).
-
-    Returns:
-        str -- The script tag to the polyfills.
-    """
-    return DjangoViteAssetLoader.instance().generate_vite_legacy_polyfills(
-        config_key, **kwargs
-    )
-
-
-@register.simple_tag
-@mark_safe
-def vite_legacy_asset(
-    path: str,
-    config_key: str = DEFAULT_CONFIG_KEY,
-    **kwargs: Dict[str, str],
-) -> str:
-    """
-    Generates a <script> tag for legacy assets JS/TS
-    generated by '@vitejs/plugin-legacy'
-    (in production only, in development do nothing).
-
-    Arguments:
-        path {str} -- Path to a Vite asset to include
-            (must contains '-legacy' in its name).
-        config_key {str} -- Configuration to use.
-
-    Keyword Arguments:
-        **kwargs {Dict[str, str]} -- Adds new attributes to generated
-            script tags.
-
-    Raises:
-        RuntimeError: If cannot find the asset path in
-            the manifest (only in production).
-
-    Returns:
-        str -- The script tag of this legacy asset.
-    """
-
-    assert path is not None
-
-    return DjangoViteAssetLoader.instance().generate_vite_legacy_asset(
-        path, config_key, **kwargs
-    )
-
-
-@register.simple_tag
-@mark_safe
-def vite_react_refresh(config_key: str = DEFAULT_CONFIG_KEY) -> str:
-    """
-    Generates the script for the Vite React Refresh for HMR.
-    Only used in development, in production this method returns
-    an empty string.
-
-    Returns:
-        str -- The script or an empty string.
-    """
-    return DjangoViteAssetLoader.instance().generate_vite_react_refresh_url(config_key)
diff --git a/django_vite/templatetags/django_vite.py b/django_vite/templatetags/django_vite.py
index c1e9956..1ffdf62 100644
--- a/django_vite/templatetags/django_vite.py
+++ b/django_vite/templatetags/django_vite.py
@@ -1,775 +1,17 @@
-import json
-from pathlib import Path
-from typing import Dict, List, Callable, NamedTuple, Optional, Type, Union
-from urllib.parse import urljoin
+from typing import Dict
 
 from django import template
-from django.apps import apps
-from django.conf import settings
 from django.utils.safestring import mark_safe
 
-from django_vite.exceptions import DjangoViteAssetNotFoundError, DjangoViteManifestError
+from django_vite.loader import DjangoViteAssetLoader, DEFAULT_APP_NAME
 
-DEFAULT_CONFIG_KEY = "default"
 
 register = template.Library()
 
 
-class DjangoViteManifest(NamedTuple):
-    """
-    Represent an entry for a file inside the "manifest.json".
-    """
-
-    file: str
-    src: Optional[str] = None
-    isEntry: Optional[bool] = False
-    css: Optional[List[str]] = []
-    imports: Optional[List[str]] = []
-
-
-class DjangoViteConfig(NamedTuple):
-    """
-    Represent the Django Vite configuration structure.
-    """
-
-    # Location of Vite compiled assets (only used in Vite production mode).
-    assets_path: Union[Path, str]
-
-    # If using in development or production mode.
-    dev_mode: bool = False
-
-    # Default Vite server protocol (http or https)
-    dev_server_protocol: str = "http"
-
-    # Default vite server hostname.
-    dev_server_host: str = "localhost"
-
-    # Default Vite server port.
-    dev_server_port: int = 3000
-
-    # Default Vite server path to HMR script.
-    ws_client_url: str = "@vite/client"
-
-    # Prefix for STATIC_URL.
-    static_url_prefix: str = ""
-
-    # Motif in the "manifest.json" to find the polyfills generated by Vite.
-    legacy_polyfills_motif: str = "legacy-polyfills"
-
-    # Path to your manifest file generated by Vite.
-    manifest_path: Union[Path, str] = ""
-
-    # Default Vite server path to React RefreshRuntime for @vitejs/plugin-react.
-    react_refresh_url: str = "@react-refresh"
-
-    @property
-    def static_url(self) -> str:
-        url = urljoin(settings.STATIC_URL, self.static_url_prefix)
-        if not url.endswith("/"):
-            url += "/"
-        return url
-
-    @property
-    def static_root(self) -> Path:
-        """
-        Compute the static root URL of assets.
-
-        Returns:
-            Union[Path, str] -- Static root URL.
-        """
-
-        return (
-            Path(self.assets_path)
-            if self.dev_mode
-            else Path(settings.STATIC_ROOT) / self.static_url_prefix
-        )
-
-    def get_computed_manifest_path(self) -> Union[Path, str]:
-        """
-        Compute the path to the "manifest.json".
-
-        Returns:
-            Union[Path, str] -- Path to the "manifest.json".
-        """
-
-        return (
-            self.manifest_path
-            if self.manifest_path
-            else self.static_root / "manifest.json"
-        )
-
-
-class DjangoViteAssetLoader:
-    """
-    Class handling Vite asset loading.
-    """
-
-    _instance = None
-
-    _configs = Dict[str, Type[DjangoViteConfig]]
-    _manifests: Dict[str, Type[DjangoViteManifest]]
-
-    def __init__(self) -> None:
-        raise RuntimeError("Use the instance() method instead.")
-
-    def generate_vite_asset(
-        self,
-        path: str,
-        config_key: str,
-        **kwargs: Dict[str, str],
-    ) -> str:
-        """
-        Generates a <script> tag for this JS/TS asset, a <link> tag for
-        all of its CSS dependencies, and a <link modulepreload>
-        for the js dependencies, as listed in the manifest file
-        (for production only).
-        In development Vite loads all by itself.
-
-        Arguments:
-            path {str} -- Path to a Vite JS/TS asset to include.
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            str -- All tags to import this file in your HTML page.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the file path in the
-                manifest (only in production).
-
-        Returns:
-            str -- The <script> tag and all <link> tags to import
-                this asset in your page.
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return DjangoViteAssetLoader._generate_script_tag(
-                DjangoViteAssetLoader._generate_vite_server_url(path, config),
-                {"type": "module", **kwargs},
-            )
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
-        tags = []
-        scripts_attrs = {"type": "module", "crossorigin": "", **kwargs}
-
-        # Add dependent CSS
-        tags.extend(self._load_css_files_of_asset(path, config_key))
-
-        # Add the script by itself
-        tags.append(
-            DjangoViteAssetLoader._generate_script_tag(
-                DjangoViteAssetLoader._generate_production_server_url(
-                    manifest_entry.file, config.static_url_prefix
-                ),
-                attrs=scripts_attrs,
-            )
-        )
-
-        # Preload imports
-        preload_attrs = {
-            "type": "text/javascript",
-            "crossorigin": "anonymous",
-            "rel": "modulepreload",
-            "as": "script",
-        }
-
-        for dep in manifest_entry.imports:
-            dep_manifest_entry = manifest[dep]
-            dep_file = dep_manifest_entry.file
-            url = DjangoViteAssetLoader._generate_production_server_url(
-                dep_file, config.static_url_prefix
-            )
-            tags.append(
-                DjangoViteAssetLoader._generate_preload_tag(
-                    url,
-                    attrs=preload_attrs,
-                )
-            )
-
-        return "\n".join(tags)
-
-    def preload_vite_asset(
-        self,
-        path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> str:
-        """
-        Generates a <link modulepreload> tag for this JS/TS asset, a
-        <link preload> tag for all of its CSS dependencies,
-        and a <link modulepreload> for the js dependencies.
-        In development this template tag renders nothing,
-        since files aren't compiled yet"
-
-        Arguments:
-            path {str} -- Path to a Vite JS/TS asset to preload.
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            str -- All tags to preload this file in your HTML page.
-
-        Raises:
-            DjangoViteAssetNotFoundError: if cannot find the file path in the
-                manifest.
-
-        Returns:
-            str -- all <link> tags to preload
-                this asset.
-        """
-        tags = []
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return ""
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
-
-        # Add the script by itself
-        script_attrs = {
-            "type": "text/javascript",
-            "crossorigin": "anonymous",
-            "rel": "modulepreload",
-            "as": "script",
-        }
-
-        manifest_file = manifest_entry.file
-        url = DjangoViteAssetLoader._generate_production_server_url(
-            manifest_file, config.static_url_prefix
-        )
-        tags.append(
-            DjangoViteAssetLoader._generate_preload_tag(
-                url,
-                attrs=script_attrs,
-            )
-        )
-
-        # Add dependent CSS
-        tags.extend(self._preload_css_files_of_asset(path, config_key))
-
-        # Preload imports
-        for dep in manifest_entry.imports:
-            dep_manifest_entry = manifest[dep]
-            dep_file = dep_manifest_entry.file
-            url = DjangoViteAssetLoader._generate_production_server_url(
-                dep_file, config.static_url_prefix
-            )
-            tags.append(
-                DjangoViteAssetLoader._generate_preload_tag(
-                    url,
-                    attrs=script_attrs,
-                )
-            )
-
-        return "\n".join(tags)
-
-    def _preload_css_files_of_asset(
-        self,
-        path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
-        return self._generate_css_files_of_asset(
-            path,
-            [],
-            DjangoViteAssetLoader._generate_stylesheet_preload_tag,
-            config_key,
-        )
-
-    def _load_css_files_of_asset(
-        self,
-        path: str,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
-        return self._generate_css_files_of_asset(
-            path,
-            [],
-            DjangoViteAssetLoader._generate_stylesheet_tag,
-            config_key,
-        )
-
-    def _generate_css_files_of_asset(
-        self,
-        path: str,
-        already_processed: List[str],
-        tag_generator: Callable,
-        config_key: str = DEFAULT_CONFIG_KEY,
-    ) -> List[str]:
-        """
-        Generates all CSS tags for dependencies of an asset.
-
-        Arguments:
-            path {str} -- Path to an asset in the 'manifest.json'.
-            config_key {str} -- Key of the configuration to use.
-            already_processed {list} -- List of already processed CSS file.
-
-        Returns:
-            list -- List of CSS tags.
-        """
-
-        tags = []
-        config = self._get_config(config_key)
-        manifest = self._get_manifest(config_key)
-        manifest_entry = manifest[path]
-
-        for import_path in manifest_entry.imports:
-            tags.extend(
-                self._generate_css_files_of_asset(
-                    import_path, already_processed, tag_generator, config_key
-                )
-            )
-
-        for css_path in manifest_entry.css:
-            if css_path not in already_processed:
-                url = DjangoViteAssetLoader._generate_production_server_url(
-                    css_path, config.static_url_prefix
-                )
-                tags.append(tag_generator(url))
-
-            already_processed.append(css_path)
-
-        return tags
-
-    def generate_vite_asset_url(self, path: str, config_key: str) -> str:
-        """
-        Generates only the URL of an asset managed by ViteJS.
-        Warning, this function does not generate URLs for dependant assets.
-
-        Arguments:
-            path {str} -- Path to a Vite asset.
-            config_key {str} -- Key of the configuration to use.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the asset path in the
-                manifest (only in production).
-
-        Returns:
-            str -- The URL of this asset.
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return DjangoViteAssetLoader._generate_vite_server_url(path, config)
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        manifest_entry = manifest[path]
-
-        return DjangoViteAssetLoader._generate_production_server_url(
-            manifest_entry.file, config.static_url_prefix
-        )
-
-    def generate_vite_legacy_polyfills(
-        self,
-        config_key: str,
-        **kwargs: Dict[str, str],
-    ) -> str:
-        """
-        Generates a <script> tag to the polyfills
-        generated by '@vitejs/plugin-legacy' if used.
-        This tag must be included at end of the <body> before
-        including other legacy scripts.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If polyfills path not found inside
-                the 'manifest.json' (only in production).
-
-        Returns:
-            str -- The script tag to the polyfills.
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return ""
-
-        manifest = self._get_manifest(config_key)
-        scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
-
-        for path, manifest_entry in manifest.items():
-            if config.legacy_polyfills_motif in path:
-                return DjangoViteAssetLoader._generate_script_tag(
-                    DjangoViteAssetLoader._generate_production_server_url(
-                        manifest_entry.file, config.static_url_prefix
-                    ),
-                    attrs=scripts_attrs,
-                )
-
-        raise DjangoViteAssetNotFoundError(
-            f"Vite legacy polyfills not found in manifest "
-            f"at {config.get_computed_manifest_path()}"
-        )
-
-    def generate_vite_legacy_asset(
-        self,
-        path: str,
-        config_key: str,
-        **kwargs: Dict[str, str],
-    ) -> str:
-        """
-        Generates a <script> tag for legacy assets JS/TS
-        generated by '@vitejs/plugin-legacy'
-        (in production only, in development do nothing).
-
-        Arguments:
-            path {str} -- Path to a Vite asset to include
-                (must contains '-legacy' in its name).
-            config_key {str} -- Key of the configuration to use.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-
-        Raises:
-            DjangoViteAssetNotFoundError: If cannot find the asset path in the
-                manifest (only in production).
-
-        Returns:
-            str -- The script tag of this legacy asset .
-        """
-
-        config = self._get_config(config_key)
-
-        if config.dev_mode:
-            return ""
-
-        manifest = self._get_manifest(config_key)
-
-        if path not in manifest:
-            raise DjangoViteAssetNotFoundError(
-                f"Cannot find {path} in Vite manifest "
-                f"at {config.get_computed_manifest_path()}"
-            )
-
-        scripts_attrs = {"nomodule": "", "crossorigin": "", **kwargs}
-
-        url = DjangoViteAssetLoader._generate_production_server_url(
-            manifest[path].file, config.static_url_prefix
-        )
-        return DjangoViteAssetLoader._generate_script_tag(
-            url,
-            attrs=scripts_attrs,
-        )
-
-    def _get_config(self, config_key: str) -> Type[DjangoViteConfig]:
-        """
-        Get configuration object registered with the key passed in
-        parameter.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to retrieve.
-
-        Raises:
-            RuntimeError: If no configuration exists for this key.
-
-        Returns:
-            Type[DjangoViteConfig] -- The configuration.
-        """
-
-        if config_key not in self._configs:
-            raise RuntimeError(f'Cannot find "{config_key}" configuration')
-
-        return self._configs[config_key]
-
-    def _parse_manifest(self, config_key: str) -> Dict[str, Type[DjangoViteManifest]]:
-        """
-        Read and parse the Vite manifest file.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Raises:
-            DjangoViteManifestError: if cannot load the file or JSON in file is
-            malformed.
-        """
-
-        config = self._get_config(config_key)
-
-        try:
-            with open(config.get_computed_manifest_path(), "r") as manifest_file:
-                manifest_content = manifest_file.read()
-                manifest_json = json.loads(manifest_content)
-
-                return {k: DjangoViteManifest(**v) for k, v in manifest_json.items()}
-
-        except Exception as error:
-            raise DjangoViteManifestError(
-                f"Cannot read Vite manifest file at "
-                f"{config.get_computed_manifest_path()} : {str(error)}"
-            ) from error
-
-    def _get_manifest(self, config_key: str) -> Dict[str, Type[DjangoViteManifest]]:
-        """
-        Load if needed and parse the "manifest.json" of the specified
-        configuration.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            Dict[str, Type[DjangoViteManifest]] -- Parsed content of
-                the "manifest.json"
-        """
-
-        if config_key not in self._manifests:
-            self._manifests[config_key] = self._parse_manifest(config_key)
-
-        return self._manifests[config_key]
-
-    @classmethod
-    def instance(cls):
-        """
-        Singleton.
-        Uses singleton to keep parsed manifests in memory after
-        the first time they are loaded.
-
-        Returns:
-            DjangoViteAssetLoader -- only instance of the class.
-        """
-
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-            cls._instance._configs = {}
-            cls._instance._manifests = {}
-
-            if hasattr(settings, "DJANGO_VITE"):
-                config = getattr(settings, "DJANGO_VITE")
-
-                for config_key, config_values in config.items():
-                    if isinstance(config_values, DjangoViteConfig):
-                        cls._instance._configs[config_key] = config_values
-                    elif isinstance(config_values, dict):
-                        cls._instance._configs[config_key] = DjangoViteConfig(
-                            **config_values
-                        )
-                    else:
-                        raise RuntimeError(
-                            f"Cannot read configuration for key '{config_key}'"
-                        )
-            else:
-                # Warning : This branch will be remove in further
-                # releases. Please use new way of handling configuration.
-
-                _config_keys = {
-                    "DJANGO_VITE_DEV_MODE": "dev_mode",
-                    "DJANGO_VITE_DEV_SERVER_PROTOCOL": "dev_server_protocol",
-                    "DJANGO_VITE_DEV_SERVER_HOST": "dev_server_host",
-                    "DJANGO_VITE_DEV_SERVER_PORT": "dev_server_port",
-                    "DJANGO_VITE_WS_CLIENT_URL": "ws_client_url",
-                    "DJANGO_VITE_ASSETS_PATH": "assets_path",
-                    "DJANGO_VITE_STATIC_URL_PREFIX": "static_url_prefix",
-                    "DJANGO_VITE_MANIFEST_PATH": "manifest_path",
-                    "DJANGO_VITE_LEGACY_POLYFILLS_MOTIF": "legacy_polyfills_motif",
-                    "DJANGO_VITE_REACT_REFRESH_URL": "react_refresh_url",
-                }
-
-                config = {
-                    _config_keys[setting_key]: getattr(settings, setting_key)
-                    for setting_key in dir(settings)
-                    if setting_key in _config_keys.keys()
-                }
-
-                cls._instance._configs[DEFAULT_CONFIG_KEY] = DjangoViteConfig(**config)
-
-                # Manifest is only used in production.
-                if not cls._instance._configs[DEFAULT_CONFIG_KEY].dev_mode:
-                    cls._instance._parse_manifest(DEFAULT_CONFIG_KEY)
-
-        return cls._instance
-
-    def generate_vite_ws_client(
-        self, config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-    ) -> str:
-        """
-        Generates the script tag for the Vite WS client for HMR.
-        Only used in development, in production this method returns
-        an empty string.
-
-        Arguments:
-            config_key {str} -- Key of the configuration to use.
-
-        Returns:
-            str -- The script tag or an empty string.
-
-        Keyword Arguments:
-            **kwargs {Dict[str, str]} -- Adds new attributes to generated
-                script tags.
-        """
-
-        config = self._get_config(config_key)
-
-        if not config.dev_mode:
-            return ""
-
-        return self._generate_script_tag(
-            self._generate_vite_server_url(config.ws_client_url, config),
-            {"type": "module", **kwargs},
-        )
-
-    @staticmethod
-    def _generate_script_tag(src: str, attrs: Dict[str, str]) -> str:
-        """
-        Generates an HTML script tag.
-
-        Arguments:
-            src {str} -- Source of the script.
-
-        Keyword Arguments:
-            attrs {Dict[str, str]} -- List of custom attributes
-                for the tag.
-
-        Returns:
-            str -- The script tag.
-        """
-
-        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
-
-        return f'<script {attrs_str} src="{src}"></script>'
-
-    @staticmethod
-    def _generate_stylesheet_tag(href: str) -> str:
-        """
-        Generates an HTML <link> stylesheet tag for CSS.
-
-        Arguments:
-            href {str} -- CSS file URL.
-
-        Returns:
-            str -- CSS link tag.
-        """
-
-        return f'<link rel="stylesheet" href="{href}" />'
-
-    def _generate_stylesheet_preload_tag(href: str) -> str:
-        """
-        Generates an HTML <link> preload tag for CSS.
-
-        Arguments:
-            href {str} -- CSS file URL.
-
-        Returns:
-            str -- CSS link tag.
-        """
-
-        return f'<link rel="preload" href="{href}" as="style" />'
-
-    @staticmethod
-    def _generate_preload_tag(href: str, attrs: Dict[str, str]) -> str:
-        attrs_str = " ".join([f'{key}="{value}"' for key, value in attrs.items()])
-
-        return f'<link href="{href}" {attrs_str} />'
-
-    @staticmethod
-    def _generate_vite_server_url(
-        path: str,
-        config: Type[DjangoViteConfig],
-    ) -> str:
-        """
-        Generates an URL to and asset served by the Vite development server.
-
-        Keyword Arguments:
-            path {str} -- Path to the asset.
-            config {Type[DjangoViteConfig]} -- Config object to use.
-
-        Returns:
-            str -- Full URL to the asset.
-        """
-
-        return urljoin(
-            f"{config.dev_server_protocol}://"
-            f"{config.dev_server_host}:{config.dev_server_port}",
-            urljoin(config.static_url, path),
-        )
-
-    def generate_vite_react_refresh_url(
-        self, config_key: str = DEFAULT_CONFIG_KEY
-    ) -> str:
-        """
-        Generates the script for the Vite React Refresh for HMR.
-        Only used in development, in production this method returns
-        an empty string.
-
-        Returns:
-            str -- The script or an empty string.
-            config_key {str} -- Key of the configuration to use.
-        """
-        config = self._get_config(config_key)
-
-        if not config.dev_mode:
-            return ""
-
-        return f"""<script type="module">
-            import RefreshRuntime from \
-            '{self._generate_vite_server_url(config.react_refresh_url, config)}'
-            RefreshRuntime.injectIntoGlobalHook(window)
-            window.$RefreshReg$ = () => {{}}
-            window.$RefreshSig$ = () => (type) => type
-            window.__vite_plugin_react_preamble_installed__ = true
-        </script>"""
-
-    @staticmethod
-    def _generate_production_server_url(path: str, static_url_prefix="") -> str:
-        """
-        Generates an URL to an asset served during production.
-
-        Keyword Arguments:
-            path {str} -- Path to the asset.
-
-        Returns:
-            str -- Full URL to the asset.
-        """
-
-        production_server_url = path
-        if prefix := static_url_prefix:
-            if not static_url_prefix.endswith("/"):
-                prefix += "/"
-            production_server_url = urljoin(prefix, path)
-
-        if apps.is_installed("django.contrib.staticfiles"):
-            from django.contrib.staticfiles.storage import staticfiles_storage
-
-            return staticfiles_storage.url(production_server_url)
-
-        return production_server_url
-
-
 @register.simple_tag
 @mark_safe
-def vite_hmr_client(
-    config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-) -> str:
+def vite_hmr_client(app: str = DEFAULT_APP_NAME, **kwargs: Dict[str, str]) -> str:
     """
     Generates the script tag for the Vite WS client for HMR.
     Only used in development, in production this method returns
@@ -786,16 +28,14 @@ def vite_hmr_client(
             script tags.
     """
 
-    return DjangoViteAssetLoader.instance().generate_vite_ws_client(
-        config_key, **kwargs
-    )
+    return DjangoViteAssetLoader.instance().generate_vite_ws_client(app, **kwargs)
 
 
 @register.simple_tag
 @mark_safe
 def vite_asset(
     path: str,
-    config_key: str = DEFAULT_CONFIG_KEY,
+    app: str = DEFAULT_APP_NAME,
     **kwargs: Dict[str, str],
 ) -> str:
     """
@@ -823,18 +63,13 @@ def vite_asset(
         str -- The <script> tag and all <link> tags to import this
             asset in your page.
     """
-
     assert path is not None
-    assert config_key is not None
-
-    return DjangoViteAssetLoader.instance().generate_vite_asset(
-        path, config_key, **kwargs
-    )
+    return DjangoViteAssetLoader.instance().generate_vite_asset(path, app, **kwargs)
 
 
 @register.simple_tag
 @mark_safe
-def vite_preload_asset(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
+def vite_preload_asset(path: str, app: str = DEFAULT_APP_NAME) -> str:
     """
     Generates preloadmodule tag for this JS/TS asset and preloads
     all of its CSS and JS dependencies by reading the manifest
@@ -853,12 +88,11 @@ def vite_preload_asset(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
 
     """
     assert path is not None
-
-    return DjangoViteAssetLoader.instance().preload_vite_asset(path, config_key)
+    return DjangoViteAssetLoader.instance().preload_vite_asset(path, app)
 
 
 @register.simple_tag
-def vite_asset_url(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
+def vite_asset_url(path: str, app: str = DEFAULT_APP_NAME) -> str:
     """
     Generates only the URL of an asset managed by ViteJS.
     Warning, this function does not generate URLs for dependant assets.
@@ -875,14 +109,12 @@ def vite_asset_url(path: str, config_key: str = DEFAULT_CONFIG_KEY) -> str:
         str -- The URL of this asset.
     """
     assert path is not None
-    return DjangoViteAssetLoader.instance().generate_vite_asset_url(path, config_key)
+    return DjangoViteAssetLoader.instance().generate_vite_asset_url(path, app)
 
 
 @register.simple_tag
 @mark_safe
-def vite_legacy_polyfills(
-    config_key: str = DEFAULT_CONFIG_KEY, **kwargs: Dict[str, str]
-) -> str:
+def vite_legacy_polyfills(app: str = DEFAULT_APP_NAME, **kwargs: Dict[str, str]) -> str:
     """
     Generates a <script> tag to the polyfills generated
     by '@vitejs/plugin-legacy' if used.
@@ -890,7 +122,7 @@ def vite_legacy_polyfills(
     other legacy scripts.
 
     Arguments:
-        config_key {str} -- Configuration to use.
+        app {str} -- Configuration to use.
 
     Keyword Arguments:
         **kwargs {Dict[str, str]} -- Adds new attributes to generated
@@ -904,7 +136,7 @@ def vite_legacy_polyfills(
         str -- The script tag to the polyfills.
     """
     return DjangoViteAssetLoader.instance().generate_vite_legacy_polyfills(
-        config_key, **kwargs
+        app, **kwargs
     )
 
 
@@ -912,7 +144,7 @@ def vite_legacy_polyfills(
 @mark_safe
 def vite_legacy_asset(
     path: str,
-    config_key: str = DEFAULT_CONFIG_KEY,
+    app: str = DEFAULT_APP_NAME,
     **kwargs: Dict[str, str],
 ) -> str:
     """
@@ -923,7 +155,7 @@ def vite_legacy_asset(
     Arguments:
         path {str} -- Path to a Vite asset to include
             (must contains '-legacy' in its name).
-        config_key {str} -- Configuration to use.
+        app {str} -- Configuration to use.
 
     Keyword Arguments:
         **kwargs {Dict[str, str]} -- Adds new attributes to generated
@@ -940,13 +172,13 @@ def vite_legacy_asset(
     assert path is not None
 
     return DjangoViteAssetLoader.instance().generate_vite_legacy_asset(
-        path, config_key, **kwargs
+        path, app, **kwargs
     )
 
 
 @register.simple_tag
 @mark_safe
-def vite_react_refresh(config_key: str = DEFAULT_CONFIG_KEY) -> str:
+def vite_react_refresh(app: str = DEFAULT_APP_NAME) -> str:
     """
     Generates the script for the Vite React Refresh for HMR.
     Only used in development, in production this method returns
@@ -955,4 +187,4 @@ def vite_react_refresh(config_key: str = DEFAULT_CONFIG_KEY) -> str:
     Returns:
         str -- The script or an empty string.
     """
-    return DjangoViteAssetLoader.instance().generate_vite_react_refresh_url(config_key)
+    return DjangoViteAssetLoader.instance().generate_vite_react_refresh_url(app)
diff --git a/pyproject.toml b/pyproject.toml
index 02d02fa..3fc9f6c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,6 +8,7 @@ addopts = '''
   --cov-report term-missing
   --cov-branch
 '''
+filterwarnings = "ignore::DeprecationWarning:django_vite.*"
 
 [tool.black]
 line-length = 88
diff --git a/tests/conftest.py b/tests/conftest.py
index 2eedec1..ff92a35 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,26 +1,20 @@
 from typing import Dict, Any
 import pytest
-from importlib import reload
-from django.apps import apps
-from django_vite.templatetags import django_vite
+
+from django_vite.loader import DjangoViteAssetLoader
 
 
 def reload_django_vite():
-    reload(django_vite)
-    django_vite_app_config = apps.get_app_config("django_vite")
-    django_vite_app_config.ready()
+    DjangoViteAssetLoader._instance = None
+    DjangoViteAssetLoader.instance()
 
 
 @pytest.fixture()
 def patch_settings(settings):
     """
     1. Patch new settings into django.conf.settings.
-    2. Reload django_vite module so that variables on the module level that use settings
-    get recalculated.
+    2. Recreate DjangoViteAssetLoader._instance with new settings applied.
     3. Restore the original settings once the test is over.
-
-    TODO: refactor django_vite so that we don't set variables on the module level using
-    settings.
     """
     __PYTEST_EMPTY__ = "__PYTEST_EMPTY__"
     original_settings_cache = {}
diff --git a/tests/tests/test_asset_loader.py b/tests/tests/test_asset_loader.py
index 470867c..fe56a32 100644
--- a/tests/tests/test_asset_loader.py
+++ b/tests/tests/test_asset_loader.py
@@ -1,5 +1,7 @@
 import pytest
+from contextlib import suppress
 
+from django_vite.exceptions import DjangoViteManifestError
 from django_vite.templatetags.django_vite import DjangoViteAssetLoader
 from django_vite.apps import check_loader_instance
 
@@ -21,12 +23,13 @@ def test_check_loader_instance_happy(patch_settings):
 
 
 def test_check_loader_instance_warnings(patch_settings):
-    patch_settings(
-        {
-            "DJANGO_VITE_DEV_MODE": False,
-            "DJANGO_VITE_MANIFEST_PATH": "fake.json",
-        }
-    )
+    with suppress(DjangoViteManifestError):
+        patch_settings(
+            {
+                "DJANGO_VITE_DEV_MODE": False,
+                "DJANGO_VITE_MANIFEST_PATH": "fake.json",
+            }
+        )
     DjangoViteAssetLoader._instance = None
     warnings = check_loader_instance()
     assert len(warnings) == 1