nuxt-i18n-micro 1.6.1 → 1.8.0

package/dist/runtime/components/i18n-t.vue.d.ts

@@ -0,0 +1,73 @@
+declare const _default: import("vue").DefineComponent<{
+    keypath: {
+        type: StringConstructor;
+        required: true;
+    };
+    plural: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    params: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    html: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideIfEmpty: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    customPluralRule: {
+        type: FunctionConstructor;
+        default: null;
+    };
+}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    keypath: {
+        type: StringConstructor;
+        required: true;
+    };
+    plural: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    params: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    html: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideIfEmpty: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    customPluralRule: {
+        type: FunctionConstructor;
+        default: null;
+    };
+}>>, {
+    tag: string;
+    params: Record<string, any>;
+    defaultValue: string;
+    html: boolean;
+    hideIfEmpty: boolean;
+    customPluralRule: Function;
+}, {}>;
+export default _default;

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

@@ -0,0 +1,22 @@
+export declare const useLocaleHead: ({ addDirAttribute, identifierAttribute, addSeoAttributes, baseUrl }?: {
+    addDirAttribute?: boolean | undefined;
+    identifierAttribute?: string | undefined;
+    addSeoAttributes?: boolean | undefined;
+    baseUrl?: string | undefined;
+}) => import("vue").Ref<{
+    htmlAttrs: {
+        lang?: string | undefined;
+        dir?: ("ltr" | "rtl" | "auto") | undefined;
+    };
+    link: {
+        [x: string]: string | undefined;
+        rel: string;
+        href: string;
+        hreflang?: string | undefined;
+    }[];
+    meta: {
+        [x: string]: string;
+        property: string;
+        content: string;
+    }[];
+}>;

package/dist/runtime/composables/useLocaleHead.js

@@ -0,0 +1,97 @@
+import { joinURL } from "ufo";
+import { unref, useRoute, useRuntimeConfig, watch, onUnmounted, ref, useNuxtApp } from "#imports";
+export const useLocaleHead = ({ addDirAttribute = true, identifierAttribute = "id", addSeoAttributes = true, baseUrl = "/" } = {}) => {
+  const metaObject = ref({
+    htmlAttrs: {},
+    link: [],
+    meta: []
+  });
+  function updateMeta() {
+    const { defaultLocale, includeDefaultLocaleRoute } = useRuntimeConfig().public.i18nConfig;
+    const { $getLocales, $getLocale } = useNuxtApp();
+    const route = useRoute();
+    const locale = unref($getLocale());
+    const routeName = (route.name ?? "").toString();
+    const currentLocale = unref($getLocales().find((l) => l.code === locale));
+    if (!currentLocale) {
+      return;
+    }
+    const currentIso = currentLocale.iso || locale;
+    const currentDir = currentLocale.dir || "auto";
+    let fullPath = unref(route.fullPath);
+    let ogUrl = joinURL(unref(baseUrl), fullPath);
+    let indexUrl = joinURL(unref(baseUrl));
+    if (!ogUrl.endsWith("/")) {
+      ogUrl += "/";
+    }
+    if (!indexUrl.endsWith("/")) {
+      indexUrl += "/";
+    }
+    if (routeName.startsWith("localized-") && fullPath.startsWith(`/${locale}`)) {
+      fullPath = fullPath.slice(locale.length + 1);
+      ogUrl = joinURL(unref(baseUrl), locale, fullPath);
+    }
+    metaObject.value = {
+      htmlAttrs: {
+        lang: currentIso,
+        ...addDirAttribute ? { dir: currentDir } : {}
+      },
+      link: [],
+      meta: []
+    };
+    if (!addSeoAttributes) return;
+    const alternateLocales = $getLocales() ?? [];
+    const ogLocaleMeta = {
+      [identifierAttribute]: "i18n-og",
+      property: "og:locale",
+      content: currentIso
+    };
+    const ogUrlMeta = {
+      [identifierAttribute]: "i18n-og-url",
+      property: "og:url",
+      content: ogUrl
+    };
+    const alternateOgLocalesMeta = alternateLocales.map((loc) => ({
+      [identifierAttribute]: `i18n-og-alt-${loc.iso || loc.code}`,
+      property: "og:locale:alternate",
+      content: unref(loc.iso || loc.code)
+    }));
+    const canonicalLink = {
+      [identifierAttribute]: "i18n-can",
+      rel: "canonical",
+      href: ogUrl
+    };
+    const alternateLinks = alternateLocales.flatMap((loc) => {
+      const href = defaultLocale === loc.code && !includeDefaultLocaleRoute ? indexUrl : joinURL(unref(baseUrl), loc.code, fullPath);
+      const links = [{
+        [identifierAttribute]: `i18n-alternate-${loc.code}`,
+        rel: "alternate",
+        href,
+        hreflang: unref(loc.code)
+      }];
+      if (loc.iso) {
+        links.push({
+          [identifierAttribute]: `i18n-alternate-${loc.iso}`,
+          rel: "alternate",
+          href,
+          hreflang: unref(loc.iso)
+        });
+      }
+      return links;
+    });
+    metaObject.value.meta = [ogLocaleMeta, ogUrlMeta, ...alternateOgLocalesMeta];
+    metaObject.value.link = [canonicalLink, ...alternateLinks];
+  }
+  if (import.meta.client) {
+    const route = useRoute();
+    const stop = watch(
+      () => route.fullPath,
+      () => updateMeta(),
+      { immediate: true }
+    );
+    onUnmounted(() => stop());
+  } else {
+    updateMeta();
+  }
+  return metaObject;
+};

package/dist/runtime/plugins/01.plugin.d.ts

@@ -10,7 +10,7 @@ interface PluralTranslations {
 declare const _default: import("#app").Plugin<{
     getLocale: () => string;
     getLocales: () => Locale[];
-    t: <T extends Record<string, string | number | boolean>>(key: string, params?: T, defaultValue?: string) => string | number | boolean | Translations | PluralTranslations | unknown[] | unknown | null;
+    t: (key: string, params?: Record<string, string | number | boolean>, defaultValue?: string) => unknown;
     tc: (key: string, count: number, defaultValue?: string) => string;
     has: (key: string) => boolean;
     mergeTranslations: (newTranslations: Translations) => void;
@@ -19,7 +19,7 @@ declare const _default: import("#app").Plugin<{
 }> & import("#app").ObjectPlugin<{
     getLocale: () => string;
     getLocales: () => Locale[];
-    t: <T extends Record<string, string | number | boolean>>(key: string, params?: T, defaultValue?: string) => string | number | boolean | Translations | PluralTranslations | unknown[] | unknown | null;
+    t: (key: string, params?: Record<string, string | number | boolean>, defaultValue?: string) => unknown;
     tc: (key: string, count: number, defaultValue?: string) => string;
     has: (key: string) => boolean;
     mergeTranslations: (newTranslations: Translations) => void;

package/dist/runtime/plugins/01.plugin.js

@@ -4,9 +4,13 @@ import { useRoute, useRouter } from "#imports";
 const i18nHelper = useTranslationHelper();
 const isDev = process.env.NODE_ENV !== "production";
 function interpolate(template, params) {
-  return template.replace(/\{(\w+)\}/g, (_, match) => {
-    return params[match] !== void 0 ? String(params[match]) : `{${match}}`;
-  });
+  return template.replace(/\{(\w+)\}/g, (_, match) => params[match] !== void 0 ? String(params[match]) : `{${match}}`);
+}
+function getCurrentLocale(route, i18nConfig) {
+  return (route.params?.locale ?? i18nConfig.defaultLocale).toString();
+}
+function getRouteName(route) {
+  return (route?.name ?? "").toString().replace("localized-", "");
 }
 function switchLocale(locale, route, router, i18nConfig) {
   const checkLocale = i18nConfig.locales?.find((l) => l.code === locale);
@@ -14,157 +18,105 @@ function switchLocale(locale, route, router, i18nConfig) {
     console.warn(`Locale ${locale} is not available`);
     return Promise.reject(`Locale ${locale} is not available`);
   }
-  const { defaultLocale } = i18nConfig;
-  const routeName = route.name.replace(`localized-`, "");
-  const newRouteName = locale !== defaultLocale || i18nConfig.includeDefaultLocaleRoute ? `localized-${routeName}` : routeName;
+  const routeName = getRouteName(route);
+  const newRouteName = locale !== i18nConfig.defaultLocale || i18nConfig.includeDefaultLocaleRoute ? `localized-${routeName}` : routeName;
   const newParams = { ...route.params };
   delete newParams.locale;
-  if (locale !== defaultLocale || i18nConfig.includeDefaultLocaleRoute) {
+  if (locale !== i18nConfig.defaultLocale || i18nConfig.includeDefaultLocaleRoute) {
     newParams.locale = locale;
   }
   return router.push({ name: newRouteName, params: newParams });
 }
 function getLocalizedRoute(to, router, route, i18nConfig, locale) {
-  const { defaultLocale } = i18nConfig;
-  const currentLocale = (locale || route.params.locale || defaultLocale).toString();
+  const currentLocale = locale || getCurrentLocale(route, i18nConfig);
   const selectRoute = router.resolve(to);
-  const routeName = selectRoute.name.replace(`localized-`, "");
-  const newRouteName = currentLocale !== defaultLocale || i18nConfig.includeDefaultLocaleRoute ? `localized-${routeName}` : routeName;
+  const routeName = selectRoute.name.replace("localized-", "");
+  const newRouteName = currentLocale !== i18nConfig.defaultLocale || i18nConfig.includeDefaultLocaleRoute ? `localized-${routeName}` : routeName;
   const newParams = { ...route.params };
   delete newParams.locale;
-  if (currentLocale !== defaultLocale || i18nConfig.includeDefaultLocaleRoute) {
+  if (currentLocale !== i18nConfig.defaultLocale || i18nConfig.includeDefaultLocaleRoute) {
     newParams.locale = currentLocale;
   }
   return router.resolve({ name: newRouteName, params: newParams });
 }
 export default defineNuxtPlugin(async (nuxtApp) => {
-  const router = useRouter();
   const registerI18nModule = (translations, locale) => {
-    i18nHelper.margeGlobalTranslation(locale, translations);
+    i18nHelper.mergeGlobalTranslation(locale, translations);
   };
   await nuxtApp.callHook("i18n:register", registerI18nModule);
   if (!nuxtApp.payload.data.translations) {
     nuxtApp.payload.data.translations = {};
   }
-  if (import.meta.server) {
-    nuxtApp.hook("app:rendered", async () => {
-      if (import.meta.server) {
-        const route2 = useRoute();
-        const locale = (route2.params?.locale ?? i18nConfig.defaultLocale).toString();
-        const routeName = (route2?.name ?? "").toString().replace(`localized-`, "");
-        const cacheKey = `${locale}:${routeName}`;
-        nuxtApp.payload.data.translations[cacheKey] = i18nHelper.getCache(locale, routeName) ?? /* @__PURE__ */ new Map();
-      }
-    });
-  } else {
-    router.beforeEach(async (to, from, next) => {
-      const locale = (to.params?.locale ?? i18nConfig.defaultLocale).toString();
-      const routeName = to.name.replace(`localized-`, "");
-      const cacheKey = `${locale}:${routeName}`;
-      if (nuxtApp.payload.data.translations) {
-        i18nHelper.setCache(locale, routeName, nuxtApp.payload.data.translations[cacheKey] || /* @__PURE__ */ new Map());
-      }
-      next();
-    });
-  }
   const route = useRoute();
   const config = useRuntimeConfig();
   const i18nConfig = config.public.i18nConfig;
   const plural = new Function("return " + i18nConfig.plural)();
-  router.beforeEach(async (to, from, next) => {
-    if (import.meta.client) {
-      const locale = (to.params?.locale ?? i18nConfig.defaultLocale).toString();
-      const initialRouteName2 = to.name.replace(`localized-`, "");
-      let routeName = initialRouteName2;
-      if (i18nConfig.routesLocaleLinks && i18nConfig.routesLocaleLinks[routeName]) {
-        routeName = i18nConfig.routesLocaleLinks[routeName];
-      }
-      if (!i18nHelper.hasPageTranslation(locale, initialRouteName2)) {
-        const data = await $fetch(`/_locales/${routeName}/${locale}/data.json?v=${i18nConfig.dateBuild}`, { baseURL: i18nConfig.baseURL });
-        await i18nHelper.loadPageTranslations(locale, initialRouteName2, data ?? {});
-      }
-    }
-    next();
-  });
-  const initialLocale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
-  const initialRouteName = route.name.replace(`localized-`, "");
+  const initialLocale = getCurrentLocale(route, i18nConfig);
   if (!i18nHelper.hasGeneralTranslation(initialLocale)) {
     const data = await $fetch(`/_locales/general/${initialLocale}/data.json?v=${i18nConfig.dateBuild}`, { baseURL: i18nConfig.baseURL });
     await i18nHelper.loadTranslations(initialLocale, data ?? {});
   }
+  const loadTranslationsIfNeeded = async (locale, routeName) => {
+    if (!i18nHelper.hasPageTranslation(locale, routeName)) {
+      let fRouteName = routeName;
+      if (i18nConfig.routesLocaleLinks && i18nConfig.routesLocaleLinks[fRouteName]) {
+        fRouteName = i18nConfig.routesLocaleLinks[fRouteName];
+      }
+      const data = await $fetch(`/_locales/${fRouteName}/${locale}/data.json?v=${i18nConfig.dateBuild}`, { baseURL: i18nConfig.baseURL });
+      await i18nHelper.loadPageTranslations(locale, routeName, data ?? {});
+    }
+  };
   if (import.meta.server) {
-    const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
-    let routeName = initialRouteName;
-    if (i18nConfig.routesLocaleLinks && i18nConfig.routesLocaleLinks[routeName]) {
-      routeName = i18nConfig.routesLocaleLinks[routeName];
+    const locale = getCurrentLocale(route, i18nConfig);
+    const initialRouteName = getRouteName(route);
+    await loadTranslationsIfNeeded(locale, initialRouteName);
+  }
+  useRouter().beforeEach(async (to, from, next) => {
+    if (import.meta.client) {
+      const locale = getCurrentLocale(to, i18nConfig);
+      const routeName = getRouteName(to);
+      await loadTranslationsIfNeeded(locale, routeName);
     }
-    if (!i18nHelper.hasPageTranslation(initialLocale, routeName)) {
-      const pageData = await $fetch(`/_locales/${routeName}/${locale}/data.json?v=${i18nConfig.dateBuild}`, { baseURL: i18nConfig.baseURL });
-      await i18nHelper.loadPageTranslations(initialLocale, initialRouteName, pageData ?? {});
+    next();
+  });
+  const getTranslation = (key, params, defaultValue) => {
+    if (!key) return "";
+    const locale = getCurrentLocale(useRoute(), i18nConfig);
+    const routeName = getRouteName(useRoute());
+    let value = i18nHelper.getTranslation(locale, routeName, key);
+    if (!value) {
+      if (isDev && import.meta.client) {
+        console.warn(`Not found '${key}' key in '${locale}' locale messages.`);
+      }
+      value = defaultValue || key;
     }
-  }
+    return typeof value === "string" && params ? interpolate(value, params) : value;
+  };
   return {
     provide: {
-      getLocale: () => {
-        const route2 = useRoute();
-        return (route2.params?.locale ?? i18nConfig.defaultLocale).toString();
-      },
+      getLocale: () => getCurrentLocale(useRoute(), i18nConfig),
       getLocales: () => i18nConfig.locales || [],
-      t: (key, params, defaultValue) => {
-        if (!key) {
-          console.log(`$t: key not exist`);
-          return "";
-        }
-        const route2 = useRoute();
-        const locale = (route2.params?.locale ?? i18nConfig.defaultLocale).toString();
-        const routeName = route2.name.replace(`localized-`, "");
-        let value = i18nHelper.getTranslation(locale, routeName, key, !!i18nConfig.cache);
-        if (!value) {
-          if (isDev && import.meta.client) {
-            console.warn(`Not found '${key}' key in '${locale}' locale messages.`);
-          }
-          value = defaultValue || key;
-        }
-        if (typeof value === "string" && params) {
-          value = interpolate(value, params);
-        }
-        return value;
-      },
+      t: getTranslation,
       tc: (key, count, defaultValue) => {
-        if (!key) {
-          console.log(`$tc: key not exist`);
-          return "";
-        }
-        const route2 = useRoute();
-        const locale = (route2.params?.locale ?? i18nConfig.defaultLocale).toString();
-        const routeName = route2.name.replace(`localized-`, "");
-        let translation = i18nHelper.getTranslation(locale, routeName, key, !!i18nConfig.cache);
-        if (!translation) {
-          if (isDev && import.meta.client) {
-            console.warn(`Not found '${key}' key in '${locale}' locale messages.`);
-          }
-          translation = defaultValue || key;
-        }
-        return plural(translation.toString(), count, locale);
+        const translation = getTranslation(key, {}, defaultValue);
+        return plural(translation?.toString(), count, getCurrentLocale(useRoute(), i18nConfig));
       },
       has: (key) => {
-        const route2 = useRoute();
-        const locale = (route2.params?.locale ?? i18nConfig.defaultLocale).toString();
-        const routeName = route2.name.replace(`localized-`, "");
-        const translation = i18nHelper.getTranslation(locale, routeName, key, !!i18nConfig.cache);
-        return !!translation;
+        return !!getTranslation(key);
       },
       mergeTranslations: (newTranslations) => {
         const route2 = useRoute();
-        const routeName = route2.name.replace(`localized-`, "");
-        const locale = (route2.params?.locale ?? i18nConfig.defaultLocale).toString();
-        i18nHelper.margeTranslation(locale, routeName, newTranslations);
+        const routeName = getRouteName(route2);
+        const locale = getCurrentLocale(route2, i18nConfig);
+        i18nHelper.mergeTranslation(locale, routeName, newTranslations);
       },
       switchLocale: (locale) => {
+        const router = useRouter();
         const route2 = useRoute();
         switchLocale(locale, route2, router, i18nConfig);
       },
       localeRoute: (to, locale) => {
+        const router = useRouter();
         const route2 = useRoute();
         return getLocalizedRoute(to, router, route2, i18nConfig, locale);
       }

package/dist/runtime/plugins/02.meta.js

@@ -1,55 +1,25 @@
+import { useLocaleHead } from "../composables/useLocaleHead.js";
 import { useHead, defineNuxtPlugin, useRuntimeConfig } from "#app";
-import { useRoute } from "#imports";
+import { useRequestURL } from "#imports";
+const host = process.env.HOST ?? "localhost";
+const port = process.env.PORT ?? "host";
 export default defineNuxtPlugin((nuxtApp) => {
-  const route = useRoute();
   const config = useRuntimeConfig();
   const i18nConfig = config.public.i18nConfig;
-  if (!i18nConfig.mata) {
+  const schema = port === "443" ? "https" : "http";
+  const defaultUrl = port === "80" || port === "443" ? `${schema}://${host}` : `${schema}://${host}:${port}`;
+  if (!i18nConfig.meta) {
     return;
   }
   nuxtApp.hook("app:rendered", (_context) => {
-    const locale = (route.params?.locale ?? i18nConfig.defaultLocale).toString();
-    const locales = i18nConfig.locales || [];
-    const currentIso = locales.find((l) => l.code === locale)?.iso || locale;
-    const currentDir = locales.find((l) => l.code === locale)?.dir || "ltr";
-    const baseUrl = config.public.baseURL || "http://localhost:3000";
-    const ogUrl = `${baseUrl}${route.fullPath}`;
-    useHead({
-      htmlAttrs: {
-        lang: currentIso,
-        dir: currentDir
-      },
-      meta: [
-        { id: "i18n-og", property: "og:locale", content: currentIso },
-        { id: "i18n-og-url", property: "og:url", content: ogUrl },
-        ...locales.filter((l) => l.code !== locale).map((loc) => ({
-          id: `i18n-og-alt-${loc.iso || loc.code}`,
-          property: "og:locale:alternate",
-          content: loc.iso || loc.code
-        }))
-      ],
-      link: [
-        { id: "i18n-can", rel: "canonical", href: ogUrl },
-        ...locales.flatMap((loc) => {
-          const links = [
-            {
-              id: `i18n-alternate-${loc.code}`,
-              rel: "alternate",
-              href: `${baseUrl}/${loc.code}${route.fullPath}`,
-              hreflang: loc.code
-            }
-          ];
-          if (loc.iso) {
-            links.push({
-              id: `i18n-alternate-${loc.iso}`,
-              rel: "alternate",
-              href: `${baseUrl}/${loc.code}${route.fullPath}`,
-              hreflang: loc.iso
-            });
-          }
-          return links;
-        })
-      ]
+    const url = useRequestURL();
+    const baseUrl = (i18nConfig.metaBaseUrl || url.origin || defaultUrl).toString();
+    const head = useLocaleHead({
+      addDirAttribute: true,
+      identifierAttribute: "id",
+      addSeoAttributes: true,
+      baseUrl
     });
+    useHead(head);
   });
 });

package/dist/runtime/translationHelper.d.ts

@@ -3,11 +3,11 @@ export declare function useTranslationHelper(): {
     hasCache(locale: string, page: string): boolean;
     getCache(locale: string, routeName: string): Map<string, unknown>;
     setCache(locale: string, routeName: string, cache: Map<string, Translations | unknown>): void;
-    margeTranslation(locale: string, routeName: string, newTranslations: Translations): void;
-    margeGlobalTranslation(locale: string, newTranslations: Translations): void;
+    mergeTranslation(locale: string, routeName: string, newTranslations: Translations): void;
+    mergeGlobalTranslation(locale: string, newTranslations: Translations): void;
     hasGeneralTranslation(locale: string): boolean;
     hasPageTranslation(locale: string, routeName: string): boolean;
-    getTranslation: <T = unknown>(locale: string, routeName: string, key: string, useCache: boolean) => T | null;
-    loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
-    loadTranslations: (locale: string, translations: Translations) => Promise<void>;
+    getTranslation: <T = unknown>(locale: string, routeName: string, key: string) => T | null;
+    loadPageTranslations(locale: string, routeName: string, translations: Translations): Promise<void>;
+    loadTranslations(locale: string, translations: Translations): Promise<void>;
 };

package/dist/runtime/translationHelper.js

@@ -13,9 +13,9 @@ function deepClone(value) {
 }
 function findTranslation(translations, parts) {
   let value = translations;
-  for (let i = 0; i < parts.length; i++) {
-    if (value && typeof value === "object" && parts[i] in value) {
-      value = value[parts[i]];
+  for (const part of parts) {
+    if (value && typeof value === "object" && part in value) {
+      value = value[part];
     } else {
       return null;
     }
@@ -28,17 +28,18 @@ function findTranslation(translations, parts) {
 export function useTranslationHelper() {
   return {
     hasCache(locale, page) {
-      return serverTranslationInit[`${locale}:${page}`] ?? false;
+      return (serverTranslationCache[`${locale}:${page}`] ?? /* @__PURE__ */ new Map()).size > 0;
     },
     getCache(locale, routeName) {
       return serverTranslationCache[`${locale}:${routeName}`];
     },
     setCache(locale, routeName, cache) {
+      const cacheKey = `${locale}:${routeName}`;
       serverTranslationCache[`${locale}:${routeName}`] = cache;
       serverTranslationInit[`${locale}:index`] = true;
-      serverTranslationInit[`${locale}:${routeName}`] = true;
+      serverTranslationInit[cacheKey] = true;
     },
-    margeTranslation(locale, routeName, newTranslations) {
+    mergeTranslation(locale, routeName, newTranslations) {
       if (!routeLocaleCache[`${locale}:${routeName}`]) {
         console.error(`marge: route ${locale}:${routeName} not loaded`);
       }
@@ -47,7 +48,7 @@ export function useTranslationHelper() {
         ...newTranslations
       };
     },
-    margeGlobalTranslation(locale, newTranslations) {
+    mergeGlobalTranslation(locale, newTranslations) {
       if (!generalLocaleCache[`${locale}`]) {
         console.error(`marge: route ${locale} not loaded`);
       }
@@ -62,37 +63,22 @@ export function useTranslationHelper() {
     hasPageTranslation(locale, routeName) {
       return !!routeLocaleCache[`${locale}:${routeName}`];
     },
-    getTranslation: (locale, routeName, key, useCache) => {
+    getTranslation: (locale, routeName, key) => {
       const cacheKey = `${locale}:${routeName}`;
-      if (useCache && serverTranslationCache[cacheKey]) {
-        const cached = serverTranslationCache[cacheKey].get(key);
-        if (cached) {
-          return cached;
-        }
+      const cached = serverTranslationCache[cacheKey]?.get(key);
+      if (cached) {
+        return cached;
       }
       const parts = key.split(".");
       let result = null;
-      if (dynamicTranslationsCaches.length) {
-        for (const dynamicCache of dynamicTranslationsCaches) {
-          const value = findTranslation(dynamicCache[locale], parts);
-          if (value !== null) {
-            result = value;
-          }
-        }
+      for (const dynamicCache of dynamicTranslationsCaches) {
+        result = findTranslation(dynamicCache[locale] || null, parts);
+        if (result !== null) break;
       }
       if (!result) {
-        const value = findTranslation(routeLocaleCache[`${locale}:${routeName}`], parts);
-        if (value !== null) {
-          result = value;
-        }
+        result = findTranslation(routeLocaleCache[cacheKey] || null, parts) ?? findTranslation(generalLocaleCache[locale] || null, parts);
       }
-      if (!result) {
-        const value = findTranslation(generalLocaleCache[locale], parts);
-        if (value !== null) {
-          return value;
-        }
-      }
-      if (useCache && result) {
+      if (result) {
         if (!serverTranslationCache[cacheKey]) {
           serverTranslationCache[cacheKey] = /* @__PURE__ */ new Map();
         }
@@ -100,21 +86,14 @@ export function useTranslationHelper() {
       }
       return result;
     },
-    loadPageTranslations: async (locale, routeName, translations) => {
-      try {
-        routeLocaleCache[`${locale}:${routeName}`] = { ...translations };
-        serverTranslationInit[`${locale}:${routeName}`] = true;
-      } catch (error) {
-        console.error(`Error loading translations for ${locale} and ${routeName}:`, error);
-      }
+    async loadPageTranslations(locale, routeName, translations) {
+      const cacheKey = `${locale}:${routeName}`;
+      routeLocaleCache[cacheKey] = { ...translations };
+      serverTranslationInit[cacheKey] = true;
     },
-    loadTranslations: async (locale, translations) => {
-      try {
-        generalLocaleCache[locale] = { ...translations };
-        serverTranslationInit[`${locale}:index`] = true;
-      } catch (error) {
-        console.error(`Error loading translations for general ${locale}:`, error);
-      }
+    async loadTranslations(locale, translations) {
+      generalLocaleCache[locale] = { ...translations };
+      serverTranslationInit[`${locale}:index`] = true;
     }
   };
 }