@astroscope/i18n 0.1.0

package/dist/chunk-Y4BE2V6F.js

@@ -0,0 +1,347 @@
+import {
+  chunkIdToName
+} from "./chunk-4A5BKHFN.js";
+
+// src/extraction/manifest.ts
+import path from "path";
+var I18N_GLOBAL_KEY = "__astroscope_i18n_manifest__";
+function getGlobalState() {
+  const g = globalThis;
+  if (!g[I18N_GLOBAL_KEY]) {
+    g[I18N_GLOBAL_KEY] = {
+      extractedKeys: [],
+      chunkManifest: {},
+      projectRoot: ""
+    };
+  }
+  return g[I18N_GLOBAL_KEY];
+}
+function getManifest() {
+  const state = getGlobalState();
+  const keysWithRelativePaths = state.extractedKeys.map((key) => ({
+    ...key,
+    file: state.projectRoot ? path.relative(state.projectRoot, key.file) : key.file
+  }));
+  return {
+    keys: keysWithRelativePaths,
+    chunks: state.chunkManifest
+  };
+}
+
+// src/extraction/vite-plugin.ts
+import fs from "fs";
+import path2 from "path";
+import { transformAsync } from "@babel/core";
+
+// src/extraction/babel-plugin.ts
+function getStringValue(t, node) {
+  if (t.isStringLiteral(node)) {
+    return node.value;
+  }
+  if (t.isTemplateLiteral(node) && node.quasis.length === 1 && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
+}
+function extractMeta(t, node) {
+  const stringValue = getStringValue(t, node);
+  if (stringValue !== null) {
+    return { fallback: stringValue };
+  }
+  if (t.isObjectExpression(node)) {
+    return extractMetaFromObject(t, node);
+  }
+  return { fallback: "" };
+}
+function extractMetaFromObject(t, obj) {
+  const meta = { fallback: "" };
+  for (const prop of obj.properties) {
+    if (!t.isObjectProperty(prop)) continue;
+    if (!t.isIdentifier(prop.key)) continue;
+    const name = prop.key.name;
+    if (name === "fallback") {
+      const value = getStringValue(t, prop.value);
+      if (value !== null) {
+        meta.fallback = value;
+      }
+    } else if (name === "description") {
+      const value = getStringValue(t, prop.value);
+      if (value !== null) {
+        meta.description = value;
+      }
+    } else if (name === "variables" && t.isObjectExpression(prop.value)) {
+      meta.variables = extractVariables(t, prop.value);
+    }
+  }
+  return meta;
+}
+function extractVariables(t, obj) {
+  const result = {};
+  for (const prop of obj.properties) {
+    if (!t.isObjectProperty(prop)) continue;
+    if (!t.isIdentifier(prop.key)) continue;
+    const varName = prop.key.name;
+    if (t.isObjectExpression(prop.value)) {
+      const varDef = {};
+      for (const varProp of prop.value.properties) {
+        if (!t.isObjectProperty(varProp)) continue;
+        if (!t.isIdentifier(varProp.key)) continue;
+        const varPropName = varProp.key.name;
+        const value = getStringValue(t, varProp.value);
+        if (value !== null) {
+          if (varPropName === "fallback") {
+            varDef.fallback = value;
+          } else if (varPropName === "description") {
+            varDef.description = value;
+          }
+        }
+      }
+      result[varName] = varDef;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function isMetaArgument(t, node) {
+  if (t.isStringLiteral(node) || t.isTemplateLiteral(node)) {
+    return true;
+  }
+  if (t.isObjectExpression(node)) {
+    for (const prop of node.properties) {
+      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "fallback") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function i18nExtractPlugin({ types: t }) {
+  return {
+    name: "@astroscope/i18n/extract",
+    visitor: {
+      CallExpression(path3, state) {
+        if (!path3.get("callee").isIdentifier({ name: "t" })) return;
+        const args = path3.node.arguments;
+        if (args.length < 1) return;
+        const keyArg = args[0];
+        if (!t.isExpression(keyArg)) return;
+        const key = getStringValue(t, keyArg);
+        if (key === null) return;
+        let meta = { fallback: "" };
+        if (args.length >= 2 && t.isExpression(args[1]) && isMetaArgument(t, args[1])) {
+          meta = extractMeta(t, args[1]);
+        }
+        state.opts.onKeyExtracted({
+          key,
+          meta,
+          file: state.filename ?? "",
+          line: path3.node.loc?.start.line ?? 0
+        });
+        if (state.opts.stripFallbacks && args.length >= 2) {
+          const secondArg = args[1];
+          if (!t.isExpression(secondArg)) return;
+          if (isMetaArgument(t, secondArg)) {
+            if (args.length === 2) {
+              path3.node.arguments = [args[0]];
+            } else if (args.length >= 3) {
+              path3.node.arguments = [args[0], args[2]];
+            }
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/extraction/vite-plugin.ts
+var VIRTUAL_MODULE_ID = "virtual:@astroscope/i18n/manifest";
+var RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+var MANIFEST_FILE_NAME = "i18n-manifest.json";
+function hasI18nImport(code) {
+  return /@astroscope\/i18n\/t/.test(code);
+}
+function getParserPlugins(filename) {
+  const plugins = [];
+  if (/\.tsx?$/.test(filename)) {
+    plugins.push("typescript");
+  }
+  if (/\.(jsx|tsx)$/.test(filename)) {
+    plugins.push("jsx");
+  }
+  return plugins;
+}
+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 = "";
+  let isBuild = false;
+  let isSSR = false;
+  return {
+    name: "@astroscope/i18n/extract",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+      getGlobalState().projectRoot = config.root;
+      isBuild = config.command === "build";
+      isSSR = !!config.build.ssr;
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+      if (id.startsWith(`${VIRTUAL_MODULE_ID}?`)) {
+        return `\0${id}`;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID || id.startsWith(`\0${VIRTUAL_MODULE_ID}?`)) {
+        if (isBuild) {
+          return `
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const manifestName = '${MANIFEST_FILE_NAME}';
+
+// manifest is emitted to server directory (not publicly accessible)
+const searchPaths = [
+  join(__dirname, manifestName),                    // same dir (server/)
+  join(__dirname, '..', manifestName),              // parent dir (from chunks/)
+];
+
+let manifestPath = searchPaths.find(p => existsSync(p));
+if (!manifestPath) {
+  console.warn('[i18n] manifest not found, using empty manifest');
+  manifestPath = null;
+}
+
+const manifestJson = manifestPath
+  ? JSON.parse(readFileSync(manifestPath, 'utf-8'))
+  : { keys: [], chunks: {} };
+
+export const manifest = manifestJson;
+export function getManifest() { return manifestJson; }
+`;
+        }
+        return `
+import { getManifest as _getManifest } from '@astroscope/i18n/extraction';
+export const manifest = { keys: [], chunks: {} }; // placeholder, use getManifest()
+export function getManifest() { return _getManifest(); }
+`;
+      }
+    },
+    async transform(code, id) {
+      if (!include.some((ext) => id.endsWith(ext))) {
+        return null;
+      }
+      if (id.includes("node_modules")) {
+        return null;
+      }
+      if (!hasI18nImport(code)) {
+        return null;
+      }
+      filesWithI18n.add(id);
+      const fileKeys = [];
+      const result = await transformAsync(code, {
+        filename: id,
+        sourceMaps: true,
+        babelrc: false,
+        configFile: false,
+        parserOpts: {
+          plugins: getParserPlugins(id)
+        },
+        plugins: [
+          [
+            i18nExtractPlugin,
+            {
+              onKeyExtracted: (key) => fileKeys.push(key),
+              stripFallbacks: isBuild
+              // only strip in production
+            }
+          ]
+        ]
+      });
+      if (fileKeys.length > 0) {
+        extractedKeys.push(...fileKeys);
+        getGlobalState().extractedKeys = extractedKeys;
+        fileToKeys.set(
+          id,
+          fileKeys.map((k) => k.key)
+        );
+      }
+      if (isBuild && result?.code) {
+        return {
+          code: result.code,
+          map: result.map
+        };
+      }
+      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;
+          }
+        }
+      }
+      getGlobalState().chunkManifest = chunkManifest;
+      const chunkCount = Object.keys(chunkManifest).length;
+      const keyCount = extractedKeys.length;
+      logger?.info(`manifest: ${chunkCount} chunks, ${keyCount} keys`);
+    },
+    writeBundle(outputOptions) {
+      if (!isSSR && outputOptions.dir) {
+        const keysWithRelativePaths = extractedKeys.map((key) => ({
+          ...key,
+          file: projectRoot ? path2.relative(projectRoot, key.file) : key.file
+        }));
+        const manifest = {
+          keys: keysWithRelativePaths,
+          chunks: chunkManifest
+        };
+        const serverDir = path2.resolve(outputOptions.dir, "..", "server");
+        const manifestPath = path2.join(serverDir, MANIFEST_FILE_NAME);
+        if (fs.existsSync(serverDir)) {
+          fs.writeFileSync(manifestPath, JSON.stringify(manifest));
+        }
+      }
+    }
+  };
+}
+
+export {
+  getManifest,
+  i18nVitePlugin
+};

package/dist/chunk-Z4IZYDIA.js

@@ -0,0 +1,24 @@
+import {
+  buildI18nChunkUrl,
+  componentUrlToChunkName
+} from "./chunk-HHRMR3TM.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-Z52G4CYY.js

@@ -0,0 +1,14 @@
+// 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 ? import(`/_i18n/${locale}/${chunkId?.replace(/^_astro\//, "")}.${hash}.js`) : Promise.resolve()
+  ]);
+  return module;
+}
+
+export {
+  importWithI18n
+};

package/dist/chunk-ZGLUYWVM.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 ?? null;
+  }
+  /**
+   * 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/client/directives/idle.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:idle directive
+ * Loads translations in parallel before delegating to Astro's original idle directive
+ */
+declare const idleDirective: ClientDirective;
+
+export { idleDirective as default };

package/dist/client/directives/idle.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../../chunk-FAKBSLNW.js";
+import "../../chunk-4A5BKHFN.js";
+
+// src/client/directives/idle.ts
+import originalIdle from "astro/client/idle.js";
+var idleDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalIdle(load, options, el);
+};
+var idle_default = idleDirective;
+export {
+  idle_default as default
+};

package/dist/client/directives/load.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:load directive
+ * Loads translations in parallel before delegating to Astro's original load directive
+ */
+declare const loadDirective: ClientDirective;
+
+export { loadDirective as default };

package/dist/client/directives/load.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../../chunk-FAKBSLNW.js";
+import "../../chunk-4A5BKHFN.js";
+
+// src/client/directives/load.ts
+import originalLoad from "astro/client/load.js";
+var loadDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalLoad(load, options, el);
+};
+var load_default = loadDirective;
+export {
+  load_default as default
+};

package/dist/client/directives/media.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:media directive
+ * Loads translations in parallel before delegating to Astro's original media directive
+ */
+declare const mediaDirective: ClientDirective;
+
+export { mediaDirective as default };

package/dist/client/directives/media.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../../chunk-FAKBSLNW.js";
+import "../../chunk-4A5BKHFN.js";
+
+// src/client/directives/media.ts
+import originalMedia from "astro/client/media.js";
+var mediaDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalMedia(load, options, el);
+};
+var media_default = mediaDirective;
+export {
+  media_default as default
+};

package/dist/client/directives/only.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:only directive
+ * Loads translations in parallel before delegating to Astro's original only directive
+ */
+declare const onlyDirective: ClientDirective;
+
+export { onlyDirective as default };

package/dist/client/directives/only.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../../chunk-FAKBSLNW.js";
+import "../../chunk-4A5BKHFN.js";
+
+// src/client/directives/only.ts
+import originalOnly from "astro/client/only.js";
+var onlyDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalOnly(load, options, el);
+};
+var only_default = onlyDirective;
+export {
+  only_default as default
+};

package/dist/client/directives/utils.d.ts

@@ -0,0 +1,10 @@
+import '../../types-B_-RxW4A.js';
+import '../../types-Bzp6KxsI.js';
+
+/**
+ * Load translations for a chunk before hydration
+ * Extracts chunk name from astro-island's component-url attribute
+ */
+declare function loadI18nForChunk(el: HTMLElement): Promise<void>;
+
+export { loadI18nForChunk };

package/dist/client/directives/utils.js

@@ -0,0 +1,7 @@
+import {
+  loadI18nForChunk
+} from "../../chunk-FAKBSLNW.js";
+import "../../chunk-4A5BKHFN.js";
+export {
+  loadI18nForChunk
+};

package/dist/client/directives/visible.d.ts

@@ -0,0 +1,9 @@
+import { ClientDirective } from 'astro';
+
+/**
+ * i18n-aware client:visible directive
+ * Loads translations in parallel before delegating to Astro's original visible directive
+ */
+declare const visibleDirective: ClientDirective;
+
+export { visibleDirective as default };

package/dist/client/directives/visible.js

@@ -0,0 +1,15 @@
+import {
+  loadI18nForChunk
+} from "../../chunk-FAKBSLNW.js";
+import "../../chunk-4A5BKHFN.js";
+
+// src/client/directives/visible.ts
+import originalVisible from "astro/client/visible.js";
+var visibleDirective = async (load, options, el) => {
+  await loadI18nForChunk(el);
+  return originalVisible(load, options, el);
+};
+var visible_default = visibleDirective;
+export {
+  visible_default as default
+};

package/dist/client/import-with-i18n.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @deprecated Not needed - translations load automatically via chunk loader.
+ * Use regular dynamic import() instead.
+ */
+declare function importx<T>(importFn: () => Promise<T>): Promise<T>;
+/**
+ * @deprecated Not needed - translations load automatically via chunk loader.
+ * Use regular React.lazy() instead.
+ */
+declare function lazyx<T>(importFn: () => Promise<{
+    default: T;
+}>): () => Promise<{
+    default: T;
+}>;
+
+export { importx, lazyx };

package/dist/client/import-with-i18n.js

@@ -0,0 +1,8 @@
+import {
+  importx,
+  lazyx
+} from "../chunk-BVPXEGTT.js";
+export {
+  importx,
+  lazyx
+};