@astroscope/i18n 0.1.0

package/dist/chunk-Y26535SI.js

@@ -0,0 +1,239 @@
+import {
+  runWithContext
+} from "./chunk-JJBBY2GR.js";
+import {
+  compileTranslations
+} from "./chunk-KNDYKTHE.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/i18n.ts
+var I18nSingleton = class {
+  config = null;
+  rawCache = /* @__PURE__ */ new Map();
+  compiledCache = /* @__PURE__ */ new Map();
+  chunkManifest = null;
+  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);
+    if (this.chunkManifest) {
+      this.hashCache.set(locale, computeAllChunkHashes(raw, this.chunkManifest));
+    }
+  }
+  getTranslations(locale) {
+    return this.rawCache.get(locale);
+  }
+  getCompiledTranslations(locale) {
+    return this.compiledCache.get(locale);
+  }
+  setChunkManifest(manifest) {
+    this.chunkManifest = manifest;
+    for (const [locale, raw] of this.rawCache) {
+      this.hashCache.set(locale, computeAllChunkHashes(raw, manifest));
+    }
+  }
+  getChunkManifest() {
+    return this.chunkManifest;
+  }
+  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();
+
+// src/server/middleware.ts
+var I18N_ENDPOINT_PREFIX = "/_i18n/";
+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;
+}
+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",
+      "Cache-Control": "public, max-age=31536000, immutable"
+    }
+  });
+}
+function createI18nMiddleware(options) {
+  return async (ctx, next) => {
+    const config = i18n.getConfig();
+    if (!config) {
+      throw new Error("i18n not configured. Call i18n.configure() before using i18nMiddleware.");
+    }
+    const pathname = new URL(ctx.request.url).pathname;
+    const chunkManifest = i18n.getChunkManifest();
+    if (chunkManifest) {
+      const endpointParams = parseI18nEndpointPath(pathname);
+      if (endpointParams) {
+        const { locale: urlLocale, chunkName, hash } = endpointParams;
+        const endpointRaw = i18n.getTranslations(urlLocale) ?? {};
+        return handleI18nEndpoint(chunkName, hash, endpointRaw, chunkManifest);
+      }
+    }
+    const locale = options.locale(ctx);
+    const compiled = i18n.getCompiledTranslations(locale) ?? {};
+    const raw = i18n.getTranslations(locale) ?? {};
+    const context = {
+      locale,
+      translations: compiled,
+      fallback: i18n.getFallbackBehavior(),
+      meta: {}
+    };
+    return runWithContext(context, async () => {
+      const response = await next();
+      let script;
+      const hasChunkManifest = chunkManifest && Object.keys(chunkManifest).length > 0;
+      if (hasChunkManifest) {
+        const hashes = i18n.getHashes(locale) ?? {};
+        script = generateI18nHashScript(locale, hashes);
+      } else {
+        script = generateI18nFullScript(locale, raw);
+      }
+      return injectI18nScript(response, script);
+    });
+  };
+}
+
+export {
+  computeChunkHash,
+  computeAllChunkHashes,
+  i18n,
+  detectLocale,
+  createI18nMiddleware
+};

package/dist/chunk-Y3PQX5TX.js

@@ -0,0 +1,152 @@
+import {
+  compileTranslations
+} from "./chunk-KNDYKTHE.js";
+
+// 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
+var I18nSingleton = class {
+  // normalized user config with defaults applied
+  config = null;
+  // locale -> raw translation strings (before ICU compilation)
+  rawCache = /* @__PURE__ */ new Map();
+  // locale -> compiled ICU MessageFormat functions
+  compiledCache = /* @__PURE__ */ new Map();
+  // locale -> chunk name -> content hash (for cache busting)
+  hashCache = /* @__PURE__ */ new Map();
+  // manifest getter (set by init module, provides live data in dev mode)
+  manifestGetter = null;
+  configure(config) {
+    if (!config.locales?.length) {
+      throw new Error("i18n.configure(): locales array is required and must not be empty");
+    }
+    for (const locale of config.locales) {
+      if (!locale) {
+        throw new Error("i18n.configure(): locale cannot be empty");
+      }
+      if (locale !== locale.trim()) {
+        throw new Error(`i18n.configure(): locale "${locale}" has leading or trailing whitespace`);
+      }
+    }
+    if (new Set(config.locales).size !== config.locales.length) {
+      throw new Error("i18n.configure(): locales array contains duplicates");
+    }
+    if (config.defaultLocale !== void 0) {
+      if (!config.defaultLocale) {
+        throw new Error("i18n.configure(): defaultLocale cannot be empty");
+      }
+      if (config.defaultLocale !== config.defaultLocale.trim()) {
+        throw new Error(`i18n.configure(): defaultLocale "${config.defaultLocale}" has leading or trailing whitespace`);
+      }
+      if (!config.locales.includes(config.defaultLocale)) {
+        throw new Error(`i18n.configure(): defaultLocale "${config.defaultLocale}" is not in locales array`);
+      }
+    }
+    this.config = {
+      locales: config.locales,
+      defaultLocale: config.defaultLocale ?? config.locales[0],
+      fallback: config.fallback ?? "fallback"
+    };
+    if (!this.manifestGetter) {
+      import("virtual:@astroscope/i18n/manifest").then((m) => {
+        this.manifestGetter = m.getManifest;
+      });
+    }
+  }
+  isConfigured() {
+    return this.config !== null;
+  }
+  getConfig() {
+    if (!this.config) {
+      throw new Error("i18n not configured. Call i18n.configure() first.");
+    }
+    return this.config;
+  }
+  setTranslations(locale, raw) {
+    this.rawCache.set(locale, raw);
+    this.compiledCache.set(locale, compileTranslations(locale, raw));
+    this.hashCache.delete(locale);
+    const { chunks } = this.getManifest();
+    if (Object.keys(chunks).length > 0) {
+      this.hashCache.set(locale, computeAllChunkHashes(raw, chunks));
+    }
+  }
+  getTranslations(locale) {
+    return this.rawCache.get(locale) ?? {};
+  }
+  getCompiledTranslations(locale) {
+    return this.compiledCache.get(locale) ?? {};
+  }
+  /**
+   * Get the extraction manifest (keys + chunks).
+   * - keys: translation keys extracted from codebase with metadata
+   * - chunks: mapping of chunk names to their translation keys
+   */
+  getManifest() {
+    if (!this.manifestGetter) {
+      throw new Error("i18n manifest not initialized. Call i18n.configure() first.");
+    }
+    return this.manifestGetter();
+  }
+  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();
+
+// 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 {
+  i18n,
+  runWithContext,
+  getContext
+};