@jojomatik/nuxt-bundle 1.2.2 → 2.0.0-beta.10

package/README.md

@@ -3,5 +3,41 @@
 
 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"] },
+  ],
+}
+```
+
 ## Licensing
 This project is licensed under the MIT License (MIT). See also [`LICENSE`](LICENSE).

package/{error.vue → app/error.vue}

@@ -1,3 +1,4 @@
+<!-- eslint-disable vue/multi-word-component-names -->
 <template>
   <v-app>
     <v-sheet class="ma-auto pa-5" border rounded="xl">

package/{pages → app/pages}/license-information.vue

@@ -33,7 +33,7 @@
 </template>
 
 <script setup lang="ts">
-import { type Composer } from "vue-i18n";
+import type { Composer } from "vue-i18n";
 const i18n: Composer = useI18n();
 
 // As nuxt can't fetch data from the public dir during SSR, the request can only be made on client side (see also nuxt/nuxt#13857).

package/lib/__tests__/license-validation.test.ts

@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createLicensePluginOptions } from "../license-plugin-options.ts";
+import {
+  applyLicenseOverrides,
+  validateDependencyLicense,
+} from "../license-validation.ts";
+
+test("applies a package license override before validation", () => {
+  assert.deepEqual(
+    validateDependencyLicense(
+      { name: "socket.io-client" },
+      { "socket.io-client": "MIT" },
+      ["MIT"],
+    ),
+    { license: "MIT", isAllowed: true },
+  );
+});
+
+test("rejects missing license metadata without an override", () => {
+  assert.deepEqual(
+    validateDependencyLicense({ name: "unlicensed-package" }, {}, ["MIT"]),
+    { license: undefined, isAllowed: false },
+  );
+});
+
+test("still rejects an overridden license outside the allow-list", () => {
+  assert.deepEqual(
+    validateDependencyLicense(
+      { name: "socket.io-client" },
+      { "socket.io-client": "MIT" },
+      ["Apache-2.0"],
+    ),
+    { license: "MIT", isAllowed: false },
+  );
+});
+
+test("applies overrides to generated metadata without mutating dependencies", () => {
+  const dependency = { name: "socket.io-client" };
+
+  assert.deepEqual(
+    applyLicenseOverrides([dependency], { "socket.io-client": "MIT" }),
+    [{ name: "socket.io-client", license: "MIT" }],
+  );
+  assert.equal(dependency.license, undefined);
+});
+
+test("allows an override callback to supply a license only when missing", () => {
+  const licenseOverrides = {
+    "socket.io-client": (license: string | undefined) => license || "MIT",
+  };
+
+  assert.deepEqual(
+    validateDependencyLicense({ name: "socket.io-client" }, licenseOverrides, [
+      "MIT",
+    ]),
+    { license: "MIT", isAllowed: true },
+  );
+  assert.deepEqual(
+    validateDependencyLicense(
+      { name: "socket.io-client", license: "GPL-3.0" },
+      licenseOverrides,
+      ["MIT"],
+    ),
+    { license: "GPL-3.0", isAllowed: false },
+  );
+  assert.deepEqual(
+    applyLicenseOverrides(
+      [{ name: "socket.io-client", license: "GPL-3.0" }],
+      licenseOverrides,
+    ),
+    [{ name: "socket.io-client", license: "GPL-3.0" }],
+  );
+});
+
+test("normalizes null license metadata before invoking an override callback", () => {
+  let callbackLicense: string | undefined = "not called";
+  const licenseOverrides = {
+    "socket.io-client": (license: string | undefined) => {
+      callbackLicense = license;
+      return license || "MIT";
+    },
+  };
+
+  assert.deepEqual(
+    validateDependencyLicense(
+      { name: "socket.io-client", license: null },
+      licenseOverrides,
+      ["MIT"],
+    ),
+    { license: "MIT", isAllowed: true },
+  );
+  assert.equal(callbackLicense, undefined);
+});
+
+test("applies license overrides in configured plugin callbacks", () => {
+  const pluginOptions = createLicensePluginOptions(
+    {
+      allowedLicenses: ["MIT"],
+      licenseOverrides: {
+        "socket.io-client": (license) => license ?? "MIT",
+      },
+    },
+    {
+      error: assert.fail,
+      info: assert.fail,
+    },
+  );
+  const dependency = { name: "socket.io-client", license: null };
+
+  assert.equal(pluginOptions.thirdParty.allow.test(dependency), true);
+  assert.deepEqual(
+    JSON.parse(pluginOptions.thirdParty.output.template([dependency])),
+    [{ name: "socket.io-client", license: "MIT" }],
+  );
+});
+
+test("allows a license only for its configured dependencies", () => {
+  const pluginOptions = createLicensePluginOptions(
+    {
+      allowedLicenses: [
+        "MIT",
+        { "SEE LICENSE IN LICENSE.md": ["apexcharts", "vue-apexcharts"] },
+      ],
+    },
+    {
+      error: () => {},
+      info: () => {},
+    },
+  );
+
+  const originalConsoleLog = console.log;
+  console.log = () => {};
+
+  try {
+    assert.equal(
+      pluginOptions.thirdParty.allow.test({
+        name: "apexcharts",
+        license: "SEE LICENSE IN LICENSE.md",
+      }),
+      true,
+    );
+    assert.equal(
+      pluginOptions.thirdParty.allow.test({
+        name: "vue-apexcharts",
+        license: "SEE LICENSE IN LICENSE.md",
+      }),
+      true,
+    );
+    assert.equal(
+      pluginOptions.thirdParty.allow.test({
+        name: "another-package",
+        license: "SEE LICENSE IN LICENSE.md",
+      }),
+      false,
+    );
+  } finally {
+    console.log = originalConsoleLog;
+  }
+});

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,45 @@
+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/license-module.ts

@@ -1,84 +1,17 @@
-import { defineNuxtModule, useLogger } from "nuxt/kit";
+import { addVitePlugin, defineNuxtModule, useLogger } from "nuxt/kit";
 import license from "rollup-plugin-license";
-import { type PluginOption } from "vite";
+import { createLicensePluginOptions } from "../lib/license-plugin-options";
 
 const moduleKey = "@jojomatik/nuxt-bundle/license-module";
-const envKey = "ALLOWED_LICENCES";
 
 const logger = useLogger(moduleKey);
 
 export default defineNuxtModule({
   meta: {
     name: moduleKey,
-    configKey: "licenseModule"
+    configKey: "licenseModule",
+  },
+  setup(options) {
+    addVitePlugin(license(createLicensePluginOptions(options, logger)));
   },
-  setup(options, nuxt) {
-    nuxt.hook("vite:extendConfig", (viteConfig) => {
-      viteConfig.plugins = viteConfig.plugins || [];
-      viteConfig.plugins.push(
-        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);
-              }
-            }
-          }
-        }) as PluginOption);
-    });
-  }
 });

package/nuxt.config.ts

@@ -1,15 +1,17 @@
 import * as fs from "fs";
 import chalk from "chalk";
-import vuetify from "vite-plugin-vuetify";
+import type { LocaleObject } from "@nuxtjs/i18n";
+import type { GeneratedLocale } from "@intlify/core-base";
+import vuetifyOptions from "./vuetify-options";
 
 /**
  * Returns all locales with their corresponding file names from `./locales`.
  */
-export function getLocales(): { code: string; file: string }[] {
+export function getLocales(): LocaleObject<GeneratedLocale>[] {
   const files = fs.readdirSync("./locales");
 
   return files.map((file) => {
-    const code = file.split(".")[0];
+    const code = file.split(".")[0] as GeneratedLocale;
 
     return {
       code,
@@ -19,6 +21,10 @@ export function getLocales(): { code: string; file: string }[] {
   });
 }
 
+const isDevServer =
+  process.argv.some((arg) => arg.endsWith("nuxi")) &&
+  process.argv.includes("dev");
+
 export default defineNuxtConfig({
   app: {
     pageTransition: { name: "page", mode: "out-in" },
@@ -74,18 +80,27 @@ export default defineNuxtConfig({
   modules: [
     "@crystal-creations/crystal-components/nuxt",
     "@nuxt/image",
-    [
-      "@nuxtjs/i18n",
-      {
-        locales: getLocales(),
-        langDir: "locales",
-      },
-    ],
+    "@nuxtjs/i18n",
     "@nuxtjs/seo",
+    "@nuxt/eslint",
+    "@nuxtjs/storybook",
+    "vuetify-nuxt-module",
   ],
   licenseModule: {
     allowedLicenses: ["MIT", "Apache-2.0"],
   },
+  i18n: {
+    locales: getLocales(),
+    defaultLocale: "en",
+    restructureDir: ".",
+    langDir: "locales",
+  },
+  vuetify: {
+    vuetifyOptions,
+  },
+  storybook: {
+    enabled: !isDevServer,
+  },
   hooks: {
     "nitro:build:before": () => {
       const fontsDir = "public/assets/fonts/";
@@ -96,16 +111,8 @@ export default defineNuxtConfig({
       console.log(chalk.green("√"), "Copied fonts to " + fontsDir);
     },
   },
-  vite: {
-    define: {
-      "process.env.DEBUG": "false",
-    },
-    ssr: {
-      noExternal: ["vuetify"],
-    },
-    plugins: [vuetify()],
-  },
   nitro: {
     compressPublicAssets: true,
   },
+  ssr: true,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jojomatik/nuxt-bundle",
-  "version": "1.2.2",
+  "version": "2.0.0-beta.10",
   "type": "module",
   "description": "A bundle of commonly used nuxt dependencies and configuration.",
   "keywords": [
@@ -15,75 +15,62 @@
     "build": "nuxi build",
     "start": "node .output/server/index.mjs",
     "lint": "eslint . --max-warnings 0",
+    "test": "node --experimental-strip-types --test lib/__tests__/*.test.ts",
     "semantic-release": "semantic-release"
   },
   "files": [
-    "assets",
+    "app",
+    "lib",
     "locales",
     "modules",
-    "pages",
-    "error.vue",
     "nuxt.config.ts",
     "package.json",
-    "README.md"
+    "README.md",
+    "vuetify-options.ts"
   ],
   "main": "nuxt.config.ts",
   "dependencies": {
-    "@crystal-creations/crystal-components": "1.0.0-beta.22",
-    "@fontsource/roboto": "5.0.12",
+    "@crystal-creations/crystal-components": "1.0.0-beta.49",
+    "@fontsource/roboto": "5.3.0",
     "@mdi/js": "7.4.47",
-    "@nuxt/image": "1.5.0",
-    "@nuxtjs/eslint-config-typescript": "12.1.0",
-    "@nuxtjs/i18n": "8.3.0",
-    "@nuxtjs/robots": "3.0.0",
-    "@nuxtjs/seo": "2.2.0",
+    "@nuxt/eslint": "1.12.1",
+    "@nuxt/image": "2.2.0",
+    "@nuxtjs/i18n": "10.2.1",
+    "@nuxtjs/seo": "5.3.16",
+    "@nuxtjs/storybook": "9.0.1",
     "@semantic-release/exec": "7.1.0",
     "@semantic-release/git": "10.0.1",
-    "@storybook/addon-essentials": "8.0.5",
-    "@storybook/addon-interactions": "8.0.5",
-    "@storybook/addon-links": "8.0.5",
-    "@storybook/blocks": "8.0.5",
-    "@storybook/components": "8.0.5",
-    "@storybook/manager-api": "8.0.5",
-    "@storybook/preview-api": "8.0.5",
-    "@storybook/testing-library": "0.2.2",
-    "@storybook/types": "8.0.5",
-    "@storybook/vue3": "8.0.5",
-    "@storybook/vue3-vite": "8.0.5",
-    "@types/node": "18.19.29",
-    "@vitejs/plugin-vue": "^5.0.4",
-    "chromatic": "11.3.0",
+    "@storybook/addon-links": "9.1.21",
+    "@storybook/addon-docs": "9.1.21",
+    "@types/node": "24.19.2",
+    "chromatic": "13.3.5",
     "conventional-changelog-conventionalcommits": "9.1.0",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-prettier": "5.1.3",
-    "eslint-plugin-storybook": "0.8.0",
-    "eslint-plugin-vue": "9.24.0",
-    "prettier": "3.2.5",
-    "rollup": "4.14.0",
-    "rollup-plugin-license": "3.3.1",
-    "sass": "1.72.0",
-    "semantic-release": "25.0.2",
-    "storybook": "8.0.5",
-    "storybook-i18n": "^3.0.1",
-    "typescript": "5.4.3",
-    "unplugin-auto-import": "0.17.5",
-    "unplugin-vue-components": "0.26.0",
-    "vite-plugin-vuetify": "2.0.3",
-    "vue-i18n": "9.10.2",
-    "vue-router": "4.3.0",
-    "vuetify": "3.5.14"
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.4",
+    "eslint-plugin-storybook": "9.1.21",
+    "eslint-plugin-vue": "10.6.2",
+    "prettier": "3.7.4",
+    "rollup": "4.59.0",
+    "rollup-plugin-license": "3.6.0",
+    "sass": "1.97.1",
+    "semantic-release": "25.0.9",
+    "storybook": "9.1.19",
+    "typescript": "5.9.3",
+    "vue-router": "4.6.4",
+    "vuetify": "3.11.6",
+    "vuetify-nuxt-module": "0.19.5"
   },
   "devDependencies": {
-    "eslint": "8.57.0",
-    "nuxt": "3.11.1",
-    "vite": "5.2.8",
-    "vue": "3.4.21"
+    "eslint": "9.39.5",
+    "nuxt": "4.6.2",
+    "vite": "7.3.7",
+    "vue": "3.5.44"
   },
   "peerDependencies": {
-    "eslint": "^8.56.0",
-    "nuxt": "^3.7.4",
-    "vite": "^5.0.11",
-    "vue": "^3.4.8"
+    "eslint": "^9.39.2",
+    "nuxt": "^4.2.2",
+    "vite": "^7.3.0",
+    "vue": "^3.5.26"
   },
   "author": {
     "name": "jojomatik",
@@ -101,5 +88,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "resolutions": {
+    "jiti": "2.6.1"
   }
 }

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: "#FFFFFF",
+          surface: "#FFFFFF",
+          "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;