@astroscope/i18n 0.1.0

package/dist/client/t.d.ts

@@ -0,0 +1,20 @@
+import { a as TranslateFunction } from '../types-Bzp6KxsI.js';
+import '../types-B_-RxW4A.js';
+
+declare function getLocale(): string;
+/**
+ * Client-side translate function
+ *
+ * Reads from window.__i18n__.translations (injected per-chunk).
+ * In production, translations are always loaded before component code runs
+ * via the chunk loader injected by the Vite plugin.
+ *
+ * Call patterns:
+ * - Development: t('key', 'fallback') or t('key', 'fallback', values)
+ * - Production: t('key') or t('key', undefined, values)
+ *
+ * Falls back to meta.fallback (dev) or key (prod) when translation is missing.
+ */
+declare const t: TranslateFunction;
+
+export { getLocale, t };

package/dist/client/t.js

@@ -0,0 +1,37 @@
+import {
+  normalizeMeta
+} from "../chunk-EMM6LRO2.js";
+import {
+  compileMessage
+} from "../chunk-KNDYKTHE.js";
+
+// src/client/t.ts
+var cache = /* @__PURE__ */ new Map();
+function getLocale() {
+  return window.__i18n__.locale;
+}
+var t = ((key, meta, values) => {
+  const normalizedMeta = meta ? normalizeMeta(meta) : { fallback: "" };
+  const raw = window.__i18n__.translations[key];
+  if (!raw) {
+    if (normalizedMeta.fallback) {
+      let compiled2 = cache.get(`__fallback__${key}`);
+      if (!compiled2) {
+        compiled2 = compileMessage(window.__i18n__.locale, normalizedMeta.fallback);
+        cache.set(`__fallback__${key}`, compiled2);
+      }
+      return compiled2(values);
+    }
+    return key;
+  }
+  let compiled = cache.get(key);
+  if (!compiled) {
+    compiled = compileMessage(window.__i18n__.locale, raw);
+    cache.set(key, compiled);
+  }
+  return compiled(values);
+});
+export {
+  getLocale,
+  t
+};

package/dist/client-directives/idle.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:idle directive
+ * Loads translations in parallel before delegating to Astro's original idle directive
+ */
+declare const idleDirective: ClientDirective;
+
+export { idleDirective as default };

package/dist/client-directives/idle.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../chunk-ESFGCYYH.js";
+import "../chunk-FI5KZ5IO.js";
+
+// src/client-directives/idle.ts
+import originalIdle from "astro/client/idle.js";
+var idleDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalIdle(load, options, el);
+};
+var idle_default = idleDirective;
+export {
+  idle_default as default
+};

package/dist/client-directives/load.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:load directive
+ * Loads translations in parallel before delegating to Astro's original load directive
+ */
+declare const loadDirective: ClientDirective;
+
+export { loadDirective as default };

package/dist/client-directives/load.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../chunk-ESFGCYYH.js";
+import "../chunk-FI5KZ5IO.js";
+
+// src/client-directives/load.ts
+import originalLoad from "astro/client/load.js";
+var loadDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalLoad(load, options, el);
+};
+var load_default = loadDirective;
+export {
+  load_default as default
+};

package/dist/client-directives/media.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:media directive
+ * Loads translations in parallel before delegating to Astro's original media directive
+ */
+declare const mediaDirective: ClientDirective;
+
+export { mediaDirective as default };

package/dist/client-directives/media.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../chunk-ESFGCYYH.js";
+import "../chunk-FI5KZ5IO.js";
+
+// src/client-directives/media.ts
+import originalMedia from "astro/client/media.js";
+var mediaDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalMedia(load, options, el);
+};
+var media_default = mediaDirective;
+export {
+  media_default as default
+};

package/dist/client-directives/only.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:only directive
+ * Loads translations in parallel before delegating to Astro's original only directive
+ */
+declare const onlyDirective: ClientDirective;
+
+export { onlyDirective as default };

package/dist/client-directives/only.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../chunk-ESFGCYYH.js";
+import "../chunk-FI5KZ5IO.js";
+
+// src/client-directives/only.ts
+import originalOnly from "astro/client/only.js";
+var onlyDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalOnly(load, options, el);
+};
+var only_default = onlyDirective;
+export {
+  only_default as default
+};

package/dist/client-directives/utils.d.ts

@@ -0,0 +1,9 @@
+import '../types-DWhsmSPP.js';
+
+/**
+ * Load translations for a chunk before hydration
+ * Extracts chunk name from astro-island's component-url attribute
+ */
+declare function loadI18nForChunk(el: HTMLElement): Promise<void>;
+
+export { loadI18nForChunk };

package/dist/client-directives/utils.js

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

package/dist/client-directives/visible.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:visible directive
+ * Loads translations in parallel before delegating to Astro's original visible directive
+ */
+declare const visibleDirective: ClientDirective;
+
+export { visibleDirective as default };

package/dist/client-directives/visible.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../chunk-ESFGCYYH.js";
+import "../chunk-FI5KZ5IO.js";
+
+// src/client-directives/visible.ts
+import originalVisible from "astro/client/visible.js";
+var visibleDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalVisible(load, options, el);
+};
+var visible_default = visibleDirective;
+export {
+  visible_default as default
+};

package/dist/extraction/index.d.ts

@@ -0,0 +1,34 @@
+import { a as ExtractionManifest } from '../types-8uKCwFda.js';
+export { C as ChunkManifest, E as ExtractedKey } from '../types-8uKCwFda.js';
+import { AstroIntegrationLogger } from 'astro';
+import { Plugin } from 'vite';
+import '../types-Bzp6KxsI.js';
+
+/**
+ * Manifest state management for i18n extraction
+ *
+ * Separated from vite-plugin to avoid bundling Babel at runtime
+ */
+
+/**
+ * Get the current extraction manifest (for dev mode live access).
+ * This bypasses Vite's module caching to return fresh data.
+ */
+declare function getManifest(): ExtractionManifest;
+
+type I18nVitePluginOptions = {
+    logger: AstroIntegrationLogger;
+};
+/**
+ * Vite plugin for i18n extraction, chunk mapping, and loader injection
+ *
+ * This plugin:
+ * 1. Extracts all t() calls using Babel AST parsing
+ * 2. Strips fallback arguments in production builds
+ * 3. Maps translation keys to output chunks
+ * 4. Generates a manifest for syncing with translation providers
+ * 5. Injects translation loader into chunks that use t()
+ */
+declare function i18nVitePlugin(options: I18nVitePluginOptions): Plugin;
+
+export { ExtractionManifest, type I18nVitePluginOptions, getManifest, i18nVitePlugin };

package/dist/extraction/index.js

@@ -0,0 +1,9 @@
+import {
+  getManifest,
+  i18nVitePlugin
+} from "../chunk-JJEDOJBR.js";
+import "../chunk-4A5BKHFN.js";
+export {
+  getManifest,
+  i18nVitePlugin
+};

package/dist/i18n-3cZHoHwP.d.ts

@@ -0,0 +1,86 @@
+import { a as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-CLWZeQhD.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 hashCache;
+    private manifest;
+    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 translation provider with keys extracted from the codebase.
+     */
+    getExtractedKeys(): ExtractedKey[];
+    /**
+     * Get the full extraction manifest (keys + chunks).
+     * In dev mode, keys are available live but chunks are empty.
+     * In build mode, both keys and chunk mappings are populated.
+     */
+    getExtractionManifest(): ExtractionManifest;
+    /**
+     * Set the extraction manifest (called by middleware entrypoint).
+     * @internal
+     */
+    setManifest(manifest: ExtractionManifest): void;
+    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 I18nContext as I, type I18nConfig as a, type ExtractionManifest as b, i18n as i };

package/dist/i18n-BGfrSNM8.d.ts

@@ -0,0 +1,56 @@
+import { a as ExtractionManifest } from './types-8uKCwFda.js';
+import { T as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-Bzp6KxsI.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 mergedCache;
+    private compiledCache;
+    private hashCache;
+    private manifestGetter;
+    configure(config: I18nConfig): Promise<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-BHU81LMA.d.ts

@@ -0,0 +1,55 @@
+import { a as ExtractionManifest } from './types-8uKCwFda.js';
+import { T as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-Bzp6KxsI.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): Promise<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-BagoeH4_.d.ts

@@ -0,0 +1,62 @@
+import { E as ExtractionManifest } from './types-C6rOJFY2.js';
+import { a as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-CLWZeQhD.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;
+    /**
+     * Set the manifest getter function (called by init module).
+     * In dev mode, this returns live data from the vite plugin.
+     * In production, this returns the static manifest loaded from JSON.
+     * @internal
+     */
+    setManifestGetter(getter: () => ExtractionManifest): void;
+    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 I18nContext as I, type I18nConfig as a, i18n as i };

package/dist/i18n-BeL84090.d.ts

@@ -0,0 +1,77 @@
+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;
+    meta: Record<string, TranslationMeta>;
+};
+
+type I18nConfig = {
+    locales: string[];
+    defaultLocale?: string | undefined;
+    fallback?: FallbackBehavior | undefined;
+};
+declare class I18nSingleton {
+    private config;
+    private rawCache;
+    private compiledCache;
+    private extractionManifest;
+    private hashCache;
+    configure(config: I18nConfig): void;
+    getConfig(): I18nConfig | null;
+    getDefaultLocale(): string | undefined;
+    getFallbackBehavior(): FallbackBehavior;
+    setTranslations(locale: string, raw: RawTranslations): void;
+    getTranslations(locale: string): RawTranslations | undefined;
+    getCompiledTranslations(locale: string): CompiledTranslations | undefined;
+    getChunkManifest(): ChunkManifest | null;
+    /**
+     * 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> | undefined;
+    /**
+     * 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/i18n-BeRWDfHi.d.ts

@@ -0,0 +1,55 @@
+import { a as ExtractionManifest } from './types-DsNK_9sI.js';
+import { T as TranslationMeta, C as CompiledTranslations, R as RawTranslations } from './types-CiIDN2sW.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): Promise<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 };