nuxt-i18n-micro 3.30.3 → 4.0.0

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

@@ -1,10 +1,8 @@
+import { trimTrailingSlashes } from "@i18n-micro/utils/app-path";
 import { mergeI18nHead } from "@i18n-micro/utils/merge-i18n-head";
-import { isMetaDisabledForRoute } from "@i18n-micro/utils/route";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { computed, watch } from "vue";
-import { getI18nConfig } from "#build/i18n.strategy.mjs";
-import { defineNuxtPlugin, useHead, useRequestURL, useRoute, useState } from "#imports";
-import { useI18nHead } from "../composables/useI18nHead.js";
+import { joinURL } from "ufo";
+import { defineNuxtPlugin, useHead, useRequestURL, useRoute, useRuntimeConfig } from "#imports";
+import { usePageHead } from "../utils/page-head.js";
 import { useLocaleHead } from "../composables/useLocaleHead.js";
 function readSiteConfigUrl(nuxtApp) {
   const stack = nuxtApp.$nuxtSiteConfig;
@@ -16,57 +14,52 @@ function readSiteConfigUrl(nuxtApp) {
     return void 0;
   }
 }
+function requestOrigin(i18nConfig) {
+  const xForwardedProto = i18nConfig.metaTrustForwardedProto !== false;
+  try {
+    return useRequestURL({ xForwardedHost: i18nConfig.metaTrustForwardedHost !== false, xForwardedProto }).origin;
+  } catch {
+    try {
+      return useRequestURL({ xForwardedProto }).origin;
+    } catch {
+      return "";
+    }
+  }
+}
 function resolveSeoBaseUrl(i18nConfig, siteUrl) {
   const configured = i18nConfig.metaBaseUrl || siteUrl;
-  if (configured) return configured.replace(/\/+$/, "");
-  const url = useRequestURL({
-    xForwardedHost: i18nConfig.metaTrustForwardedHost !== false,
-    xForwardedProto: i18nConfig.metaTrustForwardedProto !== false
-  });
-  return url.origin.replace(/\/+$/, "");
+  if (configured) return trimTrailingSlashes(configured);
+  return trimTrailingSlashes(joinURL(requestOrigin(i18nConfig), useRuntimeConfig().app.baseURL));
 }
+let warnedCachedRender = false;
 export default defineNuxtPlugin((nuxtApp) => {
   const route = useRoute();
-  const i18nRouteParams = useState("i18n-route-params", () => ({}));
-  const localeState = useState("i18n-locale", () => null);
-  const { pageHead } = useI18nHead();
-  const getRuntimeConfig = nuxtApp.$getI18nConfig;
-  const i18nConfig = resolveI18nConfigWithRuntimeOverrides(
-    typeof getRuntimeConfig === "function" ? getRuntimeConfig() : getI18nConfig()
-  );
+  const pageHead = usePageHead();
+  const i18nConfig = nuxtApp.$getI18nConfig();
   const siteUrl = readSiteConfigUrl(nuxtApp);
   const baseUrl = resolveSeoBaseUrl(i18nConfig, siteUrl);
-  const { metaObject, updateMeta } = useLocaleHead({
-    addDirAttribute: true,
-    identifierAttribute: "id",
-    addSeoAttributes: true,
+  const event = nuxtApp.ssrContext?.event;
+  const hostless = event?.context?.cache && !event.node?.req?.headers?.host;
+  if (import.meta.server && !warnedCachedRender && hostless && !i18nConfig.metaBaseUrl && !siteUrl) {
+    warnedCachedRender = true;
+    console.warn(
+      "[i18n] A route cached by `swr` or `cache` renders without the request host, so canonical and hreflang URLs point to http://localhost. Set `i18n.metaBaseUrl` or `site.url`."
+    );
+  }
+  const { build } = useLocaleHead({
     baseUrl,
     autoUpdate: false
   });
-  const mergedHead = computed(() => {
+  useHead(() => {
     const { $getLocales, $getLocale } = nuxtApp;
-    const allLocales = $getLocales?.() ?? i18nConfig.locales ?? [];
-    const locale = $getLocale?.() || i18nConfig.defaultLocale || "en";
-    if (isMetaDisabledForRoute(route, i18nConfig.routeDisableMeta, locale, i18nConfig.localizedRouteNamePrefix || "localized-")) {
-      return { htmlAttrs: {}, link: [], meta: [] };
-    }
-    return mergeI18nHead(metaObject.value, pageHead.value, {
+    const allLocales = $getLocales();
+    const locale = $getLocale() || i18nConfig.defaultLocale;
+    const head = build();
+    if (!pageHead.value || nuxtApp.$i18nStrategy.isMetaDisabled(route, locale)) return head;
+    return mergeI18nHead(head, pageHead.value, {
       identifierAttribute: "id",
       locales: allLocales,
       currentLocale: locale
     });
   });
-  useHead(mergedHead);
-  const refreshMeta = () => updateMeta();
-  if (import.meta.server) {
-    nuxtApp.hook("app:rendered", refreshMeta);
-  } else {
-    refreshMeta();
-    nuxtApp.hook("page:finish", refreshMeta);
-  }
-  watch(() => i18nRouteParams.value, refreshMeta, { deep: true, flush: "post" });
-  watch(() => [route.fullPath, route.name, route.matched.length, localeState.value], refreshMeta, {
-    flush: "post"
-  });
-  watch(pageHead, refreshMeta, { deep: true, flush: "post" });
 });

package/dist/runtime/plugins/04.vue-devtools.js

@@ -25,7 +25,7 @@ export default defineNuxtPlugin({
       return;
     }
     const notifyCurrentLoad = () => {
-      const locale = bridge.i18n.getCurrentLocale();
+      const locale = bridge.i18n.getLocale();
       const routeName = bridge.i18n.getCurrentRouteName() || "index";
       notifier.notifyLoad(locale, routeName, countLoadedTranslationKeys(bridge.i18n, locale, routeName));
     };

package/dist/runtime/plugins/06.redirect.d.ts

@@ -1,7 +1,7 @@
 /**
- * Universal redirect plugin for i18n routes (works on both server and client).
- * Handles locale detection, 404 checks, and redirects.
- * Client SPA redirects are handled by i18n-redirect route middleware.
+ * Server-side locale redirects and 404s for i18n routes. Every decision is the strategy's
+ * (`shouldReturn404`, `getClientRedirect`); this plugin only reads the request (cookie,
+ * Accept-Language) and writes the response. Client SPA redirects: the i18n-redirect middleware.
  */
 declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/06.redirect.js

@@ -1,103 +1,77 @@
 import { getEnabledLocaleCodes } from "@i18n-micro/utils/active-locales";
 import { isInternalPath, withoutAppBaseURL } from "@i18n-micro/utils/app-path";
-import { shouldAttemptLocaleRedirect } from "@i18n-micro/utils/auto-detect-path";
-import { getLocaleCookieName, getLocaleCookieOptions } from "@i18n-micro/utils/cookie";
-import { resolvePreferredLocale } from "@i18n-micro/utils/resolve-locale";
-import { getCookie, getHeader, getRequestURL, setCookie } from "h3";
-import { createError, defineNuxtPlugin, navigateTo, useRequestEvent, useRuntimeConfig, useState } from "#imports";
+import { getLocaleCookieName, getLocaleCookieOptions, getPreferenceCookieName } from "@i18n-micro/utils/cookie";
+import { preferenceCounts, redirectLocale } from "@i18n-micro/utils/resolve-locale";
+import { appendResponseHeader, getCookie, getHeader, setCookie } from "h3";
+import { requestURL } from "../utils/request-url.js";
+import { applyTrailingSlash } from "../utils/trailing-slash.js";
+import { createError, defineNuxtPlugin, navigateTo, useRequestEvent, useRouter, useRuntimeConfig, useState } from "#imports";
 const DEBUG = process.env.NUXT_I18N_DEBUG_REDIRECT === "1";
-function resolveI18nStrategy(nuxtApp) {
-  if (nuxtApp.$i18nStrategy) {
-    return nuxtApp.$i18nStrategy;
-  }
-  throw new Error("[nuxt-i18n-micro] i18n redirect plugin requires the main i18n plugin ($i18nStrategy).");
-}
 export default defineNuxtPlugin({
   name: "i18n-redirect",
   dependsOn: ["i18n-plugin-loader"],
+  // annotated: the plugin types are inferred from every plugin's setup, this one included
   setup(nuxtApp) {
-    const i18nStrategy = resolveI18nStrategy(nuxtApp);
+    const i18nStrategy = nuxtApp.$i18nStrategy;
     const getRuntimeConfig = nuxtApp.$getI18nConfig;
-    if (typeof getRuntimeConfig !== "function") {
-      throw new Error("[nuxt-i18n-micro] i18n redirect plugin requires $getI18nConfig from the main i18n plugin.");
-    }
+    const event = useRequestEvent();
+    if (!event) return;
     const i18nConfig = getRuntimeConfig();
-    const appBaseURL = useRuntimeConfig().app.baseURL;
-    const validLocales = getEnabledLocaleCodes(i18nConfig.locales);
-    const defaultLocale = i18nConfig.defaultLocale || "en";
-    const autoDetectPath = i18nConfig.autoDetectPath || "/";
-    const cookieName = getLocaleCookieName(i18nConfig);
-    if (import.meta.server) {
-      const event = useRequestEvent();
-      if (!event) return;
-      const url = getRequestURL(event);
-      const path = withoutAppBaseURL(url.pathname, appBaseURL);
-      const performRedirect = (targetUrl, code = 302) => {
-        return navigateTo(targetUrl, { redirectCode: code });
-      };
-      if (isInternalPath(path, i18nConfig.excludePatterns)) return;
-      const pathSegments = path.replace(/^\//, "").split("/").filter(Boolean);
-      const firstSegment = pathSegments[0];
-      const customRegex = i18nConfig.customRegexMatcher;
-      if (firstSegment && customRegex && !validLocales.includes(firstSegment)) {
-        const source = typeof customRegex === "string" ? customRegex : customRegex.source;
-        const regex = new RegExp(`^${source}$`);
-        if (regex.test(firstSegment)) {
-          if (DEBUG) console.error("[i18n-redirect] 404: unknown locale", firstSegment);
-          throw createError({ statusCode: 404, statusMessage: "Page Not Found" });
-        }
-      }
-      const errorMessage = i18nStrategy.shouldReturn404(path);
-      if (errorMessage) {
-        if (DEBUG) console.error("[i18n-redirect] 404:", errorMessage, path);
-        throw createError({ statusCode: 404, statusMessage: "Page Not Found" });
-      }
-      const hasLocalePrefix = Boolean(firstSegment && validLocales.includes(firstSegment));
-      const shouldDeferCookieSync = i18nConfig.redirects !== false && autoDetectPath === "*";
-      if (hasLocalePrefix && cookieName && !shouldDeferCookieSync) {
-        const currentLocale = firstSegment;
-        const { watch: _w, ...cookieOpts } = getLocaleCookieOptions();
-        setCookie(event, cookieName, currentLocale, cookieOpts);
-      }
-      if (i18nConfig.redirects !== false) {
-        const allowPreferenceRedirect = shouldAttemptLocaleRedirect(path, { autoDetectPath, hasLocalePrefix });
-        const localeState = autoDetectPath !== "*" ? useState("i18n-locale", () => null) : null;
-        let preferredLocale = resolvePreferredLocale({
-          defaultLocale,
-          validLocales,
-          autoDetectLanguage: i18nConfig.autoDetectLanguage,
-          stateLocale: localeState?.value ?? null,
-          cookieLocale: cookieName ? getCookie(event, cookieName) : null,
-          acceptLanguageHeader: getHeader(event, "accept-language"),
-          ignoreStateLocale: autoDetectPath === "*"
-        });
-        if (!hasLocalePrefix && !allowPreferenceRedirect) {
-          preferredLocale = defaultLocale;
-        }
-        if (autoDetectPath === "*" && !hasLocalePrefix) {
-          preferredLocale = defaultLocale;
-        }
-        if (autoDetectPath === "*" && hasLocalePrefix && firstSegment !== preferredLocale) {
-          const rest = pathSegments.slice(1).join("/");
-          let targetPath;
-          if (preferredLocale === defaultLocale && i18nConfig.strategy === "prefix_except_default") {
-            targetPath = rest ? `/${rest}` : "/";
-          } else {
-            targetPath = rest ? `/${preferredLocale}/${rest}` : `/${preferredLocale}`;
-          }
-          if (cookieName) {
-            const { watch: _w2, ...cookieOpts2 } = getLocaleCookieOptions();
-            setCookie(event, cookieName, preferredLocale, cookieOpts2);
-          }
-          if (DEBUG) console.error("[i18n-redirect] REDIRECT autoDetectPath *", { path, targetPath, preferredLocale });
-          return performRedirect(targetPath + (url.search || "") + (url.hash || ""));
-        }
-        const redirectPath = i18nStrategy.getClientRedirect(path, preferredLocale);
-        if (redirectPath) {
-          if (DEBUG) console.error("[i18n-redirect] REDIRECT", { path, redirectPath, preferredLocale });
-          return performRedirect(redirectPath + (url.search || "") + (url.hash || ""));
-        }
-      }
+    const url = requestURL(event);
+    const path = withoutAppBaseURL(url.pathname, useRuntimeConfig().app.baseURL);
+    const alwaysPrefixed = i18nConfig.strategy === "prefix";
+    const preferenceCookie = getPreferenceCookieName(i18nConfig);
+    const varyOnVisitor = () => {
+      const vary = [preferenceCookie && "Cookie", i18nConfig.autoDetectLanguage && "Accept-Language"].filter(Boolean);
+      if (vary.length) appendResponseHeader(event, "Vary", vary.join(", "));
+    };
+    const urlless = i18nConfig.strategy === "no_prefix" || i18nConfig.hashMode && !alwaysPrefixed;
+    if (urlless) varyOnVisitor();
+    if (isInternalPath(path, i18nConfig.excludePatterns, i18nConfig.apiBaseUrl)) return;
+    const notFound = i18nStrategy.shouldReturn404(path);
+    if (notFound) {
+      if (DEBUG) console.error("[i18n-redirect] 404:", notFound, path);
+      throw createError({ statusCode: 404, statusMessage: "Page Not Found" });
     }
+    const defaultLocale = i18nConfig.defaultLocale;
+    const autoDetectPath = i18nConfig.autoDetectPath;
+    const anyPath = autoDetectPath === "*";
+    const redirects = i18nConfig.redirects !== false;
+    const cookieName = getLocaleCookieName(i18nConfig);
+    const urlLocale = i18nStrategy.getLocaleFromPath(path);
+    const writeCookie = (locale) => {
+      if (!cookieName) return;
+      const { watch: _watch, decode: _decode, ...options } = getLocaleCookieOptions();
+      setCookie(event, cookieName, locale, options);
+    };
+    const redirectable = redirects && !urlless && !i18nConfig.hashMode && (urlLocale || i18nConfig.strategy !== "prefix_and_default");
+    if (redirectable && preferenceCounts({ path, urlLocale, autoDetectPath, alwaysPrefixed })) varyOnVisitor();
+    const router = useRouter();
+    const served = i18nConfig.strategy !== "no_prefix" && (router.getRoutes().length === 0 || router.currentRoute.value.matched.length > 0);
+    if (urlLocale && served && !(redirects && anyPath)) writeCookie(urlLocale);
+    if (i18nConfig.hashMode && alwaysPrefixed)
+      return navigateTo(`/#${applyTrailingSlash(path, i18nConfig.trailingSlash)}${url.search}`, { redirectCode: 302 });
+    if (!redirects || i18nConfig.hashMode) return;
+    const preferred = redirectLocale({
+      path,
+      urlLocale,
+      autoDetectPath,
+      alwaysPrefixed,
+      defaultLocale,
+      validLocales: getEnabledLocaleCodes(i18nConfig.locales),
+      autoDetectLanguage: i18nConfig.autoDetectLanguage,
+      cookie: preferenceCookie ? getCookie(event, preferenceCookie) : null,
+      acceptLanguage: getHeader(event, "accept-language"),
+      // a state differing from what the URL resolved to was set by the app (a plugin): a choice
+      state: anyPath ? null : chosenState(useState("i18n-locale", () => null).value, event.context.i18n?.locale)
+    });
+    const target = i18nStrategy.getClientRedirect(path, preferred, { switchPrefixed: anyPath });
+    if (!target) return;
+    if (anyPath && urlLocale) writeCookie(preferred);
+    if (DEBUG) console.error("[i18n-redirect] REDIRECT", { path, target, preferred });
+    return navigateTo(applyTrailingSlash(target, i18nConfig.trailingSlash) + url.search + url.hash, { redirectCode: 302 });
   }
 });
+function chosenState(state, urlLocale) {
+  return state && state !== urlLocale ? state : null;
+}

package/dist/runtime/server/{utils → internal}/dev-live-translations.js

@@ -1,10 +1,10 @@
-import { createTranslationDirReader, mergeDevTranslations, resolveLiveTranslationDirs } from "@i18n-micro/hmr/watcher";
+import { createTranslationDirReader, mergeDevTranslations, resolveLiveTranslationDirs } from "./translation-watcher.js";
 import { toTranslations } from "@i18n-micro/utils/normalize";
 import { getI18nPrivateConfig } from "#i18n-internal/config";
 export async function loadLiveDevTranslations(locale, pageName, config) {
   const privateConfig = getI18nPrivateConfig();
   const { translationRoots, additionalRoots } = resolveLiveTranslationDirs({
-    rootDirs: privateConfig.rootDirs?.length ? privateConfig.rootDirs : [privateConfig.rootDir],
+    rootDirs: privateConfig.rootDirs,
     translationDir: privateConfig.translationDir,
     additionalTranslationDirs: privateConfig.additionalTranslationDirs
   });
@@ -12,7 +12,8 @@ export async function loadLiveDevTranslations(locale, pageName, config) {
   const merged = await mergeDevTranslations({
     locale,
     pageName,
-    locales: config.locales,
+    // a fallback may live on another domain, as in production
+    locales: config.linkLocales ?? config.locales,
     fallbackLocale: config.fallbackLocale,
     disablePageLocales: config.disablePageLocales,
     readLocaleFile

package/dist/runtime/server/internal/server-translation-cache.d.ts

@@ -0,0 +1,9 @@
+import type { Translations } from '@i18n-micro/types';
+import { CacheControl } from '@i18n-micro/utils/cache-control';
+export type ServerTranslationCacheEntry = {
+    data: Translations;
+    json: string;
+    /** Of a root read from a file: what a delta names. */
+    mark?: string;
+};
+export declare function getOrCreateServerTranslationCache(): CacheControl<ServerTranslationCacheEntry>;

package/dist/runtime/server/internal/server-translation-cache.js

@@ -0,0 +1,10 @@
+import { DEFAULT_SERVER_CACHE_SIZE } from "../../utils/cache-keys.js";
+import { CacheControl } from "@i18n-micro/utils/cache-control";
+import { getI18nConfig } from "#i18n-internal/strategy";
+let cache;
+export function getOrCreateServerTranslationCache() {
+  if (cache) return cache;
+  const { cacheMaxSize, cacheTtl } = getI18nConfig();
+  cache = new CacheControl({ maxSize: cacheMaxSize || DEFAULT_SERVER_CACHE_SIZE, ttl: cacheTtl });
+  return cache;
+}

package/dist/runtime/server/internal/shared-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Optional level between the process LRU and the dictionary source: a Nitro storage mount several
+ * instances share (`cacheStorage`), so one of them reads the source and the others read its copy.
+ *
+ * Only ever an optimisation: every failure is a miss, and the source answers. The process LRU stays
+ * in front because `$t` is synchronous and needs the tree in memory. No lock: two instances that
+ * miss at once both read the source and write the same value.
+ */
+import type { ResolvedI18nConfig } from '@i18n-micro/types';
+import type { ServerTranslationCacheEntry } from './server-translation-cache.js';
+/**
+ * The chunk's key, or null when it must not touch the layer. `cacheStorageBuild` keeps two builds
+ * apart in a rolling deploy. `dateBuild` alone would not: it hashes only the translation files, and
+ * `0`/`''` turns it off. A runtime `fallbackLocale` changes what `source` and remote chunks hold, and
+ * a runtime host is another backend: one artifact can run against several.
+ */
+export declare function sharedChunkKey(locale: string, page: string, config: ResolvedI18nConfig, host?: string): string | null;
+export declare function readSharedChunk(key: string): Promise<ServerTranslationCacheEntry | null>;
+/**
+ * A string reaches the driver as is: no second serialization. Awaited: an edge runtime drops what outlives
+ * the response. Only while the store is trusted: a write must not wait out a store whose reads just failed.
+ * A failed write closes nothing: a read-only replica or a KV write limit still serves reads.
+ */
+export declare function writeSharedChunk(key: string, json: string, config: ResolvedI18nConfig): Promise<void>;

package/dist/runtime/server/internal/shared-cache.js

@@ -0,0 +1,71 @@
+import { useStorage } from "nitropack/runtime";
+import { getI18nPrivateConfig } from "#i18n-internal/config";
+import { toEntry } from "../../utils/translation-entry.js";
+const TRUSTED_TIMEOUT_MS = 1e3;
+const PROBATION_TIMEOUT_MS = 250;
+const FAILURES_TO_CLOSE = 3;
+const COOLDOWN_MS = 5e3;
+const WARN_EVERY_MS = 6e4;
+const DEFAULT_TTL_SECONDS = 86400;
+const MAX_KEY_LENGTH = 400;
+const MAX_PAGE_LENGTH = 200;
+let shared;
+let failures = 0;
+let closedUntil = 0;
+let warnedAt = Number.NEGATIVE_INFINITY;
+function sharedStorage() {
+  if (shared !== void 0) return shared;
+  const name = getI18nPrivateConfig().cacheStorage;
+  if (import.meta.dev || import.meta.prerender || !name) return shared = null;
+  if (useStorage().getMount(name).base) return shared = useStorage(name);
+  console.warn(`[nuxt-i18n-micro] cacheStorage: no Nitro storage is mounted as "${name}" (nitro.storage). Working without the shared cache.`);
+  return shared = null;
+}
+function warn(error) {
+  const now = Date.now();
+  if (now - warnedAt < WARN_EVERY_MS) return;
+  warnedAt = now;
+  console.warn(`[nuxt-i18n-micro] cacheStorage failed, reading dictionaries from their source: ${error?.message ?? error}`);
+}
+async function withDeadline(call, ms) {
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`no answer in ${ms} ms`)), ms);
+  });
+  try {
+    return await Promise.race([call(), deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+const segment = (value) => String(value).replace(/[^\w-]/g, (char) => `%${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+export function sharedChunkKey(locale, page, config, host = "") {
+  if (!sharedStorage()) return null;
+  const pageSegment = segment(page);
+  if (pageSegment.length > MAX_PAGE_LENGTH) return null;
+  const build = [getI18nPrivateConfig().cacheStorageBuild ?? "", config.dateBuild, config.fallbackLocale ?? "", host].map(segment).join("~");
+  const key = `i18n-micro:${build}:${segment(locale)}:${pageSegment}`;
+  return key.length > MAX_KEY_LENGTH ? null : key;
+}
+function toChunk(value) {
+  if (!value || Object.getPrototypeOf(value) !== Object.prototype || !Object.keys(value).length) return null;
+  return toEntry(value);
+}
+export async function readSharedChunk(key) {
+  if (Date.now() < closedUntil) return null;
+  try {
+    const value = await withDeadline(() => sharedStorage().getItem(key), failures ? PROBATION_TIMEOUT_MS : TRUSTED_TIMEOUT_MS);
+    failures = 0;
+    return toChunk(value);
+  } catch (error) {
+    if (++failures >= FAILURES_TO_CLOSE) closedUntil = Date.now() + COOLDOWN_MS;
+    warn(error);
+    return null;
+  }
+}
+export async function writeSharedChunk(key, json, config) {
+  if (failures) return;
+  const { cacheTtl } = config;
+  const ttl = cacheTtl > 0 && Number.isFinite(cacheTtl) ? Math.ceil(cacheTtl) : DEFAULT_TTL_SECONDS;
+  await withDeadline(() => sharedStorage().setItem(key, json, { ttl }), TRUSTED_TIMEOUT_MS).catch(warn);
+}

package/dist/runtime/server/internal/translation-watcher.d.ts

@@ -0,0 +1,79 @@
+import type { Locale } from '@i18n-micro/types';
+import { type ParsedTranslationRelativePath } from '@i18n-micro/utils/parse-path';
+/** A cache the watcher drops on change (the server cache, the SSR storage cache). */
+interface TranslationWatchCache {
+    clear(): void;
+}
+export interface DevTranslationMergeInput {
+    locale: string;
+    pageName: string;
+    locales?: Array<string | Locale>;
+    fallbackLocale?: string;
+    disablePageLocales?: boolean;
+    readLocaleFile: (relativePath: string) => Record<string, unknown> | Promise<Record<string, unknown>>;
+}
+export interface HandleTranslationWatchChangeInput {
+    relativePath: string;
+    configuredLocales: Set<string>;
+    serverCache: TranslationWatchCache;
+    storageCache?: TranslationWatchCache | null;
+}
+/**
+ * A locale file as an object: `{}` when missing; broken JSON warns with the path and is `{}`
+ * (one bad file must not silently empty a dictionary, nor crash dev).
+ */
+export declare function readTranslationFile(filePath: string): Record<string, unknown>;
+/**
+ * Absolute translation + additional roots for live/HMR reads.
+ * `rootDirs` order matches build: extends first, project last (last wins).
+ */
+export declare function resolveLiveTranslationDirs(input: {
+    rootDirs: string[];
+    translationDir: string;
+    additionalTranslationDirs?: string[];
+}): {
+    translationRoots: string[];
+    additionalRoots: string[];
+};
+/**
+ * The path of a live translation file relative to its root, or null when the file is not one:
+ * any `.json` under a `translationDir` root, a top-level `{locale}.json` in an additional root
+ * (only those take part in the global merge).
+ */
+export declare function translationRelativePath(filePath: string, dirs: {
+    translationRoots: string[];
+    additionalRoots: string[];
+}): string | null;
+/**
+ * Reader for live translation dirs (Nuxt layers + optional additional roots).
+ * Matches build merge: additional first (all layers), then `translationDir` layers (last wins).
+ */
+export declare function createTranslationDirReader(translationsRoot: string | string[], additionalRoots?: string[]): (relativeFilePath: string) => Record<string, unknown>;
+/**
+ * Merge live locale files for HMR + `import.meta.dev` cache misses.
+ * Always source-style fallback (buildDir snapshots bake fallback; live files do not).
+ */
+export declare function mergeDevTranslations(input: DevTranslationMergeInput): Promise<Record<string, unknown>>;
+/**
+ * A translation file changed: drop every cached dictionary. A root file feeds every page, and
+ * through fallback chains other locales too, so any narrower invalidation leaves stale chunks
+ * (pages it did not list, `disablePageLocales` keys, fallback locales). Dev reads are live
+ * merges, so the next request rebuilds only what is asked for.
+ */
+export declare function handleTranslationWatchChange(input: HandleTranslationWatchChangeInput): Promise<ParsedTranslationRelativePath & {
+    dropped: boolean;
+}>;
+/**
+ * Tracks translation file contents so a write that changes nothing is not acted on.
+ *
+ * Editors save on focus loss and formatters rewrite files byte-for-byte; a change drops
+ * the caches and reloads the page, which is far too much to spend on a file identical to
+ * the one already merged.
+ */
+export declare class TranslationContentTracker {
+    private readonly hashes;
+    /** `true` when the file should be processed: new content, or unreadable so assume changed. */
+    shouldProcess(filePath: string): boolean;
+    forget(filePath: string): void;
+}
+export {};

package/dist/runtime/server/internal/translation-watcher.js

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { forwardSlashes } from "@i18n-micro/utils/app-path";
+import { deepMergeTranslationsRecursive } from "@i18n-micro/utils/deep-merge";
+import { parseJsonFile } from "@i18n-micro/utils/load-dir";
+import { mergeSourceTranslations, normalizeConfiguredLocales } from "@i18n-micro/utils/merge-source";
+import { parseTranslationRelativePath } from "@i18n-micro/utils/parse-path";
+export function readTranslationFile(filePath) {
+  if (!existsSync(filePath)) return {};
+  let parsed;
+  try {
+    parsed = parseJsonFile(readFileSync(filePath, "utf-8"));
+  } catch (error) {
+    return skip(filePath, error.message);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return skip(filePath, "not a JSON object");
+  return parsed;
+}
+function skip(filePath, reason) {
+  if (!WARNED.has(filePath)) console.warn(`[nuxt-i18n-micro] Skipping invalid JSON in ${filePath}: ${reason}`);
+  WARNED.add(filePath);
+  return {};
+}
+const WARNED = /* @__PURE__ */ new Set();
+export function resolveLiveTranslationDirs(input) {
+  const translationRoots = input.rootDirs.map((root) => resolve(root, input.translationDir));
+  const additionalRoots = [];
+  for (const dir of input.additionalTranslationDirs ?? []) {
+    for (const root of input.rootDirs) {
+      additionalRoots.push(resolve(root, dir));
+    }
+  }
+  return { translationRoots, additionalRoots };
+}
+export function translationRelativePath(filePath, dirs) {
+  const inside = (root) => {
+    const rel = relative(root, filePath);
+    return rel.startsWith("..") || isAbsolute(rel) ? null : forwardSlashes(rel);
+  };
+  for (const root of dirs.additionalRoots) {
+    const rel = inside(root);
+    if (rel && !rel.includes("/") && rel.endsWith(".json")) return rel;
+  }
+  for (const root of dirs.translationRoots) {
+    const rel = inside(root);
+    if (rel?.endsWith(".json")) return rel;
+  }
+  return null;
+}
+export function createTranslationDirReader(translationsRoot, additionalRoots = []) {
+  const translationRoots = Array.isArray(translationsRoot) ? translationsRoot : [translationsRoot];
+  return (relativeFilePath) => {
+    let content = {};
+    if (!relativeFilePath.includes("/") && relativeFilePath.endsWith(".json")) {
+      const locale = relativeFilePath.slice(0, -".json".length);
+      for (const extraRoot of additionalRoots) {
+        content = deepMergeTranslationsRecursive(content, readTranslationFile(join(extraRoot, `${locale}.json`)));
+      }
+    }
+    for (const root of translationRoots) {
+      content = deepMergeTranslationsRecursive(content, readTranslationFile(join(root, relativeFilePath)));
+    }
+    return content;
+  };
+}
+export async function mergeDevTranslations(input) {
+  const locales = normalizeConfiguredLocales(input.locales);
+  const effectiveLocales = locales.length > 0 ? locales : [{ code: input.locale }];
+  return mergeSourceTranslations({
+    locale: input.locale,
+    pageName: input.pageName,
+    locales: effectiveLocales,
+    globalFallbackLocale: input.fallbackLocale,
+    disablePageLocales: input.disablePageLocales,
+    readLocaleFile: input.readLocaleFile
+  });
+}
+export async function handleTranslationWatchChange(input) {
+  const parsed = parseTranslationRelativePath(input.relativePath);
+  const dropped = parsed.type === "page" || parsed.type === "root" && input.configuredLocales.has(parsed.locale);
+  if (dropped) {
+    input.serverCache.clear();
+    input.storageCache?.clear();
+  }
+  return { ...parsed, dropped };
+}
+export class TranslationContentTracker {
+  hashes = /* @__PURE__ */ new Map();
+  /** `true` when the file should be processed: new content, or unreadable so assume changed. */
+  shouldProcess(filePath) {
+    let hash;
+    try {
+      hash = createHash("sha256").update(readFileSync(filePath)).digest("hex");
+    } catch {
+      return true;
+    }
+    if (this.hashes.get(filePath) === hash) return false;
+    this.hashes.set(filePath, hash);
+    return true;
+  }
+  forget(filePath) {
+    this.hashes.delete(filePath);
+  }
+}