vuetify-nuxt-module 0.5.9 → 0.5.10

package/README.md

@@ -32,7 +32,7 @@
 - ⚡ **Fully Tree Shakable**: by default, only the needed Vuetify components are imported
 - 🛠️ **Versatile**: custom Vuetify [directives](https://vuetifyjs.com/en/getting-started/installation/#manual-steps) and [labs components](https://vuetifyjs.com/en/labs/introduction/) registration
 - ✨ **Configurable Styles**: configure your variables using [Vuetify SASS Variables](https://vuetifyjs.com/en/features/sass-variables/) 
-- 💥 **SSR**: automatic SSR detection and configuration
+- 💥 **SSR**: automatic SSR detection and configuration including [HTTP Client hints](https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints)
 - 🔩 **Nuxt Layers and Hooks**: load your Vuetify configuration using [Nuxt Layers](https://nuxt.com/docs/getting-started/layers#layers) or using a custom module via `vuetify:registerModule` [Nuxt Hook](https://nuxt.com/docs/guide/going-further/hooks#nuxt-hooks-build-time)
 - 📥 **Vuetify Configuration File**: configure your Vuetify options using a custom `vuetify.config` file, no dev server restart needed
 - 🔥 **Pure CSS Icons**: no more font/js icons, use the new `unocss-mdi` icon set or build your own with UnoCSS Preset Icons

package/configuration.d.ts

@@ -22,3 +22,24 @@ declare module 'virtual:vuetify-icons-configuration' {
   export const isDev: boolean
   export function iconsConfiguration(): IconOptions
 }
+
+declare module 'virtual:vuetify-ssr-client-hints-configuration' {
+  export interface SSRClientHintsConfiguration {
+    reloadOnFirstRequest: boolean
+    viewportSize: boolean
+    prefersColorScheme: boolean
+    prefersReducedMotion: boolean
+    clientWidth?: number
+    clientHeight?: number
+    prefersColorSchemeOptions?: {
+      baseUrl: string
+      defaultTheme: string
+      themeNames: string[]
+      cookieName: string
+      darkThemeName: string
+      lightThemeName: string
+      useBrowserThemeOnly: boolean
+    }
+  }
+  export const ssrClientHintsConfiguration: SSRClientHintsConfiguration
+}

package/dist/module.d.ts

@@ -5,6 +5,7 @@ import * as vuetify_locale from 'vuetify/locale';
 import * as vuetify_labs_components from 'vuetify/labs/components';
 import * as vuetify_directives from 'vuetify/directives';
 import * as vuetify_components from 'vuetify/components';
+import { UnwrapNestedRefs } from 'vue';
 
 type DateAdapter = 'vuetify' | 'date-fns' | 'moment' | 'luxon' | 'dayjs' | 'js-joda' | 'date-fns-jalali' | 'jalaali' | 'hijri' | 'custom';
 /**
@@ -204,6 +205,78 @@ interface MOptions {
      * @default false
      */
     includeTransformAssetsUrls?: boolean;
+    /**
+     * Vuetify SSR client hints.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints
+     */
+    ssrClientHints?: {
+        /**
+         * Should the module reload the page on first request?
+         *
+         * @default false
+         */
+        reloadOnFirstRequest?: boolean;
+        /**
+         * Enable `Sec-CH-Viewport-Width` and `Sec-CH-Viewport-Height` headers?
+         *
+         * @see https://wicg.github.io/responsive-image-client-hints/#sec-ch-viewport-width
+         * @see https://wicg.github.io/responsive-image-client-hints/#sec-ch-viewport-height
+         *
+         * @default false
+         */
+        viewportSize?: boolean;
+        /**
+         * Enable `Sec-CH-Prefers-Color-Scheme` header?
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-CH-Prefers-Color-Scheme
+         *
+         * @default false
+         */
+        prefersColorScheme?: boolean;
+        /**
+         * The options for `prefersColorScheme`, `prefersColorScheme` must be enabled.
+         *
+         * If you want the module to handle the color scheme for you, you should configure this option, otherwise you'll need to add your custom implementation.
+         */
+        prefersColorSchemeOptions?: {
+            /**
+             * The name for the cookie.
+             *
+             * @default 'color-scheme'
+             */
+            cookieName?: string;
+            /**
+             * The name for the dark theme.
+             *
+             * @default 'dark'
+             */
+            darkThemeName?: string;
+            /**
+             * The name for the light theme.
+             *
+             * @default 'light'
+             */
+            lightThemeName?: string;
+            /**
+             * Use the browser theme only?
+             *
+             * This flag can be used when your application provides a custom dark and light themes,
+             * but will not provide a theme switcher, that's, using by default the browser theme.
+             *
+             * @default false
+             */
+            useBrowserThemeOnly?: boolean;
+        };
+        /**
+         * Enable `Sec-CH-Prefers-Reduced-Motion` header?
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-CH-Prefers-Reduced-Motion
+         *
+         * @default false
+         */
+        prefersReducedMotion?: boolean;
+    };
 }
 interface ModuleOptions {
     moduleOptions?: MOptions;
@@ -223,6 +296,54 @@ interface InlineModuleOptions extends Omit<ModuleOptions, 'vuetifyOptions'> {
 interface ExternalVuetifyOptions extends VOptions {
     config?: boolean;
 }
+/**
+ * Request headers received from the client in SSR.
+ */
+interface SSRClientHints {
+    /**
+     * Is the first request the browser hits the server?
+     */
+    firstRequest: boolean;
+    /**
+     * The browser supports prefer-color-scheme client hints?
+     */
+    prefersColorSchemeAvailable: boolean;
+    /**
+     * The browser supports prefer-reduced-motion client hints?
+     */
+    prefersReducedMotionAvailable: boolean;
+    /**
+     * The browser supports viewport-height client hints?
+     */
+    viewportHeightAvailable: boolean;
+    /**
+     * The browser supports viewport-width client hints?
+     */
+    viewportWidthAvailable: boolean;
+    prefersColorScheme?: 'dark' | 'light' | 'no-preference';
+    prefersReducedMotion?: 'no-preference' | 'reduce';
+    viewportHeight?: number;
+    viewportWidth?: number;
+    /**
+     * The theme name from the cookie.
+     */
+    colorSchemeFromCookie?: string;
+    colorSchemeCookie?: string;
+}
+interface SSRClientHintsConfiguration {
+    enabled: boolean;
+    viewportSize: boolean;
+    prefersColorScheme: boolean;
+    prefersReducedMotion: boolean;
+    prefersColorSchemeOptions?: {
+        baseUrl: string;
+        defaultTheme: string;
+        themeNames: string[];
+        cookieName: string;
+        darkThemeName: string;
+        lightThemeName: string;
+    };
+}
 declare module '@nuxt/schema' {
     interface NuxtConfig {
         vuetify?: ModuleOptions;
@@ -234,6 +355,10 @@ declare module '@nuxt/schema' {
 declare module '#app' {
     interface NuxtApp {
         $vuetify: ReturnType<typeof vuetify['createVuetify']>;
+        /**
+         * Request headers received from the client in SSR.
+         */
+        $ssrClientHints: UnwrapNestedRefs<SSRClientHints>;
     }
     interface RuntimeNuxtHooks {
         'vuetify:configuration': (options: {
@@ -244,9 +369,14 @@ declare module '#app' {
             isDev: boolean;
             vuetifyOptions: VuetifyOptions;
         }) => Promise<void> | void;
+        'vuetify:ssr-client-hints': (options: {
+            vuetifyOptions: VuetifyOptions;
+            ssrClientHints: SSRClientHints;
+            ssrClientHintsConfiguration: SSRClientHintsConfiguration;
+        }) => Promise<void> | void;
     }
 }
 
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
 
-export { ComponentName, Components, DateAdapter, DateOptions, DirectiveName, Directives, ExternalVuetifyOptions, FontAwesomeSvgIconSet, FontIconSet, IconFontName, IconSetName, IconsOptions, InlineModuleOptions, JSSVGIconSet, LabComponentName, LabComponents, MOptions, ModuleOptions, VOptions, VuetifyLocale, _default as default };
+export { ComponentName, Components, DateAdapter, DateOptions, DirectiveName, Directives, ExternalVuetifyOptions, FontAwesomeSvgIconSet, FontIconSet, IconFontName, IconSetName, IconsOptions, InlineModuleOptions, JSSVGIconSet, LabComponentName, LabComponents, MOptions, ModuleOptions, SSRClientHints, SSRClientHintsConfiguration, VOptions, VuetifyLocale, _default as default };

package/dist/module.json

@@ -4,5 +4,5 @@
   "compatibility": {
     "nuxt": "^3.0.0"
   },
-  "version": "0.5.9"
+  "version": "0.5.10"
 }

package/dist/module.mjs

@@ -12,7 +12,7 @@ import vuetify, { transformAssetUrls } from 'vite-plugin-vuetify';
 import { isAbsolute, join, relative } from 'pathe';
 import { normalizePath as normalizePath$1 } from 'vite';
 
-const version = "0.5.9";
+const version = "0.5.10";
 
 const VIRTUAL_VUETIFY_CONFIGURATION = "virtual:vuetify-configuration";
 const RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION = `/@nuxt-vuetify-configuration/${VIRTUAL_VUETIFY_CONFIGURATION.slice("virtual:".length)}`;
@@ -20,10 +20,13 @@ const VIRTUAL_VUETIFY_DATE_CONFIGURATION = "virtual:vuetify-date-configuration";
 const RESOLVED_VIRTUAL_VUETIFY_DATE_CONFIGURATION = `/@nuxt-vuetify-configuration/${VIRTUAL_VUETIFY_DATE_CONFIGURATION.slice("virtual:".length)}`;
 const VIRTUAL_VUETIFY_ICONS_CONFIGURATION = "virtual:vuetify-icons-configuration";
 const RESOLVED_VIRTUAL_VUETIFY_ICONS_CONFIGURATION = `/@nuxt-vuetify-configuration/${VIRTUAL_VUETIFY_ICONS_CONFIGURATION.slice("virtual:".length)}`;
+const VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION = "virtual:vuetify-ssr-client-hints-configuration";
+const RESOLVED_VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION = `/@nuxt-vuetify-configuration/${VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION.slice("virtual:".length)}`;
 const RESOLVED_VIRTUAL_MODULES = [
   RESOLVED_VIRTUAL_VUETIFY_DATE_CONFIGURATION,
   RESOLVED_VIRTUAL_VUETIFY_ICONS_CONFIGURATION,
-  RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION
+  RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION,
+  RESOLVED_VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION
 ];
 
 async function loadVuetifyConfiguration(cwd = process.cwd(), configOrPath = cwd, defaults = {}, extraConfigSources = []) {
@@ -335,6 +338,58 @@ function convertFontSetsToObjectNotation(sets) {
   return result;
 }
 
+const disabledClientHints = Object.freeze({
+  enabled: false,
+  reloadOnFirstRequest: false,
+  viewportSize: false,
+  prefersColorScheme: false,
+  prefersReducedMotion: false
+});
+function prepareSSRClientHints(baseUrl, ctx) {
+  if (!ctx.isSSR || ctx.isNuxtGenerate)
+    return disabledClientHints;
+  const { ssrClientHints: ssrClientHintsConfiguration } = ctx.moduleOptions;
+  const clientHints = {
+    enabled: false,
+    reloadOnFirstRequest: ssrClientHintsConfiguration?.reloadOnFirstRequest ?? false,
+    viewportSize: ssrClientHintsConfiguration?.viewportSize ?? false,
+    prefersColorScheme: ssrClientHintsConfiguration?.prefersColorScheme ?? false,
+    prefersReducedMotion: ssrClientHintsConfiguration?.prefersReducedMotion ?? false
+  };
+  clientHints.enabled = clientHints.viewportSize || clientHints.prefersColorScheme || clientHints.prefersReducedMotion;
+  if (clientHints.enabled && clientHints.prefersColorScheme && ssrClientHintsConfiguration?.prefersColorSchemeOptions) {
+    const theme = ctx.vuetifyOptions.theme;
+    if (!theme)
+      throw new Error("Vuetify theme is disabled");
+    const themes = theme.themes;
+    if (!themes)
+      throw new Error("Vuetify themes is missing in theme!");
+    const defaultTheme = theme.defaultTheme;
+    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!`);
+    const lightThemeName = ssrClientHintsConfiguration.prefersColorSchemeOptions?.lightThemeName ?? "light";
+    if (!themes[lightThemeName])
+      throw new Error(`Missing theme ${lightThemeName} in the Vuetify themes!`);
+    if (darkThemeName === lightThemeName)
+      throw new Error("Vuetify dark theme and light theme are the same, change darkThemeName or lightThemeName!");
+    clientHints.prefersColorSchemeOptions = {
+      baseUrl,
+      defaultTheme,
+      themeNames: Array.from(Object.keys(themes)),
+      cookieName: ssrClientHintsConfiguration.prefersColorSchemeOptions?.cookieName ?? "color-scheme",
+      darkThemeName,
+      lightThemeName,
+      useBrowserThemeOnly: ssrClientHintsConfiguration.prefersColorSchemeOptions?.useBrowserThemeOnly ?? false
+    };
+  }
+  return clientHints;
+}
+
 async function load(options, nuxt, ctx) {
   var _a;
   const {
@@ -386,6 +441,7 @@ async function load(options, nuxt, ctx) {
   ctx.vuetifyOptions = configuration.vuetifyOptions;
   ctx.vuetifyFilesToWatch = Array.from(vuetifyConfigurationFilesToWatch);
   ctx.icons = prepareIcons(ctx.unocss, ctx.logger, vuetifyAppOptions);
+  ctx.ssrClientHints = prepareSSRClientHints(nuxt.options.app.baseURL ?? "/", ctx);
   if (ctx.icons.enabled) {
     ctx.icons.local?.forEach((css) => nuxt.options.css.push(css));
     if (ctx.icons.cdn?.length) {
@@ -904,7 +960,7 @@ ${unocss}
     if (ctx.icons.unocss && ctx.icons.unocssAliases) {
       ctx.icons.imports.unshift("// @unocss-include");
       const prefix = `${ctx.icons.unocssIconPrefix}mdi:`;
-      unocss = `const aliases = ${JSON.stringify({
+      unocss = `const aliases = JSON.parse('${JSON.stringify({
         collapse: `${prefix}chevron-up`,
         complete: `${prefix}check`,
         cancel: `${prefix}close-circle`,
@@ -943,7 +999,7 @@ ${unocss}
         plus: `${prefix}plus`,
         minus: `${prefix}minus`,
         calendar: `${prefix}calendar`
-      })}
+      })}');
 `;
     }
     return {
@@ -1004,6 +1060,31 @@ export function dateConfiguration() {
   }
 }
 
+function vuetifySSRClientHintsPlugin(ctx) {
+  return {
+    name: "vuetify:ssr-client-hints:nuxt",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION)
+        return RESOLVED_VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION;
+    },
+    async load(id) {
+      if (id === RESOLVED_VIRTUAL_VUETIFY_SSR_CLIENT_HINTS_CONFIGURATION) {
+        const data = {
+          reloadOnFirstRequest: ctx.ssrClientHints.reloadOnFirstRequest,
+          viewportSize: ctx.ssrClientHints.viewportSize,
+          prefersColorScheme: ctx.ssrClientHints.prefersColorScheme,
+          prefersReducedMotion: ctx.ssrClientHints.prefersReducedMotion,
+          clientWidth: ctx.vuetifyOptions.ssr?.clientWidth,
+          clientHeight: ctx.vuetifyOptions.ssr?.clientHeight,
+          prefersColorSchemeOptions: ctx.ssrClientHints.prefersColorSchemeOptions
+        };
+        return `export const ssrClientHintsConfiguration = JSON.parse('${JSON.stringify(data)}');`;
+      }
+    }
+  };
+}
+
 function configureVite(configKey, nuxt, ctx) {
   nuxt.hook("vite:extend", ({ config }) => checkVuetifyPlugins(config));
   nuxt.hook("vite:extendConfig", (viteInlineConfig) => {
@@ -1020,6 +1101,8 @@ function configureVite(configKey, nuxt, ctx) {
     viteInlineConfig.plugins.push(vuetifyConfigurationPlugin(ctx));
     viteInlineConfig.plugins.push(vuetifyIconsPlugin(ctx));
     viteInlineConfig.plugins.push(vuetifyDateConfigurationPlugin(ctx));
+    if (ctx.ssrClientHints.enabled)
+      viteInlineConfig.plugins.push(vuetifySSRClientHintsPlugin(ctx));
   });
 }
 
@@ -1075,6 +1158,16 @@ function configureNuxt(configKey, nuxt, ctx) {
       meta: { docsUrl: `https://vuetifyjs.com/en/api/${toKebabCase(name)}/` }
     })));
   }
+  if (ctx.ssrClientHints.enabled) {
+    addPlugin({
+      src: ctx.resolver.resolve(runtimeDir, "plugins/vuetify-client-hints.client"),
+      mode: "client"
+    });
+    addPlugin({
+      src: ctx.resolver.resolve(runtimeDir, "plugins/vuetify-client-hints.server"),
+      mode: "server"
+    });
+  }
   addPlugin({
     src: ctx.resolver.resolve(runtimeDir, `plugins/vuetify${ctx.i18n ? "-sync" : ""}`)
   });
@@ -1130,9 +1223,11 @@ const module = defineNuxtModule({
       vuetifyFilesToWatch: [],
       isSSR: nuxt.options.ssr,
       isDev: nuxt.options.dev,
+      isNuxtGenerate: nuxt.options._generate,
       unocss: hasNuxtModule("@unocss/nuxt", nuxt),
       i18n: hasNuxtModule("@nuxtjs/i18n", nuxt),
       icons: void 0,
+      ssrClientHints: void 0,
       componentsPromise: void 0,
       labComponentsPromise: void 0
     };

package/dist/runtime/plugins/client-hints.d.ts

@@ -0,0 +1,19 @@
+export interface ClientHintRequestFeatures {
+    firstRequest: boolean;
+    prefersColorSchemeAvailable: boolean;
+    prefersReducedMotionAvailable: boolean;
+    viewportHeightAvailable: boolean;
+    viewportWidthAvailable: boolean;
+}
+export interface ClientHintsRequest extends ClientHintRequestFeatures {
+    prefersColorScheme?: 'dark' | 'light' | 'no-preference';
+    prefersReducedMotion?: 'no-preference' | 'reduce';
+    viewportHeight?: number;
+    viewportWidth?: number;
+    colorSchemeFromCookie?: string;
+    colorSchemeCookie?: string;
+}
+export interface SSRClientHints {
+    ssrClientHints: ClientHintsRequest;
+}
+export declare const VuetifyHTTPClientHints = "vuetify:nuxt:ssr-client-hints";

package/dist/runtime/plugins/client-hints.mjs

@@ -0,0 +1 @@
+export const VuetifyHTTPClientHints = "vuetify:nuxt:ssr-client-hints";

package/dist/runtime/plugins/detect-browser.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+export type DetectedInfoType = 'browser' | 'node' | 'bot-device' | 'bot' | 'react-native';
+interface DetectedInfo<T extends DetectedInfoType, N extends string, O, V = null> {
+    readonly type: T;
+    readonly name: N;
+    readonly version: V;
+    readonly os: O;
+}
+export declare class BrowserInfo implements DetectedInfo<'browser', Browser, OperatingSystem | null, string> {
+    readonly name: Browser;
+    readonly version: string;
+    readonly os: OperatingSystem | null;
+    readonly type = "browser";
+    constructor(name: Browser, version: string, os: OperatingSystem | null);
+}
+export declare class NodeInfo implements DetectedInfo<'node', 'node', NodeJS.Platform, string> {
+    readonly version: string;
+    readonly type = "node";
+    readonly name: "node";
+    readonly os: NodeJS.Platform;
+    constructor(version: string);
+}
+export declare class SearchBotDeviceInfo implements DetectedInfo<'bot-device', Browser, OperatingSystem | null, string> {
+    readonly name: Browser;
+    readonly version: string;
+    readonly os: OperatingSystem | null;
+    readonly bot: string;
+    readonly type = "bot-device";
+    constructor(name: Browser, version: string, os: OperatingSystem | null, bot: string);
+}
+export declare class BotInfo implements DetectedInfo<'bot', 'bot', null, null> {
+    readonly type = "bot";
+    readonly bot: true;
+    readonly name: "bot";
+    readonly version: null;
+    readonly os: null;
+}
+export declare class ReactNativeInfo implements DetectedInfo<'react-native', 'react-native', null, null> {
+    readonly type = "react-native";
+    readonly name: "react-native";
+    readonly version: null;
+    readonly os: null;
+}
+export type Browser = 'aol' | 'arc' | 'brave' | 'edge' | 'edge-ios' | 'yandexbrowser' | 'kakaotalk' | 'samsung' | 'silk' | 'miui' | 'beaker' | 'edge-chromium' | 'chrome' | 'chromium-webview' | 'phantomjs' | 'crios' | 'firefox' | 'fxios' | 'opera-mini' | 'opera' | 'pie' | 'netfront' | 'ie' | 'bb10' | 'android' | 'ios' | 'safari' | 'facebook' | 'instagram' | 'ios-webview' | 'curl' | 'searchbot';
+export type OperatingSystem = 'iOS' | 'Android OS' | 'BlackBerry OS' | 'Windows Mobile' | 'Amazon OS' | 'Windows 3.11' | 'Windows 95' | 'Windows 98' | 'Windows 2000' | 'Windows XP' | 'Windows Server 2003' | 'Windows Vista' | 'Windows 7' | 'Windows 8' | 'Windows 8.1' | 'Windows 10' | 'Windows ME' | 'Windows CE' | 'Open BSD' | 'Sun OS' | 'Linux' | 'Mac OS' | 'QNX' | 'BeOS' | 'OS/2' | 'Chrome OS';
+export declare function detect(userAgent?: string): BrowserInfo | SearchBotDeviceInfo | BotInfo | NodeInfo | ReactNativeInfo | null;
+export declare function browserName(ua: string): Browser | null;
+export declare function parseUserAgent(ua: string): BrowserInfo | SearchBotDeviceInfo | BotInfo | null;
+export declare function detectOS(ua: string): OperatingSystem | null;
+export declare function getNodeVersion(): NodeInfo | null;
+export {};

package/dist/runtime/plugins/detect-browser.mjs

@@ -0,0 +1,180 @@
+import process from "node:process";
+export class BrowserInfo {
+  constructor(name, version, os) {
+    this.name = name;
+    this.version = version;
+    this.os = os;
+  }
+  type = "browser";
+}
+export class NodeInfo {
+  constructor(version) {
+    this.version = version;
+  }
+  type = "node";
+  name = "node";
+  os = process.platform;
+}
+export class SearchBotDeviceInfo {
+  constructor(name, version, os, bot) {
+    this.name = name;
+    this.version = version;
+    this.os = os;
+    this.bot = bot;
+  }
+  type = "bot-device";
+}
+export class BotInfo {
+  type = "bot";
+  bot = true;
+  // NOTE: deprecated test name instead
+  name = "bot";
+  version = null;
+  os = null;
+}
+export class ReactNativeInfo {
+  type = "react-native";
+  name = "react-native";
+  version = null;
+  os = null;
+}
+const SEARCHBOX_UA_REGEX = /alexa|bot|crawl(er|ing)|facebookexternalhit|feedburner|google web preview|nagios|postrank|pingdom|slurp|spider|yahoo!|yandex/;
+const SEARCHBOT_OS_REGEX = /(nuhk|curl|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask\ Jeeves\/Teoma|ia_archiver)/;
+const REQUIRED_VERSION_PARTS = 3;
+const userAgentRules = [
+  ["aol", /AOLShield\/([0-9\._]+)/],
+  ["brave", /Brave\/([0-9\._]+)/],
+  ["edge", /Edge\/([0-9\._]+)/],
+  ["edge-ios", /EdgiOS\/([0-9\._]+)/],
+  ["yandexbrowser", /YaBrowser\/([0-9\._]+)/],
+  ["kakaotalk", /KAKAOTALK\s([0-9\.]+)/],
+  ["samsung", /SamsungBrowser\/([0-9\.]+)/],
+  ["silk", /\bSilk\/([0-9._-]+)\b/],
+  ["miui", /MiuiBrowser\/([0-9\.]+)$/],
+  ["beaker", /BeakerBrowser\/([0-9\.]+)/],
+  ["edge-chromium", /EdgA?\/([0-9\.]+)/],
+  [
+    "chromium-webview",
+    /(?!Chrom.*OPR)wv\).*Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/
+  ],
+  ["chrome", /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/],
+  ["phantomjs", /PhantomJS\/([0-9\.]+)(:?\s|$)/],
+  ["crios", /CriOS\/([0-9\.]+)(:?\s|$)/],
+  ["firefox", /Firefox\/([0-9\.]+)(?:\s|$)/],
+  ["fxios", /FxiOS\/([0-9\.]+)/],
+  ["opera-mini", /Opera Mini.*Version\/([0-9\.]+)/],
+  ["opera", /Opera\/([0-9\.]+)(?:\s|$)/],
+  ["opera", /OPR\/([0-9\.]+)(:?\s|$)/],
+  ["pie", /^Microsoft Pocket Internet Explorer\/(\d+\.\d+)$/],
+  ["pie", /^Mozilla\/\d\.\d+\s\(compatible;\s(?:MSP?IE|MSInternet Explorer) (\d+\.\d+);.*Windows CE.*\)$/],
+  ["netfront", /^Mozilla\/\d\.\d+.*NetFront\/(\d.\d)/],
+  ["ie", /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/],
+  ["ie", /MSIE\s([0-9\.]+);.*Trident\/[4-7].0/],
+  ["ie", /MSIE\s(7\.0)/],
+  ["bb10", /BB10;\sTouch.*Version\/([0-9\.]+)/],
+  ["android", /Android\s([0-9\.]+)/],
+  ["ios", /Version\/([0-9\._]+).*Mobile.*Safari.*/],
+  ["safari", /Version\/([0-9\._]+).*Safari/],
+  ["facebook", /FB[AS]V\/([0-9\.]+)/],
+  ["instagram", /Instagram\s([0-9\.]+)/],
+  ["ios-webview", /AppleWebKit\/([0-9\.]+).*Mobile/],
+  ["ios-webview", /AppleWebKit\/([0-9\.]+).*Gecko\)$/],
+  ["curl", /^curl\/([0-9\.]+)$/],
+  ["searchbot", SEARCHBOX_UA_REGEX]
+];
+const operatingSystemRules = [
+  ["iOS", /iP(hone|od|ad)/],
+  ["Android OS", /Android/],
+  ["BlackBerry OS", /BlackBerry|BB10/],
+  ["Windows Mobile", /IEMobile/],
+  ["Amazon OS", /Kindle/],
+  ["Windows 3.11", /Win16/],
+  ["Windows 95", /(Windows 95)|(Win95)|(Windows_95)/],
+  ["Windows 98", /(Windows 98)|(Win98)/],
+  ["Windows 2000", /(Windows NT 5.0)|(Windows 2000)/],
+  ["Windows XP", /(Windows NT 5.1)|(Windows XP)/],
+  ["Windows Server 2003", /(Windows NT 5.2)/],
+  ["Windows Vista", /(Windows NT 6.0)/],
+  ["Windows 7", /(Windows NT 6.1)/],
+  ["Windows 8", /(Windows NT 6.2)/],
+  ["Windows 8.1", /(Windows NT 6.3)/],
+  ["Windows 10", /(Windows NT 10.0)/],
+  ["Windows ME", /Windows ME/],
+  ["Windows CE", /Windows CE|WinCE|Microsoft Pocket Internet Explorer/],
+  ["Open BSD", /OpenBSD/],
+  ["Sun OS", /SunOS/],
+  ["Chrome OS", /CrOS/],
+  ["Linux", /(Linux)|(X11)/],
+  ["Mac OS", /(Mac_PowerPC)|(Macintosh)/],
+  ["QNX", /QNX/],
+  ["BeOS", /BeOS/],
+  ["OS/2", /OS\/2/]
+];
+export function detect(userAgent) {
+  if (userAgent)
+    return parseUserAgent(userAgent);
+  if (typeof document === "undefined" && typeof navigator !== "undefined" && navigator.product === "ReactNative")
+    return new ReactNativeInfo();
+  if (typeof navigator !== "undefined")
+    return parseUserAgent(navigator.userAgent);
+  return getNodeVersion();
+}
+function matchUserAgent(ua) {
+  return ua !== "" && userAgentRules.reduce(
+    (matched, [browser, regex]) => {
+      if (matched)
+        return matched;
+      const uaMatch = regex.exec(ua);
+      return !!uaMatch && [browser, uaMatch];
+    },
+    false
+  );
+}
+export function browserName(ua) {
+  const data = matchUserAgent(ua);
+  return data ? data[0] : null;
+}
+export function parseUserAgent(ua) {
+  const matchedRule = matchUserAgent(ua);
+  if (!matchedRule)
+    return null;
+  const [name, match] = matchedRule;
+  if (name === "searchbot")
+    return new BotInfo();
+  let versionParts = match[1] && match[1].split(".").join("_").split("_").slice(0, 3);
+  if (versionParts) {
+    if (versionParts.length < REQUIRED_VERSION_PARTS) {
+      versionParts = [
+        ...versionParts,
+        ...createVersionParts(REQUIRED_VERSION_PARTS - versionParts.length)
+      ];
+    }
+  } else {
+    versionParts = [];
+  }
+  const version = versionParts.join(".");
+  const os = detectOS(ua);
+  const searchBotMatch = SEARCHBOT_OS_REGEX.exec(ua);
+  if (searchBotMatch && searchBotMatch[1])
+    return new SearchBotDeviceInfo(name, version, os, searchBotMatch[1]);
+  return new BrowserInfo(name, version, os);
+}
+export function detectOS(ua) {
+  for (let ii = 0, count = operatingSystemRules.length; ii < count; ii++) {
+    const [os, regex] = operatingSystemRules[ii];
+    const match = regex.exec(ua);
+    if (match)
+      return os;
+  }
+  return null;
+}
+export function getNodeVersion() {
+  const isNode = typeof process !== "undefined" && process.version;
+  return isNode ? new NodeInfo(process.version.slice(1)) : null;
+}
+function createVersionParts(count) {
+  const output = [];
+  for (let ii = 0; ii < count; ii++)
+    output.push("0");
+  return output;
+}

package/dist/runtime/plugins/vuetify-client-hints.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,86 @@
+import { ssrClientHintsConfiguration } from "virtual:vuetify-ssr-client-hints-configuration";
+import { VuetifyHTTPClientHints } from "./client-hints.mjs";
+import { defineNuxtPlugin } from "#imports";
+import { useNuxtApp } from "#app";
+export default defineNuxtPlugin((nuxtApp) => {
+  const state = useState(VuetifyHTTPClientHints);
+  const {
+    firstRequest,
+    prefersColorSchemeAvailable,
+    prefersReducedMotionAvailable,
+    viewportHeightAvailable,
+    viewportWidthAvailable
+  } = state.value.ssrClientHints;
+  const {
+    reloadOnFirstRequest,
+    viewportSize,
+    prefersReducedMotion,
+    prefersColorScheme,
+    prefersColorSchemeOptions
+  } = ssrClientHintsConfiguration;
+  if (firstRequest && reloadOnFirstRequest) {
+    if (prefersColorScheme) {
+      const themeCookie = state.value.ssrClientHints.colorSchemeCookie;
+      if (prefersColorSchemeOptions && themeCookie) {
+        const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+        const cookieName = prefersColorSchemeOptions.cookieName;
+        const parseCookieName = `${cookieName}=`;
+        const cookieEntry = `${parseCookieName}${state.value.ssrClientHints.colorSchemeFromCookie ?? prefersColorSchemeOptions.defaultTheme};`;
+        const newThemeName = prefersDark ? prefersColorSchemeOptions.darkThemeName : prefersColorSchemeOptions.lightThemeName;
+        document.cookie = themeCookie.replace(cookieEntry, `${cookieName}=${newThemeName};`);
+        window.location.reload();
+      } else if (prefersColorSchemeAvailable) {
+        window.location.reload();
+      }
+    }
+    if (prefersReducedMotion && prefersReducedMotionAvailable)
+      window.location.reload();
+    if (viewportSize && viewportHeightAvailable)
+      window.location.reload();
+    if (viewportSize && viewportWidthAvailable)
+      window.location.reload();
+  }
+  if (viewportSize || prefersColorScheme && prefersColorSchemeOptions) {
+    nuxtApp.hook("vuetify:before-create", ({ vuetifyOptions }) => {
+      if (viewportSize) {
+        const clientWidth = state.value.ssrClientHints.viewportWidth;
+        const clientHeight = state.value.ssrClientHints.viewportHeight;
+        vuetifyOptions.ssr = typeof clientWidth === "number" ? {
+          clientWidth,
+          clientHeight
+        } : true;
+      }
+      if (prefersColorScheme && prefersColorSchemeOptions)
+        vuetifyOptions.theme.defaultTheme = state.value.ssrClientHints.colorSchemeFromCookie ?? prefersColorSchemeOptions.defaultTheme;
+    });
+    if (prefersColorScheme && prefersColorSchemeOptions) {
+      const themeCookie = state.value.ssrClientHints.colorSchemeCookie;
+      if (themeCookie) {
+        nuxtApp.hook("app:beforeMount", () => {
+          const vuetify = useNuxtApp().$vuetify;
+          const cookieName = prefersColorSchemeOptions.cookieName;
+          const parseCookieName = `${cookieName}=`;
+          const cookieEntry = `${parseCookieName}${state.value.ssrClientHints.colorSchemeFromCookie ?? prefersColorSchemeOptions.defaultTheme};`;
+          watch(vuetify.theme.global.name, (newThemeName) => {
+            document.cookie = themeCookie.replace(cookieEntry, `${cookieName}=${newThemeName};`);
+          });
+          if (prefersColorSchemeOptions.useBrowserThemeOnly) {
+            const { darkThemeName, lightThemeName } = prefersColorSchemeOptions;
+            const prefersDark = window.matchMedia("(prefers-color-scheme: dark)");
+            const prefersLight = window.matchMedia("(prefers-color-scheme: light)");
+            prefersDark.addEventListener("change", (e) => switchTheme(e, darkThemeName, vuetify));
+            prefersLight.addEventListener("change", (e) => switchTheme(e, lightThemeName, vuetify));
+          }
+        });
+      }
+    }
+  }
+  return {
+    provide: reactive({
+      ssrClientHints: state
+    })
+  };
+});
+function switchTheme(e, newThemeName, vuetify) {
+  e.matches && (vuetify.theme.global.name.value = newThemeName);
+}

package/dist/runtime/plugins/vuetify-client-hints.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,230 @@
+import { ssrClientHintsConfiguration } from "virtual:vuetify-ssr-client-hints-configuration";
+import { parseUserAgent } from "./detect-browser.mjs";
+import { VuetifyHTTPClientHints } from "./client-hints.mjs";
+import { defineNuxtPlugin, useNuxtApp } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  const event = useRequestEvent();
+  const state = useState(VuetifyHTTPClientHints);
+  const request = event.node.req;
+  const response = event.node.res;
+  const requestHeaders = request.headers ?? {};
+  const userAgentHeader = readClientHeader("user-agent", requestHeaders);
+  const userAgent = userAgentHeader ? parseUserAgent(userAgentHeader) : null;
+  const clientHintsRequest = collectClientHints(userAgent, ssrClientHintsConfiguration, requestHeaders);
+  writeClientHintsResponseHeaders(clientHintsRequest, ssrClientHintsConfiguration, response);
+  state.value = {
+    ssrClientHints: clientHintsRequest
+  };
+  state.value.ssrClientHints.colorSchemeCookie = writeThemeCookie(
+    clientHintsRequest,
+    ssrClientHintsConfiguration
+  );
+  nuxtApp.hook("vuetify:before-create", async ({ vuetifyOptions }) => {
+    const clientWidth = clientHintsRequest.viewportWidth;
+    const clientHeight = clientHintsRequest.viewportHeight;
+    vuetifyOptions.ssr = typeof clientWidth === "number" ? {
+      clientWidth,
+      clientHeight
+    } : true;
+    if (clientHintsRequest.colorSchemeFromCookie)
+      vuetifyOptions.theme.defaultTheme = clientHintsRequest.colorSchemeFromCookie;
+    await nuxtApp.hooks.callHook("vuetify:ssr-client-hints", {
+      vuetifyOptions,
+      ssrClientHintsConfiguration,
+      ssrClientHints: state.value
+    });
+  });
+  return {
+    provide: reactive({
+      ssrClientHints: state
+    })
+  };
+});
+const AcceptClientHintsHeaders = {
+  prefersColorScheme: "Sec-CH-Prefers-Color-Scheme",
+  prefersReducedMotion: "Sec-CH-Prefers-Reduced-Motion",
+  viewportHeight: "Sec-CH-Viewport-Height",
+  viewportWidth: "Sec-CH-Viewport-Width"
+};
+const chromiumBasedBrowserFeatures = {
+  prefersColorScheme: (_, v) => v[0] >= 93,
+  prefersReducedMotion: (_, v) => v[0] >= 108,
+  viewportHeight: (_, v) => v[0] >= 108,
+  viewportWidth: (_, v) => v[0] >= 108
+};
+const allowedBrowsers = [
+  // 'edge',
+  // 'edge-ios',
+  ["chrome", chromiumBasedBrowserFeatures],
+  ["edge-chromium", chromiumBasedBrowserFeatures],
+  ["chromium-webview", chromiumBasedBrowserFeatures],
+  ["opera", {
+    prefersColorScheme: (android, v) => v[0] >= (android ? 66 : 79),
+    prefersReducedMotion: (android, v) => v[0] >= (android ? 73 : 94),
+    viewportHeight: (android, v) => v[0] >= (android ? 73 : 94),
+    viewportWidth: (android, v) => v[0] >= (android ? 73 : 94)
+  }]
+];
+const AcceptClientHintsRequestHeaders = Object.entries(AcceptClientHintsHeaders).reduce((acc, [key, value]) => {
+  acc[key] = value.toLowerCase();
+  return acc;
+}, {});
+const ClientHeaders = ["Accept-CH", "Vary", "Critical-CH"];
+function readClientHeader(name, headers) {
+  const value = headers[name];
+  if (Array.isArray(value))
+    return value[0];
+  return value;
+}
+function browserFeatureAvailable(userAgent, feature) {
+  if (userAgent == null || userAgent.type !== "browser")
+    return false;
+  try {
+    const browserName = userAgent.name;
+    const android = userAgent.os?.toLowerCase().startsWith("android") ?? false;
+    const versions = userAgent.version.split(".").map((v) => Number.parseInt(v));
+    return allowedBrowsers.some(([name, check]) => {
+      if (browserName !== name)
+        return false;
+      try {
+        return check[feature](android, versions);
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+function lookupClientHints(userAgent, ssrClientHintsConfiguration2) {
+  const features = {
+    firstRequest: true,
+    prefersColorSchemeAvailable: false,
+    prefersReducedMotionAvailable: false,
+    viewportHeightAvailable: false,
+    viewportWidthAvailable: false
+  };
+  if (userAgent == null || userAgent.type !== "browser")
+    return features;
+  if (ssrClientHintsConfiguration2.prefersColorScheme)
+    features.prefersColorSchemeAvailable = browserFeatureAvailable(userAgent, "prefersColorScheme");
+  if (ssrClientHintsConfiguration2.prefersReducedMotion)
+    features.prefersReducedMotionAvailable = browserFeatureAvailable(userAgent, "prefersReducedMotion");
+  if (ssrClientHintsConfiguration2.viewportSize) {
+    features.viewportHeightAvailable = browserFeatureAvailable(userAgent, "viewportHeight");
+    features.viewportWidthAvailable = browserFeatureAvailable(userAgent, "viewportWidth");
+  }
+  return features;
+}
+function collectClientHints(userAgent, ssrClientHintsConfiguration2, headers) {
+  const hints = lookupClientHints(userAgent, ssrClientHintsConfiguration2);
+  if (ssrClientHintsConfiguration2.prefersColorScheme) {
+    if (ssrClientHintsConfiguration2.prefersColorSchemeOptions) {
+      const cookieName = ssrClientHintsConfiguration2.prefersColorSchemeOptions.cookieName;
+      const cookieValue = readClientHeader("cookie", headers)?.split(";").find((c) => c.trim().startsWith(`${cookieName}=`));
+      if (cookieValue) {
+        const value = cookieValue.split("=")?.[1].trim();
+        if (ssrClientHintsConfiguration2.prefersColorSchemeOptions.themeNames.includes(value)) {
+          hints.colorSchemeFromCookie = value;
+          hints.firstRequest = false;
+        }
+      }
+    }
+    if (!hints.colorSchemeFromCookie) {
+      const value = hints.prefersColorSchemeAvailable ? readClientHeader(AcceptClientHintsRequestHeaders.prefersColorScheme, headers)?.toLowerCase() : void 0;
+      if (value === "dark" || value === "light" || value === "no-preference") {
+        hints.prefersColorScheme = value;
+        hints.firstRequest = false;
+      }
+      if (ssrClientHintsConfiguration2.prefersColorSchemeOptions) {
+        if (!value || value === "no-preference") {
+          hints.colorSchemeFromCookie = ssrClientHintsConfiguration2.prefersColorSchemeOptions.defaultTheme;
+        } else {
+          hints.colorSchemeFromCookie = value === "dark" ? ssrClientHintsConfiguration2.prefersColorSchemeOptions.darkThemeName : ssrClientHintsConfiguration2.prefersColorSchemeOptions.lightThemeName;
+        }
+      }
+    }
+  }
+  if (hints.prefersReducedMotionAvailable && ssrClientHintsConfiguration2.prefersReducedMotion) {
+    const value = readClientHeader(AcceptClientHintsRequestHeaders.prefersReducedMotion, headers)?.toLowerCase();
+    if (value === "no-preference" || value === "reduce") {
+      hints.prefersReducedMotion = value;
+      hints.firstRequest = false;
+    }
+  }
+  if (hints.viewportHeightAvailable && ssrClientHintsConfiguration2.viewportSize) {
+    const header = readClientHeader(AcceptClientHintsRequestHeaders.viewportHeight, headers);
+    if (header) {
+      hints.firstRequest = false;
+      try {
+        hints.viewportHeight = Number.parseInt(header);
+      } catch {
+        hints.viewportHeight = ssrClientHintsConfiguration2.clientHeight;
+      }
+    }
+  } else {
+    hints.viewportHeight = ssrClientHintsConfiguration2.clientHeight;
+  }
+  if (hints.viewportWidthAvailable && ssrClientHintsConfiguration2.viewportSize) {
+    const header = readClientHeader(AcceptClientHintsRequestHeaders.viewportWidth, headers);
+    if (header) {
+      hints.firstRequest = false;
+      try {
+        hints.viewportWidth = Number.parseInt(header);
+      } catch {
+        hints.viewportWidth = ssrClientHintsConfiguration2.clientWidth;
+      }
+    }
+  } else {
+    hints.viewportWidth = ssrClientHintsConfiguration2.clientWidth;
+  }
+  return hints;
+}
+function writeClientHintHeaders(key, headers) {
+  ClientHeaders.forEach((header) => {
+    headers[header] = (headers[header] ? headers[header] : []).concat(key);
+  });
+}
+function writeClientHintsResponseHeaders(clientHintsRequest, ssrClientHintsConfiguration2, response) {
+  const headers = {};
+  if (ssrClientHintsConfiguration2.prefersColorScheme && clientHintsRequest.prefersColorSchemeAvailable)
+    writeClientHintHeaders(AcceptClientHintsHeaders.prefersColorScheme, headers);
+  if (ssrClientHintsConfiguration2.prefersReducedMotion && clientHintsRequest.prefersReducedMotionAvailable)
+    writeClientHintHeaders(AcceptClientHintsHeaders.prefersReducedMotion, headers);
+  if (ssrClientHintsConfiguration2.viewportSize && clientHintsRequest.viewportHeightAvailable && clientHintsRequest.viewportWidthAvailable) {
+    writeClientHintHeaders(AcceptClientHintsHeaders.viewportHeight, headers);
+    writeClientHintHeaders(AcceptClientHintsHeaders.viewportWidth, headers);
+  }
+  if (Object.keys(headers).length === 0)
+    return;
+  withNuxtAppRendered(() => {
+    Object.entries(headers).forEach(([key, value]) => {
+      response.setHeader(key, value);
+    });
+  });
+}
+function withNuxtAppRendered(callback) {
+  const nuxtApp = useNuxtApp();
+  const unhook = nuxtApp.hooks.hookOnce("app:rendered", callback);
+  nuxtApp.hooks.hookOnce("app:error", () => {
+    unhook();
+    return callback();
+  });
+}
+function writeThemeCookie(clientHintsRequest, ssrClientHintsConfiguration2) {
+  if (!ssrClientHintsConfiguration2.prefersColorScheme || !ssrClientHintsConfiguration2.prefersColorSchemeOptions)
+    return;
+  const cookieName = ssrClientHintsConfiguration2.prefersColorSchemeOptions.cookieName;
+  const themeName = clientHintsRequest.colorSchemeFromCookie ?? ssrClientHintsConfiguration2.prefersColorSchemeOptions.defaultTheme;
+  const path = ssrClientHintsConfiguration2.prefersColorSchemeOptions.baseUrl;
+  const date = /* @__PURE__ */ new Date();
+  const expires = new Date(date.setDate(date.getDate() + 365));
+  if (!clientHintsRequest.firstRequest || !ssrClientHintsConfiguration2.reloadOnFirstRequest) {
+    useCookie(cookieName, {
+      path,
+      expires,
+      sameSite: "lax"
+    }).value = themeName;
+  }
+  return `${cookieName}=${themeName}; Path=${path}; Expires=${expires.toUTCString()}; SameSite=Lax`;
+}

package/dist/types.d.ts

@@ -12,4 +12,4 @@ declare module 'nuxt/schema' {
 }
 
 
-export { ComponentName, Components, DateAdapter, DateOptions, DirectiveName, Directives, ExternalVuetifyOptions, FontAwesomeSvgIconSet, FontIconSet, IconFontName, IconSetName, IconsOptions, InlineModuleOptions, JSSVGIconSet, LabComponentName, LabComponents, MOptions, ModuleOptions, VOptions, VuetifyLocale, default } from './module'
+export { ComponentName, Components, DateAdapter, DateOptions, DirectiveName, Directives, ExternalVuetifyOptions, FontAwesomeSvgIconSet, FontIconSet, IconFontName, IconSetName, IconsOptions, InlineModuleOptions, JSSVGIconSet, LabComponentName, LabComponents, MOptions, ModuleOptions, SSRClientHints, SSRClientHintsConfiguration, VOptions, VuetifyLocale, default } from './module'

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "vuetify-nuxt-module",
   "type": "module",
-  "version": "0.5.9",
-  "packageManager": "pnpm@8.7.4",
+  "version": "0.5.10",
+  "packageManager": "pnpm@8.7.6",
   "description": "Zero-Config Nuxt Module for Vuetify",
   "author": "userquin <userquin@gmail.com>",
   "license": "MIT",
@@ -128,4 +128,4 @@
     "installDependencies": false,
     "startCommand": "node .stackblitz.js && pnpm install && pnpm run dev"
   }
-}
+}