nuxt-i18n-micro 3.18.3 → 3.20.0

package/dist/runtime/utils/nuxt-i18n.js

@@ -0,0 +1,335 @@
+import {
+  BaseI18n,
+  isNoPrefixStrategy,
+  mergeTranslationChunk,
+  resolveTranslation,
+  translationCacheKey
+} from "@i18n-micro/core";
+import { deepMergeTranslations } from "@i18n-micro/utils/deep-merge";
+import { shallowRef, triggerRef, unref } from "vue";
+import { translationStorage } from "./storage.js";
+function toRouteLocationResolved(result) {
+  const fullPath = result.fullPath ?? result.path ?? "";
+  const path = result.path ?? fullPath.split("?")[0]?.split("#")[0] ?? fullPath;
+  const out = {
+    path,
+    fullPath,
+    href: fullPath
+  };
+  if (result.query && Object.keys(result.query).length) out.query = result.query;
+  if (result.hash) out.hash = result.hash;
+  return out;
+}
+function extractSwitchLocalePath(localeRoute, resolveRouter) {
+  if (!localeRoute || typeof localeRoute !== "object") return String(localeRoute ?? "");
+  if ("fullPath" in localeRoute && localeRoute.fullPath) return localeRoute.fullPath;
+  if ("path" in localeRoute && localeRoute.path) return localeRoute.path;
+  if ("name" in localeRoute && localeRoute.name && resolveRouter.hasRoute(String(localeRoute.name))) {
+    return resolveRouter.resolve(localeRoute).fullPath;
+  }
+  return "";
+}
+export class NuxtI18n extends BaseI18n {
+  storage;
+  contextSignal;
+  cachedTranslations = {};
+  pendingCleanState = null;
+  currentLocale = "";
+  currentRouteName = "";
+  resolveRouteContext;
+  constructor(options = {}) {
+    const storage = {
+      translations: /* @__PURE__ */ new Map()
+    };
+    super({ ...options, storage });
+    this.storage = storage;
+    this.contextSignal = shallowRef(0);
+  }
+  setRouteContextResolver(resolver) {
+    this.resolveRouteContext = resolver;
+  }
+  getCacheKey(locale, routeName) {
+    return translationCacheKey(locale, routeName);
+  }
+  getChunk(locale, routeName) {
+    return this.storage.translations.get(this.getCacheKey(locale, routeName)) ?? {};
+  }
+  setChunk(locale, routeName, data) {
+    this.storage.translations.set(this.getCacheKey(locale, routeName), data);
+  }
+  hasChunk(locale, routeName) {
+    return this.storage.translations.has(this.getCacheKey(locale, routeName));
+  }
+  mergeChunk(locale, routeName, data) {
+    const cacheKey = this.getCacheKey(locale, routeName);
+    const existing = this.storage.translations.get(cacheKey) ?? {};
+    const merged = mergeTranslationChunk(existing, data);
+    this.storage.translations.set(cacheKey, merged);
+    return merged;
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  getFallbackLocale() {
+    return this.currentLocale;
+  }
+  getRoute() {
+    return this.currentRouteName || "index";
+  }
+  getCurrentLocale() {
+    return this.currentLocale;
+  }
+  getCurrentRouteName() {
+    return this.currentRouteName;
+  }
+  applySwitchContext(locale, routeName, data) {
+    this.setChunk(locale, routeName, data);
+    const sameLocale = this.currentLocale === locale;
+    if (sameLocale) {
+      this.cachedTranslations = deepMergeTranslations(this.cachedTranslations, data);
+      this.pendingCleanState = data;
+    } else {
+      this.cachedTranslations = data;
+      this.pendingCleanState = null;
+    }
+    this.currentLocale = locale;
+    this.currentRouteName = routeName || "";
+    triggerRef(this.contextSignal);
+  }
+  finishTransition() {
+    if (this.pendingCleanState) {
+      this.cachedTranslations = this.pendingCleanState;
+      this.pendingCleanState = null;
+    }
+  }
+  mergeTranslations(newTranslations) {
+    const merged = this.mergeChunk(this.currentLocale, this.currentRouteName, newTranslations);
+    this.cachedTranslations = deepMergeTranslations(this.cachedTranslations, merged);
+    if (this.pendingCleanState) this.pendingCleanState = merged;
+    triggerRef(this.contextSignal);
+  }
+  async loadPageTranslations(locale, routeName, translations) {
+    const mergedChunk = this.mergeChunk(locale, routeName, translations);
+    if (locale === this.currentLocale && routeName === this.currentRouteName) {
+      this.cachedTranslations = deepMergeTranslations(this.cachedTranslations, mergedChunk);
+      if (this.pendingCleanState) this.pendingCleanState = mergedChunk;
+      triggerRef(this.contextSignal);
+    }
+  }
+  async mergeTranslationAsync(locale, routeName, newTranslations, loadIfMissing) {
+    if (!this.hasChunk(locale, routeName)) {
+      const loaded = await loadIfMissing(locale, routeName || void 0);
+      this.setChunk(locale, routeName, loaded);
+    }
+    const mergedChunk = this.mergeChunk(locale, routeName, newTranslations);
+    if (locale === this.currentLocale && routeName === this.currentRouteName) {
+      this.cachedTranslations = deepMergeTranslations(this.cachedTranslations, mergedChunk);
+      if (this.pendingCleanState) this.pendingCleanState = mergedChunk;
+      triggerRef(this.contextSignal);
+    }
+  }
+  tForRoute(route) {
+    return (key, params, defaultValue) => this.t(key, params, defaultValue, route);
+  }
+  tsForRoute(route) {
+    return (key, params, defaultValue) => this.ts(key, params, defaultValue, route);
+  }
+  touch() {
+    this.contextSignal.value;
+  }
+  resolveLookup(key, routeContext) {
+    const translations = routeContext && this.resolveRouteContext ? (() => {
+      const { locale, routeName } = this.resolveRouteContext(routeContext);
+      return this.getChunk(locale, routeName);
+    })() : this.cachedTranslations;
+    return resolveTranslation(translations, String(key));
+  }
+  resolveHas(key) {
+    return resolveTranslation(this.cachedTranslations, String(key)) !== null;
+  }
+  getMissingContext(_routeContext) {
+    return { locale: this.currentLocale, routeName: this.currentRouteName };
+  }
+  warnMissing(key) {
+    const customHandler = this.getCustomMissingHandler?.();
+    if (customHandler) {
+      customHandler(this.currentLocale, String(key), this.currentRouteName);
+      return;
+    }
+    if (this.missingWarn && process.env.NODE_ENV !== "production" && import.meta.client) {
+      console.warn(`[i18n] Missing key '${key}' in '${this.currentLocale}' for route '${this.currentRouteName}'`);
+    }
+  }
+  clearCache() {
+    super.clearCache();
+    this.cachedTranslations = {};
+    this.pendingCleanState = null;
+    triggerRef(this.contextSignal);
+  }
+}
+export class NuxtTranslationLoader {
+  constructor(options) {
+    this.options = options;
+  }
+  pendingLoads = /* @__PURE__ */ new Map();
+  loadFromCacheSync(locale, routeName) {
+    const { i18n } = this.options;
+    if (i18n.hasChunk(locale, routeName)) {
+      return i18n.getChunk(locale, routeName);
+    }
+    const cached = translationStorage.getFromCache(locale, routeName);
+    if (cached) {
+      i18n.setChunk(locale, routeName, cached.data);
+      return cached.data;
+    }
+    return null;
+  }
+  loadAsync(locale, routeName) {
+    const { i18n, loadOptions, setSsrChunk, isDev } = this.options;
+    const cacheKey = i18n.getCacheKey(locale, routeName);
+    const pending = this.pendingLoads.get(cacheKey);
+    if (pending) return pending;
+    const promise = (async () => {
+      try {
+        const result = await translationStorage.load(locale, routeName, loadOptions);
+        const existing = i18n.getChunk(locale, routeName);
+        const mergedChunk = mergeTranslationChunk(existing, result.data, { preserveExisting: true });
+        i18n.setChunk(locale, routeName, mergedChunk);
+        if (import.meta.server) {
+          setSsrChunk(cacheKey, mergedChunk);
+        }
+        return mergedChunk;
+      } catch (e) {
+        if (isDev) console.error("[i18n] Load error:", e);
+        return {};
+      } finally {
+        this.pendingLoads.delete(cacheKey);
+      }
+    })();
+    this.pendingLoads.set(cacheKey, promise);
+    return promise;
+  }
+  async switchContext(locale, routeName) {
+    let data = this.loadFromCacheSync(locale, routeName);
+    if (data === null) {
+      data = await this.loadAsync(locale, routeName);
+    }
+    this.options.i18n.applySwitchContext(locale, routeName, data);
+  }
+}
+export function createNuxtI18nPluginApi(deps) {
+  const {
+    i18n,
+    loader,
+    i18nStrategy,
+    i18nConfig,
+    router,
+    getCurrentLocale,
+    getEffectiveLocale,
+    getPluginRouteName,
+    getRouteName,
+    i18nRouteParams,
+    setLocale,
+    isValidLocale,
+    navigateTo,
+    setMissingHandler
+  } = deps;
+  const isDev = process.env.NODE_ENV !== "production";
+  const isNoPrefix = isNoPrefixStrategy(i18nConfig.strategy);
+  const switchLocaleLogic = (toLocale, i18nParams, to) => {
+    const fromLocale = getCurrentLocale();
+    const currentRoute = router.currentRoute.value;
+    let resolvedTarget;
+    if (typeof to === "string") {
+      resolvedTarget = router.resolve(i18nStrategy.formatPathForResolve(to, fromLocale, toLocale));
+    } else {
+      resolvedTarget = to ?? currentRoute;
+    }
+    const switchedRoute = i18nStrategy.switchLocaleRoute(fromLocale, toLocale, resolvedTarget, {
+      i18nRouteParams: i18nParams
+    });
+    if (typeof switchedRoute === "string" && (switchedRoute.startsWith("http://") || switchedRoute.startsWith("https://"))) {
+      return navigateTo(switchedRoute, { redirectCode: 200, external: true });
+    }
+    if (isNoPrefix) {
+      ;
+      switchedRoute.force = true;
+    }
+    return router.push(switchedRoute);
+  };
+  const helper = {
+    async mergeTranslation(locale, routeName, newTranslations, _force = false) {
+      await i18n.mergeTranslationAsync(locale, routeName, newTranslations, (l, r) => loader.loadAsync(l, r));
+    }
+  };
+  const switchContext = (locale, routeName) => loader.switchContext(locale, routeName);
+  const provide = {
+    i18nStrategy,
+    getLocale: (route) => getEffectiveLocale(route, (r) => getCurrentLocale(r)),
+    getLocaleName: () => i18nStrategy.getCurrentLocaleName(router.currentRoute.value, getCurrentLocale() ?? null),
+    defaultLocale: () => i18nConfig.defaultLocale,
+    getLocales: () => i18nConfig.locales || [],
+    getRouteName,
+    t: i18n.t.bind(i18n),
+    ts: (key, params, defaultValue, route) => {
+      const value = route ? i18n.t(key, params, defaultValue, route) : i18n.ts(key, params, defaultValue);
+      return value?.toString() ?? defaultValue ?? key;
+    },
+    _t: (route) => i18n.tForRoute(route),
+    _ts: (route) => i18n.tsForRoute(route),
+    tc: i18n.tc.bind(i18n),
+    tn: i18n.tn.bind(i18n),
+    td: i18n.td.bind(i18n),
+    tdr: i18n.tdr.bind(i18n),
+    has: i18n.has.bind(i18n),
+    mergeTranslations: i18n.mergeTranslations.bind(i18n),
+    switchLocaleRoute: (toLocale) => {
+      const route = router.currentRoute.value;
+      const fromLocale = getCurrentLocale(route);
+      return i18nStrategy.switchLocaleRoute(fromLocale, toLocale, route, { i18nRouteParams: unref(i18nRouteParams.value) });
+    },
+    clearCache: () => {
+      translationStorage.clear();
+      i18n.clearCache();
+    },
+    switchLocalePath: (toLocale) => {
+      const route = router.currentRoute.value;
+      const fromLocale = getCurrentLocale(route);
+      const switched = i18nStrategy.switchLocaleRoute(fromLocale, toLocale, route, { i18nRouteParams: unref(i18nRouteParams.value) });
+      return extractSwitchLocalePath(switched, router);
+    },
+    switchLocale: async (toLocale) => {
+      if (!isValidLocale(toLocale)) {
+        if (isDev) console.warn(`[i18n] Invalid locale '${toLocale}'`);
+        return;
+      }
+      setLocale(toLocale);
+      if (isNoPrefixStrategy(i18nConfig.strategy) || i18nConfig.hashMode) {
+        const route = router.currentRoute.value;
+        const routeName = getPluginRouteName(route, toLocale);
+        await loader.switchContext(toLocale, routeName);
+      }
+      return switchLocaleLogic(toLocale, unref(i18nRouteParams.value));
+    },
+    switchRoute: (route, toLocale) => {
+      return switchLocaleLogic(toLocale ?? getCurrentLocale(), unref(i18nRouteParams.value), route);
+    },
+    localeRoute(to, locale) {
+      const targetLocale = locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale();
+      const result = i18nStrategy.localeRoute(targetLocale, to, router.currentRoute.value);
+      return toRouteLocationResolved(result);
+    },
+    localePath(to, locale) {
+      const targetLocale = locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale();
+      const result = i18nStrategy.localeRoute(targetLocale, to, router.currentRoute.value);
+      return result.fullPath ?? result.path ?? "";
+    },
+    setI18nRouteParams: (value) => {
+      i18nRouteParams.value = value;
+      return i18nRouteParams.value;
+    },
+    loadPageTranslations: i18n.loadPageTranslations.bind(i18n),
+    setMissingHandler
+  };
+  return { helper, switchContext, provide };
+}

package/dist/runtime/utils/storage.d.ts

@@ -1,23 +1,15 @@
-/**
- * Translation Storage
- * Unified translation storage for client and server.
- * Cache control (TTL, maxSize) delegated to CacheControl.
- */
-import { type CacheControlOptions } from './cache-control.js';
-declare global {
-    interface Window {
-        __I18N__?: Record<string, unknown>;
-    }
-}
+import { type CacheControlOptions } from '@i18n-micro/utils/cache-control';
 export interface LoadOptions {
     apiBaseUrl: string;
     baseURL: string;
+    apiBaseClientHost?: string;
+    apiBaseServerHost?: string;
     dateBuild?: string | number;
+    routesLocaleLinks?: Record<string, string>;
 }
 export interface LoadResult {
     data: Record<string, unknown>;
     cacheKey: string;
-    json?: string;
 }
 declare class TranslationStorage {
     private cc;
@@ -26,8 +18,15 @@ declare class TranslationStorage {
      * Configure cache limits. Call once from plugin with config values.
      */
     configure(options: CacheControlOptions): void;
+    /** Plain clone before freeze — SSR payload chunks may be Vue reactive proxies. */
+    private freezePlainClone;
     private getCacheKey;
     private fetchTranslations;
+    /**
+     * Seed translation cache from SSR payload (`useState('i18n-ssr-chunks')`).
+     * Called on client before the first fetch.
+     */
+    seedFromSsrChunks(chunks: Record<string, Record<string, unknown>>): void;
     /**
      * Synchronous cache check and retrieval.
      * Returns data if cached (and not expired), otherwise null.

package/dist/runtime/utils/storage.js

@@ -1,11 +1,13 @@
-import { CacheControl } from "./cache-control.js";
-const CC_KEY = Symbol.for("__NUXT_I18N_STORAGE_CC__");
+import { translationCacheKey } from "@i18n-micro/core/helpers";
+import { STORAGE_CC_KEY } from "@i18n-micro/hmr/cache-keys";
+import { CacheControl } from "@i18n-micro/utils/cache-control";
+import { buildTranslationPayloadFetchRequest } from "@i18n-micro/utils/payload-url";
 function getStorageCacheControl() {
   const g = globalThis;
-  if (!g[CC_KEY]) {
-    g[CC_KEY] = new CacheControl();
+  if (!g[STORAGE_CC_KEY]) {
+    g[STORAGE_CC_KEY] = new CacheControl();
   }
-  return g[CC_KEY];
+  return g[STORAGE_CC_KEY];
 }
 class TranslationStorage {
   cc;
@@ -21,24 +23,45 @@ class TranslationStorage {
   // ==========================================================================
   // HELPERS
   // ==========================================================================
+  /** Plain clone before freeze — SSR payload chunks may be Vue reactive proxies. */
+  freezePlainClone(data) {
+    return Object.freeze(JSON.parse(JSON.stringify(data)));
+  }
   getCacheKey(locale, routeName) {
-    return `${locale}:${routeName || "index"}`;
+    return translationCacheKey(locale, routeName);
   }
   // ==========================================================================
   // FETCH LOADER
   // ==========================================================================
   async fetchTranslations(locale, routeName, options) {
-    const { apiBaseUrl, baseURL, dateBuild } = options;
-    const page = routeName || "index";
-    const path = `/${apiBaseUrl}/${page}/${locale}/data.json`;
-    return await $fetch(path.replace(/\/{2,}/g, "/"), {
-      baseURL,
-      params: dateBuild ? { v: dateBuild } : void 0
+    const request = buildTranslationPayloadFetchRequest({
+      apiBaseUrl: options.apiBaseUrl,
+      routeName,
+      locale,
+      isServer: import.meta.server,
+      baseURL: options.baseURL,
+      apiBaseClientHost: options.apiBaseClientHost,
+      apiBaseServerHost: options.apiBaseServerHost ?? (import.meta.server ? process.env.NUXT_I18N_APP_BASE_SERVER_HOST : void 0),
+      dateBuild: options.dateBuild,
+      routesLocaleLinks: options.routesLocaleLinks
+    });
+    return await $fetch(request.path, {
+      baseURL: request.baseURL,
+      params: request.params
     });
   }
   // ==========================================================================
   // PUBLIC API
   // ==========================================================================
+  /**
+   * Seed translation cache from SSR payload (`useState('i18n-ssr-chunks')`).
+   * Called on client before the first fetch.
+   */
+  seedFromSsrChunks(chunks) {
+    for (const [cacheKey, data] of Object.entries(chunks)) {
+      this.cc.set(cacheKey, this.freezePlainClone(data));
+    }
+  }
   /**
    * Synchronous cache check and retrieval.
    * Returns data if cached (and not expired), otherwise null.
@@ -49,12 +72,6 @@ class TranslationStorage {
     if (cached) {
       return { data: cached, cacheKey };
     }
-    if (import.meta.client && typeof window !== "undefined" && window.__I18N__?.[cacheKey]) {
-      const data = window.__I18N__[cacheKey];
-      delete window.__I18N__[cacheKey];
-      this.cc.set(cacheKey, Object.freeze(data));
-      return { data: this.cc.get(cacheKey), cacheKey };
-    }
     return null;
   }
   /**
@@ -66,9 +83,8 @@ class TranslationStorage {
     if (cached) return cached;
     const cacheKey = this.getCacheKey(locale, routeName);
     const data = await this.fetchTranslations(locale, routeName, options);
-    this.cc.set(cacheKey, Object.freeze(data));
-    const json = import.meta.server ? JSON.stringify(data).replace(/</g, "\\u003c") : void 0;
-    return { data: this.cc.get(cacheKey), cacheKey, json };
+    this.cc.set(cacheKey, this.freezePlainClone(data));
+    return { data: this.cc.get(cacheKey), cacheKey };
   }
   /**
    * Clear cache and metadata.

package/dist/types.d.mts

@@ -8,6 +8,8 @@ export { type Getter, type GlobalLocaleRoutes, type Locale, type LocaleCode, typ
 
 export { type PluginsInjections } from '../dist/runtime/plugins/01.plugin.js'
 
+export { type TranslationPayloadMode, type resolveTranslationPayloadMode, type resolveTranslationPayloadOptions, type resolveTranslationPayloadPublicDir } from '@i18n-micro/utils/payload-config'
+
 export { default } from './module.mjs'
 
 export { type ModuleHooks } from './module.mjs'

package/internals.d.mts

@@ -13,6 +13,7 @@ interface I18nPrivateConfig {
   apiBaseServerHost?: string
   customRegexMatcher?: string
   routesLocaleLinks?: Record<string, string>
+  serverTranslationPreload?: boolean
 }
 
 declare module '#build/i18n.config.mjs' {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-i18n-micro",
-  "version": "3.18.3",
+  "version": "3.20.0",
   "description": "Nuxt I18n Micro is a lightweight, high-performance internationalization module for Nuxt, designed to handle multi-language support with minimal overhead, fast build times, and efficient runtime performance.",
   "repository": "s00d/nuxt-i18n-micro",
   "license": "MIT",
@@ -74,14 +74,19 @@
     "chokidar": "^3.6.0",
     "globby": "^14.1.0",
     "ufo": "^1.5.4",
-    "@i18n-micro/core": "1.3.1",
-    "@i18n-micro/route-strategy": "1.1.7",
-    "@i18n-micro/test-utils": "1.2.1",
-    "@i18n-micro/path-strategy": "1.3.2",
-    "@i18n-micro/types": "1.2.2"
+    "unplugin": "^1.16.1",
+    "@vue/compiler-sfc": "^3.5.25",
+    "@i18n-micro/hmr": "1.0.1",
+    "@i18n-micro/core": "1.3.2",
+    "@i18n-micro/path-strategy": "1.3.3",
+    "@i18n-micro/types": "1.2.4",
+    "@i18n-micro/test-utils": "1.2.2",
+    "@i18n-micro/route-strategy": "1.1.8",
+    "@i18n-micro/utils": "1.0.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.14",
+    "oxfmt": "^0.43.0",
+    "oxlint": "^1.58.0",
     "@nuxt/devtools": "^2.6.3",
     "@nuxt/devtools-ui-kit": "^2.6.3",
     "@nuxt/module-builder": "^1.0.0",
@@ -122,13 +127,14 @@
     "dev:generate": "nuxi generate playground",
     "release": "pnpm run release:check && pnpm run release:patch",
     "release:check": "pnpm run format && pnpm run lint && pnpm run typecheck && pnpm run test:types && pnpm run test && pnpm run test:vitest && pnpm run test:workspaces",
-    "release:patch": "pnpm run prepack && node scripts/run-changelogen-release.mjs patch && pnpm publish -r && git push --follow-tags",
-    "release:minor": "pnpm run prepack && node scripts/run-changelogen-release.mjs minor && pnpm publish -r && git push --follow-tags",
-    "release:major": "pnpm run prepack && node scripts/run-changelogen-release.mjs major && pnpm publish -r && git push --follow-tags",
-    "lint": "biome check .",
-    "lint:fix": "biome check --write .",
-    "format": "biome format --write .",
-    "format:check": "biome format .",
+    "release:auth": "node scripts/ensure-npm-auth.mjs",
+    "release:patch": "pnpm run release:auth && pnpm run prepack && node scripts/run-changelogen-release.mjs patch && pnpm publish -r && git push --follow-tags",
+    "release:minor": "pnpm run release:auth && pnpm run prepack && node scripts/run-changelogen-release.mjs minor && pnpm publish -r && git push --follow-tags",
+    "release:major": "pnpm run release:auth && pnpm run prepack && node scripts/run-changelogen-release.mjs major && pnpm publish -r && git push --follow-tags",
+    "lint": "oxlint src packages test client playground build.config.ts",
+    "lint:fix": "oxlint src packages test client playground build.config.ts --fix",
+    "format": "oxfmt --write src packages test client playground build.config.ts",
+    "format:check": "oxfmt --check src packages test client playground build.config.ts",
     "test": "playwright test",
     "test:vitest": "vitest run",
     "test:performance": "vitest run --config vitest.performance.config.ts",
@@ -144,7 +150,7 @@
     "verify:packages": "node scripts/verify-packages.mjs",
     "verify:packages:publint": "node scripts/verify-packages.mjs --publint",
     "compare:published": "node scripts/compare-published-dist.mjs",
-    "test:dist:packages": "pnpm --filter \"@i18n-micro/core\" --filter \"@i18n-micro/vue\" --filter \"@i18n-micro/path-strategy\" --filter \"@i18n-micro/route-strategy\" --filter \"@i18n-micro/devtools-ui\" --filter \"@i18n-micro/astro\" run test:dist",
+    "test:dist:packages": "pnpm --filter \"@i18n-micro/core\" --filter \"@i18n-micro/utils\" --filter \"@i18n-micro/hmr\" --filter \"@i18n-micro/vue\" --filter \"@i18n-micro/path-strategy\" --filter \"@i18n-micro/route-strategy\" --filter \"@i18n-micro/devtools-ui\" --filter \"@i18n-micro/astro\" run test:dist",
     "typecheck": "tsc --noEmit",
     "typecheck:nuxt": "nuxt typecheck --no-emit",
     "docs:dev": "vitepress dev docs",