better-translation 0.1.0

package/dist/vite.mjs

@@ -0,0 +1,855 @@
+import { n as getMessageId, r as serializeMeta, t as getCallMessageId } from "./message-id-7Mx7G9xT.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { Visitor, parseSync } from "oxc-parser";
+//#region src/cache.ts
+const CURRENT_VERSION = 1;
+function createEmptyCache() {
+	return {
+		version: CURRENT_VERSION,
+		entries: {}
+	};
+}
+/** Loads the translation cache from disk, resetting it when the schema version changes. */
+function loadCache(path) {
+	if (!existsSync(path)) return createEmptyCache();
+	try {
+		const data = JSON.parse(readFileSync(path, "utf-8"));
+		if (data.version !== CURRENT_VERSION) return createEmptyCache();
+		return data;
+	} catch {
+		return createEmptyCache();
+	}
+}
+/** Persists the translation cache so future runs can reuse existing translations. */
+function saveCache(path, cache) {
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const next = JSON.stringify(cache, null, 2);
+	if (existsSync(path) && readFileSync(path, "utf-8") === next) return;
+	writeFileSync(path, next);
+}
+/** Builds the cache key used to distinguish translations by stable message id and locale. */
+function getCacheKey(messageId, locale) {
+	return `${messageId}\0${locale}`;
+}
+//#endregion
+//#region src/extractor.ts
+/** Extracts messages and source edits from a file in one coordinated parse pass. */
+function analyzeSourceFile(code, filename, markers) {
+	const messages = [];
+	const edits = [];
+	const result = parseSync(filename, code);
+	if (result.errors.length > 0) return {
+		parsed: false,
+		messages,
+		edits
+	};
+	const lineStarts = getLineStarts(code);
+	new Visitor({
+		CallExpression(node) {
+			if (node.callee.type === "Identifier" && markers.call.includes(node.callee.name) && node.arguments.length >= 1 && isStringLiteral(node.arguments[0])) {
+				const value = node.arguments[0].value;
+				const meta = getMetaArgument(node.arguments[1]);
+				const id = getCallMessageId(value, meta);
+				messages.push({
+					id,
+					defaultMessage: value,
+					meta: meta ?? {},
+					placeholders: [],
+					source: createSource({
+						filename,
+						lineStarts,
+						marker: node.callee.name,
+						kind: "call",
+						start: node.start,
+						end: node.end
+					})
+				});
+				const callOptionsEdit = createCallOptionsEdit(code, node.arguments, id);
+				if (callOptionsEdit) edits.push(callOptionsEdit);
+			}
+		},
+		JSXElement(node) {
+			const opening = node.openingElement;
+			if (opening.name.type === "JSXIdentifier" && opening.name.name === "Var" && opening.attributes.length === 0) {
+				const identifier = getVarChildIdentifier(node.children);
+				if (identifier) edits.push({
+					start: node.start,
+					end: node.end,
+					replacement: `<Var ${identifier}={${identifier}} />`
+				});
+			}
+			if (opening.name.type !== "JSXIdentifier") return;
+			if (!markers.component.includes(opening.name.name)) return;
+			const extraction = extractJSXChildren(node.children);
+			if (!extraction.valid) {
+				if (markers.logging) console.warn(`[better-translation] Non-static <${opening.name.name}> in ${filename}, skipping`);
+				return;
+			}
+			const context = getJSXStringAttribute(opening.attributes, "context");
+			const meta = context ? { context } : void 0;
+			const id = getJSXStringAttribute(opening.attributes, "id") ?? getMessageId(extraction.message, meta);
+			messages.push({
+				id,
+				defaultMessage: extraction.message,
+				meta: meta ?? {},
+				placeholders: extraction.placeholders,
+				source: createSource({
+					filename,
+					lineStarts,
+					marker: opening.name.name,
+					kind: "component",
+					start: node.start,
+					end: node.end
+				})
+			});
+			if (!hasJSXAttribute(opening.attributes, "id")) edits.push({
+				start: opening.name.end,
+				end: opening.name.end,
+				replacement: ` id="${id}"`
+			});
+		},
+		TaggedTemplateExpression(node) {
+			const tag = node.tag;
+			if (tag.type !== "CallExpression" || tag.callee.type !== "Identifier" || !markers.taggedTemplate.includes(tag.callee.name) || tag.arguments.length < 1 || !isStringLiteral(tag.arguments[0])) return;
+			const id = tag.arguments[0].value;
+			const extraction = extractTaggedTemplate(node.quasi);
+			if (!extraction.valid) {
+				if (markers.logging) console.warn(`[better-translation] Non-static tagged template in ${filename}, skipping`);
+				return;
+			}
+			messages.push({
+				id,
+				defaultMessage: extraction.message,
+				meta: {},
+				placeholders: extraction.placeholders,
+				source: createSource({
+					filename,
+					lineStarts,
+					marker: tag.callee.name,
+					kind: "tagged-template",
+					start: node.start,
+					end: node.end
+				})
+			});
+		}
+	}).visit(result.program);
+	return {
+		parsed: true,
+		messages,
+		edits
+	};
+}
+function isStringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string";
+}
+function getMetaArgument(node) {
+	if (!node) return void 0;
+	if (isStringLiteral(node)) return { context: node.value };
+	if (node.type !== "ObjectExpression") return void 0;
+	for (const property of node.properties) if (property.type === "ObjectProperty" && (property.key?.type === "Identifier" && property.key.name === "context" || property.key?.type === "Literal" && property.key.value === "context") && property.value && isStringLiteral(property.value)) return { context: property.value.value };
+}
+function createCallOptionsEdit(code, args, id) {
+	const optionsArg = args[1];
+	if (!optionsArg) return {
+		start: args[0].end,
+		end: args[0].end,
+		replacement: `, { id: ${JSON.stringify(id)} }`
+	};
+	if (isStringLiteral(optionsArg)) {
+		const contextValue = code.slice(optionsArg.start, optionsArg.end);
+		return {
+			start: optionsArg.start,
+			end: optionsArg.end,
+			replacement: `{ id: ${JSON.stringify(id)}, context: ${contextValue} }`
+		};
+	}
+	if (optionsArg.type !== "ObjectExpression") return void 0;
+	if (hasObjectProperty(optionsArg, "id")) return void 0;
+	const innerSource = code.slice(optionsArg.start, optionsArg.end).slice(1, -1);
+	const replacement = innerSource.trim().length > 0 ? `{ id: ${JSON.stringify(id)},${innerSource} }` : `{ id: ${JSON.stringify(id)} }`;
+	return {
+		start: optionsArg.start,
+		end: optionsArg.end,
+		replacement
+	};
+}
+function getJSXStringAttribute(attributes, name) {
+	for (const attr of attributes) if (attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === name && attr.value?.type === "Literal" && typeof attr.value.value === "string") return attr.value.value;
+}
+function hasJSXAttribute(attributes, name) {
+	return attributes.some((attr) => {
+		const attribute = attr;
+		return attribute?.type === "JSXAttribute" && attribute.name?.type === "JSXIdentifier" && attribute.name.name === name;
+	});
+}
+function hasObjectProperty(node, name) {
+	return node.properties.some((entry) => {
+		const property = entry;
+		if (property?.type !== "ObjectProperty") return false;
+		return property.key?.type === "Identifier" && property.key.name === name || property.key?.type === "Literal" && property.key.value === name;
+	});
+}
+function createSource({ filename, lineStarts, marker, kind, start, end }) {
+	const startPosition = getPosition(start, lineStarts);
+	const endPosition = getPosition(end, lineStarts);
+	return {
+		file: filename,
+		kind,
+		marker,
+		line: startPosition.line,
+		column: startPosition.column,
+		endLine: endPosition.line,
+		endColumn: endPosition.column,
+		start,
+		end
+	};
+}
+function getLineStarts(code) {
+	const starts = [0];
+	for (let i = 0; i < code.length; i++) if (code[i] === "\n") starts.push(i + 1);
+	return starts;
+}
+function getPosition(offset, lineStarts) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const lineStart = lineStarts[mid];
+		const nextLineStart = lineStarts[mid + 1] ?? Number.POSITIVE_INFINITY;
+		if (offset < lineStart) {
+			high = mid - 1;
+			continue;
+		}
+		if (offset >= nextLineStart) {
+			low = mid + 1;
+			continue;
+		}
+		return {
+			line: mid + 1,
+			column: offset - lineStart + 1
+		};
+	}
+	const lastLine = lineStarts.length - 1;
+	const lastStart = lineStarts[lastLine] ?? 0;
+	return {
+		line: lastLine + 1,
+		column: offset - lastStart + 1
+	};
+}
+function extractJSXChildren(children) {
+	const parts = [];
+	const placeholders = [];
+	for (const child of children) switch (child.type) {
+		case "JSXText":
+			parts.push(child.value);
+			break;
+		case "JSXElement": {
+			const name = child.openingElement.name;
+			if (name.type !== "JSXIdentifier" || name.name !== "Var") return {
+				message: "",
+				placeholders: [],
+				valid: false
+			};
+			const varName = getVarPlaceholderName(child);
+			if (!varName) return {
+				message: "",
+				placeholders: [],
+				valid: false
+			};
+			placeholders.push(varName);
+			parts.push(`{${varName}}`);
+			break;
+		}
+		case "JSXExpressionContainer":
+			if (child.expression.type !== "JSXEmptyExpression") return {
+				message: "",
+				placeholders: [],
+				valid: false
+			};
+			break;
+		default: break;
+	}
+	const message = parts.join("").replace(/\s+/g, " ").trim();
+	return {
+		message,
+		placeholders,
+		valid: message.length > 0
+	};
+}
+function getVarPlaceholderName(node) {
+	const explicitName = getJSXStringAttribute(node.openingElement.attributes, "name");
+	if (explicitName) return explicitName;
+	const customPropName = getSingleJSXAttributeName(node.openingElement.attributes);
+	if (customPropName) return customPropName;
+	return getVarChildIdentifier(node.children);
+}
+function getSingleJSXAttributeName(attributes) {
+	const keys = attributes.flatMap((attr) => {
+		const attribute = attr;
+		if (attribute?.type !== "JSXAttribute" || attribute.name?.type !== "JSXIdentifier") return [];
+		return [attribute.name.name];
+	});
+	return keys.length === 1 ? keys[0] : void 0;
+}
+function getVarChildIdentifier(children) {
+	const meaningfulChildren = children.filter((child) => !(child.type === "JSXText" && child.value.trim().length === 0));
+	if (meaningfulChildren.length !== 1) return void 0;
+	const [child] = meaningfulChildren;
+	if (!child || child.type !== "JSXExpressionContainer" || child.expression.type !== "Identifier") return void 0;
+	return child.expression.name;
+}
+function extractTaggedTemplate(quasi) {
+	const parts = [];
+	const placeholders = [];
+	for (let i = 0; i < quasi.quasis.length; i++) {
+		const element = quasi.quasis[i];
+		parts.push(element.value.cooked ?? element.value.raw);
+		if (i < quasi.expressions.length) {
+			const expr = quasi.expressions[i];
+			if (expr.type !== "CallExpression") return {
+				message: "",
+				placeholders: [],
+				valid: false
+			};
+			const call = expr;
+			if (call.callee.type !== "Identifier" || call.callee.name !== "v" || call.arguments.length < 2 || !isStringLiteral(call.arguments[0])) return {
+				message: "",
+				placeholders: [],
+				valid: false
+			};
+			const varName = call.arguments[0].value;
+			placeholders.push(varName);
+			parts.push(`{${varName}}`);
+		}
+	}
+	const message = parts.join("").trim();
+	return {
+		message,
+		placeholders,
+		valid: message.length > 0
+	};
+}
+//#endregion
+//#region src/runtime-config.ts
+const DEFAULT_LOCAL_OUTPUT_DIR = "src/lib/bt";
+const RUNTIME_CONFIG_FILENAME = "runtime.json";
+`${DEFAULT_LOCAL_OUTPUT_DIR}`;
+function getRuntimeConfigPath(root, dir) {
+	return resolve(root, dir, RUNTIME_CONFIG_FILENAME);
+}
+//#endregion
+//#region src/plugin.ts
+const PREFIX = "\x1B[36m[better-translation]\x1B[0m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+const YELLOW = "\x1B[33m";
+const BOLD = "\x1B[1m";
+const CYAN = "\x1B[36m";
+const REMOTE_API_BASE_URL = "https://better-translation.com";
+const REMOTE_STUB = `${YELLOW}stub${RESET}`;
+const DEFAULT_ROOT_DIR = "src";
+const DEFAULT_SCAN_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+const CALL_MARKERS = ["t", "useT"];
+const COMPONENT_MARKERS = ["T"];
+const TAGGED_TEMPLATE_MARKERS = ["msg"];
+const PRIVATE_MANIFEST_FILENAME = "manifest.json";
+const LOAD_MESSAGES_FILENAME = "load-messages.ts";
+const LOCALES_SUBDIR = "locales";
+const GITIGNORE_FILENAME = ".gitignore";
+const GITIGNORE_CONTENTS = [
+	"# Generated by better-translation/vite",
+	"manifest.json",
+	""
+].join("\n");
+function formatLocale(locale) {
+	return locale.toUpperCase();
+}
+function formatLocales(locales) {
+	return locales.map(formatLocale).join(", ");
+}
+/** Scans source files for translatable messages and keeps locale JSON files in sync. */
+function betterTranslate(options) {
+	const { locales, defaultLocale = locales[0] ?? "en", rootDir = DEFAULT_ROOT_DIR, cacheFile = ".cache/better-translation.json", logging = true, storage = {
+		type: "bundle",
+		output: DEFAULT_LOCAL_OUTPUT_DIR
+	}, translate } = options;
+	const usesBundleStorage = storage.type === "bundle";
+	const localesDir = storage.type === "bundle" ? storage.output ?? "src/lib/bt" : DEFAULT_LOCAL_OUTPUT_DIR;
+	const remoteUrl = storage.type === "remote" ? storage.url ?? REMOTE_API_BASE_URL : REMOTE_API_BASE_URL;
+	const manifest = {};
+	const fileMessages = /* @__PURE__ */ new Map();
+	let cache = createEmptyCache();
+	let root = "";
+	let isDev = false;
+	let translateTimer = null;
+	let warnedRemoteTranslateStub = false;
+	let warnedRemoteSyncStub = false;
+	let sourceRoots = [];
+	function log(message) {
+		if (logging) console.log(message);
+	}
+	async function remoteTranslate(messages, _locale) {
+		if (!warnedRemoteTranslateStub) {
+			warnedRemoteTranslateStub = true;
+			log(`${PREFIX} ${REMOTE_STUB} remote translate via ${DIM}${remoteUrl}${RESET} not implemented yet`);
+		}
+		return Object.fromEntries(messages.map((message) => [message.id, message.text]));
+	}
+	async function syncRemote() {
+		if (!warnedRemoteSyncStub) {
+			warnedRemoteSyncStub = true;
+			log(`${PREFIX} ${REMOTE_STUB} remote locale sync via ${DIM}${remoteUrl}${RESET} not implemented yet`);
+		}
+	}
+	const resolvedTranslate = translate ?? (usesBundleStorage ? void 0 : remoteTranslate);
+	function buildMessageManifest() {
+		return Object.fromEntries(Object.entries(manifest).map(([id, entry]) => [id, {
+			defaultMessage: entry.defaultMessage,
+			meta: entry.meta,
+			placeholders: entry.placeholders,
+			sources: entry.sources
+		}]));
+	}
+	function shouldScanFile(id) {
+		const cleanId = id.split("?", 1)[0] ?? id;
+		if (cleanId.includes("node_modules")) return false;
+		if (!DEFAULT_SCAN_EXTENSIONS.find((ext) => cleanId.endsWith(ext))) return false;
+		return sourceRoots.some((sourceRoot) => cleanId === sourceRoot || cleanId.startsWith(`${sourceRoot}/`) || cleanId.startsWith(`${sourceRoot}\\`));
+	}
+	function getPrivateManifestPath() {
+		return resolve(root, localesDir, PRIVATE_MANIFEST_FILENAME);
+	}
+	function getRuntimeConfig() {
+		return {
+			storage: usesBundleStorage ? {
+				type: "bundle",
+				output: localesDir
+			} : {
+				type: "remote",
+				url: remoteUrl
+			},
+			defaultLocale,
+			locales
+		};
+	}
+	function writeRuntimeConfig() {
+		if (!usesBundleStorage) return;
+		const runtimeConfig = JSON.stringify(getRuntimeConfig(), null, 2) + "\n";
+		const path = getRuntimeConfigPath(root, localesDir);
+		const dir = dirname(path);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileIfChanged(path, runtimeConfig);
+	}
+	function getLocalesDirPath() {
+		return resolve(root, localesDir, LOCALES_SUBDIR);
+	}
+	function getLocalePath(locale) {
+		return resolve(getLocalesDirPath(), `${locale}.json`);
+	}
+	function readLocaleMessages(locale) {
+		const path = getLocalePath(locale);
+		if (!existsSync(path)) return {};
+		try {
+			return normalizeLocaleMessages(JSON.parse(readFileSync(path, "utf-8")));
+		} catch {
+			return {};
+		}
+	}
+	function writePrivateManifest() {
+		if (!usesBundleStorage) return;
+		const path = getPrivateManifestPath();
+		const dir = dirname(path);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileIfChanged(path, JSON.stringify(buildMessageManifest(), null, 2) + "\n");
+	}
+	function assertFileContents(path, expected, label) {
+		if (!existsSync(path)) throw new Error(`${PREFIX} missing committed ${label} at ${relative(root, path)}`);
+		if (readFileSync(path, "utf-8") !== expected) throw new Error([
+			`${PREFIX} committed ${label} is out of date`,
+			`expected committed file at ${relative(root, path)} to match the generated output`,
+			`run the dev workflow to regenerate locale artifacts and commit the result`
+		].join("\n"));
+	}
+	function buildLoadMessagesModule() {
+		const localeUnion = locales.map((locale) => JSON.stringify(locale)).join(" | ");
+		const importLines = locales.map((locale) => `import messages_${locale} from "./${LOCALES_SUBDIR}/${locale}.json"`);
+		const caseLines = locales.map((locale) => `    case ${JSON.stringify(locale)}: return messages_${locale}`);
+		return [
+			...importLines,
+			"",
+			`export type AppLocale = ${localeUnion}`,
+			"",
+			"export async function loadMessages(locale: AppLocale): Promise<Record<string, string>> {",
+			"  switch (locale) {",
+			...caseLines,
+			`    default: return messages_${defaultLocale}`,
+			"  }",
+			"}",
+			""
+		].join("\n");
+	}
+	function writeLoadMessagesModule() {
+		if (!usesBundleStorage) return;
+		const path = resolve(root, localesDir, LOAD_MESSAGES_FILENAME);
+		const dir = dirname(path);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const next = buildLoadMessagesModule();
+		if (existsSync(path) && readFileSync(path, "utf-8") === next) return;
+		writeFileSync(path, next);
+	}
+	function writeGitignore() {
+		if (!usesBundleStorage) return;
+		const path = resolve(root, localesDir, GITIGNORE_FILENAME);
+		const dir = dirname(path);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileIfChanged(path, GITIGNORE_CONTENTS);
+	}
+	function assertGeneratedFilesCommitted() {
+		if (!usesBundleStorage) return;
+		assertFileContents(getRuntimeConfigPath(root, localesDir), JSON.stringify(getRuntimeConfig(), null, 2) + "\n", "runtime config");
+		assertFileContents(resolve(root, localesDir, LOAD_MESSAGES_FILENAME), buildLoadMessagesModule(), "load-messages module");
+		assertFileContents(resolve(root, localesDir, GITIGNORE_FILENAME), GITIGNORE_CONTENTS, "generated .gitignore");
+	}
+	function buildLocalLocaleMessages(locale, options) {
+		const existingMessages = readLocaleMessages(locale);
+		const messages = options.pruneOrphans ? {} : { ...existingMessages };
+		if (locale === defaultLocale) {
+			for (const [id, entry] of Object.entries(manifest)) messages[id] = entry.defaultMessage;
+			return messages;
+		}
+		for (const id of Object.keys(manifest)) {
+			if (Object.hasOwn(messages, id)) continue;
+			if (Object.hasOwn(existingMessages, id)) {
+				messages[id] = existingMessages[id];
+				continue;
+			}
+			const cachedMessage = cache.entries[getCacheKey(id, locale)]?.translation;
+			if (cachedMessage !== void 0) messages[id] = cachedMessage;
+		}
+		return messages;
+	}
+	function writeLocaleFilesToDisk(options = { pruneOrphans: false }) {
+		if (!usesBundleStorage) return;
+		const dir = getLocalesDirPath();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		for (const locale of locales) writeFileIfChanged(resolve(dir, `${locale}.json`), JSON.stringify(buildLocalLocaleMessages(locale, options), null, 2) + "\n");
+		writeLoadMessagesModule();
+	}
+	function getMissingMessagesByLocale() {
+		const missingByLocale = /* @__PURE__ */ new Map();
+		for (const locale of locales) {
+			if (locale === defaultLocale) continue;
+			const existingMessages = readLocaleMessages(locale);
+			for (const [id, entry] of Object.entries(manifest)) if (!Object.hasOwn(existingMessages, id) && !Object.hasOwn(cache.entries, getCacheKey(id, locale))) {
+				const misses = missingByLocale.get(locale) ?? [];
+				misses.push({
+					id,
+					text: entry.defaultMessage,
+					meta: entry.meta,
+					placeholders: entry.placeholders,
+					sources: entry.sources
+				});
+				missingByLocale.set(locale, misses);
+			}
+		}
+		return missingByLocale;
+	}
+	function assertLocalBuildTranslationsComplete() {
+		const expectedIds = new Set(Object.keys(manifest));
+		const issues = [];
+		for (const locale of locales) {
+			const localePath = getLocalePath(locale);
+			if (!existsSync(localePath)) {
+				issues.push(`- ${locale}: missing file at ${relative(root, localePath)}`);
+				continue;
+			}
+			const localeMessages = readLocaleMessages(locale);
+			const missingIds = [...expectedIds].filter((id) => !Object.hasOwn(localeMessages, id));
+			const orphanIds = Object.keys(localeMessages).filter((id) => !expectedIds.has(id));
+			if (locale === defaultLocale) {
+				const staleIds = [...expectedIds].filter((id) => localeMessages[id] !== manifest[id].defaultMessage);
+				if (missingIds.length > 0) issues.push(formatLocaleIssue(locale, "missing", missingIds));
+				if (orphanIds.length > 0) issues.push(formatLocaleIssue(locale, "orphaned", orphanIds));
+				if (staleIds.length > 0) issues.push(formatLocaleIssue(locale, "outdated default messages", staleIds));
+				continue;
+			}
+			if (missingIds.length > 0) issues.push(formatLocaleIssue(locale, "missing", missingIds));
+			if (orphanIds.length > 0) issues.push(formatLocaleIssue(locale, "orphaned", orphanIds));
+		}
+		if (issues.length === 0) return;
+		throw new Error([
+			`${PREFIX} committed locale artifacts are out of sync for local production build`,
+			`local production builds are check-only and never regenerate locale files`,
+			`run the dev workflow to regenerate locale artifacts and commit the result`,
+			...issues
+		].join("\n"));
+	}
+	async function translateMissingMessages() {
+		if (!resolvedTranslate) return false;
+		const missingByLocale = getMissingMessagesByLocale();
+		const totalMisses = [...missingByLocale.values()].reduce((count, misses) => count + misses.length, 0);
+		if (totalMisses === 0) return false;
+		const missLocales = [...missingByLocale.keys()];
+		log(`${PREFIX} ${BOLD}Translating${RESET} ${CYAN}${totalMisses}${RESET} ${totalMisses === 1 ? "Message" : "Messages"} -> ${CYAN}${formatLocales(missLocales)}${RESET}`);
+		for (const [locale, misses] of missingByLocale) {
+			const result = await resolvedTranslate(misses, locale);
+			for (const miss of misses) {
+				const translated = result[miss.id] ?? miss.text;
+				cache.entries[getCacheKey(miss.id, locale)] = {
+					sourceText: miss.text,
+					meta: miss.meta,
+					locale,
+					translation: translated,
+					timestamp: Date.now()
+				};
+			}
+		}
+		return true;
+	}
+	function scheduleDevTranslation() {
+		if (!resolvedTranslate) return;
+		if (!isDev) return;
+		if (translateTimer) clearTimeout(translateTimer);
+		translateTimer = setTimeout(async () => {
+			if (await translateMissingMessages()) saveCache(resolve(root, cacheFile), cache);
+			writeLocaleFilesToDisk();
+			writePrivateManifest();
+		}, 1e3);
+	}
+	function removeFileMessages(file) {
+		const previous = fileMessages.get(file);
+		if (!previous) return false;
+		for (const message of previous) {
+			const entry = manifest[message.id];
+			if (!entry) continue;
+			entry.sources = entry.sources.filter((source) => !isSameSource(source, message.source));
+			if (entry.sources.length === 0) delete manifest[message.id];
+		}
+		fileMessages.delete(file);
+		return true;
+	}
+	function syncFileMessages(file, messages) {
+		const previousMessages = fileMessages.get(file) ?? [];
+		const nextEntries = groupMessagesById(messages);
+		for (const [id, entry] of Object.entries(nextEntries)) {
+			const existing = manifest[id];
+			if (existing && !hasSameMessageShape(existing, entry)) throw new Error(formatCollisionError(id, existing, entry));
+		}
+		removeFileMessages(file);
+		for (const [id, entry] of Object.entries(nextEntries)) {
+			if (!manifest[id]) {
+				manifest[id] = entry;
+				continue;
+			}
+			for (const source of entry.sources) if (!manifest[id].sources.some((existingSource) => isSameSource(existingSource, source))) manifest[id].sources.push(source);
+		}
+		if (messages.length > 0) fileMessages.set(file, messages);
+		return {
+			manifestChanged: previousMessages.length !== messages.length || previousMessages.some((message, index) => !isSameExtractedMessage(message, messages[index])),
+			localeMessagesChanged: previousMessages.length !== messages.length || previousMessages.some((message, index) => !hasSameMessageShape(message, messages[index]))
+		};
+	}
+	function syncSourceCode(file, code) {
+		const analysis = analyzeSourceFile(code, file, {
+			call: CALL_MARKERS,
+			component: COMPONENT_MARKERS,
+			taggedTemplate: TAGGED_TEMPLATE_MARKERS,
+			logging
+		});
+		if (!analysis.parsed) return null;
+		return syncFileMessages(file, analysis.messages.map((message) => ({
+			...message,
+			source: {
+				...message.source,
+				file: toRootRelativePath(message.source.file)
+			}
+		})));
+	}
+	function removeTrackedFile(file) {
+		const hadPreviousMessages = removeFileMessages(file);
+		return {
+			manifestChanged: hadPreviousMessages,
+			localeMessagesChanged: hadPreviousMessages
+		};
+	}
+	function applySyncResult(syncResult, options) {
+		if (!syncResult) return;
+		if (syncResult.localeMessagesChanged) {
+			writeLocaleFilesToDisk();
+			writePrivateManifest();
+			if (options.scheduleTranslation) scheduleDevTranslation();
+			return;
+		}
+		if (syncResult.manifestChanged) writePrivateManifest();
+	}
+	function scanAllSourceFiles() {
+		for (const id of Object.keys(manifest)) delete manifest[id];
+		fileMessages.clear();
+		for (const sourceRoot of sourceRoots) {
+			if (!existsSync(sourceRoot)) continue;
+			for (const file of collectScanFiles(sourceRoot).sort()) syncSourceCode(file, readFileSync(file, "utf-8"));
+		}
+	}
+	function toRootRelativePath(file) {
+		return relative(root, file).replaceAll("\\", "/");
+	}
+	return {
+		name: "better-translation-extract",
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+			isDev = config.command === "serve";
+			sourceRoots = (Array.isArray(rootDir) ? rootDir : [rootDir]).map((dir) => resolve(root, dir));
+			log(`${PREFIX} Locales: ${CYAN}${formatLocales(locales)}${RESET} | Default: ${CYAN}${formatLocale(defaultLocale)}${RESET} | Storage: ${CYAN}${usesBundleStorage ? "Bundle" : "Remote"}${RESET} | Out Dir: ${DIM}${usesBundleStorage ? localesDir : "n/a"}${RESET} | Roots: ${DIM}${(Array.isArray(rootDir) ? rootDir : [rootDir]).join(", ")}${RESET}`);
+		},
+		buildStart() {
+			cache = loadCache(resolve(root, cacheFile));
+			scanAllSourceFiles();
+			if (usesBundleStorage && !isDev) {
+				assertGeneratedFilesCommitted();
+				assertLocalBuildTranslationsComplete();
+				return;
+			}
+			writeRuntimeConfig();
+			writeLoadMessagesModule();
+			writeGitignore();
+			writeLocaleFilesToDisk();
+			writePrivateManifest();
+		},
+		configureServer(server) {
+			server.watcher.add(sourceRoots);
+			const syncFileFromDisk = (file) => {
+				if (!shouldScanFile(file) || !existsSync(file)) return;
+				applySyncResult(syncSourceCode(file, readFileSync(file, "utf-8")), { scheduleTranslation: true });
+			};
+			const removeFileFromManifest = (file) => {
+				if (!shouldScanFile(file)) return;
+				applySyncResult(removeTrackedFile(file), { scheduleTranslation: true });
+			};
+			server.watcher.on("add", syncFileFromDisk);
+			server.watcher.on("change", syncFileFromDisk);
+			server.watcher.on("unlink", removeFileFromManifest);
+		},
+		transform(code, id) {
+			const cleanId = id.split("?", 1)[0] ?? id;
+			if (!shouldScanFile(cleanId)) return;
+			const analysis = analyzeSourceFile(code, cleanId, {
+				call: CALL_MARKERS,
+				component: COMPONENT_MARKERS,
+				taggedTemplate: TAGGED_TEMPLATE_MARKERS,
+				logging
+			});
+			if (analysis.edits.length === 0) return;
+			return {
+				code: applyEdits(code, analysis.edits),
+				map: null
+			};
+		},
+		async generateBundle() {
+			if (usesBundleStorage) {
+				if (!isDev) assertGeneratedFilesCommitted();
+				assertLocalBuildTranslationsComplete();
+			} else await translateMissingMessages();
+			if (!usesBundleStorage) await syncRemote();
+		},
+		closeBundle() {
+			if (usesBundleStorage && !isDev) return;
+			saveCache(resolve(root, cacheFile), cache);
+		}
+	};
+}
+function formatLocaleIssue(locale, label, ids) {
+	return `- ${locale}: ${label} (${ids.slice(0, 5).map((id) => JSON.stringify(id)).join(", ")}${ids.length > 5 ? `, ... ${ids.length - 5} more` : ""})`;
+}
+function normalizeLocaleMessages(input) {
+	if (isRuntimeMessages(input)) return input;
+	if (typeof input === "object" && input !== null && "messages" in input && typeof input.messages === "object" && input.messages !== null) return Object.fromEntries(Object.entries(input.messages).flatMap(([id, entry]) => typeof entry === "object" && entry !== null && "translation" in entry && typeof entry.translation === "string" ? [[id, entry.translation]] : []));
+	return {};
+}
+function writeFileIfChanged(path, contents) {
+	if (existsSync(path) && readFileSync(path, "utf-8") === contents) return false;
+	writeFileSync(path, contents);
+	return true;
+}
+function collectScanFiles(root) {
+	const files = [];
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		const path = resolve(root, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === "node_modules") continue;
+			files.push(...collectScanFiles(path));
+			continue;
+		}
+		files.push(path);
+	}
+	return files;
+}
+function isRuntimeMessages(input) {
+	return typeof input === "object" && input !== null && Object.values(input).every((value) => typeof value === "string");
+}
+function applyEdits(code, edits) {
+	let transformed = code;
+	for (const edit of [...edits].sort((a, b) => b.start - a.start)) transformed = `${transformed.slice(0, edit.start)}${edit.replacement}${transformed.slice(edit.end)}`;
+	return transformed;
+}
+function groupMessagesById(messages) {
+	const grouped = {};
+	for (const message of messages) {
+		const existing = grouped[message.id];
+		if (existing && !hasSameMessageShape(existing, message)) throw new Error(formatCollisionError(message.id, existing, message));
+		if (!existing) {
+			grouped[message.id] = {
+				defaultMessage: message.defaultMessage,
+				meta: message.meta,
+				placeholders: message.placeholders,
+				sources: [message.source]
+			};
+			continue;
+		}
+		if (!existing.sources.some((source) => isSameSource(source, message.source))) existing.sources.push(message.source);
+	}
+	return grouped;
+}
+function hasSameMessageShape(existing, incoming) {
+	return existing.defaultMessage === incoming.defaultMessage && serializeMeta(existing.meta) === serializeMeta(incoming.meta) && JSON.stringify(existing.placeholders) === JSON.stringify(incoming.placeholders);
+}
+function isSameSource(left, right) {
+	return left.file === right.file && left.kind === right.kind && left.marker === right.marker && left.start === right.start && left.end === right.end;
+}
+function isSameExtractedMessage(left, right) {
+	if (!right) return false;
+	return hasSameMessageShape(left, right) && isSameSource(left.source, right.source);
+}
+function formatCollisionError(id, existing, incoming) {
+	const existingSources = formatSources(existing.sources);
+	const incomingSources = formatSources("source" in incoming ? [incoming.source] : incoming.sources);
+	return [
+		`${PREFIX} conflicting message definition for ${BOLD}"${id}"${RESET}`,
+		`existing: ${JSON.stringify({
+			defaultMessage: existing.defaultMessage,
+			meta: existing.meta,
+			placeholders: existing.placeholders
+		})}`,
+		`existing sources: ${existingSources}`,
+		`incoming: ${JSON.stringify({
+			defaultMessage: incoming.defaultMessage,
+			meta: incoming.meta,
+			placeholders: incoming.placeholders
+		})}`,
+		`incoming sources: ${incomingSources}`
+	].join("\n");
+}
+function formatSources(sources) {
+	return sources.map((source) => `${source.file}:${source.line}:${source.column}`).join(", ");
+}
+//#endregion
+export { betterTranslate };
+
+//# sourceMappingURL=vite.mjs.map