@astroscope/i18n 0.1.0

package/dist/t-CG3yDiEa.d.ts

@@ -0,0 +1,30 @@
+import { T as TranslationMeta } from './types-OYRgjtE_.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 };

package/dist/t-CHsBfrPr.d.ts

@@ -0,0 +1,30 @@
+import { T as TranslationMeta } from './types-BC6K-pID.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 };

package/dist/t-DQpXaDhP.d.ts

@@ -0,0 +1,30 @@
+import { T as TranslationMeta } from './types-D44mFUjA.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 };

package/dist/t.client.d.ts

@@ -0,0 +1,11 @@
+import { d as TranslateFunction } from './types-DWhsmSPP.js';
+export { T as TranslationMeta } from './types-DWhsmSPP.js';
+
+/**
+ * Client-side translate function
+ * Reads from window.__i18n__.translations (injected per-chunk)
+ * Falls back to meta.example if translation is missing
+ */
+declare const t: TranslateFunction;
+
+export { TranslateFunction, t };

package/dist/t.client.js

@@ -0,0 +1,35 @@
+// src/t.client.ts
+import MessageFormat from "@messageformat/core";
+var compiledCache = /* @__PURE__ */ new Map();
+var mf = null;
+function getMessageFormat() {
+  if (!mf) {
+    mf = new MessageFormat(window.__i18n__.locale);
+  }
+  return mf;
+}
+function compileMessage(message) {
+  try {
+    return getMessageFormat().compile(message);
+  } catch {
+    return (values) => {
+      if (!values) return message;
+      return Object.entries(values).reduce(
+        (result, [key, value]) => result.replace(new RegExp(`\\{${key}\\}`, "g"), String(value)),
+        message
+      );
+    };
+  }
+}
+var t = (key, meta, values) => {
+  let compiled = compiledCache.get(key);
+  if (!compiled) {
+    const raw = window.__i18n__.translations[key] ?? meta.example;
+    compiled = compileMessage(raw);
+    compiledCache.set(key, compiled);
+  }
+  return compiled(values);
+};
+export {
+  t
+};

package/dist/t.server.d.ts

@@ -0,0 +1,22 @@
+import { I as I18nContext, d as TranslateFunction } from './types-DWhsmSPP.js';
+export { T as TranslationMeta } from './types-DWhsmSPP.js';
+
+/**
+ * Set the i18n context for the current request (called by middleware)
+ */
+declare function setContext(context: I18nContext): void;
+/**
+ * Get the current i18n context
+ */
+declare function getContext(): I18nContext | null;
+/**
+ * Clear the context after request (called by middleware)
+ */
+declare function clearContext(): void;
+/**
+ * Server-side translate function
+ * Reads from request-scoped context set by middleware
+ */
+declare const t: TranslateFunction;
+
+export { TranslateFunction, clearContext, getContext, setContext, t };

package/dist/t.server.js

@@ -0,0 +1,12 @@
+import {
+  clearContext,
+  getContext,
+  setContext,
+  t
+} from "./chunk-KNONI6DP.js";
+export {
+  clearContext,
+  getContext,
+  setContext,
+  t
+};

package/dist/types-8uKCwFda.d.ts

@@ -0,0 +1,24 @@
+import { T as TranslationMeta } from './types-Bzp6KxsI.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;
+};
+
+export type { ChunkManifest as C, ExtractedKey as E, ExtractionManifest as a };

package/dist/types-BC6K-pID.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Variable definition with optional example for CMS/documentation
+ */
+type VariableDef = {
+    example?: string;
+    description?: string;
+};
+/**
+ * Metadata for a translation key - extracted at build time, synced to CMS
+ */
+type TranslationMeta = {
+    example: string;
+    variables?: Record<string, VariableDef>;
+    description?: string;
+};
+/**
+ * Compiled translation ready for runtime use
+ */
+type CompiledTranslation = (values?: Record<string, unknown>) => string;
+/**
+ * Map of translation keys to compiled functions
+ */
+type CompiledTranslations = Record<string, CompiledTranslation>;
+/**
+ * Raw translation strings from CMS (before compilation)
+ */
+type RawTranslations = Record<string, string>;
+/**
+ * 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' | 'example' | 'throw' | ((key: string, meta?: TranslationMeta) => string);
+/**
+ * CMS adapter interface
+ */
+type CmsAdapter = {
+    /**
+     * Fetch translations for given locale and keys
+     */
+    fetch: (locale: string, keys: string[]) => Promise<RawTranslations>;
+    /**
+     * Sync extracted keys to CMS (push metadata)
+     */
+    sync?: (manifest: ExtractionManifest) => Promise<void>;
+};
+/**
+ * Integration options
+ */
+type I18nIntegrationOptions = {
+    /**
+     * Supported locales
+     */
+    locales: string[];
+    /**
+     * Default locale
+     */
+    defaultLocale: string;
+    /**
+     * Fallback behavior when translation is missing
+     * @default 'example'
+     */
+    fallback?: FallbackBehavior;
+    /**
+     * CMS adapter for fetching/syncing translations
+     */
+    cms: CmsAdapter;
+    /**
+     * Function to detect locale from request
+     * @default reads from Astro.currentLocale or Accept-Language header
+     */
+    detectLocale?: (request: Request) => string;
+};
+/**
+ * Request-scoped i18n context
+ */
+type I18nContext = {
+    locale: string;
+    translations: CompiledTranslations;
+    fallback: FallbackBehavior;
+    meta: Record<string, TranslationMeta>;
+};
+/**
+ * Global i18n config (from virtual module)
+ */
+type I18nConfig = {
+    locales: string[];
+    defaultLocale: string;
+    fallback: FallbackBehavior;
+};
+
+export type { CmsAdapter as C, ExtractedKey as E, FallbackBehavior as F, I18nIntegrationOptions as I, RawTranslations as R, TranslationMeta as T, VariableDef as V, ChunkManifest as a, CompiledTranslation as b, CompiledTranslations as c, ExtractionManifest as d, I18nContext as e, I18nConfig as f };

package/dist/types-BUV7BZML.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Variable definition with optional example for CMS/documentation
+ */
+type VariableDef = {
+    example?: string;
+    description?: string;
+};
+/**
+ * Metadata for a translation key - extracted at build time, synced to CMS
+ */
+type TranslationMeta = {
+    example: string;
+    variables?: Record<string, VariableDef>;
+    description?: string;
+};
+/**
+ * Compiled translation ready for runtime use
+ */
+type CompiledTranslation = (values?: Record<string, unknown>) => string;
+/**
+ * Map of translation keys to compiled functions
+ */
+type CompiledTranslations = Record<string, CompiledTranslation>;
+/**
+ * Raw translation strings from CMS (before compilation)
+ */
+type RawTranslations = Record<string, string>;
+/**
+ * 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 { CompiledTranslations as C, RawTranslations as R, TranslationMeta as T, VariableDef as V, CompiledTranslation as a, TranslateFunction as b };

package/dist/types-BWGB322F.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Variable definition for CMS/documentation
+ */
+type VariableDef = {
+    fallback?: string | undefined;
+    description?: string | undefined;
+};
+/**
+ * Metadata for a translation key - extracted at build time, synced to CMS
+ */
+type TranslationMeta = {
+    fallback: string;
+    variables?: Record<string, VariableDef> | undefined;
+    description?: string | undefined;
+};
+/**
+ * Compiled translation ready for runtime use
+ */
+type CompiledTranslation = (values?: Record<string, unknown> | undefined) => string;
+/**
+ * Map of translation keys to compiled functions
+ */
+type CompiledTranslations = Record<string, CompiledTranslation>;
+/**
+ * Raw translation strings from CMS (before compilation)
+ */
+type RawTranslations = Record<string, string>;
+/**
+ * Translate function signature
+ *
+ * @param key - Translation key (e.g., 'checkout.title')
+ * @param meta - Fallback string or full metadata object
+ * @param values - Runtime values for interpolation
+ *
+ * @example
+ * t('checkout.title', 'Order Summary')
+ *
+ * @example
+ * t('cart.items', '{count, plural, one {# item} other {# items}}', { count: itemCount })
+ *
+ * @example
+ * t('cart.total', { fallback: 'Total: {amount}', description: 'Cart total' }, { amount: '$49.99' })
+ */
+type TranslateFunction = (key: string, meta: TranslationMeta | string, values?: Record<string, unknown> | undefined) => string;
+
+export type { CompiledTranslations as C, RawTranslations as R, TranslateFunction as T, TranslationMeta as a };

package/dist/types-B_-RxW4A.d.ts

@@ -0,0 +1,7 @@
+import { I as I18nClientState } from './types-Bzp6KxsI.js';
+
+declare global {
+    interface Window {
+        __i18n__: I18nClientState;
+    }
+}

package/dist/types-BaaSiz9n.d.ts

@@ -0,0 +1,7 @@
+import { I as I18nClientState } from './types-CLWZeQhD.js';
+
+declare global {
+    interface Window {
+        __i18n__: I18nClientState;
+    }
+}

package/dist/types-Bgl2V5xo.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Variable definition with optional example for CMS/documentation
+ */
+type VariableDef = {
+    example?: string;
+    description?: string;
+};
+/**
+ * Metadata for a translation key - extracted at build time, synced to CMS
+ */
+type TranslationMeta = {
+    example: string;
+    variables?: Record<string, VariableDef>;
+    description?: string;
+};
+/**
+ * Compiled translation ready for runtime use
+ */
+type CompiledTranslation = (values?: Record<string, unknown>) => string;
+/**
+ * Map of translation keys to compiled functions
+ */
+type CompiledTranslations = Record<string, CompiledTranslation>;
+/**
+ * Raw translation strings from CMS (before compilation)
+ */
+type RawTranslations = Record<string, string>;
+/**
+ * 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' | 'example' | 'throw' | ((key: string, meta?: TranslationMeta) => string);
+/**
+ * Request-scoped i18n context
+ */
+type I18nContext = {
+    locale: string;
+    translations: CompiledTranslations;
+    fallback: FallbackBehavior;
+    meta: Record<string, TranslationMeta>;
+};
+/**
+ * Client-side i18n state stored on window.__i18n__
+ * Fallback is handled server-side; client just uses example from t() call if missing
+ */
+type I18nClientState = {
+    locale: string;
+    hashes: Record<string, string>;
+    translations: Record<string, string>;
+};
+/**
+ * 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;
+declare global {
+    interface Window {
+        __i18n__?: I18nClientState;
+    }
+}
+
+export type { ChunkManifest as C, ExtractedKey as E, FallbackBehavior as F, I18nContext as I, RawTranslations as R, TranslationMeta as T, VariableDef as V, CompiledTranslations as a, CompiledTranslation as b, ExtractionManifest as c, TranslateFunction as d };

package/dist/types-BwhB6IT4.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Variable definition with optional example for CMS/documentation
+ */
+type VariableDef = {
+    example?: string;
+    description?: string;
+};
+/**
+ * Metadata for a translation key - extracted at build time, synced to CMS
+ */
+type TranslationMeta = {
+    example: string;
+    variables?: Record<string, VariableDef>;
+    description?: string;
+};
+/**
+ * Compiled translation ready for runtime use
+ */
+type CompiledTranslation = (values?: Record<string, unknown>) => string;
+/**
+ * Map of translation keys to compiled functions
+ */
+type CompiledTranslations = Record<string, CompiledTranslation>;
+/**
+ * Raw translation strings from CMS (before compilation)
+ */
+type RawTranslations = Record<string, string>;
+/**
+ * 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' | 'example' | 'throw' | ((key: string, meta?: TranslationMeta) => string);
+/**
+ * CMS adapter interface
+ */
+type CmsAdapter = {
+    /**
+     * Fetch translations for given locale and keys
+     */
+    fetch: (locale: string, keys: string[]) => Promise<RawTranslations>;
+    /**
+     * Sync extracted keys to CMS (push metadata)
+     */
+    sync?: (manifest: ExtractionManifest) => Promise<void>;
+};
+/**
+ * User's i18n.ts exports
+ */
+type I18nUserConfig = {
+    /**
+     * CMS adapter for fetching/syncing translations
+     */
+    cms: CmsAdapter;
+    /**
+     * Optional chunk manifest for per-chunk loading
+     * In production, this should be loaded from build output
+     */
+    chunkManifest?: ChunkManifest;
+};
+/**
+ * Request-scoped i18n context
+ */
+type I18nContext = {
+    locale: string;
+    translations: CompiledTranslations;
+    fallback: FallbackBehavior;
+    meta: Record<string, TranslationMeta>;
+};
+/**
+ * Global i18n config (from virtual module)
+ */
+type I18nConfig = {
+    locales: string[];
+    defaultLocale: string;
+    fallback: FallbackBehavior;
+};
+/**
+ * Client-side i18n state stored on window.__i18n__
+ * Fallback is handled server-side; client just uses example from t() call if missing
+ */
+type I18nClientState = {
+    locale: string;
+    hashes: Record<string, string>;
+    translations: Record<string, string>;
+};
+declare global {
+    interface Window {
+        __i18n__?: I18nClientState;
+    }
+}
+
+export type { CmsAdapter as C, ExtractedKey as E, FallbackBehavior as F, I18nUserConfig as I, RawTranslations as R, TranslationMeta as T, VariableDef as V, ChunkManifest as a, CompiledTranslation as b, CompiledTranslations as c, ExtractionManifest as d, I18nContext as e, I18nConfig as f };

package/dist/types-Bzp6KxsI.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Variable definition for documentation
+ */
+type VariableDef = {
+    fallback?: string | undefined;
+    description?: string | undefined;
+};
+/**
+ * Metadata for a translation key - extracted at build time
+ */
+type TranslationMeta = {
+    fallback: string;
+    variables?: Record<string, VariableDef> | undefined;
+    description?: string | undefined;
+};
+/**
+ * Compiled translation ready for runtime use
+ */
+type CompiledTranslation = (values?: Record<string, unknown> | undefined) => string;
+/**
+ * Map of translation keys to compiled functions
+ */
+type CompiledTranslations = Record<string, CompiledTranslation>;
+/**
+ * Raw translation strings (before compilation)
+ */
+type RawTranslations = Record<string, string>;
+/**
+ * Client-side i18n state injected into window.__i18n__
+ */
+type I18nClientState = {
+    locale: string;
+    hashes: Record<string, string>;
+    translations: Record<string, string>;
+};
+/**
+ * Translate function
+ *
+ * @param key - translation key
+ * @param meta - fallback string or meta object with fallback
+ * @param values - runtime interpolation values (ICU MessageFormat)
+ *
+ * @example
+ * t('checkout.title', 'Order Summary')
+ * t('cart.items', '{count, plural, one {# item} other {# items}}', { count: itemCount })
+ * t('cart.total', { fallback: 'Total: {amount}' }, { amount: '$49.99' })
+ */
+type TranslateFunction = (key: string, meta: TranslationMeta | string, values?: Record<string, unknown> | undefined) => string;
+
+export type { CompiledTranslations as C, I18nClientState as I, RawTranslations as R, TranslationMeta as T, TranslateFunction as a };