@astroscope/i18n 0.1.0

package/dist/chunk-X3L7WZLY.js

@@ -0,0 +1,254 @@
+import {
+  clearContext,
+  compileTranslations,
+  setContext
+} from "./chunk-KNONI6DP.js";
+
+// src/i18n-endpoint.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;
+}
+function createI18nEndpoint(options) {
+  const { cms, manifest } = options;
+  const translationCache2 = /* @__PURE__ */ new Map();
+  return async ({ params }) => {
+    const { path } = params;
+    if (!path) {
+      return new Response("Not found", { status: 404 });
+    }
+    const match = path.match(/^([^/]+)\/(.+)\.([a-z0-9]+)\.js$/);
+    if (!match) {
+      return new Response("Invalid path", { status: 400 });
+    }
+    const [, locale, chunkId, requestedHash] = match;
+    const keys = manifest[chunkId];
+    if (!keys) {
+      return new Response(`/* chunk not found: ${chunkId} */`, {
+        status: 404,
+        headers: { "Content-Type": "application/javascript" }
+      });
+    }
+    let translations = translationCache2.get(locale);
+    if (!translations) {
+      translations = await cms.fetch(locale, []);
+      translationCache2.set(locale, translations);
+    }
+    const actualHash = computeChunkHash(translations, keys);
+    if (requestedHash !== actualHash) {
+      console.warn(`[i18n] hash mismatch for ${chunkId}: expected ${actualHash}, got ${requestedHash}`);
+    }
+    const chunkTranslations = {};
+    for (const key of keys) {
+      if (translations[key]) {
+        chunkTranslations[key] = translations[key];
+      }
+    }
+    const js = `/* @astroscope/i18n chunk: ${chunkId} */
+(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"
+      }
+    });
+  };
+}
+
+// src/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;
+}
+var translationCache = /* @__PURE__ */ new Map();
+var hashCache = /* @__PURE__ */ new Map();
+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, cms, detectLocale, chunkManifest } = options;
+  return async (ctx, next) => {
+    const pathname = new URL(ctx.request.url).pathname;
+    if (chunkManifest) {
+      const endpointParams = parseI18nEndpointPath(pathname);
+      if (endpointParams) {
+        const { locale: urlLocale, chunkName, hash } = endpointParams;
+        let endpointRaw = translationCache.get(urlLocale);
+        if (!endpointRaw) {
+          endpointRaw = await cms.fetch(urlLocale, []);
+          translationCache.set(urlLocale, endpointRaw);
+        }
+        return handleI18nEndpoint(chunkName, hash, endpointRaw, chunkManifest);
+      }
+    }
+    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);
+      if (chunkManifest) {
+        const hashes = computeAllChunkHashes(raw, chunkManifest);
+        hashCache.set(locale, hashes);
+      }
+    }
+    const translations = compileTranslations(locale, raw);
+    const context = {
+      locale,
+      translations,
+      fallback,
+      meta: {}
+    };
+    setContext(context);
+    try {
+      const response = await next();
+      let script;
+      if (chunkManifest) {
+        const hashes = hashCache.get(locale) || {};
+        script = generateI18nHashScript(locale, hashes);
+      } else {
+        script = generateI18nFullScript(locale, raw);
+      }
+      const injectedResponse = await injectI18nScript(response, script);
+      return injectedResponse;
+    } finally {
+      clearContext();
+    }
+  };
+}
+function getCachedTranslations(locale) {
+  return translationCache.get(locale);
+}
+function clearTranslationCache(locale) {
+  if (locale) {
+    translationCache.delete(locale);
+    hashCache.delete(locale);
+  } else {
+    translationCache.clear();
+    hashCache.clear();
+  }
+}
+
+export {
+  computeChunkHash,
+  computeAllChunkHashes,
+  createI18nEndpoint,
+  createI18nMiddleware,
+  getCachedTranslations,
+  clearTranslationCache
+};

package/dist/chunk-XDD62ZM3.js

@@ -0,0 +1,255 @@
+import {
+  clearContext,
+  compileTranslations,
+  setContext
+} from "./chunk-KNONI6DP.js";
+
+// src/i18n-endpoint.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;
+}
+function createI18nEndpoint(options) {
+  const { cms, manifest } = options;
+  const translationCache2 = /* @__PURE__ */ new Map();
+  return async ({ params }) => {
+    const { path } = params;
+    if (!path) {
+      return new Response("Not found", { status: 404 });
+    }
+    const match = path.match(/^([^/]+)\/(.+)\.([a-z0-9]+)\.js$/);
+    if (!match) {
+      return new Response("Invalid path", { status: 400 });
+    }
+    const [, locale, chunkId, requestedHash] = match;
+    const keys = manifest[chunkId];
+    if (!keys) {
+      return new Response(`/* chunk not found: ${chunkId} */`, {
+        status: 404,
+        headers: { "Content-Type": "application/javascript" }
+      });
+    }
+    let translations = translationCache2.get(locale);
+    if (!translations) {
+      translations = await cms.fetch(locale, []);
+      translationCache2.set(locale, translations);
+    }
+    const actualHash = computeChunkHash(translations, keys);
+    if (requestedHash !== actualHash) {
+      console.warn(`[i18n] hash mismatch for ${chunkId}: expected ${actualHash}, got ${requestedHash}`);
+    }
+    const chunkTranslations = {};
+    for (const key of keys) {
+      if (translations[key]) {
+        chunkTranslations[key] = translations[key];
+      }
+    }
+    const js = `/* @astroscope/i18n chunk: ${chunkId} */
+(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"
+      }
+    });
+  };
+}
+
+// src/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;
+}
+var translationCache = /* @__PURE__ */ new Map();
+var hashCache = /* @__PURE__ */ new Map();
+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, cms, detectLocale, chunkManifest } = options;
+  return async (ctx, next) => {
+    const pathname = new URL(ctx.request.url).pathname;
+    if (chunkManifest) {
+      const endpointParams = parseI18nEndpointPath(pathname);
+      if (endpointParams) {
+        const { locale: urlLocale, chunkName, hash } = endpointParams;
+        let endpointRaw = translationCache.get(urlLocale);
+        if (!endpointRaw) {
+          endpointRaw = await cms.fetch(urlLocale, []);
+          translationCache.set(urlLocale, endpointRaw);
+        }
+        return handleI18nEndpoint(chunkName, hash, endpointRaw, chunkManifest);
+      }
+    }
+    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);
+      if (chunkManifest) {
+        const hashes = computeAllChunkHashes(raw, chunkManifest);
+        hashCache.set(locale, hashes);
+      }
+    }
+    const translations = compileTranslations(locale, raw);
+    const context = {
+      locale,
+      translations,
+      fallback,
+      meta: {}
+    };
+    setContext(context);
+    try {
+      const response = await next();
+      let script;
+      const hasChunkManifest = chunkManifest && Object.keys(chunkManifest).length > 0;
+      if (hasChunkManifest) {
+        const hashes = hashCache.get(locale) || {};
+        script = generateI18nHashScript(locale, hashes);
+      } else {
+        script = generateI18nFullScript(locale, raw);
+      }
+      const injectedResponse = await injectI18nScript(response, script);
+      return injectedResponse;
+    } finally {
+      clearContext();
+    }
+  };
+}
+function getCachedTranslations(locale) {
+  return translationCache.get(locale);
+}
+function clearTranslationCache(locale) {
+  if (locale) {
+    translationCache.delete(locale);
+    hashCache.delete(locale);
+  } else {
+    translationCache.clear();
+    hashCache.clear();
+  }
+}
+
+export {
+  computeChunkHash,
+  computeAllChunkHashes,
+  createI18nEndpoint,
+  createI18nMiddleware,
+  getCachedTranslations,
+  clearTranslationCache
+};

package/dist/chunk-XFXXEDRD.js

@@ -0,0 +1,36 @@
+import {
+  buildI18nChunkUrl,
+  chunkIdToName
+} from "./chunk-4A5BKHFN.js";
+
+// src/client/import-with-i18n.ts
+import { lazy } from "react";
+function loadTranslations(chunkId) {
+  if (!chunkId) return Promise.resolve();
+  const i18n = window.__i18n__;
+  const chunkName = chunkIdToName(chunkId);
+  const hash = i18n.hashes[chunkName];
+  if (!hash) return Promise.resolve();
+  return import(
+    /* @vite-ignore */
+    buildI18nChunkUrl(i18n.locale, chunkName, hash)
+  ).then(() => {
+  });
+}
+async function importx(importFn, chunkId) {
+  const [module] = await Promise.all([importFn(), loadTranslations(chunkId)]);
+  return module;
+}
+function lazyx(importFn, chunkId) {
+  return lazy(async () => {
+    const translationPromise = loadTranslations(chunkId);
+    const modulePromise = importFn();
+    const [module] = await Promise.all([modulePromise, translationPromise]);
+    return module;
+  });
+}
+
+export {
+  importx,
+  lazyx
+};

package/dist/chunk-XKYOR5UK.js

@@ -0,0 +1,8 @@
+// src/shared/types.ts
+function normalizeMeta(meta) {
+  return typeof meta === "string" ? { fallback: meta } : meta;
+}
+
+export {
+  normalizeMeta
+};