@astroscope/i18n 0.1.0

package/dist/chunk-T6WV5DW6.js

@@ -0,0 +1,156 @@
+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) {
+    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"
+    };
+  }
+  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.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 {
+  i18n
+};

package/dist/chunk-TGUXVDA3.js

@@ -0,0 +1,82 @@
+import {
+  clearContext,
+  compileTranslations,
+  setContext
+} from "./chunk-KNONI6DP.js";
+
+// src/middleware.ts
+function defaultDetectLocale(request, locales, defaultLocale) {
+  const acceptLanguage = request.headers.get("accept-language");
+  if (!acceptLanguage) {
+    return defaultLocale;
+  }
+  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;
+}
+var translationCache = /* @__PURE__ */ new Map();
+function generateI18nScript(locale, raw, fallback) {
+  const fallbackValue = typeof fallback === "function" ? "example" : fallback;
+  return `<script>window.__i18n_locale__=${JSON.stringify(locale)};window.__i18n_fallback__=${JSON.stringify(fallbackValue)};window.__i18n__=${JSON.stringify(raw)};</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 createI18nMiddleware(options) {
+  const { locales, defaultLocale, fallback, cms, detectLocale } = options;
+  return async (ctx, next) => {
+    const locale = detectLocale ? detectLocale(ctx.request) : ctx.currentLocale ?? defaultDetectLocale(ctx.request, locales, defaultLocale);
+    let raw = translationCache.get(locale);
+    if (!raw) {
+      raw = await cms.fetch(locale, []);
+      translationCache.set(locale, raw);
+    }
+    const translations = compileTranslations(locale, raw);
+    const context = {
+      locale,
+      translations,
+      fallback,
+      meta: {}
+    };
+    setContext(context);
+    try {
+      const response = await next();
+      const script = generateI18nScript(locale, raw, fallback);
+      const injectedResponse = await injectI18nScript(response, script);
+      return injectedResponse;
+    } finally {
+      clearContext();
+    }
+  };
+}
+
+export {
+  createI18nMiddleware
+};

package/dist/chunk-TYMO7K3A.js

@@ -0,0 +1,173 @@
+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();
+  // extraction manifest getter (lazy-loads from virtual module)
+  manifestGetter = null;
+  // cached manifest (populated after first async fetch)
+  manifestCache = 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"
+    };
+  }
+  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.getChunkManifest();
+    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) ?? {};
+  }
+  getChunkManifest() {
+    return this.getExtractionManifest().chunks;
+  }
+  /**
+   * Get extracted translation keys with metadata (sync, uses cached manifest).
+   * Use getExtractedKeysAsync() for fresh data in dev mode.
+   */
+  getExtractedKeys() {
+    return this.getExtractionManifest().keys;
+  }
+  /**
+   * Async fetch of extracted translation keys with metadata.
+   * In dev mode, this re-imports the virtual module to get freshly extracted keys.
+   * Use this to populate your translation provider with keys extracted from the codebase.
+   */
+  async getExtractedKeysAsync() {
+    const manifest = await this.getExtractionManifestAsync();
+    return manifest.keys;
+  }
+  /**
+   * Get the full extraction manifest (keys + chunks).
+   * Returns cached manifest or empty default if not yet fetched.
+   * Use getExtractionManifestAsync() for fresh data in dev mode.
+   */
+  getExtractionManifest() {
+    return this.manifestCache ?? { keys: [], chunks: {} };
+  }
+  /**
+   * Async fetch of extraction manifest.
+   * In dev mode, this re-imports the virtual module to get fresh extracted keys.
+   * In build mode, returns the cached manifest.
+   */
+  async getExtractionManifestAsync() {
+    if (!this.manifestGetter) {
+      return this.manifestCache ?? { keys: [], chunks: {} };
+    }
+    const manifest = await this.manifestGetter();
+    this.manifestCache = manifest;
+    return manifest;
+  }
+  /**
+   * Set the manifest getter function (called by init module).
+   * @internal
+   */
+  setManifestGetter(getter) {
+    this.manifestGetter = getter;
+  }
+  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 {
+  i18n
+};

package/dist/chunk-V4RBFLQL.js

@@ -0,0 +1,23 @@
+import {
+  buildI18nChunkUrl,
+  chunkIdToName
+} from "./chunk-LMTEO22Y.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
+};

package/dist/chunk-V4XWJXXZ.js

@@ -0,0 +1,23 @@
+import {
+  buildI18nChunkUrl,
+  chunkIdToName
+} from "./chunk-FI5KZ5IO.js";
+
+// src/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 && i18n ? import(
+      /* @vite-ignore */
+      buildI18nChunkUrl(i18n.locale, chunkName, hash)
+    ) : Promise.resolve()
+  ]);
+  return module;
+}
+
+export {
+  importWithI18n
+};