docs-i18n 0.9.2 → 0.11.0

package/admin/dist/server/assets/status-B1AGLvHn.js

@@ -0,0 +1,162 @@
+import { i as parseMdx, r as flattenSources, t as TranslationCache } from "./dist-DBv71kqn.js";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+//#region server/services/status.ts
+var _config;
+var _cache = null;
+var _projectRoot = process.cwd();
+function initStatus(config) {
+	_config = config;
+	_cache = null;
+	_projectRoot = process.env.DOCS_I18N_PROJECT_ROOT || process.cwd();
+}
+function getVersions() {
+	return flattenSources(_config).map((s) => s.versionKey);
+}
+function getLangs() {
+	return _config.languages;
+}
+function getCache() {
+	if (!_cache) _cache = new TranslationCache(resolve(_projectRoot, _config.cacheDir ?? ".cache"));
+	return _cache;
+}
+function getSourcePath(versionKey) {
+	const source = flattenSources(_config).find((s) => s.versionKey === versionKey);
+	return source ? resolve(_projectRoot, source.sourcePath) : null;
+}
+function walkFiles(dir) {
+	const results = [];
+	if (!existsSync(dir)) return results;
+	const exts = (_config.include ?? ["**/*.mdx", "**/*.md"]).map((p) => p.replace("**/*", ""));
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) results.push(...walkFiles(fullPath));
+		else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(fullPath);
+	}
+	return results;
+}
+function ensureScanned(version) {
+	const cache = getCache();
+	const enDir = getSourcePath(version);
+	if (!enDir || !existsSync(enDir)) return;
+	const files = walkFiles(enDir);
+	if (cache.sourceCount(version) >= files.length) return;
+	cache.clearSources("", version);
+	for (const file of files) {
+		const relPath = file.slice(enDir.length + 1);
+		const content = readFileSync(file, "utf8");
+		const nodes = parseMdx(content);
+		for (const node of nodes) if (node.needsTranslation && node.md5) {
+			const line = content.substring(0, node.startOffset).split("\n").length;
+			cache.setSource(node.md5, node.rawText, node.type);
+			cache.updateSource("", node.md5, relPath, line, version);
+		}
+	}
+}
+function rescan(version) {
+	const cache = getCache();
+	const enDir = getSourcePath(version);
+	if (!enDir || !existsSync(enDir)) return 0;
+	const files = walkFiles(enDir);
+	cache.clearSources("", version);
+	for (const file of files) {
+		const relPath = file.slice(enDir.length + 1);
+		const content = readFileSync(file, "utf8");
+		const nodes = parseMdx(content);
+		for (const node of nodes) if (node.needsTranslation && node.md5) {
+			const line = content.substring(0, node.startOffset).split("\n").length;
+			cache.setSource(node.md5, node.rawText, node.type);
+			cache.updateSource("", node.md5, relPath, line, version);
+		}
+	}
+	return files.length;
+}
+function getOverview() {
+	const cache = getCache();
+	const versions = getVersions();
+	const langs = getLangs();
+	const result = {};
+	for (const version of versions) {
+		ensureScanned(version);
+		const enDir = getSourcePath(version);
+		const enFileCount = enDir && existsSync(enDir) ? walkFiles(enDir).length : 0;
+		const langStats = {};
+		for (const lang of langs) {
+			const sections = cache.sectionStats(version, lang);
+			let totalFiles = 0, translatedFiles = 0, totalNodes = 0, translatedNodes = 0;
+			const sectionMap = {};
+			for (const s of sections) {
+				sectionMap[s.section] = s;
+				totalFiles += s.totalFiles;
+				translatedFiles += s.translatedFiles;
+				totalNodes += s.totalNodes;
+				translatedNodes += s.translatedNodes;
+			}
+			langStats[lang] = {
+				sections: sectionMap,
+				totalFiles,
+				translatedFiles,
+				totalNodes,
+				translatedNodes
+			};
+		}
+		result[version] = {
+			enFileCount,
+			langs: langStats
+		};
+	}
+	return result;
+}
+function getFileCoverage(version, lang) {
+	ensureScanned(version);
+	return getCache().fileCoverage(version, lang);
+}
+function getFileBlocks(version, lang, file) {
+	const enDir = getSourcePath(version);
+	if (!enDir) return null;
+	const enPath = join(enDir, file);
+	if (!existsSync(enPath)) return null;
+	const cache = getCache();
+	const content = readFileSync(enPath, "utf8");
+	const nodes = parseMdx(content);
+	const blocks = [];
+	let lastEnd = 0;
+	for (const node of nodes) {
+		if (node.startOffset > lastEnd) {
+			const gap = content.substring(lastEnd, node.startOffset);
+			blocks.push({
+				md5: null,
+				type: "gap",
+				source: gap,
+				translation: null
+			});
+		}
+		if (node.needsTranslation && node.md5) {
+			const translation = lang === "en" ? null : cache.get(lang, node.md5) ?? null;
+			blocks.push({
+				md5: node.md5,
+				type: node.type,
+				source: node.rawText,
+				translation
+			});
+		} else blocks.push({
+			md5: null,
+			type: node.type,
+			source: node.rawText,
+			translation: null
+		});
+		lastEnd = node.endOffset;
+	}
+	if (lastEnd < content.length) {
+		const tail = content.substring(lastEnd);
+		if (tail.trim()) blocks.push({
+			md5: null,
+			type: "gap",
+			source: tail,
+			translation: null
+		});
+	}
+	return blocks;
+}
+//#endregion
+export { getCache, getFileBlocks, getFileCoverage, getLangs, getOverview, getVersions, initStatus, rescan };

package/admin/dist/server/assets/status-D7PU72hm.js

@@ -0,0 +1,262 @@
+import { t as createServerFn } from "../server.js";
+import { t as createServerRpc } from "./createServerRpc-Cyyxq9HQ.js";
+import { getCache, getFileBlocks, getFileCoverage, getLangs, getOverview, getVersions, rescan } from "./status-B1AGLvHn.js";
+import { ensureInit } from "./init-CJJUsPDL.js";
+//#region server/services/d1-status.ts
+/**
+* D1-backed status service for CF Workers deployment.
+*
+* Queries the same sources/source_files/translations tables as the local
+* TranslationCache, but via D1 instead of better-sqlite3.
+*
+* This is read-only — the admin dashboard on CF Workers can view
+* translation status but cannot run translate jobs or modify the cache.
+*/
+function getD1() {
+	try {
+		return globalThis.__D1_DB ?? null;
+	} catch {
+		return null;
+	}
+}
+function requireD1() {
+	const db = getD1();
+	if (!db) throw new Error("D1 database not available");
+	return db;
+}
+async function d1GetVersions() {
+	return (await requireD1().prepare("SELECT DISTINCT version FROM source_files ORDER BY version").all()).results.map((r) => r.version);
+}
+async function d1GetLangs() {
+	return (await requireD1().prepare("SELECT DISTINCT lang FROM translations ORDER BY lang").all()).results.map((r) => r.lang);
+}
+async function d1SectionStats(version, lang) {
+	return (await requireD1().prepare(`
+      WITH file_coverage AS (
+        SELECT
+          sf.file,
+          CASE
+            WHEN sf.file LIKE 'docs/%' THEN 'docs'
+            WHEN sf.file LIKE 'blog/%' THEN 'blog'
+            WHEN sf.file LIKE 'learn/%' THEN 'learn'
+            ELSE 'other'
+          END as section,
+          COUNT(DISTINCT sf.key) as total_nodes,
+          COUNT(DISTINCT t.key) as translated_nodes
+        FROM source_files sf
+        LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+        WHERE sf.version = ?
+        GROUP BY sf.file
+      )
+      SELECT
+        section,
+        COUNT(*) as totalFiles,
+        SUM(CASE WHEN translated_nodes = total_nodes THEN 1 ELSE 0 END) as translatedFiles,
+        SUM(total_nodes) as totalNodes,
+        SUM(translated_nodes) as translatedNodes
+      FROM file_coverage
+      GROUP BY section
+      ORDER BY section
+    `).bind(lang, version).all()).results;
+}
+async function d1FileCoverage(version, lang) {
+	return (await requireD1().prepare(`
+      SELECT
+        sf.file,
+        COUNT(DISTINCT sf.key) as total,
+        COUNT(DISTINCT t.key) as translated
+      FROM source_files sf
+      LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+      WHERE sf.version = ?
+      GROUP BY sf.file
+      ORDER BY sf.file
+    `).bind(lang, version).all()).results;
+}
+async function d1FileDetail(version, lang, file) {
+	return (await requireD1().prepare(`
+      SELECT
+        s.key,
+        s.text as source,
+        s.type,
+        t.value as translation,
+        sf.line
+      FROM source_files sf
+      JOIN sources s ON s.key = sf.key
+      LEFT JOIN translations t ON t.key = sf.key AND t.lang = ?
+      WHERE sf.version = ? AND sf.file = ?
+      ORDER BY sf.line
+    `).bind(lang, version, file).all()).results;
+}
+async function d1DeleteTranslation(lang, key) {
+	return ((await requireD1().prepare("DELETE FROM translations WHERE lang = ? AND key = ?").bind(lang, key).run()).meta?.changes ?? 0) > 0;
+}
+async function d1GetOverview(versions, langs) {
+	const db = requireD1();
+	const result = {};
+	for (const version of versions) {
+		const enFileCount = (await db.prepare("SELECT COUNT(DISTINCT file) as count FROM source_files WHERE version = ?").bind(version).first())?.count ?? 0;
+		const langStats = {};
+		for (const lang of langs) {
+			const sections = await d1SectionStats(version, lang);
+			let totalFiles = 0, translatedFiles = 0, totalNodes = 0, translatedNodes = 0;
+			const sectionMap = {};
+			for (const s of sections) {
+				sectionMap[s.section] = s;
+				totalFiles += s.totalFiles;
+				translatedFiles += s.translatedFiles;
+				totalNodes += s.totalNodes;
+				translatedNodes += s.translatedNodes;
+			}
+			langStats[lang] = {
+				sections: sectionMap,
+				totalFiles,
+				translatedFiles,
+				totalNodes,
+				translatedNodes
+			};
+		}
+		result[version] = {
+			enFileCount,
+			langs: langStats
+		};
+	}
+	return result;
+}
+/**
+* Get file blocks from D1 — returns source nodes with their translations,
+* in line order. Note: without filesystem access, we can only return
+* translatable blocks (no gap/whitespace blocks between them).
+*/
+async function d1GetFileBlocks(version, lang, file) {
+	return (await d1FileDetail(version, lang, file)).map((row) => ({
+		md5: row.key,
+		type: row.type,
+		source: row.source,
+		translation: row.translation
+	}));
+}
+//#endregion
+//#region server/functions/status.ts?tss-serverfn-split
+function isCfWorkers() {
+	return !!globalThis.__CF_WORKERS;
+}
+var fetchStatus_createServerFn_handler = createServerRpc({
+	id: "4e218d79545765572808c7eab33b7663d4496209c15406d0b449366905b6b83f",
+	name: "fetchStatus",
+	filename: "server/functions/status.ts"
+}, (opts) => fetchStatus.__executeServer(opts));
+var fetchStatus = createServerFn({ method: "GET" }).handler(fetchStatus_createServerFn_handler, async () => {
+	if (isCfWorkers()) {
+		const versions = await d1GetVersions();
+		const langs = await d1GetLangs();
+		const data = await d1GetOverview(versions, langs);
+		return {
+			versions,
+			langs: ["en", ...langs],
+			data
+		};
+	}
+	await ensureInit();
+	return {
+		versions: getVersions(),
+		langs: ["en", ...getLangs()],
+		data: getOverview()
+	};
+});
+var fetchFileCoverage_createServerFn_handler = createServerRpc({
+	id: "843cd8b59095708a5ae78198708db9850f89fd3dd3830ab236f0bd924417692f",
+	name: "fetchFileCoverage",
+	filename: "server/functions/status.ts"
+}, (opts) => fetchFileCoverage.__executeServer(opts));
+var fetchFileCoverage = createServerFn({ method: "GET" }).inputValidator((d) => d).handler(fetchFileCoverage_createServerFn_handler, async ({ data }) => {
+	const { version, lang } = data;
+	if (isCfWorkers()) {
+		if (lang === "en") {
+			const anyLang = (await d1GetLangs())[0];
+			if (!anyLang) return [];
+			return (await d1FileCoverage(version, anyLang)).map((f) => ({
+				file: f.file,
+				total: f.total,
+				translated: f.total
+			}));
+		}
+		return d1FileCoverage(version, lang);
+	}
+	await ensureInit();
+	if (lang === "en") {
+		const anyLang = getLangs()[0];
+		return getFileCoverage(version, anyLang).map((f) => ({
+			file: f.file,
+			total: f.total,
+			translated: f.total
+		}));
+	}
+	return getFileCoverage(version, lang);
+});
+var fetchFileBlocks_createServerFn_handler = createServerRpc({
+	id: "e1e7281e45375c67dbe408c58452e7482b139da60e9e361615553227dce95ee0",
+	name: "fetchFileBlocks",
+	filename: "server/functions/status.ts"
+}, (opts) => fetchFileBlocks.__executeServer(opts));
+var fetchFileBlocks = createServerFn({ method: "GET" }).inputValidator((d) => d).handler(fetchFileBlocks_createServerFn_handler, async ({ data }) => {
+	const { version, lang, path } = data;
+	if (isCfWorkers()) {
+		const blocks = await d1GetFileBlocks(version, lang, path);
+		if (!blocks || blocks.length === 0) throw new Error("File not found");
+		return {
+			file: path,
+			lang,
+			version,
+			blocks
+		};
+	}
+	await ensureInit();
+	const blocks = getFileBlocks(version, lang, path);
+	if (!blocks) throw new Error("File not found");
+	return {
+		file: path,
+		lang,
+		version,
+		blocks
+	};
+});
+var deleteCacheEntry_createServerFn_handler = createServerRpc({
+	id: "e1d13d8602339a95f559345ccfc82e9f843dd375ce8e9f580637c241e7e44774",
+	name: "deleteCacheEntry",
+	filename: "server/functions/status.ts"
+}, (opts) => deleteCacheEntry.__executeServer(opts));
+var deleteCacheEntry = createServerFn({ method: "POST" }).inputValidator((d) => d).handler(deleteCacheEntry_createServerFn_handler, async ({ data }) => {
+	const { lang, key } = data;
+	if (isCfWorkers()) {
+		await d1DeleteTranslation(lang, key);
+		return {
+			deleted: key,
+			lang
+		};
+	}
+	await ensureInit();
+	getCache().db.prepare("DELETE FROM translations WHERE lang = ? AND key = ?").run(lang, key);
+	return {
+		deleted: key,
+		lang
+	};
+});
+var rescanVersion_createServerFn_handler = createServerRpc({
+	id: "1d8e3916f992485c62e62c3693083850b773fdff4ec54277de5a01eb98dab664",
+	name: "rescanVersion",
+	filename: "server/functions/status.ts"
+}, (opts) => rescanVersion.__executeServer(opts));
+var rescanVersion = createServerFn({ method: "POST" }).inputValidator((d) => d).handler(rescanVersion_createServerFn_handler, async ({ data }) => {
+	if (isCfWorkers()) return {
+		version: data.version,
+		files: 0
+	};
+	await ensureInit();
+	const count = rescan(data.version);
+	return {
+		version: data.version,
+		files: count
+	};
+});
+//#endregion
+export { deleteCacheEntry_createServerFn_handler, fetchFileBlocks_createServerFn_handler, fetchFileCoverage_createServerFn_handler, fetchStatus_createServerFn_handler, rescanVersion_createServerFn_handler };

package/admin/dist/server/assets/string-B4XlckmJ.js

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.bun/@better-auth+core@1.5.6+b884d6c866886bb4/node_modules/@better-auth/core/dist/utils/string.mjs
+function capitalizeFirstLetter(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//#endregion
+export { capitalizeFirstLetter as t };

package/admin/dist/server/assets/useNavigate-0H08s_Q2.js

@@ -0,0 +1,29 @@
+import { i as __toESM } from "./chunk-CNvmzFzq.js";
+import { l as require_react, t as useRouter } from "./useRouter-BXJvr8to.js";
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useNavigate.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+/**
+* Imperative navigation hook.
+*
+* Returns a stable `navigate(options)` function to change the current location
+* programmatically. Prefer the `Link` component for user-initiated navigation,
+* and use this hook from effects, callbacks, or handlers where imperative
+* navigation is required.
+*
+* Options:
+* - `from`: Optional route base used to resolve relative `to` paths.
+*
+* @returns A function that accepts `NavigateOptions`.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useNavigateHook
+*/
+function useNavigate(_defaultOpts) {
+	const router = useRouter();
+	return import_react.useCallback((options) => {
+		return router.navigate({
+			...options,
+			from: options.from ?? _defaultOpts?.from
+		});
+	}, [_defaultOpts?.from, router]);
+}
+//#endregion
+export { useNavigate as t };