@yiiamee/multilinguist 1.4.1 → 1.5.0

package/dist/module.json

@@ -1,15 +1,16 @@
 {
   "name": "@yiiamee/multilinguist",
   "configKey": "multilinguist",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "compatibility": {
-    "nuxt": "^3.0.0"
+    "nuxt": "^3.0.0 || ^4.0.0"
   },
   "defaults": {
     "logging": true,
     "defaultLocale": "",
     "supportedLanguages": [],
-    "setBrowserLanguage": true
+    "setBrowserLanguage": true,
+    "localesPath": "./public/locales"
   },
   "builder": {
     "@nuxt/module-builder": "1.0.1",

package/dist/module.mjs

@@ -1,6 +1,6 @@
 import { defineNuxtModule, createResolver, addPlugin, addImportsDir } from '@nuxt/kit';
 import fs from 'fs';
-import path from 'path';
+import path, { resolve } from 'path';
 
 function flattenKeys(obj, prefix = "") {
   return Object.entries(obj).flatMap(([key, value]) => {
@@ -49,9 +49,26 @@ declare module 'vue' {
 }
 `;
 };
-function GenerateLocaleKeysPlugin(defaultLocaleFromConfig, localesPath, outPath, logging = true) {
+const generateLocaleImports = (absoluteLocalesPath, relativeLocalesPath, supportedLanguages, generatedFilePath, projectRoot) => {
+  const generatedFileDir = path.dirname(generatedFilePath);
+  const relativeTo = path.relative(generatedFileDir, projectRoot);
+  const cleanLocalesPath = relativeLocalesPath.startsWith("./") ? relativeLocalesPath.slice(2) : relativeLocalesPath.startsWith("/") ? relativeLocalesPath.slice(1) : relativeLocalesPath;
+  const importBasePath = path.join(relativeTo, cleanLocalesPath).replace(/\\/g, "/");
+  const normalizedKeyPath = relativeLocalesPath.startsWith("./") ? relativeLocalesPath.slice(1) : relativeLocalesPath.startsWith("/") ? relativeLocalesPath : `/${relativeLocalesPath}`;
+  const imports = supportedLanguages.map((lang, index) => `import locale_${index} from "${importBasePath}/${lang}.json";`).join("\n");
+  const localeMap = supportedLanguages.map((lang, index) => `  "${normalizedKeyPath}/${lang}.json": { default: locale_${index} }`).join(",\n");
+  return `
+// AUTO-GENERATED LOCALE IMPORTS
+${imports}
+
+export const localeFiles = {
+${localeMap}
+};
+`;
+};
+function GenerateLocaleKeysPlugin(defaultLocaleFromConfig, absoluteLocalesPath, outPath, logging = true, relativeLocalesPath = "./public/locales", supportedLanguages = [], projectRoot = process.cwd()) {
   async function generateTypes() {
-    const defaultLocalePath = path.join(localesPath, `${defaultLocaleFromConfig}.json`);
+    const defaultLocalePath = path.join(absoluteLocalesPath, `${defaultLocaleFromConfig}.json`);
     if (!fs.existsSync(defaultLocalePath)) {
       console?.error(`\u274C Default locale file not found: ${defaultLocalePath}`);
       return;
@@ -65,14 +82,40 @@ function GenerateLocaleKeysPlugin(defaultLocaleFromConfig, localesPath, outPath,
       console?.warn(`\u2705 Generated types to ${outPath} from ${defaultLocalePath}`);
     }
   }
+  async function generateLocaleImportsFile() {
+    const importsPath = path.dirname(outPath) + "/locale-imports.ts";
+    const imports = generateLocaleImports(
+      absoluteLocalesPath,
+      relativeLocalesPath,
+      supportedLanguages,
+      importsPath,
+      projectRoot
+    );
+    fs.mkdirSync(path.dirname(importsPath), { recursive: true });
+    fs.writeFileSync(importsPath, imports, "utf-8");
+    if (logging) {
+      console?.warn(`\u2705 Generated locale imports to ${importsPath}`);
+      const generatedFileDir = path.dirname(importsPath);
+      const relativeTo = path.relative(generatedFileDir, projectRoot);
+      const cleanLocalesPath = relativeLocalesPath.startsWith("./") ? relativeLocalesPath.slice(2) : relativeLocalesPath.startsWith("/") ? relativeLocalesPath.slice(1) : relativeLocalesPath;
+      const finalPath = path.join(relativeTo, cleanLocalesPath).replace(/\\/g, "/");
+      console?.warn(`\u2705 Import path calculated: ${finalPath}`);
+    }
+  }
   return {
     name: "vite-plugin-generate-locales-types",
     async buildStart() {
       await generateTypes();
+      if (supportedLanguages.length > 0) {
+        await generateLocaleImportsFile();
+      }
     },
     async handleHotUpdate(ctx) {
-      if (ctx.file.endsWith(".json") && ctx.file.includes(localesPath)) {
+      if (ctx.file.endsWith(".json") && ctx.file.includes(absoluteLocalesPath)) {
         await generateTypes();
+        if (supportedLanguages.length > 0) {
+          await generateLocaleImportsFile();
+        }
       }
     }
   };
@@ -82,35 +125,43 @@ const module = defineNuxtModule({
   meta: {
     name: "@yiiamee/multilinguist",
     configKey: "multilinguist",
-    version: "1.4.1",
+    version: "1.5.0",
     compatibility: {
-      nuxt: "^3.0.0"
+      nuxt: "^3.0.0 || ^4.0.0"
     },
     defaults: {
       logging: true,
       defaultLocale: "",
       supportedLanguages: [],
-      setBrowserLanguage: true
+      setBrowserLanguage: true,
+      localesPath: "./public/locales"
     }
   },
   setup(moduleOptions, nuxtApp) {
     const resolver = createResolver(import.meta.url);
+    const localesPath = moduleOptions.localesPath || "./public/locales";
+    const resolvedLocalesPath = resolve(nuxtApp.options.rootDir, localesPath);
     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
+      setBrowserLanguage: typeof moduleOptions.setBrowserLanguage === "boolean" ? moduleOptions.setBrowserLanguage : true,
+      localesPath
     };
     nuxtApp.hook("vite:extendConfig", (viteConfig) => {
       viteConfig.plugins = viteConfig.plugins || [];
       viteConfig.plugins.push(
         GenerateLocaleKeysPlugin(
           moduleOptions.defaultLocale,
-          `${nuxtApp.options.rootDir}/public/locales`,
+          resolvedLocalesPath,
           resolver.resolve("./runtime/types/generated-locales.d.ts"),
-          moduleOptions.logging
+          moduleOptions.logging,
+          localesPath,
+          moduleOptions.supportedLanguages,
+          nuxtApp.options.rootDir
+          // Pass the project root
         )
       );
     });
@@ -118,6 +169,9 @@ const module = defineNuxtModule({
       references.push({
         path: resolver.resolve("./runtime/types/generated-locales.d.ts")
       });
+      references.push({
+        path: resolver.resolve("./runtime/types/locale-imports.ts")
+      });
     });
   }
 });

package/dist/runtime/composables/useLocalization.js

@@ -1,20 +1,24 @@
 import useLocale from "../composables/useLocale.js";
-import { useCookie, useState } from "nuxt/app";
+import { useCookie, useState, useRuntimeConfig } from "nuxt/app";
 import { computed, watch } from "vue";
+import { localeFiles } from "../types/locale-imports.js";
 export default function useLocalization(supportedLanguages, defaultLocale, setBrowserLanguage = true) {
   const { locale: userBrowserLocale } = useLocale(supportedLanguages, defaultLocale);
+  const config = useRuntimeConfig();
   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 fileKey = `/public/locales/${locale2}.json`;
+      const localesPath = config.public.multilinguist.localesPath || "./public/locales";
+      const normalizedPath = localesPath.startsWith("./") ? localesPath.slice(1) : localesPath.startsWith("/") ? localesPath : `/${localesPath}`;
+      const fileKey = `${normalizedPath}/${locale2}.json`;
       const messages = localeFiles[fileKey];
       if (messages) {
-        loadedLanguages.value[locale2] = messages?.default;
+        loadedLanguages.value[locale2] = messages.default;
       } else {
+        console.error(`Available locale files:`, Object.keys(localeFiles));
         throw new Error(`Locale file ${fileKey} not found`);
       }
     }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yiiamee/multilinguist",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Nuxt Multilinguist module for localizations",
   "repository": "yiiameeMich/multilinguist",
   "license": "MIT",