vuetify-nuxt-module 1.0.0-beta.1 → 1.0.0-beta.10

package/README.md

@@ -51,8 +51,11 @@
 
 > Requires Vite, will not work with Webpack
 
+`vuetify` is a peer dependency (Vuetify 3 or 4) — install it alongside the module:
+
 ```bash
-npx nuxi@latest module add vuetify-nuxt-module
+npm install -D vuetify
+npx nuxt module add vuetify-nuxt-module
 ```
 
 [![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/userquin/vuetify-nuxt-module)

package/configuration.d.ts

@@ -36,6 +36,9 @@ declare module 'virtual:vuetify-ssr-client-hints-configuration' {
       defaultTheme: string
       themeNames: string[]
       cookieName: string
+      cookieDomain?: string
+      cookieSecure?: boolean
+      cookieSameSite: 'lax' | 'strict' | 'none'
       darkThemeName: string
       lightThemeName: string
       useBrowserThemeOnly: boolean

package/dist/module.d.mts

@@ -26,8 +26,13 @@ interface DateOptions {
     adapter?: DateAdapter;
     /**
      * Formats.
+     *
+     * Only serializable `Intl.DateTimeFormatOptions` values are supported here:
+     * the date configuration is statically serialized to a virtual module, so
+     * function-valued formats cannot be expressed (see #313, #331). Use a custom
+     * date adapter if you need function formats.
      */
-    formats?: Record<string, string>;
+    formats?: Record<string, Intl.DateTimeFormatOptions>;
     /**
      * Locales.
      *
@@ -251,6 +256,18 @@ interface MOptions {
          * Path to the custom Vuetify SASS configuration file.
          */
         configFile: string;
+        /**
+         * Caching options forwarded to `@vuetify/unplugin-styles`.
+         *
+         * @default true
+         */
+        cache?: boolean | {
+            path?: string;
+            sassOptions?: Record<string, unknown>;
+        };
+        /**
+         * @deprecated Use `styles.cache` instead.
+         */
         experimental?: {
             cache?: boolean;
         };
@@ -350,9 +367,43 @@ interface MOptions {
             /**
              * The name for the cookie.
              *
+             * @deprecated Use `cookie.name` instead.
              * @default 'color-scheme'
              */
             cookieName?: string;
+            /**
+             * Cookie attributes for the color scheme cookie.
+             */
+            cookie?: {
+                /**
+                 * The name for the cookie.
+                 *
+                 * @default 'color-scheme'
+                 */
+                name?: string;
+                /**
+                 * The domain for the color scheme cookie.
+                 *
+                 * Useful to share the cookie across subdomains, e.g. `.example.com`.
+                 *
+                 * @default undefined
+                 */
+                domain?: string;
+                /**
+                 * Mark the cookie as `Secure`.
+                 *
+                 * Forced to `true` when `sameSite` is `'none'`.
+                 *
+                 * @default undefined
+                 */
+                secure?: boolean;
+                /**
+                 * The `SameSite` attribute for the cookie.
+                 *
+                 * @default 'lax'
+                 */
+                sameSite?: 'lax' | 'strict' | 'none';
+            };
             /**
              * The name for the dark theme.
              *
@@ -447,6 +498,9 @@ interface SSRClientHintsConfiguration {
         defaultTheme: string;
         themeNames: string[];
         cookieName: string;
+        cookieDomain?: string;
+        cookieSecure?: boolean;
+        cookieSameSite: 'lax' | 'strict' | 'none';
         darkThemeName: string;
         lightThemeName: string;
     };

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.15.0"
   },
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.10",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,24 +1,20 @@
-import { addPluginTemplate, addTemplate, resolvePath, extendWebpackConfig, isNuxtMajorVersion, addImports, addPlugin, addVitePlugin, useLogger, defineNuxtModule, getNuxtVersion, hasNuxtModule, createResolver } from '@nuxt/kit';
-import { isPackageExists, getPackageInfo } from 'local-pkg';
+import { existsSync, statSync, readFileSync } from 'node:fs';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { addPluginTemplate, resolvePath, addTemplate, extendWebpackConfig, isNuxtMajorVersion, addImports, addPlugin, addVitePlugin, useLogger, defineNuxtModule, getNuxtVersion, findPath, hasNuxtModule, createResolver } from '@nuxt/kit';
+import { isAbsolute, resolve, dirname, relative } from 'pathe';
 import semver from 'semver';
 import { createFilter, version as version$1 } from 'vite';
-import fs, { existsSync, statSync, readFileSync, readdirSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { isAbsolute, resolve, relative } from 'pathe';
 import defu from 'defu';
-import { transformAssetUrls } from 'vite-plugin-vuetify';
-import { pathToFileURL } from 'node:url';
-import { generateImports, resolveVuetifyBase, isObject, normalizePath } from '@vuetify/loader-shared';
-import destr from 'destr';
+import { transformAssetUrls, generateImports } from '@vuetify/loader-shared';
+import Styles from '@vuetify/unplugin-styles/vite';
+import { isPackageExists } from 'local-pkg';
 import { parseQuery, parseURL } from 'ufo';
-import fsp, { readFile } from 'node:fs/promises';
-import path from 'upath';
-import { resolve as resolve$1, dirname, join, relative as relative$1 } from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { debounce } from 'perfect-debounce';
 import process from 'node:process';
 import { createConfigLoader } from 'unconfig';
-import { createHash } from 'node:crypto';
 
-const version = "1.0.0-beta.1";
+const version = "1.0.0-beta.10";
 
 const VIRTUAL_VUETIFY_CONFIGURATION = "virtual:vuetify-configuration";
 const RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION = `\0${VIRTUAL_VUETIFY_CONFIGURATION}`;
@@ -128,6 +124,18 @@ function normalizeTransformAssetUrlsAttrs(attrs) {
   return [...result];
 }
 
+function resolveVuetifyConfigFile(configFile, nuxt) {
+  if (typeof configFile === "string" && !isAbsolute(configFile)) {
+    for (const layer of nuxt.options._layers) {
+      const resolved = resolve(layer.config.srcDir, configFile);
+      if (existsSync(resolved)) {
+        return resolved;
+      }
+    }
+  }
+  return configFile;
+}
+
 function addVuetifyNuxtPlugins(nuxt, ctx) {
   addVuetifyNuxtPlugin(nuxt, ctx, "client");
   addVuetifyNuxtPlugin(nuxt, ctx, "server");
@@ -198,17 +206,6 @@ export default defineNuxtPlugin({
 function getTemplate(source, settings) {
   return [settings ? `@use '${settings}';` : "", `@use '${source}';`].filter(Boolean).join("\n");
 }
-function resolveVuetifyConfigFile(configFile, nuxt) {
-  if (typeof configFile === "string" && !isAbsolute(configFile)) {
-    for (const layer of nuxt.options._layers) {
-      const resolved = resolve(layer.config.rootDir, configFile);
-      if (existsSync(resolved)) {
-        return resolved;
-      }
-    }
-  }
-  return configFile;
-}
 async function configureNuxt(configKey, nuxt, ctx) {
   const {
     styles,
@@ -223,9 +220,14 @@ async function configureNuxt(configKey, nuxt, ctx) {
     nuxt.options.css ??= [];
     if (typeof styles === "object" && "configFile" in styles) {
       const configFile = resolveVuetifyConfigFile(styles.configFile, nuxt);
+      ctx.stylesConfigFile = await resolvePath(configFile);
       const a = addTemplate({
-        filename: "vuetify.settings.scss",
-        getContents: async () => getTemplate("vuetify/styles", await resolvePath(configFile))
+        // Write to disk: without `write` Nuxt serves the template from its
+        // virtual FS, which 404s on Windows/SSR when the browser requests the
+        // real file (#363). Nest under `vuetify/` to match unplugin-styles.
+        write: true,
+        filename: "vuetify/vuetify.settings.scss",
+        getContents: async () => getTemplate("vuetify/styles", ctx.stylesConfigFile)
       });
       nuxt.options.css.push(a.dst);
     } else if (ctx.vuetifyGte("4.0.0")) {
@@ -592,6 +594,70 @@ ${useLocales.map((locale) => {
   };
 }
 
+const VUETIFY_TO_DATE_FNS = {
+  en: "enUS",
+  fa: "faIR",
+  no: "nb",
+  srCyrl: "sr",
+  zhHans: "zhCN",
+  zhHant: "zhTW"
+};
+const DATE_FNS_SUPPORTED = /* @__PURE__ */ new Set([
+  "af",
+  "ar",
+  "az",
+  "bg",
+  "ca",
+  "ckb",
+  "cs",
+  "da",
+  "de",
+  "el",
+  "enUS",
+  "es",
+  "et",
+  "faIR",
+  "fi",
+  "fr",
+  "he",
+  "hr",
+  "hu",
+  "id",
+  "it",
+  "ja",
+  "km",
+  "ko",
+  "lt",
+  "lv",
+  "nb",
+  "nl",
+  "pl",
+  "pt",
+  "ro",
+  "ru",
+  "sk",
+  "sl",
+  "sr",
+  "srLatn",
+  "sv",
+  "th",
+  "tr",
+  "uk",
+  "vi",
+  "zhCN",
+  "zhTW"
+]);
+function resolveDateFnsLocaleName(code) {
+  if (!code) {
+    return { name: "enUS", fallback: true };
+  }
+  const candidate = VUETIFY_TO_DATE_FNS[code] ?? code;
+  if (DATE_FNS_SUPPORTED.has(candidate)) {
+    return { name: candidate, fallback: false };
+  }
+  return { name: "enUS", fallback: true };
+}
+
 function vuetifyDateConfigurationPlugin(ctx) {
   return {
     name: "vuetify:date-configuration:nuxt",
@@ -615,34 +681,41 @@ export function dateConfiguration() {
 `;
         }
         const { adapter: _adapter, ...newDateOptions } = ctx.vuetifyOptions.date ?? {};
-        return `${buildImports()}
+        let dateFnsLocale;
+        if (ctx.dateAdapter === "date-fns") {
+          const resolved = resolveDateFnsLocaleName(ctx.vuetifyOptions.locale?.locale);
+          dateFnsLocale = resolved.name;
+          if (resolved.fallback) {
+            ctx.logger.warn(`[vuetify-nuxt-module] date-fns locale for "${ctx.vuetifyOptions.locale?.locale ?? "(unset)"}" not found, falling back to "enUS". Set "vuetifyOptions.locale.locale" to a supported locale.`);
+          }
+        }
+        return `${buildImports(dateFnsLocale)}
 export const enabled = true
 export const isDev = ${ctx.isDev}
 export const i18n = ${ctx.i18n}
 export const adapter = '${ctx.dateAdapter}'
 export function dateConfiguration() {
   const options = JSON.parse('${JSON.stringify(newDateOptions)}')
-  ${buildAdapter()}
+  ${buildAdapter(dateFnsLocale)}
   return options
 }
 `;
       }
     }
   };
-  function buildAdapter() {
+  function buildAdapter(dateFnsLocale) {
     if (ctx.dateAdapter === "custom" || ctx.dateAdapter === "vuetify" && ctx.vuetifyGte("3.4.0")) {
       return "";
     }
     if (ctx.dateAdapter === "vuetify") {
       return "options.adapter = VuetifyDateAdapter";
     }
-    const locale = ctx.vuetifyOptions.locale?.locale ?? "en";
     if (ctx.dateAdapter === "date-fns") {
-      return `options.adapter = new Adapter({ locale: ${locale} })`;
+      return `options.adapter = new Adapter({ locale: ${dateFnsLocale} })`;
     }
     return "options.adapter = Adapter";
   }
-  function buildImports() {
+  function buildImports(dateFnsLocale) {
     if (ctx.dateAdapter === "custom" || ctx.dateAdapter === "vuetify" && ctx.vuetifyGte("3.4.0")) {
       return "";
     }
@@ -651,7 +724,7 @@ export function dateConfiguration() {
     }
     const imports = [`import Adapter from '@date-io/${ctx.dateAdapter}'`];
     if (ctx.dateAdapter === "date-fns") {
-      imports.push(`import { ${ctx.vuetifyOptions.locale?.locale ?? "en"} } from 'date-fns/locale'`);
+      imports.push(`import { ${dateFnsLocale} } from 'date-fns/locale'`);
     }
     return imports.join("\n");
   }
@@ -837,10 +910,24 @@ function parseId2(id) {
   id = id.replace(/^(virtual:nuxt:|virtual:)/, "");
   return parseURL(decodeURIComponent(isAbsolute(id) ? pathToFileURL(id).href : id));
 }
+function reviver(key, value) {
+  if (key === "__proto__" || key === "constructor") {
+    return void 0;
+  }
+  return value;
+}
+function parseProps(value) {
+  try {
+    const parsed = JSON.parse(value, reviver);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function parseId(id) {
   const { search, pathname } = parseId2(id);
   const query = parseQuery(search);
-  const urlProps = query.props ? destr(query.props) : void 0;
+  const urlProps = query.props ? parseProps(query.props) : void 0;
   return {
     query: urlProps,
     path: pathname ?? id
@@ -901,122 +988,7 @@ function vuetifySSRClientHintsPlugin(ctx) {
   };
 }
 
-function vuetifyStylesPlugin(ctx) {
-  let configFile;
-  const options = { styles: ctx.moduleOptions.styles };
-  const vuetifyBase = resolveVuetifyBase();
-  const noneFiles = /* @__PURE__ */ new Set();
-  let isNone = false;
-  let sassVariables = false;
-  let fileImport = false;
-  const PREFIX = "vuetify-styles/";
-  const SSR_PREFIX = `/@${PREFIX}`;
-  const resolveCss = resolveCssFactory();
-  const toPath = (file) => fileImport ? pathToFileURL(file).href : normalizePath(file);
-  return {
-    name: "vuetify:styles:nuxt",
-    enforce: "pre",
-    async configResolved(config) {
-      if (config.plugins.some((plugin) => plugin.name === "vuetify:styles")) {
-        throw new Error("Remove vite-plugin-vuetify from your Nuxt config file, this module registers a modified version.");
-      }
-      if (isObject(options.styles) && "configFile" in options.styles) {
-        sassVariables = true;
-        fileImport = semver.gt(ctx.viteVersion, "5.4.2");
-        configFile = await resolvePath(options.styles.configFile);
-      } else {
-        isNone = options.styles === "none";
-      }
-    },
-    async resolveId(source, importer, { custom, ssr }) {
-      if (!sassVariables) {
-        return;
-      }
-      if (source.startsWith(PREFIX) || source.startsWith(SSR_PREFIX)) {
-        if (/\.s[ca]ss$/.test(source)) {
-          return source;
-        }
-        const idx = source.indexOf("?");
-        return idx === -1 ? source : source.slice(0, idx);
-      }
-      if (importer && source.endsWith(".css") && isSubdir(vuetifyBase, path.isAbsolute(source) ? source : importer)) {
-        let resolutionId;
-        if (source.startsWith(".")) {
-          resolutionId = path.resolve(path.dirname(importer), source);
-        } else if (path.isAbsolute(source)) {
-          resolutionId = source;
-        } else {
-          const resolution = await this.resolve(source, importer, { skipSelf: true, custom });
-          if (resolution) {
-            resolutionId = resolution.id;
-          }
-        }
-        if (!resolutionId) {
-          return;
-        }
-        const target = await resolveCss(resolutionId);
-        if (isNone) {
-          noneFiles.add(target);
-          return target;
-        }
-        if (ctx.stylesCachePath) {
-          const relative = path.relative(vuetifyBase, target);
-          const cacheFile = path.resolve(ctx.stylesCachePath, relative.replace(/\.s[ac]ss$/, ".css"));
-          if (fs.existsSync(cacheFile)) {
-            return cacheFile;
-          }
-        }
-        return `${ssr ? SSR_PREFIX : PREFIX}${path.relative(vuetifyBase, target)}`;
-      }
-      return void 0;
-    },
-    load(id) {
-      if (sassVariables) {
-        const target = id.startsWith(PREFIX) ? path.resolve(vuetifyBase, id.slice(PREFIX.length)) : id.startsWith(SSR_PREFIX) ? path.resolve(vuetifyBase, id.slice(SSR_PREFIX.length)) : void 0;
-        if (target) {
-          const suffix = /\.scss/.test(target) ? ";\n" : "\n";
-          return {
-            code: `@use "${toPath(configFile)}"${suffix}@use "${toPath(target)}"${suffix}`,
-            map: {
-              mappings: ""
-            }
-          };
-        }
-      }
-      return isNone && noneFiles.has(id) ? "" : void 0;
-    }
-  };
-}
-function resolveCssFactory() {
-  const mappings = /* @__PURE__ */ new Map();
-  return async (source) => {
-    let mapping = mappings.get(source);
-    if (!mapping) {
-      try {
-        mapping = source.replace(/\.css$/, ".sass");
-        await fsp.access(mapping, fs.constants.R_OK);
-      } catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
-          throw error;
-        }
-        try {
-          mapping = source.replace(/\.css$/, ".scss");
-          await fsp.access(mapping, fs.constants.R_OK);
-        } catch {
-          mapping = source;
-        }
-      }
-      mappings.set(source, mapping);
-    }
-    return mapping;
-  };
-}
-function isSubdir(root, test) {
-  const relative$1 = relative(root, test);
-  return relative$1 && !relative$1.startsWith("..") && !isAbsolute(relative$1);
-}
-
-function detectDate() {
+function detectDate(paths) {
   const result = [];
   for (const adapter of [
     "date-fns",
@@ -1028,12 +1000,15 @@ function detectDate() {
     "jalaali",
     "hijri"
   ]) {
-    if (isPackageExists(`@date-io/${adapter}`)) {
+    if (isPackageExists(`@date-io/${adapter}`, { paths })) {
       result.push(adapter);
     }
   }
   return result;
 }
+function multipleDateAdaptersError(adapters) {
+  return `Multiple date adapters found: ${adapters.map((adapter) => `@date-io/${adapter}`).join(", ")}, please specify the adapter to use in the "vuetifyOptions.date.adapter" option.`;
+}
 function cleanupBlueprint(vuetifyOptions) {
   const blueprint = vuetifyOptions.blueprint;
   if (blueprint) {
@@ -1056,12 +1031,10 @@ function checkVuetifyPlugins(config) {
     throw new Error("Remove vite-plugin-vuetify plugin from Vite Plugins entry in Nuxt config file!");
   }
 }
-function resolveVuetifyComponents(resolver) {
-  const vuetifyBase = resolveVuetifyBase();
+function resolveVuetifyComponents(resolver, vuetifyBase) {
   const componentsPromise = importMapResolver();
   const labComponentsPromise = importMapLabResolver();
   return {
-    vuetifyBase,
     componentsPromise,
     labComponentsPromise
   };
@@ -1073,6 +1046,9 @@ function resolveVuetifyComponents(resolver) {
   }
 }
 
+function resolveStylesCache(stylesOption) {
+  return stylesOption.cache ?? stylesOption.experimental?.cache;
+}
 function configureVite(configKey, nuxt, ctx) {
   nuxt.hook("vite:extend", ({ config }) => checkVuetifyPlugins(config));
   nuxt.hook("vite:extendConfig", (viteInlineConfig) => {
@@ -1081,7 +1057,7 @@ function configureVite(configKey, nuxt, ctx) {
     if (!ctx.moduleOptions.disableModernSassCompiler) {
       const enableModernSassCompiler = semver.gte(ctx.viteVersion, "5.4.0") && semver.lt(ctx.viteVersion, "7.0.0-0");
       if (enableModernSassCompiler) {
-        const sassEmbedded = isPackageExists("sass-embedded");
+        const sassEmbedded = isPackageExists("sass-embedded", { paths: ctx.resolvePaths });
         if (sassEmbedded) {
           viteInlineConfig.css ??= {};
           viteInlineConfig.css.preprocessorOptions ??= {};
@@ -1125,8 +1101,18 @@ function configureVite(configKey, nuxt, ctx) {
       autoImport.ignore = Array.isArray(ignoreDirectives) ? ignoreDirectives : [ignoreDirectives];
     }
     viteInlineConfig.plugins.push(vuetifyImportPlugin({ autoImport }));
-    if (ctx.moduleOptions.styles !== false && ctx.moduleOptions.styles !== "none") {
-      viteInlineConfig.plugins.push(vuetifyStylesPlugin(ctx));
+    const stylesOption = ctx.moduleOptions.styles;
+    if (stylesOption === "none") {
+      viteInlineConfig.plugins.push(Styles({ styles: "none" }));
+    } else if (typeof stylesOption === "object" && stylesOption !== null && "configFile" in stylesOption) {
+      if (!ctx.stylesConfigFile) {
+        throw new Error("vuetify-nuxt-module: styles.configFile could not be resolved");
+      }
+      const cache = resolveStylesCache(stylesOption);
+      viteInlineConfig.plugins.push(Styles({
+        settings: ctx.stylesConfigFile,
+        ...cache === void 0 ? {} : { cache }
+      }));
     }
     viteInlineConfig.plugins.push(vuetifyConfigurationPlugin(ctx), vuetifyIconsPlugin(ctx), vuetifyDateConfigurationPlugin(ctx));
     if (ctx.ssrClientHints.enabled) {
@@ -1165,7 +1151,8 @@ const disabledResolvedIcons = Object.freeze({
   local: [],
   svg: {}
 });
-function prepareIcons(unocssPresent, logger, vuetifyOptions) {
+function prepareIcons(unocssPresent, logger, vuetifyOptions, paths) {
+  const iconPackageExists = (name) => isPackageExists(name, { paths });
   if (vuetifyOptions.icons === false) {
     return disabledResolvedIcons;
   }
@@ -1209,7 +1196,7 @@ function prepareIcons(unocssPresent, logger, vuetifyOptions) {
       }
       resolvedIcons.imports.push(`import {${name === defaultSet ? "aliases," : ""}${name}} from 'vuetify/iconsets/${name}'`);
       resolvedIcons.sets.push(name);
-      if (isPackageExists(iconsPackageNames[name].name)) {
+      if (iconPackageExists(iconsPackageNames[name].name)) {
         resolvedIcons.local.push(iconsPackageNames[name].css);
       } else {
         resolvedIcons.cdn.push([name, cdn ?? iconsCDN[name]]);
@@ -1228,18 +1215,18 @@ function prepareIcons(unocssPresent, logger, vuetifyOptions) {
     if (!faSvg) {
       faSvg = {};
     }
-    let faSvgExists = isPackageExists("@fortawesome/fontawesome-svg-core");
+    let faSvgExists = iconPackageExists("@fortawesome/fontawesome-svg-core");
     if (!faSvgExists) {
       logger.warn("Missing @fortawesome/fontawesome-svg-core dependency, install it!");
     }
-    faSvgExists = isPackageExists("@fortawesome/vue-fontawesome");
+    faSvgExists = iconPackageExists("@fortawesome/vue-fontawesome");
     if (faSvgExists) {
       if (!faSvg.libraries?.length) {
         faSvg.libraries = [[false, "fas", "@fortawesome/free-solid-svg-icons"]];
       }
       for (const p in faSvg.libraries) {
         const [_defaultExport, _name, library] = faSvg.libraries[p];
-        if (!isPackageExists(library)) {
+        if (!iconPackageExists(library)) {
           faSvgExists = false;
           logger.warn(`Missing library ${library} dependency, install it!`);
         }
@@ -1266,7 +1253,7 @@ function prepareIcons(unocssPresent, logger, vuetifyOptions) {
     if (!mdiSvg) {
       mdiSvg = {};
     }
-    const mdiSvgExists = isPackageExists("@mdi/js");
+    const mdiSvgExists = iconPackageExists("@mdi/js");
     if (mdiSvgExists) {
       resolvedIcons.svg.mdi = true;
       resolvedIcons.aliasesImportPresent ||= defaultSet === "mdi-svg";
@@ -1314,7 +1301,7 @@ async function loadVuetifyConfiguration(cwd = process.cwd(), configOrPath = cwd,
     inlineConfig = configOrPath;
     configOrPath = process.cwd();
   }
-  const resolved = resolve$1(cwd, configOrPath);
+  const resolved = resolve(cwd, configOrPath);
   let isFile = false;
   if (existsSync(resolved) && statSync(resolved).isFile()) {
     isFile = true;
@@ -1362,6 +1349,29 @@ async function loadVuetifyConfiguration(cwd = process.cwd(), configOrPath = cwd,
   return result;
 }
 
+const MODULE_DEFAULTS = {
+  moduleOptions: {
+    importComposables: true,
+    includeTransformAssetsUrls: true,
+    styles: true,
+    rulesConfiguration: {
+      fromLabs: true
+    }
+  },
+  vuetifyOptions: {
+    labComponents: false,
+    directives: false
+  }
+};
+function finalizeConfiguration(moduleOptions) {
+  if (moduleOptions.length > 1) {
+    const [app, ...rest] = moduleOptions;
+    const configuration = defu(app, ...rest, MODULE_DEFAULTS);
+    dedupeIcons(configuration, moduleOptions.toReversed());
+    return configuration;
+  }
+  return defu(moduleOptions[0] ?? {}, MODULE_DEFAULTS);
+}
 async function mergeVuetifyModules(options, nuxt) {
   const moduleOptions = [];
   const vuetifyConfigurationFilesToWatch = /* @__PURE__ */ new Set();
@@ -1403,23 +1413,10 @@ async function mergeVuetifyModules(options, nuxt) {
     moduleOptions: options.moduleOptions,
     vuetifyOptions: resolvedOptions.config
   });
-  if (moduleOptions.length > 1) {
-    const [app, ...rest] = moduleOptions;
-    const configuration = defu(app, ...rest);
-    dedupeIcons(configuration, moduleOptions.toReversed());
-    return {
-      configuration,
-      vuetifyConfigurationFilesToWatch
-    };
-  } else {
-    return {
-      configuration: {
-        moduleOptions: options.moduleOptions,
-        vuetifyOptions: resolvedOptions.config
-      },
-      vuetifyConfigurationFilesToWatch
-    };
-  }
+  return {
+    configuration: finalizeConfiguration(moduleOptions),
+    vuetifyConfigurationFilesToWatch
+  };
 }
 function dedupeIcons(configuration, moduleOptions) {
   const vuetifyOptions = configuration.vuetifyOptions;
@@ -1452,6 +1449,28 @@ const disabledClientHints = Object.freeze({
   prefersColorScheme: false,
   prefersReducedMotion: false
 });
+function resolveColorSchemeCookie(options, logger) {
+  if (options.cookieName !== void 0) {
+    logger.warn("[vuetify-nuxt-module] `prefersColorSchemeOptions.cookieName` is deprecated, use `prefersColorSchemeOptions.cookie.name` instead.");
+  }
+  const cookieSameSite = options.cookie?.sameSite ?? "lax";
+  return {
+    cookieName: options.cookie?.name ?? options.cookieName ?? "color-scheme",
+    cookieDomain: options.cookie?.domain,
+    cookieSecure: cookieSameSite === "none" ? true : options.cookie?.secure,
+    cookieSameSite
+  };
+}
+function resolveDefaultTheme(defaultTheme, themes, lightThemeName, logger) {
+  if (defaultTheme === "system") {
+    logger.warn(`Vuetify "system" theme cannot be resolved during SSR; using "${lightThemeName}" as the server-side fallback. The browser preference is applied on the client via prefersColorScheme client hints. To avoid a flash of the wrong theme, set explicit dark/light themes and enable moduleOptions.ssrClientHints.prefersColorSchemeOptions.useBrowserThemeOnly.`);
+    return lightThemeName;
+  }
+  if (!themes[defaultTheme]) {
+    throw new Error(`Missing default theme ${defaultTheme} in the Vuetify themes!`);
+  }
+  return defaultTheme;
+}
 function prepareSSRClientHints(baseUrl, ctx) {
   if (!ctx.isSSR || ctx.isNuxtGenerate) {
     return disabledClientHints;
@@ -1478,9 +1497,6 @@ function prepareSSRClientHints(baseUrl, ctx) {
     if (!defaultTheme) {
       throw new Error("Vuetify default theme is missing in theme!");
     }
-    if (!themes[defaultTheme]) {
-      throw new Error(`Missing default theme ${defaultTheme} in the Vuetify themes!`);
-    }
     const darkThemeName = ssrClientHintsConfiguration.prefersColorSchemeOptions?.darkThemeName ?? "dark";
     if (!themes[darkThemeName]) {
       throw new Error(`Missing theme ${darkThemeName} in the Vuetify themes!`);
@@ -1492,137 +1508,21 @@ function prepareSSRClientHints(baseUrl, ctx) {
     if (darkThemeName === lightThemeName) {
       throw new Error("Vuetify dark theme and light theme are the same, change darkThemeName or lightThemeName!");
     }
+    const pcsOptions = ssrClientHintsConfiguration.prefersColorSchemeOptions;
+    const effectiveDefaultTheme = resolveDefaultTheme(defaultTheme, themes, lightThemeName, ctx.logger);
     clientHints.prefersColorSchemeOptions = {
       baseUrl,
-      defaultTheme,
+      defaultTheme: effectiveDefaultTheme,
       themeNames: Array.from(Object.keys(themes)),
-      cookieName: ssrClientHintsConfiguration.prefersColorSchemeOptions?.cookieName ?? "color-scheme",
+      ...resolveColorSchemeCookie(pcsOptions, ctx.logger),
       darkThemeName,
       lightThemeName,
-      useBrowserThemeOnly: ssrClientHintsConfiguration.prefersColorSchemeOptions?.useBrowserThemeOnly ?? false
+      useBrowserThemeOnly: pcsOptions?.useBrowserThemeOnly ?? false
     };
   }
   return clientHints;
 }
 
-async function prepareVuetifyStyles(nuxt, ctx) {
-  const stylesConfig = ctx.moduleOptions.styles;
-  if (!isObject(stylesConfig) || !("configFile" in stylesConfig)) {
-    return;
-  }
-  if (stylesConfig.experimental?.cache === false) {
-    return;
-  }
-  const vuetifyBase = resolveVuetifyBase();
-  let configFile;
-  let configContent = "";
-  if (stylesConfig.configFile) {
-    configFile = await resolvePath(stylesConfig.configFile);
-    if (existsSync(configFile)) {
-      configContent = readFileSync(configFile, "utf8");
-      if (!ctx.vuetifyFilesToWatch.includes(configFile)) {
-        ctx.vuetifyFilesToWatch.push(configFile);
-      }
-    }
-  }
-  if (!configFile) {
-    return;
-  }
-  const hash = createHash("sha256").update(ctx.vuetifyVersion).update(ctx.viteVersion).update(configContent).update(configFile).digest("hex").slice(0, 8);
-  const stylesDir = resolve$1(nuxt.options.rootDir, "node_modules/.cache/vuetify-nuxt-module/styles");
-  const cacheDir = join(stylesDir, hash);
-  ctx.stylesCachePath = cacheDir;
-  if (existsSync(stylesDir)) {
-    const dirents = readdirSync(stylesDir, { withFileTypes: true });
-    for (const dirent of dirents) {
-      if (dirent.isDirectory() && dirent.name !== hash) {
-        rmSync(join(stylesDir, dirent.name), { recursive: true, force: true });
-      }
-    }
-  }
-  if (existsSync(cacheDir)) {
-    return;
-  }
-  ctx.logger.info("Compiling Vuetify styles...");
-  let sass;
-  try {
-    sass = await import('sass');
-  } catch {
-    try {
-      sass = await import('sass-embedded');
-    } catch {
-      ctx.logger.warn('Could not load "sass" or "sass-embedded". Skipping styles pre-compilation.');
-      return;
-    }
-  }
-  const files = [];
-  findCssFiles(join(vuetifyBase, "lib/components"), files);
-  findCssFiles(join(vuetifyBase, "lib/styles"), files);
-  for (const file of files) {
-    const relativePath = relative$1(vuetifyBase, file);
-    const cacheFile = join(cacheDir, relativePath);
-    const sassFile = file.replace(/\.css$/, ".sass");
-    const scssFile = file.replace(/\.css$/, ".scss");
-    let targetFile;
-    if (existsSync(sassFile)) {
-      targetFile = sassFile;
-    } else if (existsSync(scssFile)) {
-      targetFile = scssFile;
-    }
-    if (targetFile) {
-      const dir = dirname(cacheFile);
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-      const content = `@use "${normalizePath(configFile)}";
-@use "${normalizePath(targetFile)}";
-`;
-      try {
-        const result = sass.compileString(content, {
-          loadPaths: [
-            dirname(configFile),
-            dirname(targetFile),
-            resolve$1(vuetifyBase, ".."),
-            resolve$1(vuetifyBase, "../.."),
-            // In case of monorepo/hoisting issues, but standard is enough
-            vuetifyBase
-          ],
-          url: new URL(pathToFileURL(cacheFile).href)
-        });
-        writeFileSync(cacheFile, result.css, "utf8");
-      } catch (error) {
-        ctx.logger.error(`Failed to compile ${targetFile}:`, error);
-      }
-    }
-  }
-  const metadata = {
-    hash,
-    vuetifyVersion: ctx.vuetifyVersion,
-    viteVersion: ctx.viteVersion,
-    configFile,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeFileSync(join(cacheDir, "metadata.json"), JSON.stringify(metadata, null, 2), "utf8");
-}
-function findCssFiles(dir, fileList = []) {
-  if (!existsSync(dir)) {
-    return fileList;
-  }
-  const files = readdirSync(dir);
-  for (const file of files) {
-    const filePath = join(dir, file);
-    const stat = statSync(filePath);
-    if (stat.isDirectory()) {
-      findCssFiles(filePath, fileList);
-    } else {
-      if (file.endsWith(".css")) {
-        fileList.push(filePath);
-      }
-    }
-  }
-  return fileList;
-}
-
 async function load(options, nuxt, ctx) {
   const {
     configuration,
@@ -1632,7 +1532,7 @@ async function load(options, nuxt, ctx) {
     const {
       componentsPromise,
       labComponentsPromise
-    } = resolveVuetifyComponents(ctx.resolver);
+    } = resolveVuetifyComponents(ctx.resolver, ctx.vuetifyBase);
     ctx.componentsPromise = componentsPromise;
     ctx.labComponentsPromise = labComponentsPromise;
   }
@@ -1648,9 +1548,9 @@ async function load(options, nuxt, ctx) {
   const dateOptions = vuetifyOptions.date;
   if (dateOptions) {
     const adapter = dateOptions.adapter;
-    const date = detectDate();
+    const date = detectDate(ctx.resolvePaths);
     if (!adapter && date.length > 1) {
-      throw new Error(`Multiple date adapters found: ${date.map((d) => `@date-io/${d[0]}`).join(", ")}, please specify the adapter to use in the "vuetifyOptions.date.adapter" option.`);
+      throw new Error(multipleDateAdaptersError(date));
     }
     if (adapter) {
       if (adapter === "vuetify" || adapter === "custom") {
@@ -1677,8 +1577,11 @@ async function load(options, nuxt, ctx) {
   ctx.enableRules = ctx.moduleOptions.enableRules;
   ctx.rulesConfiguration = ctx.moduleOptions.rulesConfiguration;
   ctx.vuetifyFilesToWatch = Array.from(vuetifyConfigurationFilesToWatch);
-  ctx.icons = prepareIcons(ctx.unocss, ctx.logger, vuetifyAppOptions);
+  ctx.icons = prepareIcons(ctx.unocss, ctx.logger, vuetifyAppOptions, ctx.resolvePaths);
   ctx.ssrClientHints = prepareSSRClientHints(nuxt.options.app.baseURL ?? "/", ctx);
+  if (ctx.isSSR && !ctx.ssrClientHints.prefersColorScheme && ctx.vuetifyOptions.theme && typeof ctx.vuetifyOptions.theme === "object" && ctx.vuetifyOptions.theme.defaultTheme === "system") {
+    ctx.logger.warn('`theme.defaultTheme: "system"` cannot be resolved during SSR/SSG: the server has no access to the OS color-scheme preference, so the first paint defaults to light and may flash on dark systems. Set explicit dark/light themes and enable `moduleOptions.ssrClientHints.prefersColorScheme` (optionally `prefersColorSchemeOptions.useBrowserThemeOnly`). See the SSR guide.');
+  }
   if (ctx.icons.enabled) {
     if (ctx.icons.local) {
       for (const css of ctx.icons.local) {
@@ -1698,13 +1601,12 @@ async function load(options, nuxt, ctx) {
       }
     }
   }
-  await prepareVuetifyStyles(nuxt, ctx);
 }
 function registerWatcher(options, nuxt, ctx) {
   if (nuxt.options.dev) {
     let pageReload;
     nuxt.hooks.hook("builder:watch", (_event, path) => {
-      path = relative$1(nuxt.options.srcDir, resolve$1(nuxt.options.srcDir, path));
+      path = relative(nuxt.options.srcDir, resolve(nuxt.options.srcDir, path));
       if (!pageReload && ctx.vuetifyFilesToWatch.includes(path)) {
         return nuxt.callHook("restart");
       }
@@ -1750,24 +1652,6 @@ const module$1 = defineNuxtModule({
     },
     version
   },
-  /**
-   * Default configuration options of the Nuxt module
-   */
-  defaults: () => ({
-    vuetifyOptions: {
-      labComponents: false,
-      directives: false
-    },
-    moduleOptions: {
-      importComposables: true,
-      includeTransformAssetsUrls: true,
-      styles: true,
-      disableVuetifyStyles: false,
-      rulesConfiguration: {
-        fromLabs: true
-      }
-    }
-  }),
   /**
    * Sets up the Vuetify Nuxt module.
    *
@@ -1778,8 +1662,23 @@ const module$1 = defineNuxtModule({
     if (isNuxtMajorVersion(2, nuxt)) {
       logger.error(`Cannot support nuxt version: ${getNuxtVersion(nuxt)}`);
     }
-    const vuetifyPkg = await getPackageInfo("vuetify");
-    const currentVersion = vuetifyPkg?.version;
+    let vuetifyPkgPath = await findPath("vuetify/package.json");
+    if (!vuetifyPkgPath) {
+      const metaResolve = import.meta.resolve;
+      if (metaResolve) {
+        try {
+          vuetifyPkgPath = fileURLToPath(metaResolve("vuetify/package.json"));
+        } catch {
+        }
+      }
+    }
+    if (!vuetifyPkgPath) {
+      throw new Error(
+        '[vuetify-nuxt-module] Could not resolve "vuetify". Please add it as a dependency of your project (e.g. `npm add vuetify`).'
+      );
+    }
+    const vuetifyBase = dirname(vuetifyPkgPath);
+    const currentVersion = JSON.parse(readFileSync(vuetifyPkgPath, "utf8")).version;
     const vuetifyGte = (version2) => !!currentVersion && semver.gte(currentVersion, version2);
     const viteVersion = version$1;
     const ctx = {
@@ -1799,6 +1698,8 @@ const module$1 = defineNuxtModule({
       labComponentsPromise: void 0,
       vuetifyGte,
       vuetifyVersion: currentVersion || "0.0.0",
+      vuetifyBase,
+      resolvePaths: [nuxt.options.rootDir, ...nuxt.options.modulesDir],
       viteVersion
     };
     await load(options, nuxt, ctx);

package/dist/runtime/plugins/first-request-reload-guard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session cookie marking that the one-time `reloadOnFirstRequest` reload has
+ * already happened this browser session. Prevents an infinite reload loop when
+ * a browser requests client hints but never delivers them (e.g. Brave Shields
+ * strip `Sec-CH-*`), since `firstRequest` would otherwise stay `true` forever (#334).
+ */
+export declare const RELOAD_GUARD_COOKIE = "vuetify-nuxt-client-hints-reloaded";
+/** True when the guard cookie is present in a `document.cookie` string. */
+export declare function hasReloadGuardCookie(cookie: string): boolean;
+/** Build a session guard cookie (no expiry → cleared on browser close). */
+export declare function buildReloadGuardCookie(path: string): string;
+/** Whether to perform the first-request reload: only once per session. */
+export declare function shouldReloadOnFirstRequest(firstRequest: boolean, reloadOnFirstRequest: boolean, alreadyReloaded: boolean): boolean;

package/dist/runtime/plugins/first-request-reload-guard.js

@@ -0,0 +1,11 @@
+export const RELOAD_GUARD_COOKIE = "vuetify-nuxt-client-hints-reloaded";
+export function hasReloadGuardCookie(cookie) {
+  const prefix = `${RELOAD_GUARD_COOKIE}=`;
+  return cookie.split(";").some((c) => c.trim().startsWith(prefix));
+}
+export function buildReloadGuardCookie(path) {
+  return `${RELOAD_GUARD_COOKIE}=1; Path=${path}; SameSite=Lax`;
+}
+export function shouldReloadOnFirstRequest(firstRequest, reloadOnFirstRequest, alreadyReloaded) {
+  return firstRequest && reloadOnFirstRequest && !alreadyReloaded;
+}

package/dist/runtime/plugins/i18n.js

@@ -4,6 +4,9 @@ import { useI18n } from "vue-i18n";
 function inferDecimalSeparator(n) {
   return n(0.1).includes(",") ? "," : ".";
 }
+function inferNumericGroupSeparator(n) {
+  return n(1e4, { useGrouping: true }).replace(/\p{Nd}/gu, "") || " ";
+}
 export function createAdapter(vuetifyOptions) {
   vuetifyOptions.locale = {};
   const nuxtApp = useNuxtApp();
@@ -32,7 +35,8 @@ export function createAdapter(vuetifyOptions) {
     t: (key, ...params) => i18n.t(key, params),
     n: i18n.n,
     provide: createProvideFunction({ current: currentLocale, fallback, messages }),
-    decimalSeparator: toRef(() => inferDecimalSeparator(i18n.n))
+    decimalSeparator: toRef(() => inferDecimalSeparator(i18n.n)),
+    numericGroupSeparator: toRef(() => inferNumericGroupSeparator(i18n.n))
   };
 }
 function createProvideFunction(data) {
@@ -61,6 +65,7 @@ function createProvideFunction(data) {
       t,
       n,
       decimalSeparator: toRef(() => props.decimalSeparator ?? inferDecimalSeparator(n)),
+      numericGroupSeparator: toRef(() => inferNumericGroupSeparator(n)),
       provide: createProvideFunction({ current: currentLocale, fallback: data.fallback, messages: data.messages })
     };
   };

package/dist/runtime/plugins/vuetify-client-hints.client.js

@@ -2,6 +2,7 @@ import { defineNuxtPlugin, useNuxtApp, useState } from "#imports";
 import { ssrClientHintsConfiguration } from "virtual:vuetify-ssr-client-hints-configuration";
 import { reactive, ref, watch } from "vue";
 import { VuetifyHTTPClientHints } from "./client-hints.js";
+import { buildReloadGuardCookie, hasReloadGuardCookie, shouldReloadOnFirstRequest } from "./first-request-reload-guard.js";
 const plugin = defineNuxtPlugin({
   name: "vuetify:client-hints:client:plugin",
   order: -25,
@@ -22,7 +23,11 @@ const plugin = defineNuxtPlugin({
       prefersColorScheme,
       prefersColorSchemeOptions
     } = ssrClientHintsConfiguration;
-    if (firstRequest && reloadOnFirstRequest) {
+    if (shouldReloadOnFirstRequest(firstRequest, reloadOnFirstRequest, hasReloadGuardCookie(document.cookie))) {
+      const markAndReload = () => {
+        document.cookie = buildReloadGuardCookie(prefersColorSchemeOptions?.baseUrl ?? "/");
+        window.location.reload();
+      };
       if (prefersColorScheme) {
         const themeCookie = state.value.colorSchemeCookie;
         if (prefersColorSchemeOptions && themeCookie) {
@@ -32,19 +37,19 @@ const plugin = defineNuxtPlugin({
           const cookieEntry = `${parseCookieName}${state.value.colorSchemeFromCookie ?? prefersColorSchemeOptions.defaultTheme};`;
           const newThemeName = prefersDark ? prefersColorSchemeOptions.darkThemeName : prefersColorSchemeOptions.lightThemeName;
           document.cookie = themeCookie.replace(cookieEntry, `${cookieName}=${newThemeName};`);
-          window.location.reload();
+          markAndReload();
         } else if (prefersColorSchemeAvailable) {
-          window.location.reload();
+          markAndReload();
         }
       }
       if (prefersReducedMotion && prefersReducedMotionAvailable) {
-        window.location.reload();
+        markAndReload();
       }
       if (viewportSize && viewportHeightAvailable) {
-        window.location.reload();
+        markAndReload();
       }
       if (viewportSize && viewportWidthAvailable) {
-        window.location.reload();
+        markAndReload();
       }
     }
     nuxtApp.hook("vuetify:before-create", ({ vuetifyOptions }) => {
@@ -119,12 +124,21 @@ function useSSRClientHints() {
   const {
     baseUrl,
     cookieName,
+    cookieDomain,
+    cookieSecure,
+    cookieSameSite,
     defaultTheme
   } = ssrClientHintsConfiguration.prefersColorSchemeOptions;
   const cookieNamePrefix = `${cookieName}=`;
   initial.value.colorSchemeFromCookie = document.cookie?.split(";")?.find((c) => c.trim().startsWith(cookieNamePrefix))?.split("=")[1] ?? defaultTheme;
   const date = /* @__PURE__ */ new Date();
   const expires = new Date(date.setDate(date.getDate() + 365));
-  initial.value.colorSchemeCookie = `${cookieName}=${initial.value.colorSchemeFromCookie}; Path=${baseUrl}; Expires=${expires.toUTCString()}; SameSite=Lax`;
+  initial.value.colorSchemeCookie = `${cookieName}=${initial.value.colorSchemeFromCookie}; Path=${baseUrl}; Expires=${expires.toUTCString()}; SameSite=${cookieSameSite[0].toUpperCase()}${cookieSameSite.slice(1)}`;
+  if (cookieDomain) {
+    initial.value.colorSchemeCookie += `; Domain=${cookieDomain}`;
+  }
+  if (cookieSecure) {
+    initial.value.colorSchemeCookie += "; Secure";
+  }
   return initial;
 }

package/dist/runtime/plugins/vuetify-client-hints.server.js

@@ -273,15 +273,27 @@ function writeThemeCookie(clientHintsRequest, ssrClientHintsConfiguration2) {
   const cookieName = ssrClientHintsConfiguration2.prefersColorSchemeOptions.cookieName;
   const themeName = clientHintsRequest.colorSchemeFromCookie ?? ssrClientHintsConfiguration2.prefersColorSchemeOptions.defaultTheme;
   const path = ssrClientHintsConfiguration2.prefersColorSchemeOptions.baseUrl;
+  const domain = ssrClientHintsConfiguration2.prefersColorSchemeOptions.cookieDomain;
+  const secure = ssrClientHintsConfiguration2.prefersColorSchemeOptions.cookieSecure;
+  const sameSite = ssrClientHintsConfiguration2.prefersColorSchemeOptions.cookieSameSite;
   const date = /* @__PURE__ */ new Date();
   const expires = new Date(date.setDate(date.getDate() + 365));
   if (!clientHintsRequest.firstRequest || !ssrClientHintsConfiguration2.reloadOnFirstRequest) {
     useCookie(cookieName, {
       path,
+      domain,
       expires,
-      sameSite: "lax"
+      sameSite,
+      secure
     }).value = themeName;
   }
-  return `${cookieName}=${themeName}; Path=${path}; Expires=${expires.toUTCString()}; SameSite=Lax`;
+  let cookie = `${cookieName}=${themeName}; Path=${path}; Expires=${expires.toUTCString()}; SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1)}`;
+  if (domain) {
+    cookie += `; Domain=${domain}`;
+  }
+  if (secure) {
+    cookie += "; Secure";
+  }
+  return cookie;
 }
 export default plugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vuetify-nuxt-module",
   "type": "module",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.10",
   "description": "Zero-Config Nuxt Module for Vuetify",
   "author": "userquin <userquin@gmail.com>",
   "license": "MIT",
@@ -52,17 +52,18 @@
   ],
   "dependencies": {
     "@nuxt/kit": "^4.3.1",
+    "@vuetify/loader-shared": "^2.1.2",
+    "@vuetify/unplugin-styles": "^1.0.0-beta.11",
     "defu": "^6.1.4",
-    "destr": "^2.0.5",
     "local-pkg": "^1.1.2",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.1.0",
     "semver": "^7.7.4",
     "ufo": "^1.6.3",
-    "unconfig": "^7.5.0",
-    "upath": "^2.0.1",
-    "vite-plugin-vuetify": "^2.1.3",
-    "vuetify": "^4.0.1"
+    "unconfig": "^7.5.0"
+  },
+  "peerDependencies": {
+    "vuetify": "^3.4.0 || ^4.0.0"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^7.6.1",
@@ -87,21 +88,23 @@
     "eslint": "^10.0.2",
     "luxon": "^3.7.2",
     "nuxt": "^4.3.1",
+    "playwright-core": "^1.58.0",
     "publint": "^0.3.18",
     "rimraf": "^6.1.3",
     "sass": "^1.97.3",
     "typescript": "^5.9.3",
     "vite": "7.3.1",
     "vitest": "^4.0.18",
-    "vue-tsc": "^3.2.5"
+    "vue-tsc": "^3.2.5",
+    "vuetify": "^4.0.1"
   },
   "build": {
     "externals": [
       "@vuetify/loader-shared",
+      "@vuetify/unplugin-styles",
       "node:child_process",
       "node:fs",
       "consola",
-      "destr",
       "esbuild",
       "local-pkg",
       "pathe",
@@ -109,11 +112,9 @@
       "rollup",
       "sass",
       "sass-embedded",
-      "upath",
       "ufo",
       "unconfig",
       "vite",
-      "vite-plugin-vuetify",
       "vuetify"
     ]
   },
@@ -139,8 +140,9 @@
     "lint": "eslint .",
     "lint:fix": "nr lint --fix",
     "publint": "publint",
-    "test": "vitest run",
-    "test:watch": "vitest watch",
+    "test": "vitest run --exclude 'test/e2e/**'",
+    "test:watch": "vitest watch --exclude 'test/e2e/**'",
+    "test:e2e": "vitest run test/e2e",
     "release": "bumpp"
   }
 }