@astroscope/i18n 0.1.0

package/dist/i18n-DumSqX1t.d.ts

@@ -0,0 +1,55 @@
+import { a as ExtractionManifest } from './types-DwkIalh6.js';
+import { T as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-gn4aNKGx.js';
+
+/**
+ * Fallback behavior when translation is missing
+ */
+type FallbackBehavior = 'key' | 'fallback' | 'throw' | ((key: string, meta?: TranslationMeta | undefined) => string);
+/**
+ * Request-scoped i18n context
+ */
+type I18nContext = {
+    locale: string;
+    translations: CompiledTranslations;
+    fallback: FallbackBehavior;
+};
+
+type I18nConfig = {
+    locales: string[];
+    defaultLocale?: string | undefined;
+    fallback?: FallbackBehavior | undefined;
+};
+type NormalizedConfig = {
+    locales: string[];
+    defaultLocale: string;
+    fallback: FallbackBehavior;
+};
+declare class I18nSingleton {
+    private config;
+    private rawCache;
+    private compiledCache;
+    private hashCache;
+    private manifestGetter;
+    configure(config: I18nConfig): void;
+    isConfigured(): boolean;
+    getConfig(): NormalizedConfig;
+    setTranslations(locale: string, raw: RawTranslations): void;
+    getTranslations(locale: string): RawTranslations;
+    getCompiledTranslations(locale: string): CompiledTranslations;
+    /**
+     * Get the extraction manifest (keys + chunks).
+     * - keys: translation keys extracted from codebase with metadata
+     * - chunks: mapping of chunk names to their translation keys
+     */
+    getManifest(): ExtractionManifest;
+    getHashes(locale: string): Record<string, string>;
+    /**
+     * Clear translations for specified locale(s).
+     * @param locales - Locale(s) to clear, or all if not specified
+     */
+    clear(locales?: string | string[] | undefined): void;
+    private resolveLocales;
+}
+declare const i18n: I18nSingleton;
+
+export { type FallbackBehavior as F, type I18nConfig as I, type I18nContext as a, i18n as i };

package/dist/i18n-fWTJw12h.d.ts

@@ -0,0 +1,80 @@
+import { T as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-nippsMkm.js';
+
+/**
+ * Extracted metadata for a single translation key
+ */
+type ExtractedKey = {
+    key: string;
+    meta: TranslationMeta;
+    file: string;
+    line: number;
+};
+/**
+ * Chunk-to-keys mapping produced by Vite plugin
+ */
+type ChunkManifest = Record<string, string[]>;
+/**
+ * Full extraction manifest
+ */
+type ExtractionManifest = {
+    keys: ExtractedKey[];
+    chunks: ChunkManifest;
+};
+
+/**
+ * Fallback behavior when translation is missing
+ */
+type FallbackBehavior = 'key' | 'fallback' | 'throw' | ((key: string, meta?: TranslationMeta | undefined) => string);
+/**
+ * Request-scoped i18n context
+ */
+type I18nContext = {
+    locale: string;
+    translations: CompiledTranslations;
+    fallback: FallbackBehavior;
+};
+
+type I18nConfig = {
+    locales: string[];
+    defaultLocale?: string | undefined;
+    fallback?: FallbackBehavior | undefined;
+};
+type NormalizedConfig = {
+    locales: string[];
+    defaultLocale: string;
+    fallback: FallbackBehavior;
+};
+declare class I18nSingleton {
+    private config;
+    private rawCache;
+    private compiledCache;
+    private extractionManifest;
+    private hashCache;
+    configure(config: I18nConfig): void;
+    isConfigured(): boolean;
+    getConfig(): NormalizedConfig;
+    setTranslations(locale: string, raw: RawTranslations): void;
+    getTranslations(locale: string): RawTranslations;
+    getCompiledTranslations(locale: string): CompiledTranslations;
+    getChunkManifest(): ChunkManifest;
+    /**
+     * Get extracted translation keys with metadata.
+     * Use this to populate your CMS with keys extracted from the codebase.
+     */
+    getExtractedKeys(): ExtractedKey[] | null;
+    /**
+     * Get the full extraction manifest (keys + chunks).
+     * Returns null in dev mode (manifest doesn't exist).
+     */
+    getExtractionManifest(): ExtractionManifest | null;
+    getHashes(locale: string): Record<string, string>;
+    /**
+     * Clear translations for specified locale(s).
+     * @param locales - Locale(s) to clear, or all if not specified
+     */
+    clear(locales?: string | string[] | undefined): void;
+    private resolveLocales;
+}
+declare const i18n: I18nSingleton;
+
+export { type ExtractedKey as E, type FallbackBehavior as F, type I18nConfig as I, type ExtractionManifest as a, type I18nContext as b, i18n as i };

package/dist/import-with-i18n.d.ts

@@ -0,0 +1,23 @@
+import './types-DWhsmSPP.js';
+
+/**
+ * Import a module with i18n translations loaded in parallel.
+ * Use this for dynamic imports inside React components that use translations.
+ *
+ * The Vite plugin will transform calls to inject the chunk ID at build time.
+ *
+ * @example
+ * ```tsx
+ * // The Vite plugin transforms this:
+ * const Module = await importWithI18n(() => import('./HeavyComponent'));
+ *
+ * // Into this at build time:
+ * const Module = await importWithI18n(() => import('./HeavyComponent'), '_astro/HeavyComponent.abc123');
+ * ```
+ *
+ * @param importFn - A function that returns the dynamic import promise
+ * @param chunkId - (Injected by Vite plugin) The chunk ID for loading translations
+ */
+declare function importWithI18n<T>(importFn: () => Promise<T>, chunkId?: string): Promise<T>;
+
+export { importWithI18n };

package/dist/import-with-i18n.js

@@ -0,0 +1,7 @@
+import {
+  importWithI18n
+} from "./chunk-V4XWJXXZ.js";
+import "./chunk-FI5KZ5IO.js";
+export {
+  importWithI18n
+};

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { AstroIntegration, MiddlewareHandler, APIContext } from 'astro';
+export { F as FallbackBehavior, I as I18nConfig, i as i18n } from './i18n-BGfrSNM8.js';
+export { R as RawTranslations, T as TranslationMeta } from './types-Bzp6KxsI.js';
+export { E as ExtractedKey, a as ExtractionManifest } from './types-8uKCwFda.js';
+
+interface I18nOptions {
+}
+
+/**
+ * Astro integration for i18n with automatic per-chunk translation loading.
+ *
+ * Registers:
+ * - Client directives (`client:load-x`, `client:idle-x`, `client:visible-x`, `client:media-x`, `client:only-x`)
+ * - Vite plugin for translation key extraction
+ */
+declare function i18nIntegration(_options?: I18nOptions): AstroIntegration;
+
+type I18nMiddlewareOptions = {
+    locale: (ctx: APIContext) => string;
+};
+/**
+ * Create the i18n chunk middleware that serves translation chunks at `/_i18n/` endpoints.
+ *
+ * Place this early in your middleware sequence (before session/auth)
+ * to avoid unnecessary overhead for static translation requests.
+ *
+ * @example
+ * ```typescript
+ * // src/middleware.ts
+ * import { sequence } from 'astro:middleware';
+ * import { createI18nChunkMiddleware, createI18nMiddleware } from '@astroscope/i18n';
+ *
+ * export const onRequest = sequence(
+ *   createI18nChunkMiddleware(),  // early: serves /_i18n/ chunks
+ *   sessionMiddleware,
+ *   createI18nMiddleware({ locale: (ctx) => ... }),  // after session
+ * );
+ * ```
+ */
+declare function createI18nChunkMiddleware(): MiddlewareHandler;
+/**
+ * Create the i18n locale middleware.
+ *
+ * Sets up the request context with locale and translations for use by
+ * `t()` and `<I18nScript />`. Place this after session middleware if
+ * your locale detection depends on session/cookies.
+ *
+ * @example
+ * ```typescript
+ * import { createI18nMiddleware, detectLocale, i18n } from '@astroscope/i18n';
+ *
+ * export const i18nMiddleware = createI18nMiddleware({
+ *   locale: (ctx) =>
+ *     ctx.cookies.get('locale')?.value ??
+ *     detectLocale(ctx.request) ??
+ *     i18n.getConfig().defaultLocale,
+ * });
+ * ```
+ */
+declare function createI18nMiddleware(options: I18nMiddlewareOptions): MiddlewareHandler;
+
+/**
+ * Detect locale from Accept-Language header.
+ * Returns best match from configured locales, or undefined if none match.
+ */
+declare function detectLocale(request: Request): string | undefined;
+
+export { type I18nMiddlewareOptions, createI18nChunkMiddleware, createI18nMiddleware, i18nIntegration as default, detectLocale };

package/dist/index.js

@@ -0,0 +1,151 @@
+import {
+  i18nVitePlugin
+} from "./chunk-JJEDOJBR.js";
+import {
+  i18n,
+  runWithContext
+} from "./chunk-QFAAGCP5.js";
+import "./chunk-KNDYKTHE.js";
+import "./chunk-4A5BKHFN.js";
+
+// src/integration/integration.ts
+var CLIENT_DIRECTIVES = ["load-x", "idle-x", "visible-x", "media-x", "only-x"];
+function i18nIntegration(_options = {}) {
+  return {
+    name: "@astroscope/i18n",
+    hooks: {
+      "astro:config:setup": ({ addClientDirective, updateConfig, logger }) => {
+        for (const directive of CLIENT_DIRECTIVES) {
+          const base = directive.replace("-x", "");
+          addClientDirective({
+            name: directive,
+            entrypoint: `@astroscope/i18n/client-directives/${base}.js`
+          });
+        }
+        updateConfig({
+          vite: {
+            plugins: [i18nVitePlugin({ logger })]
+          }
+        });
+      },
+      "astro:config:done": ({ injectTypes }) => {
+        const typeMap = {
+          load: "boolean",
+          idle: "boolean",
+          visible: "boolean | string",
+          media: "string",
+          only: "string"
+        };
+        const attributes = CLIENT_DIRECTIVES.map((d) => {
+          const base = d.replace("-x", "");
+          return `    'client:${d}'?: ${typeMap[base]};`;
+        }).join("\n");
+        injectTypes({
+          filename: "client-directives.d.ts",
+          content: `// generated by @astroscope/i18n
+declare namespace astroHTML.JSX {
+  interface AstroBuiltinAttributes {
+${attributes}
+  }
+}`
+        });
+      }
+    }
+  };
+}
+
+// src/server/middleware.ts
+var I18N_ENDPOINT_PREFIX = "/_i18n/";
+function createI18nChunkMiddleware() {
+  return (ctx, next) => {
+    const { pathname } = ctx.url;
+    if (!pathname.startsWith(I18N_ENDPOINT_PREFIX)) {
+      return next();
+    }
+    const path = pathname.slice(I18N_ENDPOINT_PREFIX.length);
+    const slashIdx = path.indexOf("/");
+    if (slashIdx === -1) {
+      return next();
+    }
+    const locale = path.slice(0, slashIdx);
+    const rest = path.slice(slashIdx + 1);
+    if (!rest.endsWith(".js")) {
+      return next();
+    }
+    const withoutJs = rest.slice(0, -3);
+    const lastDotIdx = withoutJs.lastIndexOf(".");
+    if (lastDotIdx === -1) {
+      return next();
+    }
+    const chunkName = withoutJs.slice(0, lastDotIdx);
+    const keys = i18n.getManifest().chunks[chunkName];
+    if (!keys) {
+      return new Response(`/* chunk not found: ${chunkName} */`, {
+        status: 404,
+        headers: { "Content-Type": "application/javascript" }
+      });
+    }
+    const translations = i18n.getTranslations(locale);
+    const chunkTranslations = {};
+    for (const key of keys) {
+      if (translations[key]) {
+        chunkTranslations[key] = translations[key];
+      }
+    }
+    const js = `/* @astroscope/i18n chunk: ${chunkName} */
+(function() {
+  var i = window.__i18n__;
+  if (i) Object.assign(i.translations, ${JSON.stringify(chunkTranslations)});
+})();
+`;
+    const body = new TextEncoder().encode(js);
+    return new Response(body, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/javascript; charset=utf-8",
+        "Content-Length": String(body.byteLength),
+        "Cache-Control": "public, max-age=31536000, immutable"
+      }
+    });
+  };
+}
+function createI18nMiddleware(options) {
+  return (ctx, next) => {
+    const locale = options.locale(ctx);
+    const context = {
+      locale,
+      translations: i18n.getCompiledTranslations(locale),
+      fallback: i18n.getConfig().fallback
+    };
+    return runWithContext(context, () => next());
+  };
+}
+
+// src/server/locale.ts
+function detectLocale(request) {
+  const config = i18n.getConfig();
+  if (!config) return void 0;
+  const { locales } = config;
+  const acceptLanguage = request.headers.get("accept-language");
+  if (!acceptLanguage) return void 0;
+  const preferred = acceptLanguage.split(",").map((part) => {
+    const [lang, q = "q=1"] = part.trim().split(";");
+    return {
+      lang: lang.split("-")[0].toLowerCase(),
+      q: parseFloat(q.replace("q=", ""))
+    };
+  }).sort((a, b) => b.q - a.q);
+  for (const { lang } of preferred) {
+    if (locales.includes(lang)) {
+      return lang;
+    }
+  }
+  return void 0;
+}
+export {
+  createI18nChunkMiddleware,
+  createI18nMiddleware,
+  i18nIntegration as default,
+  detectLocale,
+  i18n
+};

package/dist/init.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/init.js

@@ -0,0 +1,8 @@
+import {
+  i18n
+} from "./chunk-2PSXD3JJ.js";
+import "./chunk-KNDYKTHE.js";
+
+// src/init.ts
+import { getManifest } from "virtual:@astroscope/i18n/manifest";
+i18n.setManifestGetter(getManifest);

package/dist/internal.d.ts

@@ -0,0 +1,11 @@
+import { a as I18nContext } from './i18n-BGfrSNM8.js';
+export { i as i18n } from './i18n-BGfrSNM8.js';
+export { I as I18nClientState } from './types-Bzp6KxsI.js';
+import './types-8uKCwFda.js';
+
+/**
+ * Get the current i18n context
+ */
+declare function getContext(): I18nContext | null;
+
+export { getContext };

package/dist/internal.js

@@ -0,0 +1,9 @@
+import {
+  getContext,
+  i18n
+} from "./chunk-QFAAGCP5.js";
+import "./chunk-KNDYKTHE.js";
+export {
+  getContext,
+  i18n
+};

package/dist/middleware-entrypoint-C0Drh9E_.d.ts

@@ -0,0 +1,29 @@
+import { APIContext, MiddlewareHandler } from 'astro';
+
+type I18nMiddlewareOptions = {
+    locale: (ctx: APIContext) => string;
+};
+/**
+ * Detect locale from Accept-Language header.
+ * Returns best match from configured locales, or undefined if none match.
+ */
+declare function detectLocale(request: Request): string | undefined;
+/**
+ * Create the i18n middleware.
+ *
+ * @example
+ * ```typescript
+ * import { createI18nMiddleware, detectLocale, i18n } from '@astroscope/i18n';
+ *
+ * export const i18nMiddleware = createI18nMiddleware({
+ *   locale: (ctx) =>
+ *     ctx.cookies.get('locale')?.value ??
+ *     detectLocale(ctx.request) ??
+ *     i18n.getDefaultLocale() ??
+ *     'en',
+ * });
+ * ```
+ */
+declare function createI18nMiddleware(options: I18nMiddlewareOptions): MiddlewareHandler;
+
+export { type I18nMiddlewareOptions as I, createI18nMiddleware as c, detectLocale as d };

package/dist/middleware-entrypoint-mEl66IUy.d.ts

@@ -0,0 +1,29 @@
+import { APIContext, MiddlewareHandler } from 'astro';
+
+type I18nMiddlewareOptions = {
+    locale: (ctx: APIContext) => string;
+};
+/**
+ * Detect locale from Accept-Language header.
+ * Returns best match from configured locales, or undefined if none match.
+ */
+declare function detectLocale(request: Request): string | undefined;
+/**
+ * Create the i18n middleware.
+ *
+ * @example
+ * ```typescript
+ * import { createI18nMiddleware, detectLocale, i18n } from '@astroscope/i18n';
+ *
+ * export const i18nMiddleware = createI18nMiddleware({
+ *   locale: (ctx) =>
+ *     ctx.cookies.get('locale')?.value ??
+ *     detectLocale(ctx.request) ??
+ *     i18n.getConfig()?.defaultLocale ??
+ *     'en',
+ * });
+ * ```
+ */
+declare function createI18nMiddleware(options: I18nMiddlewareOptions): MiddlewareHandler;
+
+export { type I18nMiddlewareOptions as I, createI18nMiddleware as c, detectLocale as d };

package/dist/middleware-entrypoint.d.ts

@@ -0,0 +1,5 @@
+import * as astro from 'astro';
+
+declare const onRequest: astro.MiddlewareHandler;
+
+export { onRequest };

package/dist/middleware-entrypoint.js

@@ -0,0 +1,30 @@
+import {
+  createI18nMiddleware,
+  getI18nService
+} from "./chunk-FHBVI3TL.js";
+import "./chunk-KNONI6DP.js";
+
+// src/middleware-entrypoint.ts
+import fs from "fs";
+function loadChunkManifest() {
+  try {
+    const manifestPath = new URL("./i18n-manifest.json", import.meta.url);
+    const content = fs.readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    return manifest.chunks;
+  } catch {
+    return void 0;
+  }
+}
+var chunkManifest = loadChunkManifest();
+var service = getI18nService();
+var config = service.config;
+var onRequest = createI18nMiddleware({
+  locales: config.locales,
+  defaultLocale: config.defaultLocale,
+  fallback: config.fallback,
+  chunkManifest
+});
+export {
+  onRequest
+};

package/dist/server/middleware-entrypoint.d.ts

@@ -0,0 +1,2 @@
+export { c as createI18nMiddleware, d as detectLocale } from '../middleware-entrypoint-C0Drh9E_.js';
+import 'astro';

package/dist/server/middleware-entrypoint.js

@@ -0,0 +1,28 @@
+import {
+  createI18nMiddleware,
+  detectLocale,
+  i18n
+} from "../chunk-NHHTSFA7.js";
+import "../chunk-JJBBY2GR.js";
+import "../chunk-KNDYKTHE.js";
+
+// src/server/middleware-entrypoint.ts
+import fs from "fs";
+function loadChunkManifest() {
+  try {
+    const manifestPath = new URL("./i18n-manifest.json", import.meta.url);
+    const content = fs.readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    return manifest.chunks;
+  } catch {
+    return void 0;
+  }
+}
+var chunkManifest = loadChunkManifest();
+if (chunkManifest) {
+  i18n.setChunkManifest(chunkManifest);
+}
+export {
+  createI18nMiddleware,
+  detectLocale
+};

package/dist/server/t.d.ts

@@ -0,0 +1,17 @@
+import { a as TranslateFunction } from '../types-Bzp6KxsI.js';
+
+/**
+ * Get the current locale from request context.
+ * Returns defaultLocale if called outside a request (e.g. during build).
+ */
+declare function getLocale(): string;
+/**
+ * Server-side translate function
+ *
+ * Call patterns:
+ * - Development: t('key', 'fallback') or t('key', 'fallback', values)
+ * - Production: t('key') or t('key', undefined, values)
+ */
+declare const t: TranslateFunction;
+
+export { getLocale, t };

package/dist/server/t.js

@@ -0,0 +1,59 @@
+import {
+  getContext,
+  i18n
+} from "../chunk-QFAAGCP5.js";
+import {
+  normalizeMeta
+} from "../chunk-EMM6LRO2.js";
+import {
+  compileMessage
+} from "../chunk-KNDYKTHE.js";
+
+// src/server/t.ts
+var fallbackCache = /* @__PURE__ */ new Map();
+function applyFallback(key, meta, fallback) {
+  if (typeof fallback === "function") {
+    return fallback(key, meta);
+  }
+  switch (fallback) {
+    case "key":
+      return key;
+    case "fallback":
+      return meta.fallback || key;
+    case "throw":
+      throw new Error(`Missing translation for key: ${key}`);
+    default:
+      return meta.fallback || key;
+  }
+}
+function getLocale() {
+  const ctx = getContext();
+  return ctx?.locale ?? i18n.getConfig().defaultLocale;
+}
+var t = ((key, meta, values) => {
+  const normalizedMeta = meta ? normalizeMeta(meta) : { fallback: "" };
+  const ctx = getContext();
+  if (!ctx) {
+    const defaultLocale = i18n.getConfig().defaultLocale;
+    const fallbackStr = normalizedMeta.fallback || key;
+    const cacheKey = `${defaultLocale}:${fallbackStr}`;
+    let compiled2 = fallbackCache.get(cacheKey);
+    if (!compiled2) {
+      compiled2 = compileMessage(defaultLocale, fallbackStr);
+      fallbackCache.set(cacheKey, compiled2);
+    }
+    return compiled2(values);
+  }
+  const compiled = ctx.translations[key];
+  if (!compiled) {
+    const fallbackValue = applyFallback(key, normalizedMeta, ctx.fallback);
+    const compiledFallback = compileMessage(ctx.locale, fallbackValue);
+    ctx.translations[key] = compiledFallback;
+    return compiledFallback(values);
+  }
+  return compiled(values);
+});
+export {
+  getLocale,
+  t
+};

package/dist/t-BY_C9lZ1.d.ts

@@ -0,0 +1,30 @@
+import { T as TranslationMeta } from './types-BwhB6IT4.js';
+
+/**
+ * Translate function signature
+ *
+ * @param key - Translation key (e.g., 'checkout.title')
+ * @param meta - Metadata with example and variable definitions (extracted at build time)
+ * @param values - Runtime values for interpolation
+ * @returns Translated string
+ *
+ * @example
+ * // Simple
+ * t('checkout.title', { example: 'Bestellübersicht' })
+ *
+ * @example
+ * // With variables
+ * t('checkout.tax', {
+ *   example: 'Enthält {name} MwSt.',
+ *   variables: { name: { example: '19%' } }
+ * }, { name: taxRate })
+ *
+ * @example
+ * // Pluralization (ICU)
+ * t('cart.items', {
+ *   example: '{count, plural, one {# item} other {# items}}'
+ * }, { count: itemCount })
+ */
+type TranslateFunction = (key: string, meta: TranslationMeta, values?: Record<string, unknown>) => string;
+
+export type { TranslateFunction as T };