@astroscope/i18n 0.1.0

package/dist/chunk-A7MPXMOP.js

@@ -0,0 +1,202 @@
+import {
+  chunkIdToName
+} from "./chunk-4A5BKHFN.js";
+
+// src/extraction/vite-plugin.ts
+import path from "path";
+var VIRTUAL_MODULE_ID = "virtual:@astroscope/i18n/manifest";
+var RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+var globalExtractedKeys = [];
+var globalChunkManifest = {};
+var globalProjectRoot = "";
+function getManifest() {
+  const keysWithRelativePaths = globalExtractedKeys.map((key) => ({
+    ...key,
+    file: globalProjectRoot ? path.relative(globalProjectRoot, key.file) : key.file
+  }));
+  return {
+    keys: keysWithRelativePaths,
+    chunks: globalChunkManifest
+  };
+}
+function extractBalancedBraces(code, startIndex) {
+  if (code[startIndex] !== "{") return null;
+  let depth = 0;
+  let i = startIndex;
+  while (i < code.length) {
+    if (code[i] === "{") depth++;
+    else if (code[i] === "}") {
+      depth--;
+      if (depth === 0) return code.slice(startIndex, i + 1);
+    }
+    i++;
+  }
+  return null;
+}
+function extractTranslationCalls(code, filename) {
+  const keys = [];
+  const regex = /\bt\s*\(\s*['"`]([^'"`]+)['"`]\s*,\s*/g;
+  let match;
+  while ((match = regex.exec(code)) !== null) {
+    const key = match[1];
+    const afterKey = code.slice(match.index + match[0].length);
+    const upToMatch = code.slice(0, match.index);
+    const lineNumber = (upToMatch.match(/\n/g) || []).length + 1;
+    try {
+      const stringMatch = afterKey.match(/^['"`]([^'"`]*)['"`]/);
+      if (stringMatch) {
+        keys.push({
+          key,
+          meta: { fallback: stringMatch[1] },
+          file: filename,
+          line: lineNumber
+        });
+      } else if (afterKey.startsWith("{")) {
+        const metaStr = extractBalancedBraces(afterKey, 0);
+        if (metaStr) {
+          const fallbackMatch = metaStr.match(/fallback\s*:\s*['"`]([^'"`]+)['"`]/);
+          const descMatch = metaStr.match(/description\s*:\s*['"`]([^'"`]+)['"`]/);
+          const fallback = fallbackMatch ? fallbackMatch[1] : "";
+          const description = descMatch ? descMatch[1] : void 0;
+          const varsBlockMatch = metaStr.match(/variables\s*:\s*\{/);
+          let variables;
+          if (varsBlockMatch) {
+            const varsStart = metaStr.indexOf("{", varsBlockMatch.index + varsBlockMatch[0].length - 1);
+            const varsStr = extractBalancedBraces(metaStr, varsStart);
+            if (varsStr) {
+              variables = parseVariables(varsStr);
+            }
+          }
+          keys.push({
+            key,
+            meta: { fallback, description, variables },
+            file: filename,
+            line: lineNumber
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return keys;
+}
+function parseVariables(str) {
+  const result = {};
+  const varNameRegex = /(\w+)\s*:\s*\{/g;
+  let nameMatch;
+  while ((nameMatch = varNameRegex.exec(str)) !== null) {
+    const varName = nameMatch[1];
+    const varStart = str.indexOf("{", nameMatch.index + nameMatch[0].length - 1);
+    const varObj = extractBalancedBraces(str, varStart);
+    if (varObj) {
+      const fallbackMatch = varObj.match(/fallback\s*:\s*['"`]([^'"`]*)['"`]/);
+      const descMatch = varObj.match(/description\s*:\s*['"`]([^'"`]*)['"`]/);
+      result[varName] = {
+        fallback: fallbackMatch ? fallbackMatch[1] : void 0,
+        description: descMatch ? descMatch[1] : void 0
+      };
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function hasI18nImport(code) {
+  return /@astroscope\/i18n\/t/.test(code);
+}
+function i18nVitePlugin(options) {
+  const { include = [".ts", ".tsx", ".js", ".jsx", ".astro"], logger } = options;
+  const extractedKeys = [];
+  const fileToKeys = /* @__PURE__ */ new Map();
+  const filesWithI18n = /* @__PURE__ */ new Set();
+  let chunkManifest = {};
+  let projectRoot = "";
+  return {
+    name: "@astroscope/i18n/extract",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+      globalProjectRoot = config.root;
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+        return `
+import { getManifest } from '@astroscope/i18n/extraction';
+export { getManifest };
+// for static import compatibility, also export current snapshot
+export const manifest = getManifest();
+`;
+      }
+    },
+    transform(code, id) {
+      if (!include.some((ext) => id.endsWith(ext))) {
+        return null;
+      }
+      if (id.includes("node_modules")) {
+        return null;
+      }
+      if (hasI18nImport(code)) {
+        filesWithI18n.add(id);
+      }
+      const keys = extractTranslationCalls(code, id);
+      if (keys.length > 0) {
+        extractedKeys.push(...keys);
+        globalExtractedKeys = extractedKeys;
+        fileToKeys.set(
+          id,
+          keys.map((k) => k.key)
+        );
+      }
+      return null;
+    },
+    generateBundle(_, bundle) {
+      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);
+            if (moduleKeys) {
+              moduleKeys.forEach((k) => keys.add(k));
+            }
+            if (filesWithI18n.has(moduleId)) {
+              hasI18nModule = true;
+            }
+          }
+          if (keys.size > 0) {
+            const chunkName = chunkIdToName(fileName.replace(/\.js$/, ""));
+            chunkManifest[chunkName] = Array.from(keys);
+          }
+          if (hasI18nModule && chunk.type === "chunk") {
+            const chunkName = chunkIdToName(fileName.replace(/\.js$/, ""));
+            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 */
+`;
+            chunk.code = loaderCode + chunk.code;
+          }
+        }
+      }
+      globalChunkManifest = chunkManifest;
+      const chunkCount = Object.keys(chunkManifest).length;
+      const keyCount = extractedKeys.length;
+      logger?.info(`manifest: ${chunkCount} chunks, ${keyCount} keys`);
+    }
+  };
+}
+
+export {
+  getManifest,
+  i18nVitePlugin
+};

package/dist/chunk-AWZ2SQDW.js

@@ -0,0 +1,149 @@
+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 (injected by middleware entrypoint from virtual module)
+  manifest = { keys: [], chunks: {} };
+  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.
+   * Use this to populate your translation provider with keys extracted from the codebase.
+   */
+  getExtractedKeys() {
+    return this.getExtractionManifest().keys;
+  }
+  /**
+   * 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() {
+    return this.manifest;
+  }
+  /**
+   * Set the extraction manifest (called by middleware entrypoint).
+   * @internal
+   */
+  setManifest(manifest) {
+    this.manifest = manifest;
+  }
+  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-AYY2YIBQ.js

@@ -0,0 +1,52 @@
+// src/server/messageformat.ts
+import MessageFormat from "@messageformat/core";
+var mfCache = /* @__PURE__ */ new Map();
+function getMessageFormat(locale) {
+  let mf = mfCache.get(locale);
+  if (!mf) {
+    mf = new MessageFormat(locale);
+    mfCache.set(locale, mf);
+  }
+  return mf;
+}
+function compileMessage(locale, message) {
+  const mf = getMessageFormat(locale);
+  try {
+    return mf.compile(message);
+  } catch {
+    return (values) => {
+      if (!values) return message;
+      return Object.entries(values).reduce(
+        (result, [key, value]) => result.replace(new RegExp(`\\{${key}\\}`, "g"), String(value)),
+        message
+      );
+    };
+  }
+}
+function compileTranslations(locale, raw) {
+  const compiled = {};
+  for (const [key, message] of Object.entries(raw)) {
+    compiled[key] = compileMessage(locale, message);
+  }
+  return compiled;
+}
+
+// src/server/context.ts
+var currentContext = null;
+function setContext(context) {
+  currentContext = context;
+}
+function getContext() {
+  return currentContext;
+}
+function clearContext() {
+  currentContext = null;
+}
+
+export {
+  compileMessage,
+  compileTranslations,
+  setContext,
+  getContext,
+  clearContext
+};

package/dist/chunk-BMNEJFTD.js

@@ -0,0 +1,56 @@
+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 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();
+      return response;
+    } finally {
+      clearContext();
+    }
+  };
+}
+
+export {
+  createI18nMiddleware
+};

package/dist/chunk-BSXQGEUK.js

@@ -0,0 +1,16 @@
+// src/client-directives/utils.ts
+async function loadI18nForChunk(el) {
+  const componentUrl = el.getAttribute("component-url");
+  if (!componentUrl) return;
+  const chunkId = componentUrl.replace(/^\//, "").replace(/\.js$/, "");
+  const hash = window.__i18n_hashes__?.[chunkId];
+  const locale = window.__i18n_locale__ || "en";
+  if (hash) {
+    const chunkName = chunkId.replace(/^_astro\//, "");
+    await import(`/_i18n/${locale}/${chunkName}.${hash}.js`);
+  }
+}
+
+export {
+  loadI18nForChunk
+};

package/dist/chunk-BSYTJFGF.js

@@ -0,0 +1,21 @@
+import {
+  buildI18nChunkUrl
+} from "./chunk-OFNFSDW3.js";
+
+// src/import-with-i18n.ts
+async function importWithI18n(importFn, chunkId) {
+  const hash = chunkId ? window.__i18n_hashes__?.[chunkId] : void 0;
+  const locale = window.__i18n_locale__ || "en";
+  const [module] = await Promise.all([
+    importFn(),
+    hash && chunkId ? import(
+      /* @vite-ignore */
+      buildI18nChunkUrl(locale, chunkId, hash)
+    ) : Promise.resolve()
+  ]);
+  return module;
+}
+
+export {
+  importWithI18n
+};

package/dist/chunk-BVPXEGTT.js

@@ -0,0 +1,12 @@
+// src/client/import-with-i18n.ts
+async function importx(importFn) {
+  return importFn();
+}
+function lazyx(importFn) {
+  return importFn;
+}
+
+export {
+  importx,
+  lazyx
+};

package/dist/chunk-C4DJYWF6.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 serverDir = path2.resolve(outputOptions.dir, "..", "server");
+        const manifestPath = path2.join(serverDir, MANIFEST_FILE_NAME);
+        if (fs.existsSync(serverDir)) {
+          fs.writeFileSync(manifestPath, JSON.stringify(getManifest()));
+        } else {
+          logger.error(`server directory not found, cannot write manifest to ${manifestPath}`);
+        }
+      }
+    }
+  };
+}
+
+export {
+  getManifest,
+  i18nVitePlugin
+};