@i18n-micro/astro 1.3.24 → 2.0.0

package/src/utils.ts

@@ -1,15 +1,21 @@
+import { getByPath, interpolate, isProduction, ownValue, resolveText, setTranslationAtKey, type ResolveTextOptions } from '@i18n-micro/core'
 import type { CleanTranslation, Locale, Params, TranslationKey, Translations } from '@i18n-micro/types'
-import { resolveHreflangAlternates } from '@i18n-micro/utils/resolve-hreflang'
-import { resolveOgLocale, warnUnresolvedOgLocale } from '@i18n-micro/utils/resolve-og-locale'
+import { getEnabledLocaleCodes, getEnabledLocales } from '@i18n-micro/utils/active-locales'
+import { withoutAppBaseURL } from '@i18n-micro/utils/app-path'
+import { buildLocaleHead, joinBase, type LocaleHead } from '@i18n-micro/utils/locale-head'
 import type { AstroGlobal } from 'astro'
 import type { AstroI18n } from './composer'
-import type { I18nRoutingStrategy } from './router/types'
+import { localizeHref, withBase, type HrefContext } from './request'
+import { createAstroRouterAdapter } from './router/adapter'
 import './env.d'
 
+/** The subset of `AstroGlobal` the helpers read. */
+type Astro = Pick<AstroGlobal, 'locals' | 'url'> & Partial<Pick<AstroGlobal, 'params' | 'site'>>
+
 /**
  * Get i18n instance from Astro context
  */
-export function getI18n(astro: AstroGlobal): AstroI18n {
+export function getI18n(astro: Pick<AstroGlobal, 'locals'>): AstroI18n {
   const i18n = astro.locals.i18n
   if (!i18n) {
     throw new Error('i18n instance not found. Make sure i18n middleware is configured.')
@@ -21,42 +27,51 @@ export function getI18n(astro: AstroGlobal): AstroI18n {
 /**
  * Get current locale from Astro context
  */
-export function getLocale(astro: AstroGlobal): string {
-  return astro.locals.locale || 'en'
+export function getLocale(astro: Pick<AstroGlobal, 'locals'>): string {
+  return astro.locals.locale ?? getI18n(astro).getLocale()
 }
 
 /**
  * Get default locale from Astro context
  */
-export function getDefaultLocale(astro: AstroGlobal): string {
-  return astro.locals.defaultLocale || 'en'
+export function getDefaultLocale(astro: Pick<AstroGlobal, 'locals'>): string {
+  return astro.locals.defaultLocale ?? getI18n(astro).getFallbackLocale()
 }
 
 /**
  * Get all locales from Astro context
  */
-export function getLocales(astro: AstroGlobal): Locale[] {
+export function getLocales(astro: Pick<AstroGlobal, 'locals'>): Locale[] {
   return astro.locals.locales || []
 }
 
-/**
- * Get routing strategy from Astro locals
- */
-function getRoutingStrategy(astro: AstroGlobal): I18nRoutingStrategy | null {
-  return (astro.locals.routingStrategy as I18nRoutingStrategy | undefined) || null
+/** How this request builds URLs. Without the middleware's strategy, the default one. */
+function hrefContext(astro: Astro): HrefContext & { path: string } {
+  const { locals } = astro
+  const base = locals.i18nBase ?? ''
+  const defaultLocale = getDefaultLocale(astro)
+  const locales = getLocales(astro)
+  return {
+    base,
+    defaultLocale,
+    codes: getEnabledLocaleCodes(locales),
+    strategy: locals.routingStrategy ?? createAstroRouterAdapter(locales, defaultLocale),
+    path: withoutAppBaseURL((locals.currentUrl ?? astro.url).pathname, base),
+  }
 }
 
 /**
  * Use i18n in Astro pages/components
  * Returns helper functions for translations
  */
-export function useI18n(astro: AstroGlobal) {
+export function useI18n(astro: Astro) {
   const i18n = getI18n(astro)
   const locale = getLocale(astro)
   const defaultLocale = getDefaultLocale(astro)
   const locales = getLocales(astro)
-  const localeCodes = locales.map((l) => l.code)
-  const routingStrategy = getRoutingStrategy(astro)
+  const links = hrefContext(astro)
+  const { strategy, codes, base, path: currentPath } = links
+  const bare = (path: string) => withoutAppBaseURL(path, base)
 
   return {
     // Current locale
@@ -65,139 +80,81 @@ export function useI18n(astro: AstroGlobal) {
     locales,
 
     // Translation methods
-    t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeName?: string): CleanTranslation => {
-      return i18n.t(key, params, defaultValue, routeName)
-    },
-    ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeName?: string): string => {
-      return i18n.ts(key, params, defaultValue, routeName)
-    },
-    tc: (key: TranslationKey, count: number | Params, defaultValue?: string): string => {
-      return i18n.tc(key, count, defaultValue)
-    },
+    t: i18n.t.bind(i18n),
+    ts: i18n.ts.bind(i18n),
+    tc: i18n.tc.bind(i18n),
     tn: i18n.tn.bind(i18n),
     td: i18n.td.bind(i18n),
     tdr: i18n.tdr.bind(i18n),
-    has: (key: TranslationKey, routeName?: string): boolean => {
-      return i18n.has(key, routeName)
-    },
+    has: i18n.has.bind(i18n),
 
     // Route management
-    getRoute: (): string => {
-      return i18n.getRoute()
-    },
-    getRouteName: (path?: string): string => {
-      const targetPath = path || astro.url.pathname
-      if (routingStrategy?.getRouteName) {
-        return routingStrategy.getRouteName(targetPath, localeCodes)
-      }
-      // Fallback: basic route name extraction
-      const cleanPath = targetPath.replace(/^\//, '').replace(/\/$/, '')
-      if (!cleanPath) return 'index'
-      const segments = cleanPath.split('/').filter(Boolean)
-      const firstSegment = segments[0]
-      if (firstSegment && localeCodes.includes(firstSegment)) {
-        segments.shift()
-      }
-      return segments.length === 0 ? 'index' : segments.join('-')
-    },
-    getLocaleFromPath: (path?: string): string => {
-      const targetPath = path || astro.url.pathname
-      if (routingStrategy?.getLocaleFromPath) {
-        return routingStrategy.getLocaleFromPath(targetPath, defaultLocale, localeCodes)
-      }
-      // Fallback: check first segment
-      const segments = targetPath.split('/').filter(Boolean)
-      const firstSegment = segments[0]
-      return firstSegment && localeCodes.includes(firstSegment) ? firstSegment : defaultLocale
-    },
-
-    // Path utilities
-    switchLocalePath: (newLocale: string): string => {
-      if (routingStrategy?.switchLocalePath) {
-        return routingStrategy.switchLocalePath(astro.url.pathname, newLocale, localeCodes, defaultLocale)
-      }
-      // Fallback: basic locale switching
-      const segments = astro.url.pathname.split('/').filter(Boolean)
-      const firstSegment = segments[0]
-      if (firstSegment && localeCodes.includes(firstSegment)) {
-        segments.shift()
-      }
-      if (newLocale !== defaultLocale) {
-        segments.unshift(newLocale)
-      }
-      return `/${segments.join('/')}`
-    },
-    localizePath: (path: string, targetLocale?: string): string => {
-      if (routingStrategy?.localizePath) {
-        return routingStrategy.localizePath(path, targetLocale || locale, localeCodes, defaultLocale)
-      }
-      // Fallback: basic localization
-      const cleanPath = path.replace(/^\//, '').replace(/\/$/, '') || ''
-      const segments = cleanPath.split('/').filter(Boolean)
-      const firstSegment = segments[0]
-      if (firstSegment && localeCodes.includes(firstSegment)) {
-        segments.shift()
-      }
-      if (targetLocale && targetLocale !== defaultLocale) {
-        segments.unshift(targetLocale)
-      }
-      return `/${segments.join('/')}`
-    },
+    getRoute: i18n.getRoute.bind(i18n),
+    getRouteName: (path?: string): string => (path === undefined ? i18n.getRoute() : strategy.getRouteName!(bare(path), codes)),
+    getLocaleFromPath: (path?: string): string => strategy.getLocaleFromPath!(path === undefined ? currentPath : bare(path), defaultLocale, codes),
+
+    // Path utilities: URLs of the site, `base` included
+    switchLocalePath: (newLocale: string): string => withBase(strategy.switchLocalePath!(currentPath, newLocale, codes, defaultLocale), base),
+    localizePath: (path: string, targetLocale?: string): string => localizeHref(path, targetLocale || locale, links),
 
     // Get i18n instance
-    getI18n: (): AstroI18n => {
-      return i18n
-    },
-
-    // Get base path without locale (for rewrite)
-    getBasePath: (url?: URL): string => {
-      const targetUrl = url || astro.url
-      const pathname = targetUrl.pathname
-      const segments = pathname.split('/').filter(Boolean)
-
-      // Remove locale from path if present
-      const firstSegment = segments[0]
-      if (firstSegment && localeCodes.includes(firstSegment)) {
-        segments.shift()
-      }
-
-      const basePath = segments.length > 0 ? `/${segments.join('/')}` : '/'
-      return basePath
-    },
+    getI18n: () => i18n,
+
+    // Path of a URL without locale and `base`: what `Astro.rewrite` takes
+    getBasePath: (url?: URL): string => strategy.removeLocaleFromPath!(url ? bare(url.pathname) : currentPath, codes),
 
     // Translation management
-    addTranslations: (locale: string, translations: Record<string, unknown>, merge: boolean = true): void => {
-      i18n.addTranslations(locale, translations, merge)
-    },
-    addRouteTranslations: (locale: string, routeName: string, translations: Record<string, unknown>, merge: boolean = true): void => {
-      i18n.addRouteTranslations(locale, routeName, translations, merge)
-    },
-    mergeTranslations: (locale: string, routeName: string, translations: Record<string, unknown>): void => {
-      i18n.mergeTranslations(locale, routeName, translations)
-    },
-    clearCache: (): void => {
-      i18n.clearCache()
-    },
+    addTranslations: i18n.addTranslations.bind(i18n),
+    addRouteTranslations: i18n.addRouteTranslations.bind(i18n),
+    mergeTranslations: i18n.mergeTranslations.bind(i18n),
+    clearCache: i18n.clearCache.bind(i18n),
   }
 }
 
+/** What `<I18nSwitcher>` shows for a locale. A code is free-form: `constructor` must not read an inherited member. */
+export function localeLabel(locale: Locale, customLabels: Record<string, string>): string {
+  return (ownValue(customLabels, locale.code) as string | undefined) || locale.displayName || locale.code
+}
+
+/** `href` of an `<I18nLink>`: relative to the page, in `locale` (default the current one). */
+export function resolveLinkHref(astro: Astro, href: string, locale?: string): string {
+  const links = hrefContext(astro)
+  return localizeHref(href, locale || getLocale(astro), { ...links, from: links.path })
+}
+
+export interface I18nTProps extends ResolveTextOptions {
+  defaultValue?: string
+}
+
+/** The text of an `<I18nT>`, `null` when `hideIfEmpty` hides it. With `html`, params arrive escaped; the translation is trusted. */
+export function resolveI18nT(astro: Astro, props: I18nTProps): string | null {
+  const i18n = getI18n(astro)
+  const { defaultValue } = props
+  // `t` with the default for `resolveText`, every other member from the instance
+  const host = defaultValue
+    ? (Object.create(i18n, {
+        t: { value: (key: string, params?: Params, fallback?: string | null) => i18n.t(key, params, fallback ?? defaultValue) },
+      }) as AstroI18n)
+    : i18n
+  const text = resolveText(host, props)
+  return text && interpolate(text.template, text.params)
+}
+
 /**
  * Strip locale prefix from the current URL for `Astro.rewrite()` on `/[locale]/*` routes.
  */
-export function getLocaleRewritePath(astro: AstroGlobal): string {
-  const url = astro.locals.currentUrl ?? astro.url
-  return useI18n(astro).getBasePath(url)
+export function getLocaleRewritePath(astro: Astro): string {
+  return useI18n(astro).getBasePath(astro.locals.currentUrl ?? astro.url)
 }
 
 /**
  * Validate `:locale`, sync i18n/locals, and return the base path for `Astro.rewrite()`.
  * Returns a `Response` when the locale param is invalid.
  */
-export function prepareLocaleRewrite(astro: AstroGlobal): Response | string {
+export function prepareLocaleRewrite(astro: Astro & Pick<AstroGlobal, 'params'>): Response | string {
   const { locale } = astro.params
-  const localeCodes = getLocales(astro).map((entry) => entry.code)
 
-  if (!locale || !localeCodes.includes(locale)) {
+  if (!locale || !getEnabledLocaleCodes(getLocales(astro)).includes(locale)) {
     return new Response(null, { status: 404 })
   }
 
@@ -214,6 +171,7 @@ export function prepareLocaleRewrite(astro: AstroGlobal): Response | string {
  * Generate locale head meta tags for SEO
  */
 export interface LocaleHeadOptions {
+  /** Origin of the absolute URLs. Default: `site` from the Astro config, else root-relative URLs. */
   baseUrl?: string
   addDirAttribute?: boolean
   addSeoAttributes?: boolean
@@ -224,148 +182,29 @@ export interface LocaleHeadOptions {
   hreflangBaseLanguage?: boolean
 }
 
-export interface LocaleHeadResult {
-  htmlAttrs: {
-    lang?: string
-    dir?: 'ltr' | 'rtl' | 'auto'
-  }
-  link: Array<{
-    rel: string
-    href: string
-    hreflang?: string
-  }>
-  meta: Array<{
-    property: string
-    content: string
-  }>
-}
-
-export function useLocaleHead(astro: AstroGlobal, options: LocaleHeadOptions = {}): LocaleHeadResult {
-  const { baseUrl = '/', addDirAttribute = true, addSeoAttributes = true, hreflangBaseLanguage = false } = options
-
-  const locale = getLocale(astro)
-  const defaultLocale = getDefaultLocale(astro)
-  const allLocales = getLocales(astro)
-  const locales = allLocales.filter((l) => !l.disabled)
-  const localesForSeo = locales.filter((l) => l.seo !== false)
-  const currentLocaleObj = locales.find((l) => l.code === locale)
-
-  if (!currentLocaleObj) {
-    return { htmlAttrs: {}, link: [], meta: [] }
-  }
-
-  const currentIso = currentLocaleObj.iso || locale
-  const currentOg = resolveOgLocale(currentLocaleObj)
-  const currentDir = currentLocaleObj.dir || 'auto'
-
-  const result: LocaleHeadResult = {
-    htmlAttrs: {
-      lang: currentIso,
-      ...(addDirAttribute ? { dir: currentDir } : {}),
-    },
-    link: [],
-    meta: [],
-  }
-
-  if (!addSeoAttributes) {
-    return result
-  }
-
-  // Canonical URL (uses pathname only — query params are excluded)
-  const canonicalUrl = `${baseUrl}${astro.url.pathname}`
-  result.link.push({
-    rel: 'canonical',
-    href: canonicalUrl,
-  })
-
-  // Get routing strategy
-  const routingStrategy = getRoutingStrategy(astro)
-  const allLocaleCodes = locales.map((l) => l.code)
-
-  // Alternate languages (includes current locale for self-referencing hreflang, per Google guidelines)
-  const hrefByCode = new Map<string, string>()
-  for (const loc of localesForSeo) {
-    let alternatePath = astro.url.pathname
-    if (routingStrategy?.switchLocalePath) {
-      alternatePath = routingStrategy.switchLocalePath(astro.url.pathname, loc.code, allLocaleCodes, defaultLocale)
-    } else {
-      // Fallback: basic locale switching
-      const segments = astro.url.pathname.split('/').filter(Boolean)
-      const firstSegment = segments[0]
-      if (firstSegment && allLocaleCodes.includes(firstSegment)) {
-        segments.shift()
-      }
-      if (loc.code !== defaultLocale) {
-        segments.unshift(loc.code)
-      }
-      alternatePath = `/${segments.join('/')}`
-    }
-    hrefByCode.set(String(loc.code), `${baseUrl}${alternatePath}`)
-  }
+export type LocaleHeadResult = LocaleHead
 
-  for (const { hreflang, localeCode } of resolveHreflangAlternates(localesForSeo, { hreflangBaseLanguage })) {
-    const alternateUrl = hrefByCode.get(localeCode)
-    if (!alternateUrl) continue
-    result.link.push({
-      rel: 'alternate',
-      href: alternateUrl,
-      hreflang,
-    })
-  }
-
-  // x-default hreflang — points to the default locale's URL.
-  // Tells search engines which URL to show when none of the
-  // specified languages match the user's browser settings.
-  const defaultLocaleObj = locales.find((l) => l.code === defaultLocale)
-  if (defaultLocaleObj?.seo !== false) {
-    let xDefaultPath = astro.url.pathname
-    if (routingStrategy?.switchLocalePath) {
-      xDefaultPath = routingStrategy.switchLocalePath(astro.url.pathname, defaultLocale, allLocaleCodes, defaultLocale)
-    } else {
-      const segments = astro.url.pathname.split('/').filter(Boolean)
-      const firstSegment = segments[0]
-      if (firstSegment && allLocaleCodes.includes(firstSegment)) {
-        segments.shift()
-      }
-      xDefaultPath = `/${segments.join('/')}`
-    }
-    result.link.push({
-      rel: 'alternate',
-      href: `${baseUrl}${xDefaultPath}`,
-      hreflang: 'x-default',
-    })
-  }
+export function useLocaleHead(astro: Astro, options: LocaleHeadOptions = {}): LocaleHeadResult {
+  const { addDirAttribute, addSeoAttributes, hreflangBaseLanguage } = options
+  const origin = options.baseUrl ?? astro.site?.origin ?? ''
+  const { base, defaultLocale, codes, strategy, path } = hrefContext(astro)
+  const code = getLocale(astro)
+  const enabled = getEnabledLocales(getLocales(astro))
+  const locale = enabled.find((entry) => entry.code === code)
+  if (!locale) return { htmlAttrs: {}, link: [], meta: [] }
 
-  // Open Graph locale
-  if (currentOg) {
-    result.meta.push({
-      property: 'og:locale',
-      content: currentOg,
-    })
-  } else {
-    warnUnresolvedOgLocale(currentLocaleObj, { tag: 'og:locale' })
-  }
-
-  result.meta.push({
-    property: 'og:url',
-    content: canonicalUrl,
+  const hrefOf = (target: string) => joinBase(origin, withBase(strategy.switchLocalePath!(path, target, codes, defaultLocale), base))
+  const defaultEntry = enabled.find((entry) => entry.code === defaultLocale)
+  return buildLocaleHead({
+    locale,
+    seoLocales: enabled.filter((entry) => entry.seo !== false),
+    hrefOf,
+    canonical: joinBase(origin, withBase(path, base)),
+    xDefault: defaultEntry && defaultEntry.seo !== false ? hrefOf(defaultLocale) : undefined,
+    addDirAttribute,
+    addSeoAttributes,
+    hreflangBaseLanguage,
   })
-
-  // Alternate OG locales
-  for (const loc of localesForSeo) {
-    if (loc.code === locale) continue
-    const ogAlt = resolveOgLocale(loc)
-    if (!ogAlt) {
-      warnUnresolvedOgLocale(loc, { tag: 'og:locale:alternate' })
-      continue
-    }
-    result.meta.push({
-      property: 'og:locale:alternate',
-      content: ogAlt,
-    })
-  }
-
-  return result
 }
 
 /**
@@ -373,77 +212,64 @@ export function useLocaleHead(astro: AstroGlobal, options: LocaleHeadOptions = {
  */
 export interface I18nClientProps {
   locale: string
+  /** The tag plurals go by: the locale's `iso` when it has one. */
+  pluralLocale?: string
+  /** Tags of the codes that have one, for `setLocale`. Absent when there are none. */
+  localeIso?: Record<string, string>
   fallbackLocale: string
   translations: Record<string, Translations> // routeName -> translations
   currentRoute: string
 }
 
-/**
- * Creates a nested structure from a key (e.g. 'islands.vue.title' -> { islands: { vue: { title: value } } })
- */
-function setNestedValue(obj: Translations, key: string, value: unknown): void {
-  const parts = key.split('.')
-  let current: Translations = obj
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i]!
-    if (!current[part]) {
-      current[part] = {}
-    }
-    current = current[part] as Translations
+/** `keys` of `tree`, nested back into objects. Only the copy is written: a value may be a stored subtree. */
+function pickKeys(tree: Translations, keys: string[]): Translations {
+  let picked: Translations = {}
+  for (const key of keys) {
+    const value = getByPath(tree, key)
+    if (value !== undefined && value !== null) picked = setTranslationAtKey(picked, key, value) as Translations
   }
-  const last = parts[parts.length - 1]
-  if (last !== undefined) {
-    current[last] = value
+  return picked
+}
+
+/** Above this, a dictionary in every island's props is worth a word to the developer. */
+const PROPS_WARN_SIZE = 20_000
+const warned = new WeakSet<object>()
+
+/** A cyclic tree has no JSON, and no size to warn about. */
+function sizeOf(tree: Translations): number {
+  try {
+    return JSON.stringify(tree).length
+  } catch {
+    return 0
   }
 }
 
+/** Once per dictionary: the merged tree is the same object until a write. */
+function warnOversizedProps(tree: Translations): void {
+  if (isProduction() || warned.has(tree)) return
+  warned.add(tree)
+  const size = sizeOf(tree)
+  if (size > PROPS_WARN_SIZE)
+    console.warn(`[i18n-micro] getI18nProps() without keys puts ${size} bytes in every island's props: pass the keys the island uses.`)
+}
+
 /**
- * Prepares props to pass to a client island.
- * Accepts a list of keys to pass to the island.
- * Uses i18n methods for proper routesLocaleLinks support.
- * currentRoute is already normalized via middleware (getRouteName), so we use it directly.
+ * Props for a client island: what `t()` can answer on this page (route, root and fallback keys),
+ * or only `keys` of that, which is the way to keep the page small. Stored trees are shared, an
+ * island must not write into them.
  */
-export function getI18nProps(astro: AstroGlobal, keys?: string[]): I18nClientProps {
+export function getI18nProps(astro: Pick<AstroGlobal, 'locals'>, keys?: string[]): I18nClientProps {
   const i18n = getI18n(astro)
-  const locale = getLocale(astro)
-  const fallbackLocale = getDefaultLocale(astro)
-  // currentRoute is already normalized via middleware.setRoute(getRouteName(...))
-  // getRouteName takes routesLocaleLinks into account if configured
   const currentRoute = i18n.getRoute()
-
-  const translations: Record<string, Translations> = {}
-
-  // If keys are specified, extract only those from cache
-  if (keys && keys.length > 0) {
-    const extracted: Translations = {}
-
-    // Use i18n methods to get translations
-    // This guarantees proper routesLocaleLinks support
-    for (const key of keys) {
-      // Use i18n.t() which internally uses helper.getTranslation
-      // and properly resolves the cache key considering routesLocaleLinks
-      const value = i18n.t(key, undefined, undefined, currentRoute)
-      if (value !== null && value !== undefined && value !== key) {
-        setNestedValue(extracted, key, value)
-      }
-    }
-
-    if (Object.keys(extracted).length > 0) {
-      translations[currentRoute] = extracted
-    }
-  } else {
-    // If no keys specified, get route-specific translations
-    // Use the public getRouteTranslations method for safe access
-    const routeTrans = i18n.getRouteTranslations(locale, currentRoute)
-    if (routeTrans) {
-      translations[currentRoute] = routeTrans
-    }
-  }
-
+  const all = i18n.resolveTranslations(currentRoute)
+  if (!keys?.length) warnOversizedProps(all)
+  const localeIso = i18n.getLocaleIso()
   return {
-    locale,
-    fallbackLocale,
+    locale: getLocale(astro),
+    pluralLocale: i18n.pluralLocale(),
+    ...(Object.keys(localeIso).length > 0 && { localeIso }),
+    fallbackLocale: i18n.getFallbackLocale(),
     currentRoute,
-    translations,
+    translations: { [currentRoute]: keys && keys.length > 0 ? pickKeys(all, keys) : all },
   }
 }

package/src/virtual.d.ts

@@ -0,0 +1,21 @@
+declare module 'virtual:i18n-micro/config' {
+  export const config: {
+    defaultLocale: string
+    fallbackLocale: string
+    locales: import('@i18n-micro/types').Locale[]
+    localeCodes: string[]
+    translationDir: string | null
+    autoDetect: boolean
+    redirectToDefault: boolean
+    localeCookie: string | null
+    missingWarn: boolean
+    base: string
+  }
+}
+
+declare module 'virtual:i18n-micro/messages' {
+  export const messages: {
+    root: Record<string, import('@i18n-micro/types').Translations>
+    routes: Record<string, Record<string, import('@i18n-micro/types').Translations>>
+  }
+}

package/dist/core-DwkpOV-H.cjs

@@ -1 +0,0 @@
-let e=require("@i18n-micro/core");function t(e,t){if(e===null||typeof t!=`string`)return null;let n=e;if(e[t])n=e[t];else{let e=t.toString().split(`.`);for(let t of e)if(n&&typeof n==`object`&&n&&t in n)n=n[t];else return null}return n??null}function n(n,r,i,a,o){if(!r)return a||r||``;let s=o||n.currentRoute,c=null;return n.translations[s]&&(c=t(n.translations[s],r)),c||=a===void 0?r:a||r,typeof c==`string`&&i?(0,e.interpolate)(c,i):c}function r(e,n,r){let i=r||e.currentRoute,a=e.translations[i];if(a){let e=t(a,n);if(e!==null&&typeof e!=`object`)return!0}return!1}Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return r}});

package/dist/core-VSnkGRWR.js

@@ -1,28 +0,0 @@
-import { interpolate as e } from "@i18n-micro/core";
-//#region src/client/core.ts
-function t(e, t) {
-	if (e === null || typeof t != "string") return null;
-	let n = e;
-	if (e[t]) n = e[t];
-	else {
-		let e = t.toString().split(".");
-		for (let t of e) if (n && typeof n == "object" && n && t in n) n = n[t];
-		else return null;
-	}
-	return n ?? null;
-}
-function n(n, r, i, a, o) {
-	if (!r) return a || r || "";
-	let s = o || n.currentRoute, c = null;
-	return n.translations[s] && (c = t(n.translations[s], r)), c ||= a === void 0 ? r : a || r, typeof c == "string" && i ? e(c, i) : c;
-}
-function r(e, n, r) {
-	let i = r || e.currentRoute, a = e.translations[i];
-	if (a) {
-		let e = t(a, n);
-		if (e !== null && typeof e != "object") return !0;
-	}
-	return !1;
-}
-//#endregion
-export { n, r as t };