@let-value/translate-extract 1.0.6-beta.2

package/dist/src/index.js

@@ -0,0 +1,710 @@
+import fs from "node:fs";
+import path, { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { globSync } from "glob";
+import fs$1, { readFile } from "node:fs/promises";
+import { assign, 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/core/queries/comment.ts
+function getReference(node, { path: path$1 }) {
+	const line = node.startPosition.row + 1;
+	const col = node.startPosition.column + 1;
+	const rel = relative(process.cwd(), path$1);
+	return `${rel}:${line}:${col}`;
+}
+function getComment(node) {
+	const text = node.text;
+	if (text.startsWith("/*")) return text.slice(2, -2).replace(/^\s*\*?\s*/gm, "").trim();
+	return text.replace(/^\/\/\s?/, "").trim();
+}
+const withComment = (query) => ({
+	pattern: `(
+	((comment) @comment)?
+    .
+	(_ ${query.pattern})
+)`,
+	extract(match) {
+		const result = query.extract(match);
+		if (!result?.translation) return result;
+		const comment = match.captures.find((c) => c.name === "comment")?.node;
+		if (!comment) return result;
+		if (comment) result.translation.comments = {
+			...result.translation.comments,
+			extracted: getComment(comment)
+		};
+		return result;
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/import.ts
+const importQuery = {
+	pattern: `
+    [
+      (import_statement
+        source: (string (string_fragment) @import))
+      (export_statement
+        source: (string (string_fragment) @import))
+      (call_expression
+        function: (identifier) @func
+        arguments: (arguments (string (string_fragment) @import))
+        (#eq? @func "require"))
+      (call_expression
+        function: (member_expression
+            object: (identifier) @obj
+            property: (property_identifier) @method)
+        arguments: (arguments (string (string_fragment) @import))
+        (#eq? @obj "require")
+        (#eq? @method "resolve"))
+      (call_expression
+        function: (import)
+        arguments: (arguments (string (string_fragment) @import)))
+    ]
+  `,
+	extract(match) {
+		const node = match.captures.find((c) => c.name === "import")?.node;
+		return node?.text;
+	}
+};
+
+//#endregion
+//#region src/plugins/core/queries/utils.ts
+const callPattern = (fnName, args, allowMember = true) => `(
+  (call_expression
+    function: ${allowMember ? `[
+      (identifier) @func
+      (member_expression property: (property_identifier) @func)
+    ]` : `(identifier) @func`}
+    arguments: ${args}
+  ) @call
+  (#eq? @func "${fnName}")
+)`;
+function isDescendant(node, ancestor) {
+	let current = node;
+	while (current) {
+		if (current.id === ancestor.id) return true;
+		current = current.parent;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/plugins/core/queries/message.ts
+const notInPlural = (query) => ({
+	pattern: query.pattern,
+	extract(match) {
+		const result = query.extract(match);
+		if (!result?.node) return result;
+		let parent = result.node.parent;
+		if (parent && parent.type === "arguments") parent = parent.parent;
+		if (parent && parent.type === "call_expression") {
+			const fn = parent.childForFieldName("function");
+			if (fn) {
+				if (fn.type === "identifier" && (fn.text === "plural" || fn.text === "ngettext" || fn.text === "pgettext" || fn.text === "npgettext") || fn.type === "member_expression" && [
+					"plural",
+					"ngettext",
+					"pgettext",
+					"npgettext"
+				].includes(fn.childForFieldName("property")?.text ?? "")) return void 0;
+			}
+		}
+		return result;
+	}
+});
+const messageArg = `[
+    (string (string_fragment) @msgid)
+    (object
+            (_)*
+            (pair
+                key: (property_identifier) @id_key
+                value: (string (string_fragment) @id)
+                (#eq? @id_key "id")
+            )?
+            (_)*
+            (pair
+                key: (property_identifier) @msg_key
+                value: (string (string_fragment) @message)
+                (#eq? @msg_key "message")
+            )?
+            (_)*
+    )
+    (template_string) @tpl
+]`;
+const messageArgs = `[ (arguments ${messageArg}) (template_string) @tpl ]`;
+const extractMessage = (name) => (match) => {
+	const node = match.captures.find((c) => c.name === "call")?.node;
+	if (!node) return void 0;
+	const msgid = match.captures.find((c) => c.name === "msgid")?.node.text;
+	if (msgid) return {
+		node,
+		translation: {
+			id: msgid,
+			message: [msgid]
+		}
+	};
+	const tpl = match.captures.find((c) => c.name === "tpl")?.node;
+	if (tpl) {
+		for (const child of tpl.children) {
+			if (child.type !== "template_substitution") continue;
+			const expr = child.namedChildren[0];
+			if (!expr || expr.type !== "identifier") return {
+				node,
+				error: `${name}() template expressions must be simple identifiers`
+			};
+		}
+		const text = tpl.text.slice(1, -1);
+		return {
+			node,
+			translation: {
+				id: text,
+				message: [text]
+			}
+		};
+	}
+	const id = match.captures.find((c) => c.name === "id")?.node.text;
+	const message = match.captures.find((c) => c.name === "message")?.node.text;
+	const msgId = id ?? message;
+	if (!msgId) return void 0;
+	const msgstr = message ?? id ?? "";
+	return {
+		node,
+		translation: {
+			id: msgId,
+			message: [msgstr]
+		}
+	};
+};
+const messageQuery = notInPlural(withComment({
+	pattern: callPattern("message", messageArgs),
+	extract: extractMessage("message")
+}));
+const allowed$1 = new Set([
+	"string",
+	"object",
+	"template_string"
+]);
+const messageInvalidQuery = notInPlural({
+	pattern: callPattern("message", "(arguments (_) @arg)"),
+	extract(match) {
+		const call = match.captures.find((c) => c.name === "call")?.node;
+		const node = match.captures.find((c) => c.name === "arg")?.node;
+		if (!call || !node) return void 0;
+		if (allowed$1.has(node.type)) return void 0;
+		return {
+			node,
+			error: "message() argument must be a string literal, object literal, or template literal"
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/plural-utils.ts
+const extractPluralForms = (name) => (match) => {
+	const call = match.captures.find((c) => c.name === "call")?.node;
+	const n = match.captures.find((c) => c.name === "n")?.node;
+	if (!call || !n || n.nextNamedSibling) return void 0;
+	const msgctxt = match.captures.find((c) => c.name === "msgctxt")?.node?.text;
+	const msgNodes = match.captures.filter((c) => c.name === "msg").map((c) => c.node);
+	const ids = [];
+	const strs = [];
+	for (const node of msgNodes) {
+		const relevant = match.captures.filter((c) => [
+			"msgid",
+			"id",
+			"message",
+			"tpl"
+		].includes(c.name) && isDescendant(c.node, node));
+		const subMatch = {
+			pattern: 0,
+			captures: [{
+				name: "call",
+				node
+			}, ...relevant]
+		};
+		const result = extractMessage(name)(subMatch);
+		if (!result) continue;
+		if (result.error) return {
+			node: call,
+			error: result.error
+		};
+		if (result.translation) {
+			ids.push(result.translation.id);
+			strs.push(result.translation.message[0] ?? "");
+		}
+	}
+	if (ids.length === 0) return void 0;
+	const translation = {
+		id: ids[0],
+		plural: ids[1],
+		message: strs
+	};
+	if (msgctxt) translation.context = msgctxt;
+	return {
+		node: call,
+		translation
+	};
+};
+
+//#endregion
+//#region src/plugins/core/queries/context.ts
+const ctxCall = callPattern("context", `(arguments (string (string_fragment) @msgctxt))`).replace(/@call/g, "@ctx").replace(/@func/g, "@ctxfn");
+const contextMsgQuery = withComment({
+	pattern: `(
+  (call_expression
+    function: (member_expression
+      object: ${ctxCall}
+      property: (property_identifier) @func
+    )
+    arguments: ${messageArgs}
+  ) @call
+  (#eq? @func "message")
+)`,
+	extract(match) {
+		const result = extractMessage("context.message")(match);
+		const contextNode = match.captures.find((c) => c.name === "msgctxt")?.node;
+		if (!result || !result.translation || !contextNode) return result;
+		return {
+			node: result.node,
+			translation: {
+				...result.translation,
+				context: contextNode.text
+			}
+		};
+	}
+});
+const msgCall$3 = callPattern("message", messageArgs, false).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const contextPluralQuery = withComment({
+	pattern: `(
+  (call_expression
+    function: (member_expression
+      object: ${ctxCall}
+      property: (property_identifier) @func
+    )
+    arguments: (arguments (
+      (${msgCall$3} ("," )?)+
+      (number) @n
+    ))
+  ) @call
+  (#eq? @func "plural")
+)`,
+	extract: extractPluralForms("context.plural")
+});
+const contextInvalidQuery = withComment({
+	pattern: ctxCall,
+	extract(match) {
+		const call = match.captures.find((c) => c.name === "ctx")?.node;
+		if (!call) return void 0;
+		const parent = call.parent;
+		if (parent && parent.type === "member_expression" && parent.childForFieldName("object")?.id === call.id) {
+			const property = parent.childForFieldName("property")?.text;
+			const grandparent = parent.parent;
+			if (grandparent && grandparent.type === "call_expression" && grandparent.childForFieldName("function")?.id === parent.id && (property === "message" || property === "plural")) return void 0;
+		}
+		return {
+			node: call,
+			error: "context() must be used with message() or plural() in the same expression"
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/gettext.ts
+const gettextQuery = withComment({
+	pattern: callPattern("gettext", messageArgs),
+	extract: extractMessage("gettext")
+});
+const allowed = new Set([
+	"string",
+	"object",
+	"template_string",
+	"identifier",
+	"call_expression"
+]);
+const gettextInvalidQuery = {
+	pattern: callPattern("gettext", "(arguments (_) @arg)"),
+	extract(match) {
+		const call = match.captures.find((c) => c.name === "call")?.node;
+		const node = match.captures.find((c) => c.name === "arg")?.node;
+		if (!call || !node) return void 0;
+		if (allowed.has(node.type)) return void 0;
+		return {
+			node,
+			error: "gettext() argument must be a string literal, object literal, or template literal"
+		};
+	}
+};
+
+//#endregion
+//#region src/plugins/core/queries/ngettext.ts
+const msgCall$2 = callPattern("message", messageArgs).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const plainMsg$1 = `(${messageArg}) @msg`;
+const msgArg$1 = `[${msgCall$2} ${plainMsg$1}]`;
+const ngettextQuery = withComment({
+	pattern: callPattern("ngettext", `(arguments ${msgArg$1} "," ${msgArg$1} ("," ${msgArg$1})* "," (_) @n)`),
+	extract: extractPluralForms("ngettext")
+});
+
+//#endregion
+//#region src/plugins/core/queries/npgettext.ts
+const msgCall$1 = callPattern("message", messageArgs).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const plainMsg = `(${messageArg}) @msg`;
+const msgArg = `[${msgCall$1} ${plainMsg}]`;
+const npgettextQuery = withComment({
+	pattern: callPattern("npgettext", `(arguments (string (string_fragment) @msgctxt) "," ${msgArg} "," ${msgArg} ("," ${msgArg})* "," (_) @n)`),
+	extract: extractPluralForms("npgettext")
+});
+
+//#endregion
+//#region src/plugins/core/queries/pgettext.ts
+const pgettextQuery = withComment({
+	pattern: callPattern("pgettext", `(arguments (string (string_fragment) @msgctxt) "," ${messageArg})`),
+	extract(match) {
+		const result = extractMessage("pgettext")(match);
+		const contextNode = match.captures.find((c) => c.name === "msgctxt")?.node;
+		if (!result || !contextNode || !result.translation) return result;
+		return {
+			node: result.node,
+			translation: {
+				...result.translation,
+				context: contextNode.text
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/plural.ts
+const msgCall = callPattern("message", messageArgs, false).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const pluralQuery = withComment({
+	pattern: callPattern("plural", `(arguments (
+            (${msgCall} ("," )?)+
+            (number) @n
+        ))`, false),
+	extract: extractPluralForms("plural")
+});
+
+//#endregion
+//#region src/plugins/core/queries/index.ts
+const queries = [
+	messageQuery,
+	messageInvalidQuery,
+	gettextQuery,
+	gettextInvalidQuery,
+	pluralQuery,
+	ngettextQuery,
+	pgettextQuery,
+	npgettextQuery,
+	contextMsgQuery,
+	contextPluralQuery,
+	contextInvalidQuery
+];
+
+//#endregion
+//#region src/plugins/core/parse.ts
+function getLanguage(ext) {
+	switch (ext) {
+		case ".ts": return TS.typescript;
+		case ".tsx": return TS.tsx;
+		default: return JavaScript;
+	}
+}
+const getCachedParser = memo(function getCachedParser$1(ext) {
+	const parser = new Parser();
+	const language = getLanguage(ext);
+	parser.setLanguage(language);
+	return {
+		parser,
+		language
+	};
+});
+function getParser(path$1) {
+	const ext = extname(path$1);
+	return getCachedParser(ext);
+}
+function parseSource(source, path$1) {
+	const context = { path: path$1 };
+	const { parser, language } = getParser(path$1);
+	const tree = parser.parse(source);
+	const translations = [];
+	const imports = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const spec of queries) {
+		const query = new Parser.Query(language, spec.pattern);
+		for (const match of query.matches(tree.rootNode)) {
+			const message = spec.extract(match);
+			if (!message) continue;
+			const { node, translation, error } = message;
+			if (seen.has(node.id)) continue;
+			seen.add(node.id);
+			const reference = getReference(node, context);
+			if (translation) translations.push({
+				...translation,
+				comments: {
+					...translation.comments,
+					reference
+				}
+			});
+			if (error) console.warn(`Parsing error at ${reference}: ${error}`);
+		}
+	}
+	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
+	};
+}
+
+//#endregion
+//#region src/plugins/core/resolve.ts
+function findTsconfig(dir) {
+	let current = dir;
+	while (true) {
+		const config = path.join(current, "tsconfig.json");
+		if (fs.existsSync(config)) return config;
+		const parent = path.dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
+const resolverCache = /* @__PURE__ */ new Map();
+function getResolver(dir) {
+	const tsconfig = findTsconfig(dir);
+	const key = tsconfig ?? "__default__";
+	let resolver = resolverCache.get(key);
+	if (!resolver) {
+		resolver = new ResolverFactory({
+			extensions: [
+				".ts",
+				".tsx",
+				".js",
+				".jsx",
+				".mjs",
+				".cjs",
+				".json"
+			],
+			conditionNames: [
+				"import",
+				"require",
+				"node"
+			],
+			...tsconfig ? { tsconfig: { configFile: tsconfig } } : {}
+		});
+		resolverCache.set(key, resolver);
+	}
+	return resolver;
+}
+function resolveImports(file, imports) {
+	const dir = path.dirname(path.resolve(file));
+	const resolver = getResolver(dir);
+	const resolved = [];
+	for (const spec of imports) {
+		const res = resolver.sync(dir, spec);
+		if (res.path) resolved.push(res.path);
+	}
+	return resolved;
+}
+
+//#endregion
+//#region src/plugins/core/core.ts
+const filter = /\.([cm]?tsx?|jsx?)$/;
+function core() {
+	return {
+		name: "core",
+		setup(build) {
+			build.onResolve({ filter: /.*/ }, ({ entrypoint, path: path$1 }) => {
+				return {
+					entrypoint,
+					path: resolve(path$1)
+				};
+			});
+			build.onLoad({ filter }, async ({ entrypoint, path: path$1 }) => {
+				const contents = await readFile(path$1, "utf8");
+				return {
+					entrypoint,
+					path: path$1,
+					contents
+				};
+			});
+			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 path$2 of paths) build.resolvePath({
+						entrypoint,
+						path: path$2
+					});
+				}
+				return {
+					entrypoint,
+					path: path$1,
+					translations
+				};
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/po/po.ts
+function formatDate(date) {
+	const pad = (n) => n.toString().padStart(2, "0");
+	const year = date.getFullYear();
+	const month = pad(date.getMonth() + 1);
+	const day = pad(date.getDate());
+	const hours = pad(date.getHours());
+	const minutes = pad(date.getMinutes());
+	const tzo = -date.getTimezoneOffset();
+	const sign = tzo >= 0 ? "+" : "-";
+	const offsetHours = pad(Math.floor(Math.abs(tzo) / 60));
+	const offsetMinutes = pad(Math.abs(tzo) % 60);
+	return `${year}-${month}-${day} ${hours}:${minutes}${sign}${offsetHours}${offsetMinutes}`;
+}
+function collect(source, locale) {
+	const translations = { "": {} };
+	const nplurals = locale ? getNPlurals(locale) : void 0;
+	for (const { context, id, message, comments, obsolete, plural } of source) {
+		const ctx = context || "";
+		if (!translations[ctx]) translations[ctx] = {};
+		const length = plural ? nplurals ?? message.length : 1;
+		translations[ctx][id] = {
+			msgctxt: context || void 0,
+			msgid: id,
+			msgid_plural: plural,
+			msgstr: Array.from({ length }, () => ""),
+			comments,
+			obsolete
+		};
+	}
+	return translations;
+}
+function merge(locale, sources, existing, strategy = "mark", timestamp = /* @__PURE__ */ new Date()) {
+	let headers = {};
+	let translations = { "": {} };
+	const nplurals = getNPlurals(locale);
+	if (existing) {
+		const parsed = gettextParser.po.parse(existing);
+		headers = parsed.headers || {};
+		translations = parsed.translations || { "": {} };
+		for (const ctx of Object.keys(translations)) for (const id of Object.keys(translations[ctx])) {
+			if (ctx === "" && id === "") continue;
+			translations[ctx][id].obsolete = true;
+		}
+	}
+	const collected = sources.reduce((acc, { translations: translations$1 }) => assign(acc, translations$1), { "": {} });
+	for (const [ctx, msgs] of Object.entries(collected)) {
+		if (!translations[ctx]) translations[ctx] = {};
+		for (const [id, entry] of Object.entries(msgs)) {
+			const existingEntry = translations[ctx][id];
+			if (existingEntry) {
+				entry.msgstr = existingEntry.msgstr;
+				entry.comments = {
+					...entry.comments,
+					translator: existingEntry.comments?.translator
+				};
+			}
+			entry.obsolete = false;
+			entry.msgstr = entry.msgstr.slice(0, nplurals);
+			while (entry.msgstr.length < nplurals) entry.msgstr.push("");
+			translations[ctx][id] = entry;
+		}
+	}
+	headers = {
+		...headers,
+		"content-type": headers["content-type"] || "text/plain; charset=UTF-8",
+		"plural-forms": `nplurals=${nplurals}; plural=${getFormula(locale)};`,
+		language: locale,
+		"pot-creation-date": formatDate(timestamp),
+		"x-generator": "@let-value/translate-extract"
+	};
+	if (strategy === "remove") {
+		for (const ctx of Object.keys(translations)) for (const id of Object.keys(translations[ctx])) if (translations[ctx][id].obsolete) delete translations[ctx][id];
+	}
+	const poObj = {
+		charset: "utf-8",
+		headers,
+		translations
+	};
+	return gettextParser.po.compile(poObj).toString();
+}
+function po() {
+	return {
+		name: "po",
+		setup(build) {
+			build.onCollect({ filter: /.*/ }, ({ entrypoint, translations,...rest }, ctx) => {
+				const record = collect(translations, ctx.locale);
+				const destination = `${basename(entrypoint, extname(entrypoint))}.po`;
+				return {
+					...rest,
+					entrypoint,
+					destination,
+					translations: record
+				};
+			});
+			build.onGenerate({ filter: /.*\/po$/ }, async ({ path: path$1, locale, collected }, ctx) => {
+				const existing = await fs$1.readFile(path$1).catch(() => void 0);
+				const out = merge(locale, collected, existing, ctx.config.obsolete, ctx.generatedAt);
+				await fs$1.mkdir(dirname(path$1), { recursive: true });
+				await fs$1.writeFile(path$1, out);
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/configuration.ts
+const defaultPlugins = [core(), po()];
+const defaultDestination = (locale, _entrypoint, path$1) => join(locale, path$1);
+function defineConfig(config) {
+	let plugins;
+	const user = config.plugins;
+	if (typeof user === "function") plugins = user(defaultPlugins);
+	else if (Array.isArray(user)) plugins = [...defaultPlugins, ...user];
+	else plugins = defaultPlugins;
+	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 } = ep;
+		const paths = globSync(entrypoint, { nodir: true });
+		if (paths.length === 0) entrypoints.push({
+			entrypoint,
+			destination: destination$1,
+			obsolete: obsolete$1
+		});
+		else for (const path$1 of paths) entrypoints.push({
+			entrypoint: path$1,
+			destination: destination$1,
+			obsolete: obsolete$1
+		});
+	}
+	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;
+	return {
+		plugins,
+		entrypoints,
+		defaultLocale,
+		locales,
+		destination,
+		obsolete,
+		walk
+	};
+}
+
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=index.js.map