@jojomatik/nuxt-bundle 2.0.0-beta.3 → 2.0.0-beta.31

package/README.md

@@ -3,5 +3,62 @@
 
 A bundle of commonly used nuxt dependencies and configuration.
 
+## Usage
+Extend your Nuxt configuration with `@jojomatik/nuxt-bundle` to use its shared dependencies and configuration. Dependency licenses are validated during builds.
+
+Use `licenseModule.licenseOverrides` to provide license metadata for dependencies whose manifests omit it. Overrides are still checked against `licenseModule.allowedLicenses`:
+
+```ts
+export default defineNuxtConfig({
+  extends: "@jojomatik/nuxt-bundle",
+  licenseModule: {
+    licenseOverrides: {
+      "socket.io-client": "MIT",
+    },
+  },
+});
+```
+
+Dependencies without an override still fail validation when their license metadata is missing.
+An override can also be a function that receives the license from the package metadata. For example, to supply MIT only when the license is missing:
+
+```ts
+licenseOverrides: {
+  "socket.io-client": (license) => license || "MIT",
+}
+```
+
+Use an object in `allowedLicenses` to allow a license only for specific dependencies:
+
+```ts
+licenseModule: {
+  allowedLicenses: [
+    "MIT",
+    { "SEE LICENSE IN LICENSE.md": ["apexcharts", "vue-apexcharts"] },
+  ],
+}
+```
+
+## Favicons
+The favicon module is opt-in. When enabled, it generates all favicon files from a single SVG during the build:
+
+```ts
+export default defineNuxtConfig({
+  extends: "@jojomatik/nuxt-bundle",
+  faviconModule: {
+    enabled: true,
+    // source: "public/favicon.svg",
+  },
+});
+```
+
+- `source` is the SVG to generate from (default `public/favicon.svg`). If it does not exist, nothing is generated.
+
+Generated files: `favicon.ico`, `favicon-16x16.png`, `favicon-32x32.png`, `apple-touch-icon.png`, `android-chrome-192x192.png`, `android-chrome-512x512.png`, `safari-pinned-tab.svg` and `site.webmanifest`.
+
+The files are written to a cache directory under `node_modules/.cache` (not your source tree) and served from `/assets/favicon/` with `max-age=0`, so clients revalidate them (the file names are not versioned). A file that already exists in `public/assets/favicon/` is never generated or overridden, so you can supply your own version of any of them.
+
+The `site.webmanifest` uses the `name` from your `package.json` (without scope, default `App`) as `name` and `short_name`, and the `primary` and `background` colors of the default Vuetify theme (set via `vuetify.vuetifyOptions.theme`) as `theme_color` and `background_color` (default `#ffffff`).
+
 ## Licensing
 This project is licensed under the MIT License (MIT). See also [`LICENSE`](LICENSE).

package/app/components/CLicenseCard.stories.ts

@@ -0,0 +1,21 @@
+import { CLicenseCard } from "@crystal-creations/crystal-components";
+
+export default {
+  title: "Molecules/CLicenseCard",
+  component: CLicenseCard,
+  args: {
+    softwareInfo: {
+      name: "Example package",
+      version: "1.2.3",
+      author: "Example Author",
+      repositoryLink: "https://github.com/example/example-package",
+      notice: `MIT License
+
+Copyright (c) 2026 Example Author
+
+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.`,
+    },
+  },
+};
+
+export const Default = {};

package/app/pages/license-information.vue

@@ -68,8 +68,8 @@ function softwareInfo() {
         // 1. Remove `[...]github.com` prefix with protocol etc., if present.
         // 2. Remove `.git` suffix, if present.
         const repositoryCoordinates = repositoryLink
-          .replace(/.+?(github.com\/)/, "")
-          .replace(".git", "");
+          .replace(/^(?:.*?github\.com\/)?/, "")
+          .replace(/\.git$/, "");
 
         // 3. Prepend `https://github.com/`.
         repositoryLink = "https://github.com/" + repositoryCoordinates;

package/lib/license-plugin-options.ts

@@ -0,0 +1,104 @@
+import {
+  applyLicenseOverrides,
+  validateDependencyLicense,
+  type LicenseOverride,
+} from "./license-validation.ts";
+
+type AllowedLicense = string | Record<string, string[]>;
+
+type LicenseModuleOptions = {
+  allowedLicenses: AllowedLicense[];
+  licenseOverrides?: Record<string, LicenseOverride>;
+};
+
+type LicenseLogger = {
+  error(message: string): void;
+  info(message: string): void;
+};
+
+type LicenseDependency = {
+  name: string;
+  license?: string | null;
+};
+
+const envKey = "ALLOWED_LICENCES";
+
+export function createLicensePluginOptions(
+  options: LicenseModuleOptions,
+  logger: LicenseLogger,
+) {
+  return {
+    thirdParty: {
+      includePrivate: false,
+      allow: {
+        test: (dependency: LicenseDependency) => {
+          const allowedLicensesFromEnv = process.env[envKey]
+            ?.split(",")
+            .map((license) => license.trim());
+          const allowedLicenses =
+            allowedLicensesFromEnv ?? options.allowedLicenses;
+          const dependencyAllowedLicenses = allowedLicenses.flatMap(
+            (allowedLicense) => {
+              if (typeof allowedLicense === "string") return [allowedLicense];
+
+              return Object.entries(allowedLicense)
+                .filter(([, dependencies]) =>
+                  dependencies.includes(dependency.name),
+                )
+                .map(([license]) => license);
+            },
+          );
+          const overrides = options.licenseOverrides ?? {};
+          const validation = validateDependencyLicense(
+            dependency,
+            overrides,
+            dependencyAllowedLicenses,
+          );
+
+          if (!validation.license) return false;
+
+          if (!validation.isAllowed) {
+            logger.error(
+              `Dependency "${dependency.name}" has a license (${validation.license}) that is not in the dependency-specific list of allowed licenses (${dependencyAllowedLicenses.join(", ")}).`,
+            );
+
+            const requiredLicenses = [...allowedLicenses, validation.license];
+            const configContent = JSON.stringify(
+              {
+                extends: "@jojomatik/nuxt-bundle",
+                licenseModule: {
+                  allowedLicenses: requiredLicenses,
+                },
+              },
+              undefined,
+              2,
+            );
+            const configExample =
+              "export default defineNuxtConfig(" + configContent + ");\n";
+
+            logger.info(
+              `You can specify allowed licenses in "nuxt.config.ts" environment variable:`,
+            );
+            console.log(configExample);
+
+            logger.info(
+              `You can also specify allowed licenses via "${envKey}" environment variable (ALLOWED_LICENCES=${requiredLicenses.join(",")}).`,
+            );
+          }
+
+          return validation.isAllowed;
+        },
+        failOnUnlicensed: true,
+        failOnViolation: true,
+      },
+      output: {
+        file: "public/dependencies.json",
+        template(dependencies: LicenseDependency[]) {
+          return JSON.stringify(
+            applyLicenseOverrides(dependencies, options.licenseOverrides ?? {}),
+          );
+        },
+      },
+    },
+  };
+}

package/lib/license-validation.ts

@@ -0,0 +1,44 @@
+type LicenseDependency = {
+  name: string;
+  license?: string | null;
+};
+
+export type LicenseOverride =
+  string | ((license: string | undefined) => string | undefined);
+
+function resolveLicense(
+  dependency: LicenseDependency,
+  licenseOverrides: Record<string, LicenseOverride>,
+) {
+  const originalLicense = dependency.license ?? undefined;
+  const override = licenseOverrides[dependency.name];
+
+  if (!Object.hasOwn(licenseOverrides, dependency.name)) {
+    return originalLicense;
+  }
+
+  return typeof override === "function" ? override(originalLicense) : override;
+}
+
+export function validateDependencyLicense(
+  dependency: LicenseDependency,
+  licenseOverrides: Record<string, LicenseOverride>,
+  allowedLicenses: string[],
+) {
+  const license = resolveLicense(dependency, licenseOverrides);
+
+  return {
+    license,
+    isAllowed: Boolean(license && allowedLicenses.includes(license)),
+  };
+}
+
+export function applyLicenseOverrides(
+  dependencies: LicenseDependency[],
+  licenseOverrides: Record<string, LicenseOverride>,
+) {
+  return dependencies.map((dependency) => ({
+    ...dependency,
+    license: resolveLicense(dependency, licenseOverrides),
+  }));
+}

package/modules/favicon-module.ts

@@ -0,0 +1,223 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { defineNuxtModule, resolvePath, useLogger } from "nuxt/kit";
+import sharp from "sharp";
+
+const moduleKey = "@jojomatik/nuxt-bundle/favicon-module";
+
+const logger = useLogger(moduleKey);
+
+/** URL path (below the app root) the files are served from. */
+export const publicPath = "assets/favicon";
+
+export interface FaviconModuleOptions {
+  /** Opt-in: favicons are only generated when set to `true`. */
+  enabled: boolean;
+  /** Path of the source SVG, relative to the project root. */
+  source: string;
+}
+
+/** PNG files to generate: file name and edge length in pixels. */
+export const pngTargets = [
+  { name: "favicon-16x16.png", size: 16 },
+  { name: "favicon-32x32.png", size: 32 },
+  { name: "apple-touch-icon.png", size: 180 },
+  { name: "android-chrome-192x192.png", size: 192 },
+  { name: "android-chrome-512x512.png", size: 512 },
+];
+
+/** Removes leading and trailing slashes without regular expressions. */
+export function trimSlashes(value: string): string {
+  let start = 0;
+  let end = value.length;
+  while (start < end && value[start] === "/") start++;
+  while (end > start && value[end - 1] === "/") end--;
+  return value.slice(start, end);
+}
+
+/** Wraps a PNG image in an ICO container. */
+export function pngToIco(png: Buffer, size: number): Buffer {
+  const header = Buffer.alloc(22);
+  header.writeUInt16LE(0, 0); // reserved
+  header.writeUInt16LE(1, 2); // type: icon
+  header.writeUInt16LE(1, 4); // image count
+  header.writeUInt8(size >= 256 ? 0 : size, 6);
+  header.writeUInt8(size >= 256 ? 0 : size, 7);
+  header.writeUInt16LE(1, 10); // color planes
+  header.writeUInt16LE(32, 12); // bits per pixel
+  header.writeUInt32LE(png.length, 14);
+  header.writeUInt32LE(header.length, 18);
+  return Buffer.concat([header, png]);
+}
+
+export interface ManifestInput {
+  name?: string;
+  themeColor?: string;
+  backgroundColor?: string;
+  publicPath: string;
+}
+
+/** Builds the web manifest content (icon URLs are relative to the manifest), falling back to sensible defaults. */
+export function createManifest({
+  name,
+  themeColor,
+  backgroundColor,
+}: ManifestInput) {
+  const appName = name?.trim() || "App";
+  // Icons are served next to the manifest, so resolve them relative to it.
+  const base = ".";
+  return {
+    name: appName,
+    short_name: appName,
+    icons: [
+      {
+        src: `${base}/android-chrome-192x192.png`,
+        sizes: "192x192",
+        type: "image/png",
+      },
+      {
+        src: `${base}/android-chrome-512x512.png`,
+        sizes: "512x512",
+        type: "image/png",
+      },
+    ],
+    theme_color: themeColor || "#ffffff",
+    background_color: backgroundColor || "#ffffff",
+    display: "standalone",
+  };
+}
+
+interface ThemeLike {
+  defaultTheme?: string;
+  themes?: Record<string, { colors?: Record<string, unknown> } | undefined>;
+}
+
+/** Reads a theme color of the default (or first) vuetify theme. */
+export function getThemeColor(
+  theme: ThemeLike | undefined,
+  color: string,
+): string | undefined {
+  const themes = theme?.themes ?? {};
+  const selected =
+    themes[theme?.defaultTheme ?? "light"] ?? Object.values(themes)[0];
+  const value = selected?.colors?.[color];
+  return typeof value === "string" ? value : undefined;
+}
+
+/**
+ * Generates all favicon files from the single SVG source.
+ * Returns the names of the generated files.
+ */
+export async function generateFavicons(
+  source: string,
+  outputDir: string,
+  skip: (name: string) => boolean = () => false,
+): Promise<string[]> {
+  fs.mkdirSync(outputDir, { recursive: true });
+  const svg = fs.readFileSync(source);
+  const generated: string[] = [];
+
+  const renderPng = (size: number) =>
+    sharp(svg, { density: 384 })
+      .resize(size, size, { fit: "contain", background: "#0000" })
+      .png()
+      .toBuffer();
+
+  const targets = pngTargets.filter(({ name }) => !skip(name));
+  const pngs = await Promise.all(targets.map(({ size }) => renderPng(size)));
+  targets.forEach(({ name }, index) => {
+    fs.writeFileSync(path.join(outputDir, name), pngs[index]);
+    generated.push(name);
+  });
+
+  if (!skip("favicon.ico")) {
+    const icoPng = await renderPng(48);
+    fs.writeFileSync(path.join(outputDir, "favicon.ico"), pngToIco(icoPng, 48));
+    generated.push("favicon.ico");
+  }
+
+  if (!skip("safari-pinned-tab.svg")) {
+    fs.copyFileSync(source, path.join(outputDir, "safari-pinned-tab.svg"));
+    generated.push("safari-pinned-tab.svg");
+  }
+
+  return generated;
+}
+
+export default defineNuxtModule<FaviconModuleOptions>({
+  meta: {
+    name: moduleKey,
+    configKey: "faviconModule",
+  },
+  defaults: {
+    enabled: false,
+    source: "public/favicon.svg",
+  },
+  async setup(options, nuxt) {
+    if (!options.enabled) {
+      return;
+    }
+
+    const source = path.resolve(nuxt.options.rootDir, options.source);
+    if (!fs.existsSync(source)) {
+      logger.info(`No favicon source found at ${source}, skipping.`);
+      return;
+    }
+
+    // Generated files live in a cache directory, never in the source tree.
+    // Nuxt's build directory can't be used, as it is cleaned during the build.
+    const outputDir = path.join(
+      nuxt.options.rootDir,
+      "node_modules/.cache/@jojomatik/nuxt-bundle/favicon",
+    );
+    const publicDir = await resolvePath(nuxt.options.dir.public);
+    const existsInSource = (name: string) =>
+      fs.existsSync(path.join(publicDir, publicPath, name));
+
+    nuxt.hook("nitro:config", async (nitroConfig) => {
+      const files = await generateFavicons(source, outputDir, existsInSource);
+
+      if (!existsInSource("site.webmanifest")) {
+        let name: string | undefined;
+        try {
+          name = JSON.parse(
+            fs.readFileSync(
+              path.join(nuxt.options.rootDir, "package.json"),
+              "utf-8",
+            ),
+          ).name;
+        } catch {
+          // no readable package.json, use the default name
+        }
+        if (name?.startsWith("@")) {
+          name = name.slice(name.indexOf("/") + 1);
+        }
+        const theme = (
+          nuxt.options as {
+            vuetify?: { vuetifyOptions?: { theme?: ThemeLike } };
+          }
+        ).vuetify?.vuetifyOptions?.theme;
+        const manifest = createManifest({
+          name,
+          themeColor: getThemeColor(theme, "primary"),
+          backgroundColor: getThemeColor(theme, "background"),
+          publicPath,
+        });
+        fs.writeFileSync(
+          path.join(outputDir, "site.webmanifest"),
+          JSON.stringify(manifest, null, 2),
+        );
+        files.push("site.webmanifest");
+      }
+
+      nitroConfig.publicAssets ||= [];
+      nitroConfig.publicAssets.push({
+        dir: outputDir,
+        baseURL: "/" + publicPath,
+        // Fixed file names (not versioned): always revalidate instead of caching long-term.
+        maxAge: 0,
+      });
+      logger.success(`Generated ${files.length} favicon files in ${outputDir}`);
+    });
+  },
+});

package/modules/license-module.ts

@@ -1,8 +1,8 @@
 import { addVitePlugin, defineNuxtModule, useLogger } from "nuxt/kit";
 import license from "rollup-plugin-license";
+import { createLicensePluginOptions } from "../lib/license-plugin-options";
 
 const moduleKey = "@jojomatik/nuxt-bundle/license-module";
-const envKey = "ALLOWED_LICENCES";
 
 const logger = useLogger(moduleKey);
 
@@ -12,77 +12,6 @@ export default defineNuxtModule({
     configKey: "licenseModule",
   },
   setup(options) {
-    addVitePlugin(
-      license({
-        thirdParty: {
-          includePrivate: false,
-          allow: {
-            test: (dependency) => {
-              // Return false for unlicensed dependencies.
-              if (!dependency.license) return false;
-
-              // Load allowed licenses from environment-variable
-              const allowedLicensesFromEnv = process.env[envKey]
-                ?.split(",")
-                .map((license) => license.trim());
-
-              // Load allowed licenses from module options
-              // Allow MIT and Apache-2.0 licenses by default
-              const allowedLicenses =
-                allowedLicensesFromEnv ?? options.allowedLicenses;
-
-              const isLicenseAllowed = allowedLicenses.includes(
-                dependency.license,
-              );
-
-              if (!isLicenseAllowed) {
-                logger.error(
-                  `Dependency "${dependency.name}" has a license (${dependency.license}) that is not the list of allowed licenses (${allowedLicenses.join(", ")}).`,
-                );
-
-                const requiredLicenses = [
-                  ...allowedLicenses,
-                  dependency.license,
-                ];
-
-                const configContent = JSON.stringify(
-                  {
-                    extends: "@jojomatik/nuxt-bundle",
-                    licenseModule: {
-                      allowedLicenses: requiredLicenses,
-                    },
-                  },
-                  undefined,
-                  2,
-                );
-
-                const configExample =
-                  "export default defineNuxtConfig(" + configContent + ");\n";
-
-                logger.info(
-                  `You can specify allowed licenses in "nuxt.config.ts" environment variable:`,
-                );
-                console.log(configExample);
-
-                logger.info(
-                  `You can also specify allowed licenses via "${envKey}" environment variable (ALLOWED_LICENCES=${requiredLicenses.join(",")}).`,
-                );
-              }
-
-              return isLicenseAllowed;
-            },
-            failOnUnlicensed: true,
-            failOnViolation: true,
-          },
-          output: {
-            // Output file into public directory which is included in the build output.
-            file: "public/dependencies.json",
-            template(dependencies) {
-              return JSON.stringify(dependencies);
-            },
-          },
-        },
-      }),
-    );
+    addVitePlugin(license(createLicensePluginOptions(options, logger)));
   },
 });

package/nuxt.config.ts

@@ -25,6 +25,8 @@ const isDevServer =
   process.argv.some((arg) => arg.endsWith("nuxi")) &&
   process.argv.includes("dev");
 
+const isStorybook = process.argv.some((arg) => arg.includes("storybook"));
+
 export default defineNuxtConfig({
   app: {
     pageTransition: { name: "page", mode: "out-in" },
@@ -41,6 +43,11 @@ export default defineNuxtConfig({
           href: "/assets/fonts/roboto/index.css",
         },
         // Favicon generated with https://realfavicongenerator.net/
+        {
+          rel: "icon",
+          type: "image/vnd.microsoft.icon",
+          href: "/assets/favicon/favicon.ico",
+        },
         {
           rel: "icon",
           type: "image/png",
@@ -82,7 +89,7 @@ export default defineNuxtConfig({
     "vuetify-nuxt-module",
   ],
   licenseModule: {
-    allowedLicenses: ["MIT", "Apache-2.0"],
+    allowedLicenses: ["MIT", "Apache-2.0", "ISC", "OFL-1.1"],
   },
   i18n: {
     locales: getLocales(),
@@ -96,6 +103,10 @@ export default defineNuxtConfig({
   storybook: {
     enabled: !isDevServer,
   },
+  // Storybook's Nuxt preset disables experimental.appManifest, which nuxt-skew-protection requires.
+  skewProtection: {
+    enabled: !isStorybook,
+  },
   hooks: {
     "nitro:build:before": () => {
       const fontsDir = "public/assets/fonts/";

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jojomatik/nuxt-bundle",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.31",
   "type": "module",
+  "packageManager": "yarn@1.22.22",
   "description": "A bundle of commonly used nuxt dependencies and configuration.",
   "keywords": [
     "nuxt",
@@ -11,62 +12,76 @@
     "configuration"
   ],
   "scripts": {
+    "prepare": "nuxi prepare",
     "dev": "nuxi dev",
     "build": "nuxi build",
     "start": "node .output/server/index.mjs",
+    "storybook": "storybook dev -p 6006 --disable-telemetry",
+    "build-storybook": "storybook build --disable-telemetry",
     "lint": "eslint . --max-warnings 0",
+    "test": "vitest run --coverage",
+    "test:release-notes": "node scripts/check-release-notes.ts",
     "semantic-release": "semantic-release"
   },
   "files": [
     "app",
+    "lib",
     "locales",
     "modules",
     "nuxt.config.ts",
     "package.json",
-    "README.md"
+    "public/favicon.svg",
+    "README.md",
+    "vuetify-options.ts"
   ],
   "main": "nuxt.config.ts",
   "dependencies": {
-    "@crystal-creations/crystal-components": "1.0.0-beta.43",
-    "@fontsource/roboto": "5.2.9",
+    "@crystal-creations/crystal-components": "1.0.0-beta.49",
+    "@fontsource/roboto": "5.3.0",
     "@mdi/js": "7.4.47",
-    "@nuxt/eslint": "^1.12.1",
-    "@nuxt/image": "2.0.0",
-    "@nuxtjs/i18n": "10.2.1",
-    "@nuxtjs/seo": "3.3.0",
-    "@nuxtjs/storybook": "9.0.1",
+    "@nuxt/eslint": "1.17.0",
+    "@nuxt/image": "2.2.0",
+    "@nuxtjs/i18n": "10.6.0",
+    "@nuxtjs/seo": "6.0.1",
+    "@nuxtjs/storybook": "10.0.3",
     "@semantic-release/exec": "7.1.0",
-    "@semantic-release/git": "10.0.1",
-    "@storybook/addon-links": "9.1.17",
-    "@storybook/addon-docs": "9.1.17",
-    "@types/node": "24.10.4",
-    "chromatic": "13.3.4",
-    "conventional-changelog-conventionalcommits": "9.1.0",
+    "@semantic-release/git": "11.0.1",
+    "@storybook/addon-docs": "10.6.5",
+    "@storybook/addon-links": "10.6.5",
+    "@types/node": "26.6.5",
+    "chromatic": "18.13.3",
+    "conventional-changelog-conventionalcommits": "9.3.1",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-prettier": "5.5.4",
-    "eslint-plugin-storybook": "9.1.17",
-    "eslint-plugin-vue": "10.6.2",
-    "prettier": "3.7.4",
-    "rollup": "4.55.1",
-    "rollup-plugin-license": "3.6.0",
-    "sass": "1.97.1",
-    "semantic-release": "25.0.2",
-    "storybook": "9.1.17",
-    "typescript": "5.9.3",
-    "vue-router": "4.6.4",
-    "vuetify": "3.11.6",
-    "vuetify-nuxt-module": "0.19.2"
+    "eslint-plugin-prettier": "5.5.7",
+    "eslint-plugin-storybook": "10.6.5",
+    "eslint-plugin-vue": "10.12.0",
+    "prettier": "3.9.10",
+    "rollup": "4.66.0",
+    "rollup-plugin-license": "3.7.1",
+    "sass": "1.106.1",
+    "semantic-release": "25.0.9",
+    "sharp": "0.34.5",
+    "storybook": "10.6.5",
+    "typescript": "6.0.3",
+    "vue-router": "5.4.0",
+    "vuetify": "3.13.7",
+    "vuetify-nuxt-module": "1.0.0-rc.6"
   },
   "devDependencies": {
-    "eslint": "9.39.2",
-    "nuxt": "4.2.2",
-    "vite": "7.3.0",
-    "vue": "3.5.26"
+    "@vitejs/plugin-vue": "6.0.10",
+    "@vitest/coverage-v8": "5.0.5",
+    "@vue/test-utils": "2.5.1",
+    "eslint": "10.13.0",
+    "happy-dom": "21.0.4",
+    "nuxt": "4.6.3",
+    "vite": "8.3.5",
+    "vitest": "5.0.5",
+    "vue": "3.5.44"
   },
   "peerDependencies": {
-    "eslint": "^9.39.2",
-    "nuxt": "^4.2.2",
-    "vite": "^7.3.0",
+    "eslint": "^9.39.2 || ^10.0.0",
+    "nuxt": "^4.6.1",
+    "vite": "^7.3.0 || ^8.0.0",
     "vue": "^3.5.26"
   },
   "author": {

package/public/favicon.svg

@@ -0,0 +1 @@
+<svg id="Ebene_1" data-name="Ebene 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 512 512"><defs><style>.cls-1{fill:none;}.cls-2{fill:url(#Unbenannter_Verlauf_2);}.cls-3{fill:url(#Unbenannter_Verlauf_3);}</style><linearGradient id="Unbenannter_Verlauf_2" x1="191.53" y1="124.12" x2="445.95" y2="378.54" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#004c6d"/><stop offset="1" stop-color="#037a7a"/></linearGradient><linearGradient id="Unbenannter_Verlauf_3" x1="133.22" y1="194.26" x2="382.3" y2="443.34" gradientUnits="userSpaceOnUse"><stop offset="0.01" stop-color="#004c6d"/><stop offset="1" stop-color="#037a7a"/></linearGradient></defs><rect class="cls-1" width="512" height="512"/><path class="cls-2" d="M204.21,371.81l33.08-33.09c19.46,15.57,32.76,33,52.69,33,30.49,0,46.23-16.54,46.23-63V90.11H394V313.69c0,59.58-29.29,108.2-97.24,108.2C251.12,421.89,231.45,402.94,204.21,371.81Z"/><polygon class="cls-3" points="209.4 311.75 176.03 345.11 68 237.07 176.03 129.04 209.4 162.4 134.73 237.07 209.4 311.75"/></svg>

package/vuetify-options.ts

@@ -0,0 +1,48 @@
+import type { VOptions } from "vuetify-nuxt-module";
+
+const vuetifyOptions: VOptions = {
+  theme: {
+    defaultTheme: "light",
+    themes: {
+      light: {
+        dark: false,
+        colors: {
+          background: "#EDEDED",
+          surface: "#FCFCFC",
+          "surface-variant": "#424242",
+          "on-surface-variant": "#EEEEEE",
+          primary: "#004c6d",
+          "primary-darken-1": "#3700B3",
+          secondary: "#037a7a",
+          "secondary-darken-1": "#018786",
+          error: "#B00020",
+          info: "#2196F3",
+          success: "#4CAF50",
+          warning: "#FB8C00",
+        },
+        variables: {},
+      },
+      dark: {
+        dark: true,
+        colors: {
+          background: "#121212",
+          surface: "#212121",
+          "surface-variant": "#BDBDBD",
+          "on-surface-variant": "#424242",
+          primary: "#0074a5",
+          secondary: "#039e9e",
+          error: "#CF6679",
+          info: "#2196F3",
+          success: "#4CAF50",
+          warning: "#FB8C00",
+        },
+        variables: {},
+      },
+    },
+  },
+  icons: {
+    defaultSet: "mdi-svg",
+  },
+};
+
+export default vuetifyOptions;