@x18n/builtins 0.0.13 → 0.0.15

package/dist/angular-templates-DqIOGfzT.mjs

@@ -0,0 +1,8 @@
+//#region src/presets/shared/angular-templates.ts
+const angularTemplates = [
+	"html",
+	"ts",
+	"js"
+];
+//#endregion
+export { angularTemplates as t };

package/dist/checks.d.mts

@@ -3,6 +3,7 @@ import { Check, Plugin } from "@x18n/core";
 export declare const missingKey: Check;
 export declare const missingTranslation: Check;
 export declare const staleTranslation: Check;
+export declare const reviewChangesRequested: Check;
 export declare const emptyTranslation: Check;
 export declare const redundantTranslation: Check;
 export declare const keyConflict: Check;

package/dist/checks.mjs

@@ -88,6 +88,30 @@ const staleTranslation = {
 		};
 	}
 };
+const reviewChangesRequested = {
+	id: "review-changes-requested",
+	defaultSeverity: "info",
+	description: "A message with an open \"request change\" review.",
+	*run(ctx) {
+		for (const thread of ctx.reviews({ open: true })) {
+			if (thread.state !== "changes-requested") continue;
+			const request = thread.comments.findLast((comment) => comment.type === "request-change");
+			const by = request.author?.name ? ` by ${request.author.name}` : "";
+			yield {
+				key: thread.key,
+				locale: thread.locale,
+				message: `Change requested${by} for "${thread.key}" in ${thread.locale}${request.text ? `: ${request.text}` : "."}`,
+				fixes: [{
+					title: "Resolve the review",
+					ops: [{
+						type: "resolve-review",
+						id: request.id
+					}]
+				}]
+			};
+		}
+	}
+};
 const emptyTranslation = {
 	id: "empty-translation",
 	defaultSeverity: "warning",
@@ -361,6 +385,7 @@ const allChecks = [
 	keyConflict,
 	missingTranslation,
 	staleTranslation,
+	reviewChangesRequested,
 	emptyTranslation,
 	redundantTranslation,
 	unusedKey,
@@ -379,4 +404,4 @@ function recommended() {
 	};
 }
 //#endregion
-export { allChecks, dynamicKey, emptyTranslation, glossary, hardString, identicalToSource, invalidSyntax, keyConflict, keyStyle, localeCodeConflict, missingKey, missingTranslation, placeholderMismatch, recommended, redundantTranslation, staleTranslation, unusedKey };
+export { allChecks, dynamicKey, emptyTranslation, glossary, hardString, identicalToSource, invalidSyntax, keyConflict, keyStyle, localeCodeConflict, missingKey, missingTranslation, placeholderMismatch, recommended, redundantTranslation, reviewChangesRequested, staleTranslation, unusedKey };

package/dist/extractors.mjs

@@ -4,6 +4,7 @@ const textKinds = /* @__PURE__ */ new Set([
 	"jsx-text",
 	"vue-template-text",
 	"svelte-text",
+	"astro-text",
 	"html-text"
 ]);
 /** Built-in rules, applied in order. A `must-*` wins at once; otherwise the last `should-*` decides. */
@@ -123,11 +124,11 @@ function slugify(text, keyCase = "camel", maxLength = 40) {
 const defaultTemplates = [
 	{
 		template: "{t('{key}'{args})}",
-		kinds: ["jsx-text"]
+		kinds: ["jsx-text", "astro-text"]
 	},
 	{
 		template: "{attr}={t('{key}'{args})}",
-		kinds: ["jsx-attribute"]
+		kinds: ["jsx-attribute", "astro-attribute"]
 	},
 	{
 		template: "{{ $t('{key}'{args}) }}",
@@ -258,7 +259,10 @@ function quoteKey(before, key) {
 	return inAttribute ? out.replace(/&/g, "&").replace(/"/g, """) : out;
 }
 function fillTemplate(template, values) {
-	return template.replace(/\{(key|attr|args)\}/g, (_, name, at) => name === "key" ? quoteKey(template.slice(0, at), values.key) : values[name]);
+	return template.replace(/\{(key|attr|args)\}/g, (_, name, at) => {
+		if (name === "key") return quoteKey(template.slice(0, at), values.key);
+		return name === "args" && template[at - 1] === "(" ? values.args.replace(/^, /, "") : values[name];
+	});
 }
 /** Hard strings worth extracting, with proposed keys, values and replacements. */
 function findCandidates(project, options = {}) {

package/dist/finders.d.mts

@@ -23,7 +23,10 @@ export declare const patternFinder: LocaleFinder;
 export declare function pattern(): Plugin;
 //#endregion
 //#region src/finders/sfc-blocks.d.ts
-/** Vue `<i18n>` blocks: one resource per block and locale (`locale="en"`, or every top-level locale key). */
+/**
+ * Vue `<i18n>` blocks: one resource per block and locale (`locale="en"`, or every top-level locale key).
+ * A block with `src` is a resource in the referenced file, so edits go there.
+ */
 export declare function sfcBlocks(): Plugin;
 /** fluent-vue `<fluent locale="en">` blocks in Vue SFCs, read with the `ftl` format. */
 export declare function sfcFluentBlocks(): Plugin;

package/dist/finders.mjs

@@ -1,3 +1,3 @@
 import { a as patternFinder, i as pattern, n as guessResources, r as namespaceFromPath, t as compilePattern } from "./finders-CqTGh4OJ.mjs";
-import { n as sfcFluentBlocks, t as sfcBlocks } from "./sfc-blocks-BqQ8m9rX.mjs";
+import { n as sfcFluentBlocks, t as sfcBlocks } from "./sfc-blocks-DaGKDZsb.mjs";
 export { compilePattern, guessResources, namespaceFromPath, pattern, patternFinder, sfcBlocks, sfcFluentBlocks };

package/dist/formats/ecmascript.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from "@x18n/core";
+//#region src/formats/ecmascript/index.d.ts
+export declare function ecmascript(): Plugin;
+//#endregion
+export { ecmascript as default };

package/dist/formats/ecmascript.mjs

@@ -0,0 +1,232 @@
+import { r as indentUnit } from "../shared-C7ceptwi.mjs";
+import { n as literalText, t as editLiteral } from "../literal-gIdB1VGy.mjs";
+import { applyMessageOps, diffText, errors, pathId } from "@x18n/core";
+import { parseSync } from "oxc-parser";
+//#region src/formats/ecmascript/index.ts
+/** Type-only wrappers, `defineX({ ... })` helpers that return their argument, and loaders that only return an object (`defineI18nLocale(() => ({ ... }))`). */
+function unwrap(node) {
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "ParenthesizedExpression") return unwrap(node.expression);
+	if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") return unwrap(node.body);
+	if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.body?.type === "BlockStatement") {
+		const [only, ...rest] = node.body.body;
+		if (only?.type === "ReturnStatement" && only.argument && rest.length === 0) return unwrap(only.argument);
+	}
+	const argument = node.type === "CallExpression" && node.arguments.length === 1 ? node.arguments[0] : void 0;
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && /^define[A-Z]/.test(node.callee.name) && argument && argument.type !== "SpreadElement") return unwrap(argument);
+	return node;
+}
+function findRoot(program, fail) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations) if (declarator.id.type === "Identifier" && declarator.init) bindings.set(declarator.id.name, declarator.init);
+	}
+	let exported;
+	for (const statement of program.body) if (statement.type === "ExportDefaultDeclaration" && statement.declaration.type !== "FunctionDeclaration" && statement.declaration.type !== "ClassDeclaration" && statement.declaration.type !== "TSInterfaceDeclaration") exported = statement.declaration;
+	else if (statement.type === "ExpressionStatement" && statement.expression.type === "AssignmentExpression" && isModuleExports(statement.expression.left)) exported = statement.expression.right;
+	else if (statement.type === "ExportDefaultDeclaration") fail("X18N2004", statement, "the default export is not an object literal");
+	if (!exported) return program.body.length === 0 ? void 0 : fail("X18N2004", program, "no `export default { ... }` or `module.exports = { ... }`");
+	let root = unwrap(exported);
+	if (root.type === "Identifier" && bindings.has(root.name)) root = unwrap(bindings.get(root.name));
+	if (root.type === "ObjectExpression") return root;
+	return fail(root.type === "Literal" || root.type === "ArrayExpression" ? "X18N2003" : "X18N2004", root, "the default export is not an object literal");
+}
+function isModuleExports(node) {
+	return node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "module" && node.property.type === "Identifier" && node.property.name === "exports";
+}
+function readProperty(property, fail) {
+	if (property.type === "SpreadElement" || property.kind !== "init" || property.method || property.shorthand) return fail("X18N2004", property, "only `key: value` properties are static");
+	const { key, value } = property;
+	if (key.type === "Identifier" && !property.computed) return {
+		key: key.name,
+		range: {
+			start: key.start,
+			end: key.end
+		},
+		value: unwrap(value)
+	};
+	if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) return {
+		key: String(key.value),
+		range: typeof key.value === "string" ? {
+			start: key.start + 1,
+			end: key.end - 1
+		} : {
+			start: key.start,
+			end: key.end
+		},
+		value: unwrap(value)
+	};
+	return fail("X18N2004", key, "computed keys are not static");
+}
+function readLeaf(node, text) {
+	if (node.type === "Literal" && !("regex" in node) && typeof node.value !== "bigint") return {
+		value: node.value,
+		quote: typeof node.value === "string" ? text[node.start] : void 0
+	};
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis[0]?.value.cooked != null) return {
+		value: node.quasis[0].value.cooked,
+		quote: "`"
+	};
+	if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "Literal" && typeof node.argument.value === "number") return {
+		value: -node.argument.value,
+		quote: void 0
+	};
+}
+function readObject(node, path, ranges, text, fail) {
+	const tree = {};
+	const items = [];
+	for (const property of node.properties) {
+		const { key, range, value } = readProperty(property, fail);
+		const childPath = [...path, key];
+		const item = {
+			key,
+			range: {
+				start: property.start,
+				end: property.end
+			}
+		};
+		if (value.type === "ObjectExpression") {
+			ranges.set(pathId(childPath), {
+				key: range,
+				value: {
+					start: value.start,
+					end: value.end
+				}
+			});
+			const child = readObject(value, childPath, ranges, text, fail);
+			tree[key] = child.tree;
+			items.push({
+				...item,
+				value: child.literal
+			});
+			continue;
+		}
+		const leaf = readLeaf(value, text);
+		if (!leaf) return fail("X18N2004", value, `${value.type} is not a static value`);
+		ranges.set(pathId(childPath), {
+			key: range,
+			value: leaf.quote === void 0 ? {
+				start: value.start,
+				end: value.end
+			} : {
+				start: value.start + 1,
+				end: value.end - 1
+			}
+		});
+		tree[key] = leaf.value;
+		items.push({
+			...item,
+			value: {
+				kind: "scalar",
+				range: {
+					start: value.start,
+					end: value.end
+				},
+				quote: leaf.quote
+			}
+		});
+	}
+	return {
+		tree,
+		literal: {
+			kind: "object",
+			range: {
+				start: node.start,
+				end: node.end
+			},
+			items
+		}
+	};
+}
+function readModule(text, path) {
+	const fail = (code, node, reason) => {
+		throw errors[code]({
+			path,
+			line: text.slice(0, node.start).split("\n").length,
+			reason
+		});
+	};
+	const result = parseSync(path, text, {
+		lang: /\.[mc]?ts$/.test(path) ? "ts" : "js",
+		sourceType: "module"
+	});
+	if (result.errors.length > 0) throw errors.X18N2002({
+		path,
+		reason: result.errors[0].message
+	});
+	const root = findRoot(result.program, fail);
+	const ranges = /* @__PURE__ */ new Map();
+	if (!root) return {
+		tree: {},
+		ranges,
+		literal: void 0
+	};
+	return {
+		...readObject(root, [], ranges, text, fail),
+		ranges
+	};
+}
+const singleEncodings = {
+	"\\": "\\\\",
+	"'": "\\'",
+	"\n": "\\n",
+	"\r": "\\r",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+function literal(value, quote) {
+	if (typeof value !== "string") return String(value);
+	if (quote === "\"") return JSON.stringify(value);
+	if (quote === "`") return `\`${value.replace(/\\|`|\$\{/g, (match) => `\\${match}`)}\``;
+	return `'${value.replace(/[\\'\n\r\u2028\u2029]/g, (char) => singleEncodings[char])}'`;
+}
+function syntaxOf(text, indent) {
+	return {
+		open: "{",
+		close: "}",
+		separator: ": ",
+		key: (key) => /^[a-z_$][\w$]*$/i.test(key) ? key : literal(key, "'"),
+		leaf: (value, quote) => literal(value, quote ?? "'"),
+		unit: indentUnit(text, indent, "  "),
+		trailingComma: true
+	};
+}
+function moduleText(tree, path, syntax) {
+	return `${path.endsWith(".cjs") ? "module.exports =" : "export default"} ${literalText(tree, syntax)}\n`;
+}
+function applyOp(text, op, path, syntax) {
+	const root = readModule(text, path).literal;
+	return root ? editLiteral(text, root, op, syntax) : moduleText(applyMessageOps({}, [op]), path, syntax);
+}
+function ecmascript() {
+	return {
+		name: "x18n:format-js",
+		formats: [{
+			id: "js",
+			extensions: [
+				"js",
+				"mjs",
+				"cjs",
+				"ts",
+				"mts",
+				"cts"
+			],
+			parse(text, ctx) {
+				const { tree, ranges } = readModule(text, ctx.path);
+				return {
+					tree,
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				const syntax = syntaxOf(text, ctx.indent);
+				let next = text;
+				for (const op of ops) next = applyOp(next, op, ctx.path, syntax);
+				return diffText(text, next);
+			},
+			serialize: (tree, ctx) => moduleText(tree, ctx.path, syntaxOf("", ctx.indent))
+		}]
+	};
+}
+//#endregion
+export { ecmascript as default, ecmascript };

package/dist/formats/ftl.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from "@x18n/core";
+//#region src/formats/ftl/index.d.ts
+export declare function ftl(): Plugin;
+//#endregion
+export { ftl as default };

package/dist/formats/ftl.mjs

@@ -0,0 +1,234 @@
+import { a as splice, c as withBlankLines, i as leafText, n as detectEol, o as splitLines, t as appendLines } from "../shared-C7ceptwi.mjs";
+import { diffText, errors, pathId, walkLeaves } from "@x18n/core";
+//#region src/formats/ftl/index.ts
+const trimmedEnd = (text, line) => line.start + text.slice(line.start, line.end).trimEnd().length;
+const indentOf = (text, line) => /^[ \t]*/.exec(text.slice(line.start, line.end))[0].length;
+function finishPattern(text, draft) {
+	const lines = [...draft.lines];
+	while (lines.length > 0 && text.slice(lines.at(-1).start, lines.at(-1).end).trim() === "") lines.pop();
+	const indent = Math.min(...lines.filter((l) => text.slice(l.start, l.end).trim() !== "").map((l) => indentOf(text, l)));
+	const inline = text.slice(draft.inline.start, draft.inline.end).trimEnd();
+	const parts = [...inline ? [inline] : [], ...lines.map((l) => text.slice(Math.min(l.start + indent, l.end), trimmedEnd(text, l)))];
+	const first = lines[0];
+	if (!inline && !first) return {
+		value: void 0,
+		range: {
+			start: draft.after,
+			end: draft.after
+		},
+		source: {
+			start: draft.after,
+			end: draft.inline.end
+		}
+	};
+	const start = inline ? draft.inline.start : first.start + indent;
+	const end = lines.length > 0 ? trimmedEnd(text, lines.at(-1)) : trimmedEnd(text, draft.inline);
+	return {
+		value: parts.join("\n"),
+		range: {
+			start,
+			end
+		},
+		source: {
+			start: draft.after,
+			end
+		}
+	};
+}
+function read(text, path) {
+	const messages = [];
+	let current;
+	let commentStart;
+	let blanks = [];
+	let lineNumber = 0;
+	for (const line of splitLines(text)) {
+		lineNumber++;
+		const content = text.slice(line.start, line.end);
+		if (content.trim() === "") {
+			blanks.push(line);
+			commentStart = void 0;
+			continue;
+		}
+		if (/^[ \t]/.test(content)) {
+			if (!current) throw errors.X18N2002({
+				path,
+				line: lineNumber,
+				reason: "indented line outside a message"
+			});
+			const attribute = /^[ \t]+\.([a-z][\w-]*)[ \t]*=[ \t]*/i.exec(content);
+			if (attribute) {
+				const nameStart = line.start + attribute[0].indexOf(".") + 1;
+				const after = line.start + attribute[0].trimEnd().length;
+				current.attributes.push({
+					name: attribute[1],
+					nameRange: {
+						start: nameStart,
+						end: nameStart + attribute[1].length
+					},
+					pattern: {
+						after,
+						inline: {
+							start: line.start + attribute[0].length,
+							end: line.end
+						},
+						lines: []
+					},
+					lines: {
+						start: line.start,
+						end: line.next
+					}
+				});
+			} else {
+				const last = current.attributes.at(-1);
+				(last ?? current).pattern.lines.push(...blanks, line);
+				if (last) last.lines.end = line.next;
+			}
+			current.block.end = line.next;
+			blanks = [];
+			continue;
+		}
+		blanks = [];
+		current = void 0;
+		if (content.startsWith("#")) {
+			commentStart = /^#(?: |$)/.test(content) ? commentStart ?? line.start : void 0;
+			continue;
+		}
+		const message = /^(-?[a-z][\w-]*)[ \t]*=[ \t]*/i.exec(content);
+		if (!message) throw errors.X18N2002({
+			path,
+			line: lineNumber,
+			reason: "expected a message, a term or a comment"
+		});
+		current = {
+			id: message[1],
+			idRange: {
+				start: line.start,
+				end: line.start + message[1].length
+			},
+			block: {
+				start: commentStart ?? line.start,
+				end: line.next
+			},
+			pattern: {
+				after: line.start + message[0].trimEnd().length,
+				inline: {
+					start: line.start + message[0].length,
+					end: line.end
+				},
+				lines: []
+			},
+			attributes: []
+		};
+		commentStart = void 0;
+		messages.push(current);
+	}
+	return messages;
+}
+function encode(value, indent, eol) {
+	if (value === "") return " { \"\" }";
+	const lines = value.split("\n");
+	if (lines.length === 1) return ` ${value}`;
+	return lines.map((line) => line === "" ? eol : `${eol}${" ".repeat(indent)}${line}`).join("");
+}
+function splitKey(key) {
+	const dot = key.indexOf(".");
+	return dot === -1 ? {
+		id: key,
+		attribute: void 0
+	} : {
+		id: key.slice(0, dot),
+		attribute: key.slice(dot + 1)
+	};
+}
+function setValue(text, key, value, messages) {
+	const eol = detectEol(text);
+	const { id, attribute } = splitKey(key);
+	const message = messages.findLast((m) => m.id === id);
+	if (!message) return appendLines(text, attribute ? `${id} =\n    .${attribute} =${encode(value, 8, "\n")}\n` : `${id} =${encode(value, 4, "\n")}\n`);
+	if (!attribute) return splice(text, finishPattern(text, message.pattern).source, encode(value, 4, eol));
+	const existing = message.attributes.findLast((a) => a.name === attribute);
+	if (existing) return splice(text, finishPattern(text, existing.pattern).source, encode(value, indentOf(text, existing.lines) + 4, eol));
+	const end = message.block.end;
+	const lead = end === text.length && !text.endsWith("\n") ? eol : "";
+	return splice(text, {
+		start: end,
+		end
+	}, `${lead}    .${attribute} =${encode(value, 8, eol)}${eol}`);
+}
+function remove(text, key, messages) {
+	const { id, attribute } = splitKey(key);
+	const message = messages.findLast((m) => m.id === id);
+	if (!message) return text;
+	const pattern = finishPattern(text, message.pattern);
+	if (!attribute) {
+		if (pattern.value === void 0) return text;
+		return message.attributes.length > 0 ? splice(text, pattern.source, "") : splice(text, withBlankLines(text, message.block), "");
+	}
+	const existing = message.attributes.findLast((a) => a.name === attribute);
+	if (!existing) return text;
+	if (pattern.value === void 0 && message.attributes.length === 1) return splice(text, withBlankLines(text, message.block), "");
+	return splice(text, existing.lines, "");
+}
+function applyOp(text, op, path) {
+	const key = op.path.join(".");
+	const messages = read(text, path);
+	return op.type === "set" ? setValue(text, key, leafText(op.value), messages) : remove(text, key, messages);
+}
+function serialize(tree) {
+	const messages = /* @__PURE__ */ new Map();
+	for (const leaf of walkLeaves(tree)) {
+		const { id, attribute } = splitKey(leaf.path.join("."));
+		const message = messages.get(id) ?? {
+			value: void 0,
+			attributes: []
+		};
+		messages.set(id, message);
+		if (attribute) message.attributes.push(`    .${attribute} =${encode(leafText(leaf.value), 8, "\n")}\n`);
+		else message.value = leafText(leaf.value);
+	}
+	return [...messages].map(([id, m]) => `${id} =${m.value === void 0 ? "" : encode(m.value, 4, "\n")}\n${m.attributes.join("")}`).join("");
+}
+function ftl() {
+	return {
+		name: "x18n:format-ftl",
+		formats: [{
+			id: "ftl",
+			extensions: ["ftl"],
+			parse(text, ctx) {
+				const tree = {};
+				const ranges = /* @__PURE__ */ new Map();
+				for (const message of read(text, ctx.path)) {
+					const pattern = finishPattern(text, message.pattern);
+					if (pattern.value !== void 0) {
+						tree[message.id] = pattern.value;
+						ranges.set(pathId([message.id]), {
+							key: message.idRange,
+							value: pattern.range
+						});
+					}
+					for (const attribute of message.attributes) {
+						const key = `${message.id}.${attribute.name}`;
+						const value = finishPattern(text, attribute.pattern);
+						tree[key] = value.value ?? "";
+						ranges.set(pathId([key]), {
+							key: attribute.nameRange,
+							value: value.range
+						});
+					}
+				}
+				return {
+					tree,
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) next = applyOp(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize
+		}]
+	};
+}
+//#endregion
+export { ftl as default, ftl };

package/dist/formats/ini.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from "@x18n/core";
+//#region src/formats/ini/index.d.ts
+export declare function ini(): Plugin;
+//#endregion
+export { ini as default };