@futurra/multilinguist 0.0.0-stage → 1.7.0

package/README.md

@@ -1,3 +1,234 @@
-# Temporary Holding Version
+# Nuxt Multilinguist module
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Multilinguist is a simple but smoothly working module for easy and seamless localization implementation for Nuxt
+applications.
+
+## Key Features
+
+- Easy translations that you're used to
+- Works perfectly fine on both SSR + CSR
+- No memory leaks and running out of memory errors
+- Autocompletion & validation of keys
+- Autodetection of browser's locale
+
+## Installation
+
+```bash
+npm install @futurra/multilinguist
+```
+
+Then, add the module to your nuxt.config
+
+```nuxt.config.ts
+export default defineNuxtConfig({
+    modules: [
+        "@futurra/multilinguist",
+    ],
+    multilinguist: {
+        defaultLocale: "en", // string representing key to your default (fallback) locale
+        supportedLanguages: ["en", "es"], // array of strings representing all available locales' keys
+    },
+})
+```
+
+Then, create a "locales" directory in root directory of your project.
+
+![directory_structure.png](directory_structure.png)
+
+Now, you're ready to use Multilinguist Module!
+
+After running your project, you can see the following warning:
+
+![vite-warning.png](vite-warning.png)
+
+**Dont be scared**, this is just a message from the module, indicating that your locales are typed, and that the module
+can properly perform type-checks and autocompletion.
+
+Also, on both SSR and CSR, you will see the following message:
+
+![initialized.png](initialized.png)
+
+It indicated that the module has been initialized successfully.
+
+To disable logs, you can set the `logging` option in your nuxt.config to `false` (by default, it is `true`):
+
+```nuxt.config.ts
+export default defineNuxtConfig({
+    modules: [
+        "@futurra/multilinguist",
+    ],
+    multilinguist: {
+        defaultLocale: "en",
+        supportedLanguages: ["en", "es"],
+        logging: false, // Boolean value to define if the module should send internal logs to console
+    },
+})
+```
+Also, Multilinguist offers a functionality to set the default browser's locale as default if it is available in the supported languages array.
+
+To disable this option, you can set the `setBrowserLanguage` option to `false` as it is `true` by default:
+
+```nuxt.config.ts
+export default defineNuxtConfig({
+    modules: [
+        "@futurra/multilinguist",
+    ],
+    multilinguist: {
+        defaultLocale: "en",
+        supportedLanguages: ["en", "es"],
+        logging: false,
+        setBrowserLanguage: false, // by default: true
+    },
+})
+```
+
+Also, if you want to use a different folder name for your locales' files, or you want to specify other path to the directory, you can set the `localesPath` option in your nuxt.config:
+
+```nuxt.config.ts
+export default defineNuxtConfig({
+    modules: [
+        "@futurra/multilinguist",
+    ],
+    multilinguist: {
+        defaultLocale: "en",
+        supportedLanguages: ["en", "es"],
+        logging: false,
+        setBrowserLanguage: false, // by default: true
+        localesPath: "./languages", // by default: "./locales"
+    },
+})
+```
+
+### Important! Keep in mind, that it is not recommended to use "public" folder for your locales' files, as it may lead to rendering, security and other issues.
+
+# Usage
+
+### t()—famous translate function
+
+```vue
+
+<script setup lang="ts">
+  const { t } = useMultilinguist(); // Call useMultilinguist composable to get the translation function
+
+  const pageTitle = computed(() => {
+    return t("Hello, World");
+  });
+</script>
+
+<template>
+  <h3>{{ pageTitle }}</h3>
+  <button>{{ t("Switch Locale") }}</button>
+</template>
+```
+
+It also supports nested keys and dynamic keys with variables;
+you only need to pass the second argument, an object with used in the key variables:
+
+```vue
+
+<template>
+  <span>{{ t("Paste your variable here", { variable: locale }) }}</span>
+</template>
+```
+
+And your JSON must look like that:
+
+```json
+{
+  "Paste your variable here": "Here is your variable: {variable}"
+}
+```
+
+```vue
+
+<script setup lang="ts">
+  const { t } = useMultilinguist(); // Call useMultilinguist composable to get the translation function
+
+  const pageTitle = computed(() => {
+    return t("Hello, World");
+  });
+</script>
+
+<template>
+  <h3>{{ pageTitle }}</h3>
+  <button>{{ t("Switch Locale") }}</button>
+  <br />
+  <span>{{ t("Paste your variable here", { variable: locale }) }}</span>
+  <br />
+  <h1>{{ t("nested.Nested key") }}: <span>{{ t("nested.Language") }}</span></h1>
+</template>
+```
+
+You can already see how keys auto-completion works:
+
+![autocompletion.png](autocompletion.png)
+
+And validation:
+
+![validation.png](validation.png)
+
+### Set another value to the current locale:
+
+```vue
+
+<script setup lang="ts">
+  const { t, setLocale } = useMultilinguist();
+  // setLocale function accepts a string that should match one of defined
+  // in the nuxt.config strings from supportedLanguages array
+
+  const pageTitle = computed(() => {
+    return t("Hello, World");
+  });
+</script>
+
+<template>
+  <h3>{{ pageTitle }}</h3>
+  <button @click="setLocale('es')">{{ t("Switch Locale") }}</button>
+</template>
+```
+
+### Get current locale
+
+```vue
+
+<script setup lang="ts">
+  const { t, setLocale, locale } = useMultilinguist();
+  // locale is SSR friendly, shared among the app ref state  
+
+  const pageTitle = computed(() => {
+    return t("Hello, World");
+  });
+</script>
+
+<template>
+  <h3>{{ pageTitle }}</h3>
+  <h6>Current Locale: {{ locale }}</h6>
+  <button @click="setLocale('es')">{{ t("Switch Locale") }}</button>
+</template>
+```
+
+### Get locales list
+
+```vue
+
+<script setup lang="ts">
+  const { t, setLocale, locale, locales } = useMultilinguist();
+  // Locales is a computed ref, which value is being set from your nuxt.config
+
+  const pageTitle = computed(() => {
+    return t("Hello, World");
+  });
+</script>
+
+<template>
+  <h3>{{ pageTitle }}</h3>
+  <h6>Current Locale: {{ locale }}</h6>
+  <span
+    v-for="localeItem from locales"
+    :key="localeItem"
+  >
+    | {{ localeItem }} |
+  </span>
+  <button @click="setLocale('es')">{{ t("Switch Locale") }}</button>
+</template>
+```

package/dist/module.d.mts

@@ -0,0 +1,5 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+declare const _default: _nuxt_schema.NuxtModule<_nuxt_schema.ModuleOptions, _nuxt_schema.ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,18 @@
+{
+  "name": "@futurra/multilinguist",
+  "configKey": "multilinguist",
+  "version": "1.6.2",
+  "compatibility": {
+    "nuxt": "^3.0.0 || ^4.0.0"
+  },
+  "defaults": {
+    "logging": true,
+    "defaultLocale": "",
+    "supportedLanguages": [],
+    "setBrowserLanguage": true
+  },
+  "builder": {
+    "@nuxt/module-builder": "1.0.1",
+    "unbuild": "3.6.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,125 @@
+import { defineNuxtModule, createResolver, addPlugin, addImportsDir } from '@nuxt/kit';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function flattenKeys(obj, prefix = "") {
+  return Object.entries(obj).flatMap(([key, value]) => {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "object" && value !== null) {
+      return flattenKeys(value, fullKey);
+    }
+    return [fullKey];
+  });
+}
+const generateOutputString = (func) => {
+  return `
+// AUTO-GENERATED FILE \u2014 DO NOT EDIT MANUALLY
+
+export interface TranslationMessages {
+${func()}
+}
+
+export type LocaleKey = keyof TranslationMessages;
+
+export type TFunction = <K extends LocaleKey>(
+  key: K,
+  variables?: Record<string, string>
+) => string;
+
+declare global {
+  type LocaleKey = keyof TranslationMessages;
+  type TFunction = <K extends LocaleKey>(
+    key: K,
+    variables?: Record<string, string>
+  ) => string;
+}
+
+declare module '#app' {
+  interface NuxtApp {
+    $t: TFunction;
+    t: TFunction;
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $t: TFunction;
+    t: TFunction;
+  }
+}
+`;
+};
+function GenerateLocaleKeysPlugin(defaultLocaleFromConfig, absoluteLocalesPath, outPath, logging = true) {
+  async function generateTypes() {
+    const defaultLocalePath = path.join(absoluteLocalesPath, `${defaultLocaleFromConfig}.json`);
+    if (!fs.existsSync(defaultLocalePath)) {
+      console?.error(`\u274C Default locale file not found: ${defaultLocalePath}`);
+      return;
+    }
+    const json = JSON.parse(fs.readFileSync(defaultLocalePath, "utf-8"));
+    const keys = flattenKeys(json);
+    const output = generateOutputString(() => keys.map((key) => `  ${JSON.stringify(key)}: string;`).join("\n"));
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, output, "utf-8");
+    if (logging) {
+      console?.warn(`\u2705 Generated types to ${outPath} from ${defaultLocalePath}`);
+    }
+  }
+  return {
+    name: "vite-plugin-generate-locales-types",
+    async buildStart() {
+      await generateTypes();
+    },
+    async handleHotUpdate(ctx) {
+      if (ctx.file.endsWith(".json") && ctx.file.includes(absoluteLocalesPath)) {
+        await generateTypes();
+      }
+    }
+  };
+}
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@futurra/multilinguist",
+    configKey: "multilinguist",
+    version: "1.6.2",
+    compatibility: {
+      nuxt: "^3.0.0 || ^4.0.0"
+    },
+    defaults: {
+      logging: true,
+      defaultLocale: "",
+      supportedLanguages: [],
+      setBrowserLanguage: true
+    }
+  },
+  setup(moduleOptions, nuxtApp) {
+    const resolver = createResolver(import.meta.url);
+    addPlugin(resolver.resolve("runtime/plugin"));
+    addImportsDir(resolver.resolve("runtime/composables"));
+    nuxtApp.options.runtimeConfig.public.multilinguist = {
+      defaultLocale: moduleOptions.defaultLocale,
+      supportedLanguages: moduleOptions.supportedLanguages,
+      logging: typeof moduleOptions.logging === "boolean" ? moduleOptions.logging : true,
+      setBrowserLanguage: typeof moduleOptions.setBrowserLanguage === "boolean" ? moduleOptions.setBrowserLanguage : true
+    };
+    nuxtApp.hook("vite:extendConfig", (viteConfig) => {
+      viteConfig.plugins = viteConfig.plugins || [];
+      viteConfig.plugins.push(
+        GenerateLocaleKeysPlugin(
+          moduleOptions.defaultLocale,
+          `${nuxtApp.options.rootDir}/public/locales`,
+          resolver.resolve("./runtime/types/generated-locales.d.ts"),
+          moduleOptions.logging
+        )
+      );
+    });
+    nuxtApp.hook("prepare:types", ({ references }) => {
+      references.push({
+        path: resolver.resolve("./runtime/types/generated-locales.d.ts")
+      });
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/composables/useLocale.d.ts

@@ -0,0 +1,12 @@
+import type { Locale, TranslationMap } from "./useLocalization.js";
+/**
+ * Resolves a browser locale code (e.g. "pt-BR", "en-US", "de") against the list of supported locales.
+ *
+ * 1. Exact match on the full code (case-insensitive): "pt-BR" -> "pt-BR"
+ * 2. Fallback to the base language part before the "-": "pt-BR" -> "pt"
+ * 3. Otherwise the default locale.
+ */
+export declare function resolveLocale<const T extends TranslationMap>(candidate: string | undefined | null, supportedLanguages: T, defaultLocale: Locale<T>): Locale<T>;
+export default function useLocale<const T extends TranslationMap>(supportedLanguages: T, defaultLocale: Locale<T>): {
+    locale: import("vue").ComputedRef<Locale<T>>;
+};

package/dist/runtime/composables/useLocale.js

@@ -0,0 +1,30 @@
+import { computed } from "vue";
+import { useRequestHeaders } from "nuxt/app";
+export function resolveLocale(candidate, supportedLanguages, defaultLocale) {
+  const normalized = candidate?.trim().toLowerCase();
+  if (!normalized) {
+    return defaultLocale;
+  }
+  const exact = supportedLanguages.find((supported) => supported.toLowerCase() === normalized);
+  if (exact) {
+    return exact;
+  }
+  const base = normalized.split("-")[0];
+  const partial = supportedLanguages.find((supported) => supported.toLowerCase() === base);
+  return partial ?? defaultLocale;
+}
+export default function useLocale(supportedLanguages, defaultLocale) {
+  const locale = computed(() => {
+    if (import.meta.server) {
+      const headers = useRequestHeaders(["accept-language"]);
+      const browserLocale = headers["accept-language"]?.split(",")[0]?.split(";")[0];
+      return resolveLocale(browserLocale, supportedLanguages, defaultLocale);
+    } else if (import.meta.client) {
+      return resolveLocale(navigator.language, supportedLanguages, defaultLocale);
+    }
+    return defaultLocale;
+  });
+  return {
+    locale
+  };
+}

package/dist/runtime/composables/useLocalization.d.ts

@@ -0,0 +1,13 @@
+import { type ComputedRef, type Ref } from "vue";
+import type { LocaleKey } from "../types/generated-locales.js";
+export type TranslationMap = readonly string[];
+export type Locale<T extends TranslationMap> = T[number];
+export type LocaleKeys<T extends TranslationMap> = T[keyof T];
+export type TMultilinguistResponse<T extends TranslationMap> = {
+    t<K extends LocaleKey>(key: K, variables?: Record<string, string>): string;
+    setLocale: (locale: Locale<T>) => void;
+    initLocalization: () => Promise<void>;
+    locale: Ref<Locale<T>>;
+    locales: ComputedRef<T>;
+};
+export default function useLocalization<const T extends TranslationMap>(supportedLanguages: T, defaultLocale: Locale<T>, setBrowserLanguage?: boolean): TMultilinguistResponse<T>;

package/dist/runtime/composables/useLocalization.js

@@ -0,0 +1,76 @@
+import useLocale from "../composables/useLocale.js";
+import { useCookie, useState } from "nuxt/app";
+import { computed, watch } from "vue";
+export default function useLocalization(supportedLanguages, defaultLocale, setBrowserLanguage = true) {
+  const { locale: userBrowserLocale } = useLocale(supportedLanguages, defaultLocale);
+  const userSelectedLocale = useCookie("multilinguist-locale", {
+    default: () => supportedLanguages.includes(userBrowserLocale.value) && setBrowserLanguage ? userBrowserLocale.value : defaultLocale
+  });
+  const localeFiles = import.meta.glob("@@/public/locales/*.json", { eager: true });
+  const loadedLanguages = useState("loaded-languages", () => ({}));
+  const loadLocaleMessages = async (locale2) => {
+    if (!loadedLanguages.value[locale2]) {
+      const fileKeyVersion4 = `../public/locales/${locale2}.json`;
+      const fileKeyVersion3 = `/public/locales/${locale2}.json`;
+      const messages = localeFiles[fileKeyVersion4] || localeFiles[fileKeyVersion3];
+      if (messages) {
+        loadedLanguages.value[locale2] = messages?.default;
+      } else {
+        if (!localeFiles[fileKeyVersion4]) {
+          throw new Error(`Locale file ${localeFiles[fileKeyVersion4]} not found`);
+        } else {
+          throw new Error(`Locale file ${localeFiles[fileKeyVersion3]} not found`);
+        }
+      }
+    }
+  };
+  const userPrefferableLocale = computed(() => {
+    return userSelectedLocale.value ? userSelectedLocale.value : userBrowserLocale.value;
+  });
+  const locale = useState("current-locale-multilinguist", () => {
+    return userPrefferableLocale.value || defaultLocale;
+  });
+  const t = (key, variables) => {
+    const messages = loadedLanguages.value[locale.value];
+    let translatedText = messages?.[key] ?? key;
+    if (key.includes(".") && !messages?.[key]) {
+      const nestedKeyArray = key.split(".");
+      translatedText = nestedKeyArray.reduce((acc, key2) => acc?.[key2], messages);
+    }
+    if (variables && typeof translatedText === "string") {
+      translatedText = translatedText.replace(/\{([^}]+)\}/g, (_, varKey) => {
+        return variables[varKey] ?? `{${varKey}}`;
+      });
+    }
+    return String(translatedText);
+  };
+  const setLocale = async (newLocale) => {
+    if (!loadedLanguages.value[newLocale] && supportedLanguages.includes(newLocale)) {
+      await loadLocaleMessages(newLocale);
+    }
+    userSelectedLocale.value = newLocale;
+    locale.value = newLocale;
+  };
+  const initLocalization = async () => {
+    await loadLocaleMessages(defaultLocale);
+    await setLocale(userPrefferableLocale.value);
+  };
+  const locales = computed(() => {
+    return supportedLanguages;
+  });
+  watch(
+    () => locale.value,
+    async (val) => {
+      if (val !== userSelectedLocale.value) {
+        userSelectedLocale.value = val;
+      }
+    }
+  );
+  return {
+    t,
+    setLocale,
+    initLocalization,
+    locale,
+    locales
+  };
+}

package/dist/runtime/composables/useMultilinguist.d.ts

@@ -0,0 +1,8 @@
+import type { TranslationMap } from "./useLocalization.js";
+export default function useMultilinguist(): {
+    t<K extends import("../types/generated-locales.js").LocaleKey>(key: K, variables?: Record<string, string>): string;
+    setLocale: (locale: string) => void;
+    initLocalization: () => Promise<void>;
+    locale: import("vue").Ref<string, string>;
+    locales: import("vue").ComputedRef<TranslationMap>;
+};

package/dist/runtime/composables/useMultilinguist.js

@@ -0,0 +1,9 @@
+import { useNuxtApp } from "nuxt/app";
+export default function useMultilinguist() {
+  const nuxtApp = useNuxtApp();
+  const localization = nuxtApp.$localization || nuxtApp._localization;
+  if (!localization) {
+    throw new Error("Localization plugin not initialized");
+  }
+  return { ...localization };
+}

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,25 @@
+import { defineNuxtPlugin } from "#app";
+import useLocalization from "../runtime/composables/useLocalization";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const config = nuxtApp.$config.public.multilinguist || {
+    defaultLocale: "en",
+    supportedLanguages: ["en"],
+    logging: true,
+    setBrowserLanguage: true
+  };
+  const supportedLanguages = config.supportedLanguages;
+  const defaultLocale = config.defaultLocale;
+  const shouldSetBrowserLanguage = config.setBrowserLanguage;
+  const { initLocalization, ...localizationProperties } = useLocalization(
+    supportedLanguages,
+    defaultLocale,
+    shouldSetBrowserLanguage
+  );
+  await initLocalization();
+  if (nuxtApp.$config.public.multilinguist.logging) {
+    console.log("[multilinguist] is initialised");
+  }
+  nuxtApp.provide("localization", localizationProperties);
+  nuxtApp.provide("t", localizationProperties.t);
+  nuxtApp._localization = localizationProperties;
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/types/generated-locales.d.ts

@@ -0,0 +1,40 @@
+
+// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY
+
+export interface TranslationMessages {
+  "Hello, World": string;
+  "Switch Locale": string;
+  "Paste your variable here": string;
+  "nested.Nested key": string;
+  "nested.Language": string;
+  "nested.nested second level.nested second level language": string;
+}
+
+export type LocaleKey = keyof TranslationMessages;
+
+export type TFunction = <K extends LocaleKey>(
+  key: K,
+  variables?: Record<string, string>
+) => string;
+
+declare global {
+  type LocaleKey = keyof TranslationMessages;
+  type TFunction = <K extends LocaleKey>(
+    key: K,
+    variables?: Record<string, string>
+  ) => string;
+}
+
+declare module '#app' {
+  interface NuxtApp {
+    $t: TFunction;
+    t: TFunction;
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $t: TFunction;
+    t: TFunction;
+  }
+}

package/dist/runtime/types/locale-imports.d.ts

@@ -0,0 +1,30 @@
+export declare const localeFiles: {
+    "/locales/en.json": {
+        default: {
+            "Hello, World": string;
+            "Switch Locale": string;
+            "Paste your variable here": string;
+            nested: {
+                "Nested key": string;
+                Language: string;
+                "nested second level": {
+                    "nested second level language": string;
+                };
+            };
+        };
+    };
+    "/locales/es.json": {
+        default: {
+            "Hello, World": string;
+            "Switch Locale": string;
+            "Paste your variable here": string;
+            nested: {
+                "Nested key": string;
+                Language: string;
+                "nested second level": {
+                    "nested second level language": string;
+                };
+            };
+        };
+    };
+};

package/dist/runtime/types/locale-imports.js

@@ -0,0 +1,6 @@
+import locale_0 from "../../../playground/locales/en.json";
+import locale_1 from "../../../playground/locales/es.json";
+export const localeFiles = {
+  "/locales/en.json": { default: locale_0 },
+  "/locales/es.json": { default: locale_1 }
+};

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "@futurra/multilinguist",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.7.0",
+  "description": "Nuxt Multilinguist module for localizations",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.fx2.io/ai/frontend/multilinguist.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/module.mjs",
+      "types": "./dist/types.d.mts"
+    }
+  },
+  "types": "./dist/types.d.mts",
+  "files": [
+    "dist",
+    "runtime/types"
+  ],
+  "keywords": [
+    "localization",
+    "nuxt localization",
+    "nuxt",
+    "internationalization",
+    "languages",
+    "locales",
+    "translation",
+    "localization nuxt",
+    "translation nuxt",
+    "nuxt translation",
+    "nuxt multilinguist",
+    "multilinguist nuxt",
+    "ssr localization"
+  ],
+  "bugs": {
+    "email": "michaelkukh.dev@gmail.com"
+  },
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "build": "vite build"
+  },
+  "peerDependencies": {
+    "nuxt": "^3.0.0 || ^4.0.0"
+  },
+  "dependencies": {
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.4.1",
+    "prettier": "^3.5.3"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^2.4.1",
+    "@nuxt/eslint-config": "^1.4.1",
+    "@nuxt/kit": "^4.0.1",
+    "@nuxt/module-builder": "^1.0.1",
+    "@nuxt/schema": "^4.0.1",
+    "@nuxt/test-utils": "^3.19.1",
+    "@types/node": "latest",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.27.0",
+    "nuxt": "^4.0.3",
+    "typescript": "~5.8.3",
+    "vitest": "^3.1.4",
+    "vue-tsc": "^2.2.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}