@let-value/translate-extract 1.0.9 → 1.0.10

package/dist/src/index.js

@@ -1,16 +1,58 @@
-import { run } from "../run-BMvkoNJ4.js";
+import { run } from "../run-CMzN4vHt.js";
 import path, { basename, dirname, extname, join, relative, resolve } from "node:path";
-import { globSync } from "glob";
 import fs, { readFile } from "node:fs/promises";
+import * as gettextParser from "gettext-parser";
 import fs$1 from "node:fs";
-import { memo } from "radash";
 import Parser from "tree-sitter";
 import JavaScript from "tree-sitter-javascript";
 import TS from "tree-sitter-typescript";
 import { ResolverFactory } from "oxc-resolver";
-import * as gettextParser from "gettext-parser";
 import { getFormula, getNPlurals } from "plural-forms";
 
+//#region src/plugins/cleanup/cleanup.ts
+function cleanup() {
+	return {
+		name: "cleanup",
+		setup(build) {
+			build.context.logger?.debug("cleanup plugin initialized");
+			const processedDirs = /* @__PURE__ */ new Set();
+			const generated = /* @__PURE__ */ new Set();
+			build.onResolve({
+				namespace: "cleanup",
+				filter: /.*/
+			}, (args) => {
+				generated.add(args.path);
+				return args;
+			});
+			build.onProcess({
+				namespace: "cleanup",
+				filter: /.*/
+			}, async ({ path: path$1 }) => {
+				await build.defer("translate");
+				const dir = dirname(path$1);
+				if (processedDirs.has(dir)) return void 0;
+				processedDirs.add(dir);
+				const files = await fs.readdir(dir).catch(() => []);
+				for (const f of files.filter((p) => p.endsWith(".po"))) {
+					const full = join(dir, f);
+					if (generated.has(full)) continue;
+					const contents = await fs.readFile(full).catch(() => void 0);
+					if (!contents) continue;
+					const parsed = gettextParser.po.parse(contents);
+					const hasTranslations = Object.entries(parsed.translations || {}).some(([ctx, msgs]) => Object.keys(msgs).some((id) => !(ctx === "" && id === "")));
+					if (hasTranslations) build.context.logger?.warn({ path: full }, "stray translation file");
+					else {
+						await fs.unlink(full);
+						build.context.logger?.info({ path: full }, "removed empty translation file");
+					}
+				}
+				return void 0;
+			});
+		}
+	};
+}
+
+//#endregion
 //#region src/plugins/core/queries/comment.ts
 function getReference(node, { path: path$1 }) {
 	const line = node.startPosition.row + 1;
@@ -390,7 +432,7 @@ const pluralQuery$1 = withComment({
 
 //#endregion
 //#region src/plugins/core/queries/index.ts
-const queries = [
+const queries$1 = [
 	messageQuery$1,
 	messageInvalidQuery,
 	gettextQuery,
@@ -413,28 +455,52 @@ function getLanguage(ext) {
 		default: return JavaScript;
 	}
 }
-const getCachedParser = memo(function getCachedParser$1(ext) {
-	const parser = new Parser();
-	const language = getLanguage(ext);
-	parser.setLanguage(language);
-	return {
-		parser,
-		language
-	};
-});
+const parserCache = /* @__PURE__ */ new Map();
+const queryCache = /* @__PURE__ */ new WeakMap();
+function getCachedParser(ext) {
+	let cached = parserCache.get(ext);
+	if (!cached) {
+		const parser = new Parser();
+		const language = getLanguage(ext);
+		parser.setLanguage(language);
+		cached = {
+			parser,
+			language
+		};
+		parserCache.set(ext, cached);
+	}
+	return cached;
+}
+function getCachedQuery(language, pattern) {
+	let cache = queryCache.get(language);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		queryCache.set(language, cache);
+	}
+	let query = cache.get(pattern);
+	if (!query) {
+		query = new Parser.Query(language, pattern);
+		cache.set(pattern, query);
+	}
+	return query;
+}
 function getParser(path$1) {
 	const ext = extname(path$1);
 	return getCachedParser(ext);
 }
+function getQuery(language, pattern) {
+	return getCachedQuery(language, pattern);
+}
 function parseSource$1(source, path$1) {
 	const context = { path: path$1 };
 	const { parser, language } = getParser(path$1);
 	const tree = parser.parse(source);
 	const translations = [];
+	const warnings = [];
 	const imports = [];
 	const seen = /* @__PURE__ */ new Set();
-	for (const spec of queries) {
-		const query = new Parser.Query(language, spec.pattern);
+	for (const spec of queries$1) {
+		const query = getCachedQuery(language, spec.pattern);
 		for (const match of query.matches(tree.rootNode)) {
 			const message = spec.extract(match);
 			if (!message) continue;
@@ -449,17 +515,21 @@ function parseSource$1(source, path$1) {
 					reference
 				}
 			});
-			if (error) console.warn(`Parsing error at ${reference}: ${error}`);
+			if (error) warnings.push({
+				error,
+				reference
+			});
 		}
 	}
-	const importTreeQuery = new Parser.Query(language, importQuery.pattern);
+	const importTreeQuery = getCachedQuery(language, importQuery.pattern);
 	for (const match of importTreeQuery.matches(tree.rootNode)) {
 		const imp = importQuery.extract(match);
 		if (imp) imports.push(imp);
 	}
 	return {
 		translations,
-		imports
+		imports,
+		warnings
 	};
 }
 
@@ -516,39 +586,55 @@ function resolveImports(file, imports) {
 //#endregion
 //#region src/plugins/core/core.ts
 const filter$1 = /\.([cm]?tsx?|jsx?)$/;
+const namespace$1 = "source";
 function core() {
 	return {
 		name: "core",
 		setup(build) {
 			build.context.logger?.debug("core plugin initialized");
-			build.onResolve({ filter: /.*/ }, ({ entrypoint, path: path$1 }) => {
+			build.onResolve({
+				filter: filter$1,
+				namespace: namespace$1
+			}, ({ entrypoint, path: path$1 }) => {
 				return {
 					entrypoint,
+					namespace: namespace$1,
 					path: resolve(path$1)
 				};
 			});
-			build.onLoad({ filter: filter$1 }, async ({ entrypoint, path: path$1 }) => {
-				const contents = await readFile(path$1, "utf8");
+			build.onLoad({
+				filter: filter$1,
+				namespace: namespace$1
+			}, async ({ entrypoint, path: path$1 }) => {
+				const data = await readFile(path$1, "utf8");
 				return {
 					entrypoint,
 					path: path$1,
-					contents
+					namespace: namespace$1,
+					data
 				};
 			});
-			build.onExtract({ filter: filter$1 }, ({ entrypoint, path: path$1, contents }) => {
-				const { translations, imports } = parseSource$1(contents, path$1);
+			build.onProcess({
+				filter: filter$1,
+				namespace: namespace$1
+			}, ({ entrypoint, path: path$1, data }) => {
+				const { translations, imports, warnings } = parseSource$1(data, path$1);
 				if (build.context.config.walk) {
 					const paths = resolveImports(path$1, imports);
-					for (const path$2 of paths) build.resolvePath({
+					for (const path$2 of paths) build.resolve({
 						entrypoint,
-						path: path$2
+						path: path$2,
+						namespace: namespace$1
 					});
 				}
-				return {
+				for (const warning of warnings) build.context.logger?.warn(`${warning.error} at ${warning.reference}`);
+				build.resolve({
 					entrypoint,
 					path: path$1,
-					translations
-				};
+					namespace: "translate",
+					data: translations
+				});
+				return void 0;
 			});
 		}
 	};
@@ -682,26 +768,74 @@ function merge(sources, existing, obsolete, locale, generatedAt) {
 	};
 	return gettextParser.po.compile(poObj).toString();
 }
+const namespace = "translate";
 function po() {
 	return {
 		name: "po",
 		setup(build) {
 			build.context.logger?.debug("po plugin initialized");
-			build.onCollect({ filter: /.*/ }, ({ entrypoint, translations, destination,...rest }, ctx) => {
-				const record = collect(translations, ctx.locale);
-				const redirected = join(dirname(destination), `${basename(destination, extname(destination))}.po`);
+			const collections = /* @__PURE__ */ new Map();
+			let dispatched = false;
+			build.onResolve({
+				filter: /.*/,
+				namespace
+			}, async ({ entrypoint, path: path$1, data }) => {
+				if (!data || !Array.isArray(data)) return void 0;
+				for (const locale of build.context.config.locales) {
+					const destination = build.context.config.destination({
+						entrypoint,
+						locale,
+						path: path$1
+					});
+					if (!collections.has(destination)) collections.set(destination, {
+						locale,
+						translations: []
+					});
+					collections.get(destination)?.translations.push(...data);
+				}
+				build.defer("source").then(() => {
+					if (dispatched) return;
+					dispatched = true;
+					for (const path$2 of collections.keys()) build.load({
+						entrypoint,
+						path: path$2,
+						namespace
+					});
+				});
+				return void 0;
+			});
+			build.onLoad({
+				filter: /.*\.po$/,
+				namespace
+			}, async ({ entrypoint, path: path$1 }) => {
+				const data = await fs.readFile(path$1).catch(() => void 0);
 				return {
-					...rest,
 					entrypoint,
-					destination: redirected,
-					translations: record
+					path: path$1,
+					namespace,
+					data
 				};
 			});
-			build.onGenerate({ filter: /\.po$/ }, async ({ path: path$1, collected }, ctx) => {
-				const existing = await fs.readFile(path$1).catch(() => void 0);
-				const out = merge(collected, existing, ctx.config.obsolete, ctx.locale, ctx.generatedAt);
+			build.onProcess({
+				filter: /.*\.po$/,
+				namespace
+			}, async ({ entrypoint, path: path$1, data }) => {
+				const collected = collections.get(path$1);
+				if (!collected) {
+					build.context.logger?.warn({ path: path$1 }, "no translations collected for this path");
+					return void 0;
+				}
+				const { locale, translations } = collected;
+				const record = collect(translations, locale);
+				const out = merge([{ translations: record }], data, build.context.config.obsolete, locale, build.context.generatedAt);
 				await fs.mkdir(dirname(path$1), { recursive: true });
 				await fs.writeFile(path$1, out);
+				build.resolve({
+					entrypoint,
+					path: path$1,
+					namespace: "cleanup",
+					data: translations
+				});
 			});
 		}
 	};
@@ -711,7 +845,8 @@ function po() {
 //#region src/configuration.ts
 const defaultPlugins = {
 	core,
-	po
+	po,
+	cleanup
 };
 const defaultDestination = ({ entrypoint, locale }) => join(dirname(entrypoint), "translations", `${basename(entrypoint, extname(entrypoint))}.${locale}.po`);
 const defaultExclude = [
@@ -723,52 +858,40 @@ function normalizeExclude(exclude) {
 	if (!exclude) return [];
 	return Array.isArray(exclude) ? exclude : [exclude];
 }
+function resolveEntrypoint(ep) {
+	if (typeof ep === "string") return { entrypoint: ep };
+	const { entrypoint, destination, obsolete, exclude } = ep;
+	return {
+		entrypoint,
+		destination,
+		obsolete,
+		exclude: exclude ? normalizeExclude(exclude) : void 0
+	};
+}
+function resolvePlugins(user) {
+	if (typeof user === "function") return user(defaultPlugins);
+	if (Array.isArray(user)) return [...Object.values(defaultPlugins).map((plugin) => plugin()), ...user];
+	return Object.values(defaultPlugins).map((plugin) => plugin());
+}
+/**
+* Type helper to make it easier to use translate.config.ts
+* @param config - {@link UserConfig}.
+*/
 function defineConfig(config) {
-	let plugins;
-	const user = config.plugins;
-	if (typeof user === "function") plugins = user(defaultPlugins);
-	else if (Array.isArray(user)) plugins = [...Object.values(defaultPlugins).map((plugin) => plugin()), ...user];
-	else plugins = Object.values(defaultPlugins).map((plugin) => plugin());
-	const raw = Array.isArray(config.entrypoints) ? config.entrypoints : [config.entrypoints];
-	const entrypoints = [];
-	for (const ep of raw) if (typeof ep === "string") {
-		const paths = globSync(ep, { nodir: true });
-		if (paths.length === 0) entrypoints.push({ entrypoint: ep });
-		else for (const path$1 of paths) entrypoints.push({ entrypoint: path$1 });
-	} else {
-		const { entrypoint, destination: destination$1, obsolete: obsolete$1, exclude: exclude$1 } = ep;
-		const paths = globSync(entrypoint, { nodir: true });
-		const epExclude = exclude$1 ? [...defaultExclude, ...normalizeExclude(exclude$1)] : void 0;
-		if (paths.length === 0) entrypoints.push({
-			entrypoint,
-			destination: destination$1,
-			obsolete: obsolete$1,
-			exclude: epExclude
-		});
-		else for (const path$1 of paths) entrypoints.push({
-			entrypoint: path$1,
-			destination: destination$1,
-			obsolete: obsolete$1,
-			exclude: epExclude
-		});
-	}
 	const defaultLocale = config.defaultLocale ?? "en";
-	const locales = config.locales ?? [defaultLocale];
-	const destination = config.destination ?? defaultDestination;
-	const obsolete = config.obsolete ?? "mark";
-	const walk = config.walk ?? true;
-	const logLevel = config.logLevel ?? "info";
-	const exclude = [...defaultExclude, ...normalizeExclude(config.exclude)];
+	const plugins = resolvePlugins(config.plugins);
+	const raw = Array.isArray(config.entrypoints) ? config.entrypoints : [config.entrypoints];
+	const entrypoints = raw.map(resolveEntrypoint);
 	return {
 		plugins,
 		entrypoints,
 		defaultLocale,
-		locales,
-		destination,
-		obsolete,
-		walk,
-		logLevel,
-		exclude
+		locales: config.locales ?? [defaultLocale],
+		destination: config.destination ?? defaultDestination,
+		obsolete: config.obsolete ?? "mark",
+		walk: config.walk ?? true,
+		logLevel: config.logLevel ?? "info",
+		exclude: config.exclude ? normalizeExclude(config.exclude) : defaultExclude
 	};
 }
 
@@ -787,12 +910,26 @@ function buildTemplate(node) {
 			if (text$1) strings[strings.length - 1] += text$1;
 		} else if (child.type === "jsx_expression") {
 			const expr = child.namedChildren[0];
-			if (!expr || expr.type !== "identifier") return {
+			if (!expr) return {
 				text: "",
-				error: "JSX expressions must be simple identifiers"
+				error: "Empty JSX expression"
+			};
+			if (expr.type === "identifier") {
+				values.push(expr.text);
+				strings.push("");
+			} else if (expr.type === "string") strings[strings.length - 1] += expr.text.slice(1, -1);
+			else if (expr.type === "template_string") {
+				const hasSubstitutions = expr.children.some((c) => c.type === "template_substitution");
+				if (hasSubstitutions) return {
+					text: "",
+					error: "JSX expressions with template substitutions are not supported"
+				};
+				const content = expr.text.slice(1, -1);
+				strings[strings.length - 1] += content;
+			} else return {
+				text: "",
+				error: "JSX expressions must be simple identifiers, strings, or template literals"
 			};
-			values.push(expr.text);
-			strings.push("");
 		} else if (child.type === "string") strings[strings.length - 1] += child.text.slice(1, -1);
 		else return {
 			text: "",
@@ -810,11 +947,24 @@ function buildAttrValue(node) {
 	if (node.type === "string") return { text: node.text.slice(1, -1) };
 	if (node.type === "jsx_expression") {
 		const expr = node.namedChildren[0];
-		if (!expr || expr.type !== "identifier") return {
+		if (!expr) return {
 			text: "",
-			error: "JSX expressions must be simple identifiers"
+			error: "Empty JSX expression"
+		};
+		if (expr.type === "identifier") return { text: `\${${expr.text}}` };
+		else if (expr.type === "string") return { text: expr.text.slice(1, -1) };
+		else if (expr.type === "template_string") {
+			const hasSubstitutions = expr.children.some((c) => c.type === "template_substitution");
+			if (hasSubstitutions) return {
+				text: "",
+				error: "JSX expressions with template substitutions are not supported"
+			};
+			const content = expr.text.slice(1, -1);
+			return { text: content };
+		} else return {
+			text: "",
+			error: "JSX expressions must be simple identifiers, strings, or template literals"
 		};
-		return { text: `\${${expr.text}}` };
 	}
 	return {
 		text: "",
@@ -827,9 +977,17 @@ function buildAttrValue(node) {
 const messageQuery = withComment({
 	pattern: `(
         [
-            (jsx_element (jsx_opening_element name: (identifier) @name))
-            (jsx_self_closing_element name: (identifier) @name)
-        ] @call
+            (jsx_element (jsx_opening_element name: (identifier) @name)) @call
+            (jsx_self_closing_element name: (identifier) @name) @call
+            (lexical_declaration 
+                (variable_declarator 
+                    value: [
+                        (jsx_element (jsx_opening_element name: (identifier) @name)) @call
+                        (jsx_self_closing_element name: (identifier) @name) @call
+                    ]
+                )
+            )
+        ]
         (#eq? @name "Message")
     )`,
 	extract(match) {
@@ -942,7 +1100,7 @@ const pluralQuery = withComment({
 
 //#endregion
 //#region src/plugins/react/queries/index.ts
-const queries$1 = [messageQuery, pluralQuery];
+const queries = [messageQuery, pluralQuery];
 
 //#endregion
 //#region src/plugins/react/parse.ts
@@ -951,10 +1109,10 @@ function parseSource(source, path$1) {
 	const { parser, language } = getParser(path$1);
 	const tree = parser.parse(source);
 	const translations = [];
-	const imports = [];
+	const warnings = [];
 	const seen = /* @__PURE__ */ new Set();
-	for (const spec of [...queries, ...queries$1]) {
-		const query = new Parser.Query(language, spec.pattern);
+	for (const spec of queries) {
+		const query = getQuery(language, spec.pattern);
 		for (const match of query.matches(tree.rootNode)) {
 			const message = spec.extract(match);
 			if (!message) continue;
@@ -969,17 +1127,15 @@ function parseSource(source, path$1) {
 					reference
 				}
 			});
-			if (error) console.warn(`Parsing error at ${reference}: ${error}`);
+			if (error) warnings.push({
+				error,
+				reference
+			});
 		}
 	}
-	const importTreeQuery = new Parser.Query(language, importQuery.pattern);
-	for (const match of importTreeQuery.matches(tree.rootNode)) {
-		const imp = importQuery.extract(match);
-		if (imp) imports.push(imp);
-	}
 	return {
 		translations,
-		imports
+		warnings
 	};
 }
 
@@ -991,39 +1147,46 @@ function react() {
 		name: "react",
 		setup(build) {
 			build.context.logger?.debug("react plugin initialized");
-			build.onResolve({ filter: /.*/ }, ({ entrypoint, path: path$1 }) => {
+			build.onResolve({
+				filter: /.*/,
+				namespace: "source"
+			}, ({ entrypoint, path: path$1, namespace: namespace$2 }) => {
 				return {
 					entrypoint,
+					namespace: namespace$2,
 					path: resolve(path$1)
 				};
 			});
-			build.onLoad({ filter }, async ({ entrypoint, path: path$1 }) => {
-				const contents = await readFile(path$1, "utf8");
+			build.onLoad({
+				filter,
+				namespace: "source"
+			}, async ({ entrypoint, path: path$1, namespace: namespace$2 }) => {
+				const data = await readFile(path$1, "utf8");
 				return {
 					entrypoint,
 					path: path$1,
-					contents
+					namespace: namespace$2,
+					data
 				};
 			});
-			build.onExtract({ filter }, ({ entrypoint, path: path$1, contents }) => {
-				const { translations, imports } = parseSource(contents, path$1);
-				if (build.context.config.walk) {
-					const paths = resolveImports(path$1, imports);
-					for (const p of paths) build.resolvePath({
-						entrypoint,
-						path: p
-					});
-				}
-				return {
+			build.onProcess({
+				filter,
+				namespace: "source"
+			}, ({ entrypoint, path: path$1, data }) => {
+				const { translations, warnings } = parseSource(data, path$1);
+				for (const warning of warnings) build.context.logger?.warn(`${warning.error} at ${warning.reference}`);
+				build.resolve({
 					entrypoint,
 					path: path$1,
-					translations
-				};
+					namespace: "translate",
+					data: translations
+				});
+				return void 0;
 			});
 		}
 	};
 }
 
 //#endregion
-export { collect, core, defineConfig, formatDate, merge, po, react, run };
+export { cleanup, collect, core, defineConfig, formatDate, merge, po, react, run };
 //# sourceMappingURL=index.js.map