vuetify-nuxt-module 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-PRESENT Joaquín Sánchez <https://github.com/userquin>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+<p align='center'>
+<img src='./hero.svg' alt="vuetify-nuxt-module - Zero-config Nuxt module for Vuetify"><br>
+Zero-config Nuxt module for Vuetify
+</p>
+
+<p align='center'>
+<a href='https://www.npmjs.com/package/vuetify-nuxt-module' target="__blank">
+<img src='https://img.shields.io/npm/v/vuetify-nuxt-module?color=33A6B8&label=' alt="NPM version">
+</a>
+<a href="https://www.npmjs.com/package/vuetify-nuxt-module" target="__blank">
+    <img alt="NPM Downloads" src="https://img.shields.io/npm/dm/vuetify-nuxt-module?color=476582&label=">
+</a>
+<!--
+<a href="https://vite-pwa-org.netlify.app/frameworks/nuxt" target="__blank">
+    <img src="https://img.shields.io/static/v1?label=&message=docs%20%26%20guides&color=2e859c" alt="Docs & Guides">
+</a>
+-->
+<br>
+<a href="https://github.com/userquin/vuetify-nuxt-module" target="__blank">
+<img alt="GitHub stars" src="https://img.shields.io/github/stars/userquin/vuetify-nuxt-module?style=social">
+</a>
+</p>
+
+<br>
+
+## 🚀 Features
+
+- 📖 [**Documentation & guides**](README.md#-features) (WIP)
+- 👌 **Zero-Config**: sensible built-in default [Vuetify](https://vuetifyjs.com/) configuration for common use cases
+- 🔩 **Extensible**: expose the ability to customize the Vuetify configuration via [Nuxt Plugin Hooks](https://nuxt.com/docs/guide/going-further/hooks#usage-with-plugins)
+- ⚡ **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
+- 🦾 **Type Strong**: written in [TypeScript](https://www.typescriptlang.org/)
+
+## 📦 Install
+
+> Requires Vite 3.2.0+, will not work with Webpack
+
+```bash
+npm i vuetify-nuxt-module -D 
+
+# yarn 
+yarn add vuetify-nuxt-module -D
+
+# pnpm 
+pnpm add vuetify-nuxt-module -D
+```
+
+## 🦄 Usage
+
+> `vuetify-nuxt-module` is strongly opinionated and has a built-in default configuration out of the box. You can use it without any configuration, and it will work for most use cases.
+
+Add `vuetify-nuxt-module` module to `nuxt.config.ts` and configure it:
+
+```ts
+// nuxt.config.ts
+import { defineNuxtConfig } from 'nuxt/config'
+
+export default defineNuxtConfig({
+  modules: [
+    'vuetify-nuxt-module'
+  ],
+  vuetify: {
+    moduleOptions: {
+      /* module specific options */
+    },
+    vuetifyOptions: {
+      /* vuetify options */
+    }
+  }
+})
+```
+
+<!--
+Read the [📖 documentation](https://vite-pwa-org.netlify.app/frameworks/nuxt) for a complete guide on how to configure and use
+this plugin.
+-->
+
+## 👀 Full config
+
+**WIP**
+<!--
+Check out the type declaration [src/types.ts](./src/types.ts) and the following links for more details.
+
+- [Web app manifests](https://developer.mozilla.org/en-US/docs/Web/Manifest)
+- [Workbox](https://developers.google.com/web/tools/workbox)
+-->
+
+## 📄 License
+
+[MIT](./LICENSE) License &copy; 2023-PRESENT [Joaquín Sánchez](https://github.com/userquin)

package/configuration.d.ts

@@ -0,0 +1,6 @@
+declare module 'virtual:vuetify-configuration' {
+  import type { VuetifyOptions } from 'vuetify';
+
+  export const isDev: boolean
+  export const vuetifyConfiguration: () => VuetifyOptions
+}

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -0,0 +1,46 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { VuetifyOptions } from 'vuetify';
+
+type BooleanOrArrayString = boolean | string[];
+interface VOptions extends Partial<Omit<VuetifyOptions, 'ssr' | 'directives'>> {
+    /**
+     * Include the lab components?
+     *
+     * You can include all lab components configuring `labComponents: true`.
+     *
+     * You can provide an array with the names of the lab components to include.
+     *
+     * @see https://vuetifyjs.com/en/labs/introduction/
+     *
+     * @default false
+     */
+    labComponents?: BooleanOrArrayString;
+    /**
+     * Include the directives?
+     *
+     * You can include all directives configuring `directives: true`.
+     *
+     * You can provide an array with the names of the directives to include.
+     *
+     * @default false
+     */
+    directives?: BooleanOrArrayString;
+}
+interface ModuleOptions {
+    moduleOptions?: {
+        writePlugin?: boolean;
+        styles?: true | 'none' | 'expose' | 'sass' | {
+            configFile: string;
+        };
+    };
+    vuetifyOptions?: VOptions;
+}
+declare module '#app' {
+    interface RuntimeNuxtHooks {
+        'vuetify:configuration': (vuetifyOptions: VuetifyOptions) => void;
+    }
+}
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { BooleanOrArrayString, ModuleOptions, VOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,8 @@
+{
+  "name": "vuetify-nuxt-module",
+  "configKey": "vuetify",
+  "compatibility": {
+    "nuxt": "^3.0.0"
+  },
+  "version": "0.0.1"
+}

package/dist/module.mjs

@@ -0,0 +1,326 @@
+import { useLogger, defineNuxtModule, createResolver, extendWebpackConfig, addPluginTemplate } from '@nuxt/kit';
+import defu from 'defu';
+import vuetify from 'vite-plugin-vuetify';
+import { utimes } from 'node:fs/promises';
+import { resolveVuetifyBase, normalizePath, writeStyles, cacheDir } from '@vuetify/loader-shared';
+import * as path from 'upath';
+import { normalizePath as normalizePath$1 } from 'vite';
+
+const version = "0.0.1";
+
+function isSubdir(root, test) {
+  const relative = path.relative(root, test);
+  return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+const styleImportRegexp = /(@use |meta\.load-css\()['"](vuetify(?:\/lib)?(?:\/styles(?:\/main(?:\.sass)?)?)?)['"]/;
+function stylesPlugin(options, logger) {
+  const vuetifyBase = resolveVuetifyBase();
+  const files = /* @__PURE__ */ new Set();
+  let server;
+  let context;
+  let resolve;
+  let promise;
+  let needsTouch = false;
+  const blockingModules = /* @__PURE__ */ new Set();
+  let pendingModules;
+  async function getPendingModules() {
+    if (!server) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const modules = Array.from(context.getModuleIds()).filter((id) => {
+        return !blockingModules.has(id) && !/\w\.(s[ac]|c)ss/.test(id);
+      }).map((id) => context.getModuleInfo(id)).filter((module) => module.code == null);
+      pendingModules = modules.map((module) => module.id);
+      if (!pendingModules.length)
+        return 0;
+      const promises = modules.map((module) => context.load(module));
+      await Promise.race(promises);
+      return promises.length;
+    } else {
+      const modules = Array.from(server.moduleGraph.urlToModuleMap.entries()).filter(([k, v]) => v.transformResult == null && !k.startsWith("/@id/") && !/\w\.(s[ac]|c)ss/.test(k) && !blockingModules.has(v.id) && !/\/node_modules\/\.vite\/deps\/(?!vuetify[._])/.test(k));
+      pendingModules = modules.map(([, v]) => v.id);
+      if (!pendingModules.length)
+        return 0;
+      const promises = modules.map(([k, v]) => server.transformRequest(k).then(() => v));
+      await Promise.race(promises);
+      return promises.length;
+    }
+  }
+  let timeout;
+  async function awaitBlocking() {
+    let pending;
+    do {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        console.error("vuetify:styles fallback timeout hit", {
+          blockingModules: Array.from(blockingModules.values()),
+          pendingModules,
+          // @ts-expect-error not exported?
+          pendingRequests: server?._pendingRequests.keys()
+        });
+        resolve(false);
+      }, options.stylesTimeout);
+      pending = await Promise.any([
+        promise,
+        getPendingModules()
+      ]);
+      logger.info(pending, "pending modules", pendingModules);
+    } while (pending);
+    resolve(false);
+  }
+  async function awaitResolve(id) {
+    if (id)
+      blockingModules.add(id);
+    if (!promise) {
+      promise = new Promise((_resolve) => resolve = _resolve);
+      awaitBlocking();
+      await promise;
+      clearTimeout(timeout);
+      blockingModules.clear();
+      logger.info("writing styles");
+      await writeStyles(files);
+      if (server && needsTouch) {
+        const cacheFile = normalizePath$1(cacheDir("styles.scss"));
+        logger.log("cacheFile", cacheFile);
+        server.moduleGraph.getModulesByFile(cacheFile)?.forEach((module) => {
+          module.importers.forEach((module2) => {
+            if (module2.file) {
+              const now = /* @__PURE__ */ new Date();
+              logger.info(`touching ${module2.file}`);
+              utimes(module2.file, now, now);
+            }
+          });
+        });
+        needsTouch = false;
+      }
+      promise = null;
+    }
+    return promise;
+  }
+  let configFile;
+  const tempFiles = /* @__PURE__ */ new Map();
+  return {
+    name: "vuetify:styles:nuxt",
+    enforce: "pre",
+    configureServer(_server) {
+      server = _server;
+    },
+    buildStart() {
+      if (!server) {
+        context = this;
+      }
+    },
+    configResolved(config) {
+      if (typeof options.styles === "object") {
+        if (path.isAbsolute(options.styles.configFile))
+          configFile = options.styles.configFile;
+        else
+          configFile = path.join(config.root || process.cwd(), options.styles.configFile);
+      }
+    },
+    async resolveId(source, importer, { custom }) {
+      if (source === "vuetify/styles" || importer && source.endsWith(".css") && isSubdir(vuetifyBase, path.isAbsolute(source) ? source : importer)) {
+        if (options.styles === "none") {
+          return "/@plugin-vuetify/lib/__void__";
+        } else if (options.styles === "sass") {
+          const target = source.replace(/\.css$/, ".sass");
+          return this.resolve(target, importer, { skipSelf: true, custom });
+        } else if (options.styles === "expose") {
+          awaitResolve();
+          const resolution = await this.resolve(
+            source.replace(/\.css$/, ".sass"),
+            importer,
+            { skipSelf: true, custom }
+          );
+          if (resolution) {
+            if (!files.has(resolution.id)) {
+              needsTouch = true;
+              files.add(resolution.id);
+            }
+            return "/@plugin-vuetify/lib/__void__";
+          }
+        } else if (typeof options.styles === "object") {
+          const resolution = await this.resolve(source, importer, { skipSelf: true, custom });
+          if (!resolution)
+            return null;
+          const target = resolution.id.replace(/\.css$/, ".sass");
+          const file = path.relative(path.join(vuetifyBase, "lib"), target);
+          const contents = `@use "${normalizePath(configFile)}"
+@use "${normalizePath(target)}"`;
+          tempFiles.set(file, contents);
+          return `/@plugin-vuetify/lib/${file}`;
+        }
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (options.styles === "expose" && [".scss", ".sass"].some((v) => id.endsWith(v)) && styleImportRegexp.test(code)) {
+        logger.info(`awaiting ${id}`);
+        await awaitResolve(id);
+        logger.info(`returning ${id}`);
+        return {
+          code: code.replace(styleImportRegexp, '$1".cache/vuetify/styles.scss"'),
+          map: null
+        };
+      }
+    },
+    load(id) {
+      if (/^\/@plugin-vuetify\/lib\/__void__(\?.*)?$/.test(id))
+        return "";
+      if (id.startsWith("/@plugin-vuetify/lib/")) {
+        const file = /^\/@plugin-vuetify\/lib\/(.*?)(\?.*)?$/.exec(id)[1];
+        return tempFiles.get(file);
+      }
+    }
+  };
+}
+
+function vuetifyConfigurationPlugin(isDev, directives, labComponents, vuetifyAppOptions) {
+  const VIRTUAL_VUETIFY_CONFIGURATION = "virtual:vuetify-configuration";
+  const RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION = `\0${VIRTUAL_VUETIFY_CONFIGURATION}`;
+  return {
+    name: "vuetify:configuration:nuxt",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_VUETIFY_CONFIGURATION)
+        return RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION;
+    },
+    async load(id) {
+      if (id === RESOLVED_VIRTUAL_VUETIFY_CONFIGURATION) {
+        const directivesResult = buildDirectives();
+        const labsComponentsResult = buildLabsComponents();
+        return `${directivesResult.imports}
+${labsComponentsResult.imports}
+
+export const isDev = ${isDev}
+export function vuetifyConfiguration() {
+  const options = ${JSON.stringify(vuetifyAppOptions)}
+  ${directivesResult.expression}
+  ${labsComponentsResult.expression}
+  return options
+}
+`;
+      }
+    }
+  };
+  function buildDirectives() {
+    if (!directives)
+      return { imports: "", expression: "" };
+    if (typeof directives === "boolean") {
+      return {
+        imports: "import * as directives from 'vuetify/directives'",
+        expression: "options.directives = directives"
+      };
+    } else {
+      return {
+        imports: `${directives.map((d) => `import { ${d} } from 'vuetify/directives/${d}'`).join("\n")}`,
+        expression: `options.directives = {${directives.join(",")}}`
+      };
+    }
+  }
+  function buildLabsComponents() {
+    if (!labComponents)
+      return { imports: "", expression: "" };
+    if (typeof labComponents === "boolean") {
+      return {
+        imports: "import * as labsComponents from 'vuetify/labs/components'",
+        expression: "options.components = labsComponents"
+      };
+    } else {
+      return {
+        imports: `${labComponents.map((d) => `import { ${d} } from 'vuetify/labs/${d}'`).join("\n")}`,
+        expression: `options.components = {${labComponents.join(",")}}`
+      };
+    }
+  }
+}
+
+const CONFIG_KEY = "vuetify";
+const logger = useLogger(`nuxt:${CONFIG_KEY}`);
+const module = defineNuxtModule({
+  meta: {
+    name: "vuetify-nuxt-module",
+    configKey: "vuetify",
+    compatibility: { nuxt: "^3.0.0" },
+    version
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    vuetifyOptions: {
+      labComponents: false,
+      directives: false
+    },
+    moduleOptions: {
+      writePlugin: true,
+      styles: true
+    }
+  },
+  setup(options, nuxt) {
+    var _a;
+    const resolver = createResolver(import.meta.url);
+    const { moduleOptions, vuetifyOptions } = options;
+    const {
+      directives = false,
+      labComponents = false,
+      ...vOptions
+    } = vuetifyOptions ?? {};
+    const isSSR = nuxt.options.ssr;
+    const vuetifyAppOptions = defu(vOptions, {
+      ssr: isSSR
+    });
+    const runtimeDir = resolver.resolve("./runtime");
+    nuxt.options.build.transpile.push(runtimeDir);
+    nuxt.options.build.transpile.push(CONFIG_KEY);
+    const { styles = true, writePlugin = nuxt.options.dev } = moduleOptions ?? {};
+    nuxt.options.build.transpile.push(CONFIG_KEY);
+    (_a = nuxt.options).css ?? (_a.css = []);
+    if (typeof styles === "string" && ["sass", "expose"].includes(styles))
+      nuxt.options.css.unshift("vuetify/styles/main.sass");
+    else if (styles === true)
+      nuxt.options.css.unshift("vuetify/styles");
+    else if (typeof styles === "object" && styles?.configFile && typeof styles.configFile === "string")
+      nuxt.options.css.unshift(styles.configFile);
+    extendWebpackConfig(() => {
+      throw new Error("Webpack is not supported yet: vuetify-nuxt-module module can only be used with Vite!");
+    });
+    nuxt.hook("vite:extend", ({ config }) => checkVuetifyPlugins(config));
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({ types: "vuetify-nuxt-module/configuration" });
+      references.push({ types: "vuetify/components" });
+    });
+    nuxt.hook("vite:extendConfig", (viteInlineConfig) => {
+      viteInlineConfig.plugins = viteInlineConfig.plugins || [];
+      checkVuetifyPlugins(viteInlineConfig);
+      viteInlineConfig.optimizeDeps = defu(viteInlineConfig.optimizeDeps, { exclude: ["vuetify"] });
+      viteInlineConfig.ssr || (viteInlineConfig.ssr = {});
+      viteInlineConfig.ssr.noExternal = [
+        ...Array.isArray(viteInlineConfig.ssr.noExternal) ? viteInlineConfig.ssr.noExternal : [],
+        CONFIG_KEY
+      ];
+      const autoImportPlugin = vuetify({ styles, autoImport: true }).find((p) => p && typeof p === "object" && "name" in p && p.name === "vuetify:import");
+      viteInlineConfig.plugins.push(autoImportPlugin);
+      viteInlineConfig.plugins.push(stylesPlugin({ styles }, logger));
+      viteInlineConfig.plugins.push(vuetifyConfigurationPlugin(
+        nuxt.options.dev,
+        directives,
+        labComponents,
+        vuetifyAppOptions
+      ));
+    });
+    addPluginTemplate({
+      src: resolver.resolve(runtimeDir, "templates/plugin.mts"),
+      write: nuxt.options.dev || writePlugin
+    }, {
+      append: true
+    });
+  }
+});
+function checkVuetifyPlugins(config) {
+  let plugin = config.plugins?.find((p) => p && typeof p === "object" && "name" in p && p.name === "vuetify:import");
+  if (plugin)
+    throw new Error("Remove vite-plugin-vuetify plugin from Vite Plugins entry in Nuxt config file!");
+  plugin = config.plugins?.find((p) => p && typeof p === "object" && "name" in p && p.name === "vuetify:styles");
+  if (plugin)
+    throw new Error("Remove vite-plugin-vuetify plugin from Vite Plugins entry in Nuxt config file!");
+}
+
+export { module as default };

package/dist/runtime/templates/plugin.mts

@@ -0,0 +1,30 @@
+import { createVuetify } from 'vuetify'
+import { isDev, vuetifyConfiguration } from 'virtual:vuetify-configuration'
+import { defineNuxtPlugin, useNuxtApp } from '#app'
+
+export default defineNuxtPlugin({
+  name: 'vuetify:configuration:plugin',
+  enforce: 'post',
+  parallel: false,
+  async setup() {
+    const nuxtApp = useNuxtApp()
+    const options = vuetifyConfiguration()
+
+    await nuxtApp.hooks.callHook('vuetify:configuration', options)
+
+    const vuetify = createVuetify(vuetifyConfiguration())
+
+    nuxtApp.vueApp.use(vuetify)
+
+    if (!process.server && isDev) {
+      // eslint-disable-next-line no-console
+      console.log('Vuetify 3 initialized', vuetify)
+    }
+
+    return {
+      provide: {
+        vuetify,
+      },
+    }
+  },
+})

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+
+import { ModuleOptions } from './module'
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['vuetify']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['vuetify']?: ModuleOptions }
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['vuetify']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['vuetify']?: ModuleOptions }
+}
+
+
+export { BooleanOrArrayString, ModuleOptions, VOptions, default } from './module'

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "vuetify-nuxt-module",
+  "type": "module",
+  "version": "0.0.1",
+  "packageManager": "pnpm@8.6.5",
+  "description": "Zero-Config Nuxt Module for Vuetify ",
+  "author": "userquin <userquin@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/userquin/vuetify-nuxt-module#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/userquin/vuetify-nuxt-module.git"
+  },
+  "bugs": "https://github.com/userquin/vuetify-nuxt-module/issues",
+  "keywords": [
+    "nuxt",
+    "nuxt 3",
+    "vuetify",
+    "vuetify 3",
+    "nuxt-module"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "require": "./dist/module.cjs",
+      "import": "./dist/module.mjs"
+    },
+    "./configuration": {
+      "types": "./configuration.d.ts"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist",
+    "*.d.ts"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "prepublishOnly": "npm run prepack",
+    "release": "bumpp && npm publish",
+    "lint": "eslint .",
+    "lint:fix": "nr lint --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": "^3.5.3",
+    "vite-plugin-vuetify": "^1.0.2",
+    "vuetify": "^3.3.6"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^3.6.1",
+    "defu": "^6.1.2",
+    "vite-plugin-vuetify": "^1.0.2",
+    "vuetify": "^3.3.6"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^0.39.6",
+    "@antfu/ni": "^0.21.4",
+    "@nuxt/devtools": "^0.6.6",
+    "@nuxt/module-builder": "^0.4.0",
+    "@nuxt/schema": "^3.6.1",
+    "@nuxt/test-utils": "^3.6.1",
+    "@parcel/watcher": "^2.1.0",
+    "@types/node": "^18",
+    "bumpp": "^9.1.1",
+    "eslint": "^8.43.0",
+    "nuxt": "^3.6.1",
+    "sass": "^1.63.6",
+    "typescript": "^5.1.6",
+    "vite": "^4.3.9",
+    "vitest": "^0.31.4"
+  },
+  "build": {
+    "externals": [
+      "@vuetify/loader-shared",
+      "node:child_process",
+      "node:fs",
+      "consola",
+      "esbuild",
+      "pathe",
+      "rollup",
+      "upath",
+      "ufo",
+      "vite",
+      "vite-plugin-vuetify",
+      "vuetify"
+    ]
+  }
+}