@i18n-micro/astro 1.0.0 → 1.1.0

package/dist/integration.d.ts

@@ -1,6 +1,7 @@
 import { AstroIntegration } from 'astro';
 import { AstroI18n, AstroI18nOptions } from './composer';
 import { Locale, ModuleOptions, PluralFunc } from '@i18n-micro/types';
+import { I18nRoutingStrategy } from './router/types';
 export interface I18nIntegrationOptions extends Omit<ModuleOptions, 'plural'> {
     locale: string;
     fallbackLocale?: string;
@@ -13,7 +14,10 @@ export interface I18nIntegrationOptions extends Omit<ModuleOptions, 'plural'> {
     autoDetect?: boolean;
     redirectToDefault?: boolean;
     translationDir?: string;
+    routingStrategy?: I18nRoutingStrategy;
 }
+export declare function getGlobalRoutingStrategy(): I18nRoutingStrategy | null;
+export declare function setGlobalRoutingStrategy(strategy: I18nRoutingStrategy | null): void;
 /**
  * Astro Integration for i18n-micro
  */

package/dist/load-translations.d.ts

@@ -0,0 +1,44 @@
+import { Translations } from '@i18n-micro/types';
+/**
+ * WARNING: Node.js-only functions
+ *
+ * The functions in this file use Node.js filesystem APIs (node:fs) and will NOT work
+ * in Edge runtime environments (Cloudflare Workers, Vercel Edge, Deno Deploy, etc.).
+ *
+ * If you import this module in an Edge environment, the bundler will fail at build time
+ * because node:fs is not available. This is the intended behavior (Fail Fast).
+ *
+ * For Edge-compatible translation loading, use import.meta.glob in your middleware:
+ * const translations = import.meta.glob('/src/locales/*.json', { eager: true })
+ */
+/**
+ * Load translations from a directory structure
+ * Supports both flat structure (en.json, fr.json) and nested structure (pages/home/en.json)
+ */
+export interface LoadTranslationsOptions {
+    translationDir: string;
+    rootDir?: string;
+    disablePageLocales?: boolean;
+}
+export interface LoadedTranslations {
+    general: Record<string, Translations>;
+    routes: Record<string, Record<string, Translations>>;
+}
+/**
+ * Load all translations from a directory
+ *
+ * WARNING: Node.js-only - This function uses node:fs and will NOT work in Edge runtime.
+ * If imported in Edge environment, bundler will fail at build time (Fail Fast).
+ * Use import.meta.glob for Edge-compatible loading.
+ */
+export declare function loadTranslationsFromDir(options: LoadTranslationsOptions): LoadedTranslations;
+/**
+ * Load translations and add them to an AstroI18n instance
+ *
+ * WARNING: Node.js-only - This function uses node:fs and will NOT work in Edge runtime.
+ * For Edge environments, use import.meta.glob to load translations at build time.
+ */
+export declare function loadTranslationsIntoI18n(i18n: {
+    addTranslations: (locale: string, translations: Translations, merge?: boolean) => void;
+    addRouteTranslations: (locale: string, routeName: string, translations: Translations, merge?: boolean) => void;
+}, options: LoadTranslationsOptions): void;

package/dist/middleware.d.ts

@@ -1,6 +1,7 @@
 import { AstroI18n } from './composer';
 import { MiddlewareHandler } from 'astro';
 import { Locale } from '@i18n-micro/types';
+import { I18nRoutingStrategy } from './router/types';
 export interface I18nMiddlewareOptions {
     i18n: AstroI18n;
     defaultLocale: string;
@@ -8,6 +9,7 @@ export interface I18nMiddlewareOptions {
     localeObjects?: Locale[];
     autoDetect?: boolean;
     redirectToDefault?: boolean;
+    routingStrategy?: I18nRoutingStrategy;
 }
 /**
  * Create Astro middleware for i18n locale detection

package/dist/router/adapter.d.ts

@@ -0,0 +1,8 @@
+import { I18nRoutingStrategy } from './types';
+import { Locale } from '@i18n-micro/types';
+/**
+ * Factory for Astro router adapter
+ * Implements routing utilities for Astro file-based routing
+ * Uses standard Astro APIs: Astro.url, context.url
+ */
+export declare function createAstroRouterAdapter(locales: Locale[], defaultLocale: string, getCurrentUrl?: () => URL): I18nRoutingStrategy;

package/dist/router/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Routing strategy interface for i18n in Astro
+ * Implement this interface to integrate with any routing logic
+ * Matches Vue/Solid/React package interface for consistency
+ * Adapted for Astro SSR context (push/replace are optional)
+ */
+export interface I18nRoutingStrategy {
+    /**
+     * Returns current path (without locale prefix if needed, or full path)
+     * Used for determining active classes in links
+     */
+    getCurrentPath: () => string;
+    /**
+     * Generate path for specific locale
+     */
+    resolvePath?: (to: string | {
+        path?: string;
+    }, locale: string) => string | {
+        path?: string;
+    };
+    /**
+     * Get route name from path (e.g., /en/about -> about)
+     * Used in middleware to set route name
+     */
+    getRouteName?: (path: string, locales: string[]) => string;
+    /**
+     * Get locale from path
+     * Checks if first segment is a locale code
+     */
+    getLocaleFromPath?: (path: string, defaultLocale: string, locales: string[]) => string;
+    /**
+     * Switch locale in path
+     * Replaces or adds locale prefix to path
+     */
+    switchLocalePath?: (path: string, newLocale: string, locales: string[], defaultLocale?: string) => string;
+    /**
+     * Localize path with locale prefix
+     */
+    localizePath?: (path: string, locale: string, locales: string[], defaultLocale?: string) => string;
+    /**
+     * Remove locale from path
+     */
+    removeLocaleFromPath?: (path: string, locales: string[]) => string;
+    /**
+     * (Optional) Function to navigate to another route/locale
+     * Not used in SSR, but can be used in client-side islands
+     */
+    push?: (target: {
+        path: string;
+    }) => void;
+    /**
+     * (Optional) Function to replace current route
+     * Not used in SSR, but can be used in client-side islands
+     */
+    replace?: (target: {
+        path: string;
+    }) => void;
+    /**
+     * (Optional) Get current route object for SEO/Meta tags
+     */
+    getRoute?: () => {
+        fullPath: string;
+        query: Record<string, unknown>;
+    };
+}

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import { AstroI18n } from './composer';
-import { Params, Locale, CleanTranslation, TranslationKey } from '@i18n-micro/types';
+import { Params, Locale, CleanTranslation, TranslationKey, Translations } from '@i18n-micro/types';
 import { AstroGlobal } from 'astro';
 /**
  * Get i18n instance from Astro context
@@ -69,3 +69,19 @@ export interface LocaleHeadResult {
     }>;
 }
 export declare function useLocaleHead(astro: AstroGlobal, options?: LocaleHeadOptions): LocaleHeadResult;
+/**
+ * Props для передачи в клиентские острова (Vue, React, Svelte, Preact)
+ */
+export interface I18nClientProps {
+    locale: string;
+    fallbackLocale: string;
+    translations: Record<string, Translations>;
+    currentRoute: string;
+}
+/**
+ * Подготавливает пропсы для передачи в клиентский остров.
+ * Принимает список ключей, которые нужно передать в остров.
+ * Использует методы i18n для правильной работы с routesLocaleLinks.
+ * currentRoute уже нормализован через middleware (getRouteName), поэтому используем его напрямую.
+ */
+export declare function getI18nProps(astro: AstroGlobal, keys?: string[]): I18nClientProps;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@i18n-micro/astro",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -18,31 +18,75 @@
     "./components/i18n-link.astro": "./src/components/i18n-link.astro",
     "./components/i18n-switcher.astro": "./src/components/i18n-switcher.astro",
     "./components/i18n-group.astro": "./src/components/i18n-group.astro",
-    "./toolbar-app": "./src/toolbar-app.ts"
+    "./i18n-t": "./src/components/i18n-t.astro",
+    "./i18n-link": "./src/components/i18n-link.astro",
+    "./i18n-switcher": "./src/components/i18n-switcher.astro",
+    "./i18n-group": "./src/components/i18n-group.astro",
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./client/vue": {
+      "types": "./dist/client/vue.d.ts",
+      "import": "./dist/client/vue.js"
+    },
+    "./client/react": {
+      "types": "./dist/client/react.d.ts",
+      "import": "./dist/client/react.js"
+    },
+    "./client/preact": {
+      "types": "./dist/client/preact.d.ts",
+      "import": "./dist/client/preact.js"
+    },
+    "./client/svelte": {
+      "types": "./dist/client/svelte.d.ts",
+      "import": "./dist/client/svelte.js"
+    }
   },
   "files": [
     "dist",
-    "src/components"
+    "src"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@i18n-micro/devtools-ui": "1.0.0",
-    "@i18n-micro/core": "1.0.27",
-    "@i18n-micro/types": "1.0.15",
-    "@i18n-micro/node": "1.0.0"
+    "@i18n-micro/core": "1.0.28",
+    "@i18n-micro/types": "1.0.16",
+    "@i18n-micro/node": "1.0.1"
   },
   "peerDependencies": {
-    "astro": "^5.0.0"
+    "astro": "^5.0.0",
+    "svelte": "^4.0.0 || ^5.0.0",
+    "vue": "^3.0.0",
+    "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+    "preact": "^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "preact": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "astro": "^5.0.0",
-    "vite": "^5.0.0",
-    "vite-plugin-dts": "^4.3.0",
+    "astro": "^5.16.5",
+    "vite": "^7.2.7",
+    "vite-plugin-dts": "^4.5.4",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
-    "@types/jest": "^29.5.0"
+    "ts-jest": "^29.4.6",
+    "@types/jest": "^29.5.14",
+    "svelte": "^5.0.0",
+    "vue": "^3.4.0",
+    "react": "^18.3.0",
+    "preact": "^10.0.0"
   },
   "scripts": {
     "build": "vite build",

package/src/client/core.ts

@@ -0,0 +1,121 @@
+import type { Translations, Params } from '@i18n-micro/types'
+import { interpolate } from '@i18n-micro/core'
+
+/**
+ * Состояние i18n для клиентских островов
+ */
+export interface I18nState {
+  locale: string
+  fallbackLocale: string
+  translations: Record<string, Translations> // routeName -> translations
+  currentRoute: string
+}
+
+// Вспомогательная функция для поиска перевода в объекте Translations
+// Returns the value as-is, including objects (for nested translations)
+function findTranslation<T = unknown>(translations: Translations | null, key: string): T | null {
+  if (translations === null || typeof key !== 'string') {
+    return null
+  }
+
+  let value: string | number | boolean | Translations | unknown | null = translations
+
+  // Прямой доступ к ключу
+  if (translations[key]) {
+    value = translations[key]
+  }
+  else {
+    // Поиск по вложенным ключам (например, "nested.message")
+    const parts = key.toString().split('.')
+    for (const part of parts) {
+      if (value && typeof value === 'object' && value !== null && part in value) {
+        value = (value as Translations)[part]
+      }
+      else {
+        return null
+      }
+    }
+  }
+
+  // Return value as-is (can be string, number, boolean, object, or null)
+  // This matches CleanTranslation type which allows objects
+  return (value as T) ?? null
+}
+
+/**
+ * Чистая функция для получения перевода из состояния
+ *
+ * Note: This is a simplified version optimized for client-side islands.
+ * It supports basic translation lookup, interpolation, and fallback to general translations.
+ * Returns CleanTranslation which can be string, number, boolean, object, or null.
+ * For advanced features like Linked Messages (@:path.to.key), use the server-side i18n instance.
+ */
+export function translate(
+  state: I18nState,
+  key: string,
+  params?: Params,
+  defaultValue?: string | null,
+  routeName?: string,
+): string | number | boolean | Translations | null {
+  if (!key) {
+    return defaultValue || key || ''
+  }
+
+  const route = routeName || state.currentRoute
+  let value: string | number | boolean | Translations | null = null
+
+  // 1. Ищем в route-specific переводах
+  if (state.translations[route]) {
+    value = findTranslation<string | number | boolean | Translations>(state.translations[route], key)
+  }
+
+  // 2. Fallback на general переводы
+  if (!value && state.translations.general) {
+    value = findTranslation<string | number | boolean | Translations>(state.translations.general, key)
+  }
+
+  // 3. Если не найдено, используем defaultValue или key
+  if (!value) {
+    value = defaultValue === undefined ? key : (defaultValue || key)
+  }
+
+  // 4. Интерполяция параметров (только для строк)
+  if (typeof value === 'string' && params) {
+    return interpolate(value, params)
+  }
+
+  // 5. Возвращаем value как есть (может быть string, number, boolean, object, или null)
+  // Это соответствует типу CleanTranslation
+  return value
+}
+
+/**
+ * Проверяет наличие перевода в состоянии
+ */
+export function hasTranslation(
+  state: I18nState,
+  key: string,
+  routeName?: string,
+): boolean {
+  const route = routeName || state.currentRoute
+  const routeTranslations = state.translations[route]
+  const generalTranslations = state.translations.general
+
+  // Проверяем в route-specific переводах
+  if (routeTranslations) {
+    const value = findTranslation(routeTranslations, key)
+    if (value !== null && typeof value !== 'object') {
+      return true
+    }
+  }
+
+  // Проверяем в general переводах
+  if (generalTranslations) {
+    const value = findTranslation(generalTranslations, key)
+    if (value !== null && typeof value !== 'object') {
+      return true
+    }
+  }
+
+  return false
+}

package/src/client/index.ts

@@ -0,0 +1,15 @@
+// Core utilities (чистые функции)
+export { translate, hasTranslation } from './core'
+export type { I18nState } from './core'
+
+// Vue adapter
+export { provideI18n, useAstroI18n as useAstroI18nVue } from './vue'
+
+// React adapter
+export { I18nProvider, useAstroI18n as useAstroI18nReact } from './react'
+
+// Preact adapter
+export { I18nProvider as I18nProviderPreact, useAstroI18n as useAstroI18nPreact } from './preact'
+
+// Svelte adapter
+export { createI18nStore, useAstroI18n as useAstroI18nSvelte } from './svelte'

package/src/client/preact.tsx

@@ -0,0 +1,114 @@
+// Preact может использовать React Context API, так как Preact совместим с React
+import type { ComponentChildren } from 'preact'
+import { createContext, createElement } from 'preact'
+import { useContext, useState, useMemo } from 'preact/hooks'
+import type { I18nClientProps } from '../utils'
+import { translate, hasTranslation, type I18nState } from './core'
+import { defaultPlural, FormatService } from '@i18n-micro/core'
+import type { Params, TranslationKey, CleanTranslation } from '@i18n-micro/types'
+
+const formatter = new FormatService()
+
+const I18nContext = createContext<I18nState | null>(null)
+
+/**
+ * Провайдер для i18n в Preact островах
+ */
+export const I18nProvider = ({ children, value }: { children: ComponentChildren, value: I18nClientProps }) => {
+  const [state] = useState<I18nState>(() => ({
+    locale: value.locale,
+    fallbackLocale: value.fallbackLocale,
+    translations: value.translations,
+    currentRoute: value.currentRoute,
+  }))
+
+  return createElement(I18nContext.Provider, { value: state }, children)
+}
+
+/**
+ * Хук для использования i18n в Preact компонентах
+ */
+export function useAstroI18n() {
+  const state = useContext(I18nContext)
+  if (!state) {
+    throw new Error('useAstroI18n must be used within an I18nProvider')
+  }
+
+  const t = useMemo(() => (
+    key: TranslationKey,
+    params?: Params,
+    defaultValue?: string | null,
+    routeName?: string,
+  ): CleanTranslation => {
+    return translate(state, key as string, params, defaultValue, routeName)
+  }, [state])
+
+  const ts = useMemo(() => (
+    key: TranslationKey,
+    params?: Params,
+    defaultValue?: string,
+    routeName?: string,
+  ): string => {
+    const value = t(key, params, defaultValue, routeName)
+    return value?.toString() ?? defaultValue ?? (key as string)
+  }, [t])
+
+  const tc = useMemo(() => (key: TranslationKey, count: number | Params, defaultValue?: string): string => {
+    const { count: countValue, ...params } = typeof count === 'number' ? { count } : count
+
+    if (countValue === undefined) {
+      return defaultValue ?? (key as string)
+    }
+
+    const getter = (k: TranslationKey, p?: Params, dv?: string) => {
+      return t(k, p, dv)
+    }
+
+    const result = defaultPlural(
+      key,
+      Number.parseInt(countValue.toString(), 10),
+      params,
+      state.locale,
+      getter,
+    )
+
+    return result ?? defaultValue ?? (key as string)
+  }, [t, state])
+
+  const tn = useMemo(() => (value: number, options?: Intl.NumberFormatOptions): string => {
+    return formatter.formatNumber(value, state.locale, options)
+  }, [state.locale])
+
+  const td = useMemo(() => (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string => {
+    return formatter.formatDate(value, state.locale, options)
+  }, [state.locale])
+
+  const tdr = useMemo(() => (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions): string => {
+    return formatter.formatRelativeTime(value, state.locale, options)
+  }, [state.locale])
+
+  const has = useMemo(() => (key: TranslationKey, routeName?: string): boolean => {
+    return hasTranslation(state, key as string, routeName)
+  }, [state])
+
+  return {
+    // Translation methods
+    t,
+    ts,
+    tc,
+    tn,
+    td,
+    tdr,
+    has,
+
+    // Locale state
+    locale: state.locale,
+    fallbackLocale: state.fallbackLocale,
+    currentRoute: state.currentRoute,
+
+    // Route management (read-only в клиентских островах)
+    getRoute: (): string => {
+      return state.currentRoute
+    },
+  }
+}

package/src/client/react.tsx

@@ -0,0 +1,111 @@
+import React, { createContext, useContext, useState, useMemo } from 'react'
+import type { I18nClientProps } from '../utils'
+import { translate, hasTranslation, type I18nState } from './core'
+import { defaultPlural, FormatService } from '@i18n-micro/core'
+import type { Params, TranslationKey, CleanTranslation } from '@i18n-micro/types'
+
+const formatter = new FormatService()
+
+const I18nContext = createContext<I18nState | null>(null)
+
+/**
+ * Провайдер для i18n в React островах
+ */
+export function I18nProvider({ children, value }: { children: React.ReactNode, value: I18nClientProps }): React.ReactElement {
+  const [state] = useState<I18nState>(() => ({
+    locale: value.locale,
+    fallbackLocale: value.fallbackLocale,
+    translations: value.translations,
+    currentRoute: value.currentRoute,
+  }))
+
+  return React.createElement(I18nContext.Provider, { value: state }, children)
+}
+
+/**
+ * Хук для использования i18n в React компонентах
+ */
+export function useAstroI18n() {
+  const state = useContext(I18nContext)
+  if (!state) {
+    throw new Error('useAstroI18n must be used within an I18nProvider')
+  }
+
+  const t = useMemo(() => (
+    key: TranslationKey,
+    params?: Params,
+    defaultValue?: string | null,
+    routeName?: string,
+  ): CleanTranslation => {
+    return translate(state, key as string, params, defaultValue, routeName)
+  }, [state])
+
+  const ts = useMemo(() => (
+    key: TranslationKey,
+    params?: Params,
+    defaultValue?: string,
+    routeName?: string,
+  ): string => {
+    const value = t(key, params, defaultValue, routeName)
+    return value?.toString() ?? defaultValue ?? (key as string)
+  }, [t])
+
+  const tc = useMemo(() => (key: TranslationKey, count: number | Params, defaultValue?: string): string => {
+    const { count: countValue, ...params } = typeof count === 'number' ? { count } : count
+
+    if (countValue === undefined) {
+      return defaultValue ?? (key as string)
+    }
+
+    const getter = (k: TranslationKey, p?: Params, dv?: string) => {
+      return t(k, p, dv)
+    }
+
+    const result = defaultPlural(
+      key,
+      Number.parseInt(countValue.toString(), 10),
+      params,
+      state.locale,
+      getter,
+    )
+
+    return result ?? defaultValue ?? (key as string)
+  }, [t, state])
+
+  const tn = useMemo(() => (value: number, options?: Intl.NumberFormatOptions): string => {
+    return formatter.formatNumber(value, state.locale, options)
+  }, [state.locale])
+
+  const td = useMemo(() => (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string => {
+    return formatter.formatDate(value, state.locale, options)
+  }, [state.locale])
+
+  const tdr = useMemo(() => (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions): string => {
+    return formatter.formatRelativeTime(value, state.locale, options)
+  }, [state.locale])
+
+  const has = useMemo(() => (key: TranslationKey, routeName?: string): boolean => {
+    return hasTranslation(state, key as string, routeName)
+  }, [state])
+
+  return {
+    // Translation methods
+    t,
+    ts,
+    tc,
+    tn,
+    td,
+    tdr,
+    has,
+
+    // Locale state
+    locale: state.locale,
+    fallbackLocale: state.fallbackLocale,
+    currentRoute: state.currentRoute,
+
+    // Route management (read-only в клиентских островах)
+    getRoute: (): string => {
+      return state.currentRoute
+    },
+  }
+}