@ox-content/vite-plugin 0.13.0 → 0.14.0

package/dist/index.cjs

@@ -10964,6 +10964,251 @@ function createOgViewerPlugin(options) {
 	};
 }
 
+//#endregion
+//#region src/i18n.ts
+/**
+* i18n plugin for Ox Content.
+*
+* Provides:
+* - Dictionary loading and validation at build time
+* - Virtual module for i18n config
+* - Build-time i18n checking
+* - Locale-aware routing middleware for dev server
+*/
+/**
+* Resolves i18n options with defaults.
+*/
+function resolveI18nOptions(options) {
+	if (options === false) return false;
+	if (!options || !options.enabled) return false;
+	const defaultLocale = options.defaultLocale ?? "en";
+	const locales = options.locales ?? [{
+		code: defaultLocale,
+		name: defaultLocale
+	}];
+	if (!locales.some((l) => l.code === defaultLocale)) locales.unshift({
+		code: defaultLocale,
+		name: defaultLocale
+	});
+	return {
+		enabled: true,
+		dir: options.dir ?? "content/i18n",
+		defaultLocale,
+		locales,
+		hideDefaultLocale: options.hideDefaultLocale ?? true,
+		check: options.check ?? true,
+		functionNames: options.functionNames ?? ["t", "$t"]
+	};
+}
+/**
+* Creates the i18n sub-plugin for the Vite plugin array.
+*/
+function createI18nPlugin(resolvedOptions) {
+	const i18nOptions = resolvedOptions.i18n;
+	let root = process.cwd();
+	return {
+		name: "ox-content:i18n",
+		configResolved(config) {
+			root = config.root;
+		},
+		resolveId(id) {
+			if (id === "virtual:ox-content/i18n") return "\0virtual:ox-content/i18n";
+			return null;
+		},
+		load(id) {
+			if (id === "\0virtual:ox-content/i18n") {
+				if (!i18nOptions) return `export const i18n = { enabled: false }; export default i18n;`;
+				return generateI18nModule(i18nOptions, root);
+			}
+			return null;
+		},
+		async buildStart() {
+			if (!i18nOptions || !i18nOptions.check) return;
+			const dictDir = path$1.resolve(root, i18nOptions.dir);
+			if (!fs.existsSync(dictDir)) {
+				console.warn(`[ox-content:i18n] Dictionary directory not found: ${dictDir}`);
+				return;
+			}
+			try {
+				const { loadDictionaries, checkI18n, extractTranslationKeys } = await import("@ox-content/napi");
+				const loadResult = loadDictionaries(dictDir);
+				if (loadResult.errors.length > 0) {
+					for (const error of loadResult.errors) console.warn(`[ox-content:i18n] ${error}`);
+					return;
+				}
+				console.log(`[ox-content:i18n] Loaded ${loadResult.localeCount} locales: ${loadResult.locales.join(", ")}`);
+				const checkResult = checkI18n(dictDir, collectKeysFromSource(root, extractTranslationKeys, i18nOptions));
+				if (checkResult.errorCount > 0 || checkResult.warningCount > 0) {
+					for (const diag of checkResult.diagnostics) if (diag.severity === "error") console.error(`[ox-content:i18n] ${diag.message}`);
+					else if (diag.severity === "warning") console.warn(`[ox-content:i18n] ${diag.message}`);
+				}
+			} catch {}
+		},
+		configureServer(server) {
+			if (!i18nOptions) return;
+			const dictDir = path$1.resolve(root, i18nOptions.dir);
+			if (fs.existsSync(dictDir)) {
+				server.watcher.add(dictDir);
+				server.watcher.on("change", (filePath) => {
+					if (!filePath.startsWith(dictDir)) return;
+					if (!/\.(json|yaml|yml)$/.test(filePath)) return;
+					const mod = server.moduleGraph.getModuleById("\0virtual:ox-content/i18n");
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				});
+			}
+			server.middlewares.use((req, _res, next) => {
+				if (!req.url) return next();
+				const localeMatch = req.url.match(/^\/([a-z]{2}(?:-[a-zA-Z]+)?)(\/|$)/);
+				if (localeMatch) {
+					const localeCode = localeMatch[1];
+					if (i18nOptions.locales.some((l) => l.code === localeCode)) req.__oxLocale = localeCode;
+				} else if (i18nOptions.hideDefaultLocale) req.__oxLocale = i18nOptions.defaultLocale;
+				next();
+			});
+		}
+	};
+}
+/**
+* Generates the virtual module for i18n configuration.
+*/
+function generateI18nModule(options, root) {
+	const dictDir = path$1.resolve(root, options.dir);
+	const localesJson = JSON.stringify(options.locales);
+	const defaultLocale = JSON.stringify(options.defaultLocale);
+	let dictionariesCode = "{}";
+	try {
+		const napi = require("@ox-content/napi");
+		if (napi.loadDictionariesFlat) {
+			const dictData = napi.loadDictionariesFlat(dictDir);
+			dictionariesCode = JSON.stringify(dictData);
+		} else dictionariesCode = JSON.stringify(loadDictionariesFallback(options, dictDir));
+	} catch {
+		try {
+			dictionariesCode = JSON.stringify(loadDictionariesFallback(options, dictDir));
+		} catch {}
+	}
+	return `
+export const i18nConfig = {
+  enabled: true,
+  defaultLocale: ${defaultLocale},
+  locales: ${localesJson},
+  hideDefaultLocale: ${JSON.stringify(options.hideDefaultLocale)},
+};
+
+export const dictionaries = ${dictionariesCode};
+
+export function t(key, params, locale) {
+  const dict = dictionaries[locale || i18nConfig.defaultLocale] || {};
+  let message = dict[key];
+  if (!message) {
+    const fallback = dictionaries[i18nConfig.defaultLocale] || {};
+    message = fallback[key] || key;
+  }
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      message = message.replace(new RegExp('\\\\{\\\\$' + k + '\\\\}', 'g'), String(v));
+    }
+  }
+  return message;
+}
+
+export function getLocaleFromPath(pathname) {
+  const match = pathname.match(/^\\/([a-z]{2}(?:-[a-zA-Z]+)?)(\\//|$)/);
+  if (match) {
+    const code = match[1];
+    if (i18nConfig.locales.some(l => l.code === code)) {
+      return code;
+    }
+  }
+  return i18nConfig.defaultLocale;
+}
+
+export function localePath(pathname, locale) {
+  const current = getLocaleFromPath(pathname);
+  let clean = pathname;
+  if (current !== i18nConfig.defaultLocale || !i18nConfig.hideDefaultLocale) {
+    clean = pathname.replace(new RegExp('^/' + current + '(/|$)'), '/');
+  }
+  if (locale === i18nConfig.defaultLocale && i18nConfig.hideDefaultLocale) {
+    return clean || '/';
+  }
+  return '/' + locale + (clean.startsWith('/') ? clean : '/' + clean);
+}
+
+export default { i18nConfig, dictionaries, t, getLocaleFromPath, localePath };
+`;
+}
+/**
+* Flattens a nested object into dot-separated keys.
+*/
+function flattenObject(obj, prefix, result) {
+	for (const [key, value] of Object.entries(obj)) {
+		const fullKey = `${prefix}.${key}`;
+		if (typeof value === "string") result[fullKey] = value;
+		else if (typeof value === "object" && value !== null && !Array.isArray(value)) flattenObject(value, fullKey, result);
+		else result[fullKey] = String(value);
+	}
+}
+/**
+* Fallback dictionary loading using TS-based JSON file reading.
+*/
+function loadDictionariesFallback(options, dictDir) {
+	const dictData = {};
+	for (const locale of options.locales) {
+		const localeDir = path$1.join(dictDir, locale.code);
+		if (!fs.existsSync(localeDir)) continue;
+		const files = fs.readdirSync(localeDir);
+		const localeDict = {};
+		for (const file of files) {
+			if (!file.endsWith(".json")) continue;
+			const filePath = path$1.join(localeDir, file);
+			const content = fs.readFileSync(filePath, "utf-8");
+			const namespace = path$1.basename(file, ".json");
+			try {
+				flattenObject(JSON.parse(content), namespace, localeDict);
+			} catch {}
+		}
+		dictData[locale.code] = localeDict;
+	}
+	return dictData;
+}
+/**
+* Collects translation keys from source files using NAPI extractTranslationKeys.
+*/
+function collectKeysFromSource(root, extractTranslationKeys, options) {
+	const srcDir = path$1.resolve(root, "src");
+	const keys = /* @__PURE__ */ new Set();
+	if (fs.existsSync(srcDir)) walkDir(srcDir, /\.(ts|tsx|js|jsx)$/, (filePath) => {
+		const usages = extractTranslationKeys(fs.readFileSync(filePath, "utf-8"), filePath, options.functionNames);
+		for (const usage of usages) keys.add(usage.key);
+	});
+	const contentDir = path$1.resolve(root, "content");
+	if (fs.existsSync(contentDir)) {
+		const tPattern = /\{\{t\(['"]([^'"]+)['"]\)\}\}/g;
+		walkDir(contentDir, /\.(md|mdx)$/, (filePath) => {
+			const content = fs.readFileSync(filePath, "utf-8");
+			let match;
+			while ((match = tPattern.exec(content)) !== null) keys.add(match[1]);
+			tPattern.lastIndex = 0;
+		});
+	}
+	return Array.from(keys);
+}
+/**
+* Recursively walks a directory, calling the callback for files matching the pattern.
+*/
+function walkDir(dir, pattern, callback) {
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path$1.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === "node_modules" || entry.name === ".git") continue;
+			walkDir(fullPath, pattern, callback);
+		} else if (pattern.test(entry.name)) callback(fullPath);
+	}
+}
+
 //#endregion
 //#region src/jsx-runtime.ts
 /**
@@ -11690,6 +11935,7 @@ function oxContent(options = {}) {
 			}
 		}
 	];
+	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
 	if (resolvedOptions.ogViewer) plugins.push(createOgViewerPlugin(resolvedOptions));
 	return plugins;
 }
@@ -11719,7 +11965,8 @@ function resolveOptions(options) {
 		transformers: options.transformers ?? [],
 		docs: resolveDocsOptions(options.docs),
 		search: resolveSearchOptions(options.search),
-		ogViewer: options.ogViewer ?? true
+		ogViewer: options.ogViewer ?? true,
+		i18n: resolveI18nOptions(options.i18n)
 	};
 }
 /**
@@ -11749,6 +11996,7 @@ exports.buildSsg = buildSsg;
 exports.clearRenderContext = clearRenderContext;
 exports.collectGitHubRepos = require_github.collectGitHubRepos;
 exports.collectOgpUrls = require_ogp.collectOgpUrls;
+exports.createI18nPlugin = createI18nPlugin;
 exports.createMarkdownEnvironment = createMarkdownEnvironment;
 exports.createTheme = createTheme;
 exports.defaultTheme = defaultTheme;
@@ -11779,6 +12027,7 @@ exports.renderAllPages = renderAllPages;
 exports.renderPage = renderPage;
 exports.renderToString = renderToString;
 exports.resolveDocsOptions = resolveDocsOptions;
+exports.resolveI18nOptions = resolveI18nOptions;
 exports.resolveOgImageOptions = resolveOgImageOptions;
 exports.resolveSearchOptions = resolveSearchOptions;
 exports.resolveSsgOptions = resolveSsgOptions;