@astroscope/i18n 0.1.0

package/dist/chunk-IPJWKKHJ.js

@@ -0,0 +1,324 @@
+import {
+  clearContext,
+  compileTranslations,
+  setContext
+} from "./chunk-AYY2YIBQ.js";
+
+// src/extraction/hash.ts
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36).substring(0, 8);
+}
+function computeChunkHash(translations, keys) {
+  const relevantTranslations = {};
+  for (const key of keys.sort()) {
+    if (translations[key]) {
+      relevantTranslations[key] = translations[key];
+    }
+  }
+  return hashString(JSON.stringify(relevantTranslations));
+}
+function computeAllChunkHashes(translations, manifest) {
+  const hashes = {};
+  for (const [chunkId, keys] of Object.entries(manifest)) {
+    hashes[chunkId] = computeChunkHash(translations, keys);
+  }
+  return hashes;
+}
+
+// src/server/service.ts
+var instance = null;
+function createI18nService(config) {
+  if (instance) {
+    throw new Error("i18n service already created. Call createI18nService() only once.");
+  }
+  instance = new I18nServiceImpl(config);
+  return instance;
+}
+function getI18nService() {
+  if (!instance) {
+    throw new Error(
+      "i18n service not initialized. Call createI18nService() before first request (e.g., in your boot file)."
+    );
+  }
+  return instance;
+}
+function hasI18nService() {
+  return instance !== null;
+}
+var I18nServiceImpl = class {
+  config;
+  // raw translation cache per locale
+  rawCache = /* @__PURE__ */ new Map();
+  // compiled translation cache per locale
+  compiledCache = /* @__PURE__ */ new Map();
+  // hash cache per locale (for per-chunk loading)
+  hashCache = /* @__PURE__ */ new Map();
+  // chunk manifest from build
+  chunkManifest;
+  // track in-progress fetches to avoid duplicate requests
+  fetchInProgress = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = Object.freeze({ ...config });
+  }
+  invalidate(locales) {
+    const targets = this.resolveLocales(locales);
+    for (const locale of targets) {
+      this.rawCache.delete(locale);
+      this.compiledCache.delete(locale);
+      this.hashCache.delete(locale);
+      this.fetchInProgress.delete(locale);
+    }
+  }
+  async refresh(locales) {
+    const targets = this.resolveLocales(locales);
+    const fetches = targets.map(async (locale) => {
+      const raw = await this.fetchTranslations(locale);
+      return { locale, raw };
+    });
+    const results = await Promise.all(fetches);
+    for (const { locale, raw } of results) {
+      this.rawCache.set(locale, raw);
+      this.compiledCache.set(locale, compileTranslations(locale, raw));
+      if (this.chunkManifest) {
+        this.hashCache.set(locale, computeAllChunkHashes(raw, this.chunkManifest));
+      }
+    }
+  }
+  async prefetch(locales) {
+    const targets = this.resolveLocales(locales);
+    await Promise.all(
+      targets.map(async (locale) => {
+        if (this.rawCache.has(locale)) return;
+        const raw = await this.fetchTranslations(locale);
+        this.rawCache.set(locale, raw);
+        this.compiledCache.set(locale, compileTranslations(locale, raw));
+        if (this.chunkManifest) {
+          this.hashCache.set(locale, computeAllChunkHashes(raw, this.chunkManifest));
+        }
+      })
+    );
+  }
+  async getTranslations(locale) {
+    const cached = this.compiledCache.get(locale);
+    if (cached) return cached;
+    const raw = await this.ensureRawTranslations(locale);
+    const compiled = compileTranslations(locale, raw);
+    this.compiledCache.set(locale, compiled);
+    return compiled;
+  }
+  async getRawTranslations(locale) {
+    return this.ensureRawTranslations(locale);
+  }
+  getHashes(locale) {
+    return this.hashCache.get(locale);
+  }
+  setChunkManifest(manifest) {
+    this.chunkManifest = manifest;
+    if (manifest) {
+      for (const [locale, raw] of this.rawCache) {
+        this.hashCache.set(locale, computeAllChunkHashes(raw, manifest));
+      }
+    }
+  }
+  getChunkManifest() {
+    return this.chunkManifest;
+  }
+  /**
+   * Ensure raw translations are cached, fetching if needed
+   */
+  async ensureRawTranslations(locale) {
+    const cached = this.rawCache.get(locale);
+    if (cached) return cached;
+    const raw = await this.fetchTranslations(locale);
+    this.rawCache.set(locale, raw);
+    if (this.chunkManifest) {
+      this.hashCache.set(locale, computeAllChunkHashes(raw, this.chunkManifest));
+    }
+    return raw;
+  }
+  /**
+   * Fetch translations, deduplicating concurrent requests
+   */
+  async fetchTranslations(locale) {
+    const inProgress = this.fetchInProgress.get(locale);
+    if (inProgress) return inProgress;
+    const fetchPromise = this.config.fetch(locale, []).finally(() => {
+      this.fetchInProgress.delete(locale);
+    });
+    this.fetchInProgress.set(locale, fetchPromise);
+    return fetchPromise;
+  }
+  /**
+   * Resolve locale argument to array of locales
+   */
+  resolveLocales(locales) {
+    if (!locales) return this.config.locales;
+    if (typeof locales === "string") return [locales];
+    return locales;
+  }
+};
+
+// src/server/middleware.ts
+var I18N_ENDPOINT_PREFIX = "/_i18n/";
+function defaultDetectLocale(request, locales, defaultLocale) {
+  const url = new URL(request.url);
+  const localeParam = url.searchParams.get("locale");
+  if (localeParam && locales.includes(localeParam)) {
+    return localeParam;
+  }
+  const acceptLanguage = request.headers.get("accept-language");
+  if (acceptLanguage) {
+    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 defaultLocale;
+}
+function generateI18nHashScript(locale, hashes) {
+  const state = { locale, hashes, translations: {} };
+  return `<script>window.__i18n__=${JSON.stringify(state)};</script>`;
+}
+function generateI18nFullScript(locale, raw) {
+  const state = { locale, hashes: {}, translations: raw };
+  return `<script>window.__i18n__=${JSON.stringify(state)};</script>`;
+}
+async function injectI18nScript(response, script) {
+  const contentType = response.headers.get("content-type");
+  if (!contentType?.includes("text/html")) {
+    return response;
+  }
+  const html = await response.text();
+  let injectedHtml;
+  if (html.includes("</head>")) {
+    injectedHtml = html.replace("</head>", `${script}</head>`);
+  } else if (html.includes("<body")) {
+    injectedHtml = html.replace(/<body([^>]*)>/, `<body$1>${script}`);
+  } else {
+    injectedHtml = script + html;
+  }
+  return new Response(injectedHtml, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function parseI18nEndpointPath(pathname) {
+  if (!pathname.startsWith(I18N_ENDPOINT_PREFIX)) {
+    return null;
+  }
+  const path = pathname.slice(I18N_ENDPOINT_PREFIX.length);
+  const match = path.match(/^([^/]+)\/(.+)\.([a-z0-9]+)\.js$/);
+  if (!match) {
+    return null;
+  }
+  return { locale: match[1], chunkName: match[2], hash: match[3] };
+}
+function handleI18nEndpoint(chunkName, requestedHash, translations, chunkManifest) {
+  const keys = chunkManifest[chunkName];
+  if (!keys) {
+    return new Response(`/* chunk not found: ${chunkName} */`, {
+      status: 404,
+      headers: { "Content-Type": "application/javascript" }
+    });
+  }
+  const actualHash = computeChunkHash(translations, keys);
+  if (requestedHash !== actualHash) {
+    console.warn(`[i18n] hash mismatch for ${chunkName}: expected ${actualHash}, got ${requestedHash}`);
+  }
+  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)});
+})();
+`;
+  return new Response(js, {
+    status: 200,
+    headers: {
+      "Content-Type": "application/javascript",
+      // immutable cache - hash in URL ensures cache busting
+      "Cache-Control": "public, max-age=31536000, immutable"
+    }
+  });
+}
+function createI18nMiddleware(options) {
+  const { locales, defaultLocale, fallback, detectLocale, chunkManifest } = options;
+  const service = getI18nService();
+  if (chunkManifest) {
+    service.setChunkManifest(chunkManifest);
+  }
+  return async (ctx, next) => {
+    const pathname = new URL(ctx.request.url).pathname;
+    const serviceChunkManifest = service.getChunkManifest();
+    if (serviceChunkManifest) {
+      const endpointParams = parseI18nEndpointPath(pathname);
+      if (endpointParams) {
+        const { locale: urlLocale, chunkName, hash } = endpointParams;
+        const endpointRaw = await service.getRawTranslations(urlLocale);
+        return handleI18nEndpoint(chunkName, hash, endpointRaw, serviceChunkManifest);
+      }
+    }
+    const locale = detectLocale ? detectLocale(ctx.request) : ctx.currentLocale ?? defaultDetectLocale(ctx.request, locales, defaultLocale);
+    const translations = await service.getTranslations(locale);
+    const raw = await service.getRawTranslations(locale);
+    const context = {
+      locale,
+      translations,
+      fallback,
+      meta: {}
+    };
+    setContext(context);
+    try {
+      const response = await next();
+      let script;
+      const hasChunkManifest = serviceChunkManifest && Object.keys(serviceChunkManifest).length > 0;
+      if (hasChunkManifest) {
+        const hashes = service.getHashes(locale) ?? {};
+        script = generateI18nHashScript(locale, hashes);
+      } else {
+        script = generateI18nFullScript(locale, raw);
+      }
+      const injectedResponse = await injectI18nScript(response, script);
+      return injectedResponse;
+    } finally {
+      clearContext();
+    }
+  };
+}
+function clearTranslationCache(locale) {
+  getI18nService().invalidate(locale);
+}
+async function getCachedTranslations(locale) {
+  return getI18nService().getRawTranslations(locale);
+}
+
+export {
+  computeChunkHash,
+  computeAllChunkHashes,
+  createI18nService,
+  getI18nService,
+  hasI18nService,
+  createI18nMiddleware,
+  clearTranslationCache,
+  getCachedTranslations
+};

package/dist/chunk-ITTL4V7J.js

@@ -0,0 +1,24 @@
+import {
+  buildI18nChunkUrl,
+  componentUrlToChunkName
+} from "./chunk-LMTEO22Y.js";
+
+// src/client/directives/utils.ts
+async function loadI18nForChunk(el) {
+  const componentUrl = el.getAttribute("component-url");
+  if (!componentUrl) return;
+  const chunkName = componentUrlToChunkName(componentUrl);
+  const i18n = window.__i18n__;
+  const hash = i18n.hashes[chunkName];
+  if (hash) {
+    const url = buildI18nChunkUrl(i18n.locale, chunkName, hash);
+    await import(
+      /* @vite-ignore */
+      url
+    );
+  }
+}
+
+export {
+  loadI18nForChunk
+};

package/dist/chunk-IWUBCMOK.js

@@ -0,0 +1,128 @@
+import {
+  compileTranslations
+} from "./chunk-KNDYKTHE.js";
+
+// src/server/i18n.ts
+import fs from "fs";
+
+// src/extraction/hash.ts
+import { createHash } from "crypto";
+function hashString(str) {
+  return createHash("sha256").update(str).digest("hex").substring(0, 8);
+}
+function computeChunkHash(translations, keys) {
+  const relevantTranslations = {};
+  for (const key of keys.sort()) {
+    if (translations[key]) {
+      relevantTranslations[key] = translations[key];
+    }
+  }
+  return hashString(JSON.stringify(relevantTranslations));
+}
+function computeAllChunkHashes(translations, manifest) {
+  const hashes = {};
+  for (const [chunkId, keys] of Object.entries(manifest)) {
+    hashes[chunkId] = computeChunkHash(translations, keys);
+  }
+  return hashes;
+}
+
+// src/server/i18n.ts
+function loadExtractionManifest() {
+  const candidates = [
+    "./i18n-manifest.json",
+    // same directory
+    "../i18n-manifest.json"
+    // parent (when code is in chunks/)
+  ];
+  for (const candidate of candidates) {
+    try {
+      const manifestPath = new URL(candidate, import.meta.url);
+      const content = fs.readFileSync(manifestPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  return void 0;
+}
+var I18nSingleton = class {
+  config = null;
+  rawCache = /* @__PURE__ */ new Map();
+  compiledCache = /* @__PURE__ */ new Map();
+  extractionManifest = void 0;
+  // undefined = not loaded yet
+  hashCache = /* @__PURE__ */ new Map();
+  configure(config) {
+    this.config = config;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getDefaultLocale() {
+    return this.config?.defaultLocale ?? this.config?.locales[0];
+  }
+  getFallbackBehavior() {
+    return this.config?.fallback ?? "fallback";
+  }
+  setTranslations(locale, raw) {
+    this.rawCache.set(locale, raw);
+    this.compiledCache.set(locale, compileTranslations(locale, raw));
+    this.hashCache.delete(locale);
+    const chunks = this.getChunkManifest();
+    if (chunks) {
+      this.hashCache.set(locale, computeAllChunkHashes(raw, chunks));
+    }
+  }
+  getTranslations(locale) {
+    return this.rawCache.get(locale) ?? {};
+  }
+  getCompiledTranslations(locale) {
+    return this.compiledCache.get(locale) ?? {};
+  }
+  getChunkManifest() {
+    return this.getExtractionManifest()?.chunks ?? {};
+  }
+  /**
+   * Get extracted translation keys with metadata.
+   * Use this to populate your CMS with keys extracted from the codebase.
+   */
+  getExtractedKeys() {
+    return this.getExtractionManifest()?.keys ?? null;
+  }
+  /**
+   * Get the full extraction manifest (keys + chunks).
+   * Returns null in dev mode (manifest doesn't exist).
+   */
+  getExtractionManifest() {
+    if (this.extractionManifest === void 0) {
+      this.extractionManifest = loadExtractionManifest() ?? null;
+    }
+    return this.extractionManifest;
+  }
+  getHashes(locale) {
+    return this.hashCache.get(locale) ?? {};
+  }
+  /**
+   * Clear translations for specified locale(s).
+   * @param locales - Locale(s) to clear, or all if not specified
+   */
+  clear(locales) {
+    const targets = this.resolveLocales(locales);
+    for (const locale of targets) {
+      this.rawCache.delete(locale);
+      this.compiledCache.delete(locale);
+      this.hashCache.delete(locale);
+    }
+  }
+  resolveLocales(locales) {
+    if (!locales) return this.config?.locales ?? [];
+    if (typeof locales === "string") return [locales];
+    return locales;
+  }
+};
+var i18n = new I18nSingleton();
+
+export {
+  computeChunkHash,
+  i18n
+};

package/dist/chunk-JJBBY2GR.js

@@ -0,0 +1,14 @@
+// src/server/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var als = new AsyncLocalStorage();
+function runWithContext(context, fn) {
+  return als.run(context, fn);
+}
+function getContext() {
+  return als.getStore() ?? null;
+}
+
+export {
+  runWithContext,
+  getContext
+};

package/dist/chunk-JJEDOJBR.js

@@ -0,0 +1,193 @@
+import {
+  chunkIdToName
+} from "./chunk-4A5BKHFN.js";
+
+// src/extraction/manifest.ts
+import path from "path";
+var I18N_MANIFEST_GLOBAL_KEY = "__astroscope_i18n_manifest__";
+function getGlobalState() {
+  const g = globalThis;
+  if (!g[I18N_MANIFEST_GLOBAL_KEY]) {
+    g[I18N_MANIFEST_GLOBAL_KEY] = {
+      extractedKeys: [],
+      chunkManifest: {},
+      projectRoot: ""
+    };
+  }
+  return g[I18N_MANIFEST_GLOBAL_KEY];
+}
+function getManifest() {
+  const state = getGlobalState();
+  const keys = state.extractedKeys.map((key) => ({
+    ...key,
+    // make file paths relative to project root for better readability
+    // and avoiding leaking absolute paths from dev or ci environments
+    file: state.projectRoot ? path.relative(state.projectRoot, key.file) : key.file
+  }));
+  return { keys, chunks: state.chunkManifest };
+}
+
+// src/extraction/vite-plugin.ts
+import fs from "fs";
+import path2 from "path";
+import MagicString from "magic-string";
+var VIRTUAL_MODULE_ID = "virtual:@astroscope/i18n/manifest";
+var isVirtualModuleId = (id) => id === VIRTUAL_MODULE_ID || id.startsWith(`${VIRTUAL_MODULE_ID}?`);
+var RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+var isResolvedVirtualModuleId = (id) => id === RESOLVED_VIRTUAL_MODULE_ID || id.startsWith(`\0${VIRTUAL_MODULE_ID}?`);
+var MANIFEST_FILE_NAME = "i18n-manifest.json";
+var INCLUDE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".astro"];
+function i18nVitePlugin(options) {
+  const { logger } = options;
+  const extractedKeys = [];
+  const fileToKeys = /* @__PURE__ */ new Map();
+  const filesWithI18n = /* @__PURE__ */ new Set();
+  let isBuild = false;
+  let isSSR = false;
+  return {
+    name: "@astroscope/i18n/extract",
+    enforce: "pre",
+    configResolved(config) {
+      const state = getGlobalState();
+      state.projectRoot = config.root;
+      state.extractedKeys = extractedKeys;
+      isBuild = config.command === "build";
+      isSSR = !!config.build.ssr;
+    },
+    resolveId(id) {
+      if (isVirtualModuleId(id)) {
+        return `\0${id}`;
+      }
+    },
+    load(id) {
+      if (isResolvedVirtualModuleId(id)) {
+        if (isBuild) {
+          return `
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const manifestJson = JSON.parse(readFileSync(join(__dirname, '${MANIFEST_FILE_NAME}'), 'utf-8'));
+
+export const manifest = manifestJson;
+export function getManifest() { return manifestJson; }
+`;
+        }
+        return `
+import { getManifest as _getManifest } from '@astroscope/i18n/extraction';
+export const manifest = { keys: [], chunks: {} };
+export function getManifest() { return _getManifest(); }
+`;
+      }
+    },
+    async transform(code, filename) {
+      if (!INCLUDE_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
+        return null;
+      }
+      if (filename.includes("node_modules")) {
+        return null;
+      }
+      if (!code.includes("@astroscope/i18n/t")) {
+        return null;
+      }
+      filesWithI18n.add(filename);
+      const fileKeys = [];
+      const [{ transformAsync }, { i18nExtractPlugin }] = await Promise.all([
+        import("@babel/core"),
+        import("./babel-plugin-K2K4ZPM5.js")
+      ]);
+      const result = await transformAsync(code, {
+        filename,
+        sourceMaps: true,
+        babelrc: false,
+        configFile: false,
+        parserOpts: {
+          plugins: [
+            ...filename.endsWith(".ts") || filename.endsWith(".tsx") ? ["typescript"] : [],
+            ...filename.endsWith(".jsx") || filename.endsWith(".tsx") ? ["jsx"] : []
+          ]
+        },
+        plugins: [
+          [
+            i18nExtractPlugin,
+            {
+              stripFallbacks: isBuild,
+              // only strip in production
+              onKeyExtracted: (key) => fileKeys.push(key),
+              logger
+            }
+          ]
+        ]
+      });
+      if (fileKeys.length > 0) {
+        extractedKeys.push(...fileKeys);
+        fileToKeys.set(
+          filename,
+          fileKeys.map((k) => k.key)
+        );
+      }
+      if (isBuild && result?.code) {
+        return { code: result.code, map: result.map };
+      }
+      return null;
+    },
+    generateBundle(_, bundle) {
+      const state = getGlobalState();
+      state.chunkManifest = {};
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "chunk" && chunk.moduleIds) {
+          const keys = /* @__PURE__ */ new Set();
+          let hasI18nModule = false;
+          for (const moduleId of chunk.moduleIds) {
+            const moduleKeys = fileToKeys.get(moduleId);
+            moduleKeys?.forEach((k) => keys.add(k));
+            if (filesWithI18n.has(moduleId)) {
+              hasI18nModule = true;
+            }
+          }
+          const chunkName = chunkIdToName(fileName.replace(/\.js$/, ""));
+          if (keys.size) {
+            state.chunkManifest[chunkName] = Array.from(keys);
+          }
+          if (hasI18nModule) {
+            const loaderCode = `
+/* @astroscope/i18n loader */
+if (typeof window !== 'undefined' && window.__i18n__) {
+  const __i18n__ = window.__i18n__;
+  const __i18n_hash__ = __i18n__.hashes[${JSON.stringify(chunkName)}];
+  if (__i18n_hash__) {
+    await import(\`/_i18n/\${__i18n__.locale}/${chunkName}.\${__i18n_hash__}.js\`);
+  }
+}
+/* end @astroscope/i18n loader */
+`;
+            const s = new MagicString(chunk.code);
+            s.prepend(loaderCode);
+            chunk.code = s.toString();
+            if (chunk.map) {
+              chunk.map = s.generateMap({ hires: true });
+            }
+          }
+        }
+      }
+      logger.info(`manifest: ${Object.keys(state.chunkManifest).length} chunks, ${extractedKeys.length} keys`);
+    },
+    writeBundle(outputOptions) {
+      if (!isSSR && outputOptions.dir) {
+        const chunksDir = path2.resolve(outputOptions.dir, "..", "server", "chunks");
+        const manifestPath = path2.join(chunksDir, MANIFEST_FILE_NAME);
+        if (fs.existsSync(chunksDir)) {
+          fs.writeFileSync(manifestPath, JSON.stringify(getManifest()));
+        } else {
+          logger.error(`server chunks directory not found, cannot write manifest to ${manifestPath}`);
+        }
+      }
+    }
+  };
+}
+
+export {
+  getManifest,
+  i18nVitePlugin
+};

package/dist/chunk-JTUKXNIJ.js

@@ -0,0 +1,23 @@
+import {
+  buildI18nChunkUrl,
+  chunkIdToName
+} from "./chunk-HHRMR3TM.js";
+
+// src/client/import-with-i18n.ts
+async function importWithI18n(importFn, chunkId) {
+  const i18n = window.__i18n__;
+  const chunkName = chunkId ? chunkIdToName(chunkId) : void 0;
+  const hash = chunkName ? i18n.hashes[chunkName] : void 0;
+  const [module] = await Promise.all([
+    importFn(),
+    hash && chunkName ? import(
+      /* @vite-ignore */
+      buildI18nChunkUrl(i18n.locale, chunkName, hash)
+    ) : Promise.resolve()
+  ]);
+  return module;
+}
+
+export {
+  importWithI18n
+};