@x18n/builtins 0.0.2 → 0.0.5

package/dist/presets.d.mts

@@ -0,0 +1,58 @@
+import { Preset, PresetFactory } from "@x18n/core";
+//#region src/presets/angular.d.ts
+export declare function ngxTranslate(): Preset;
+export declare function transloco(): Preset;
+//#endregion
+//#region src/presets/js.d.ts
+export declare function vueI18n(): Preset;
+export declare function nuxtI18n(): Preset;
+export declare function i18next(): Preset;
+export declare function reactI18next(): Preset;
+export declare function nextIntl(): Preset;
+export declare function reactIntl(): Preset;
+export declare function svelteI18n(): Preset;
+export declare function vscodeExtension(): Preset;
+/** Always last: hard-string extraction templates for plain JS, TS and HTML. */
+export declare function general(): Preset;
+//#endregion
+//#region src/presets/mobile.d.ts
+/** Flutter with `flutter_i18n`: JSON or YAML assets, `FlutterI18n.translate(context, 'key')`. */
+export declare function flutter(): Preset;
+//#endregion
+//#region src/presets/server.d.ts
+/** Laravel: `lang/{locale}/{file}.php` arrays and `lang/{locale}.json`; keys are `file.key`. Exclusive like i18n-ally. */
+export declare function laravel(): Preset;
+/** Joomla: INI language files, `Text::_('KEY')`. */
+export declare function phpJoomla(): Preset;
+/** PHP gettext with `.po` files. Exclusive and never detected, as in i18n-ally: list it in `presets`. */
+export declare function phpGettext(): Preset;
+/** `t('.title')` in `app/views/users/index.html.erb` means `users.index.title`. */
+export declare function railsLazyKey(raw: string, path: string): string | undefined;
+export declare function rubyRails(): Preset;
+export declare function jekyll(): Preset;
+//#endregion
+//#region src/presets/web.d.ts
+export declare function nextInternational(): Preset;
+export declare function nextTranslate(): Preset;
+/** Shopify's i18next format: plural and ordinal forms as nested keys (`{key}.one`). */
+export declare function i18nextShopify(): Preset;
+export declare function i18nTag(): Preset;
+export declare function fluentVue(): Preset;
+export declare function polyglot(): Preset;
+export declare function globalize(): Preset;
+export declare function ui5(): Preset;
+export declare function lingui(): Preset;
+export declare function emberIntl(): Preset;
+export declare function i18nJs(): Preset;
+/** Chrome and WebExtension `_locales/{locale}/messages.json`: `{ "name": { "message": "..." } }` reads as `name`. */
+export declare function chromeExtension(): Preset;
+//#endregion
+//#region src/presets/index.d.ts
+/**
+ * Presets by name, in detection order: every i18n-ally framework has one.
+ * Presets that share plugins (react-i18next and i18next) apply them once.
+ */
+export declare const presets: {
+  readonly [name: string]: PresetFactory;
+};
+//#endregion

package/dist/presets.mjs

@@ -0,0 +1 @@
+export { n as chromeExtension, r as emberIntl, i as fluentVue, b as flutter, x as general, a as globalize, o as i18nJs, s as i18nTag, S as i18next, c as i18nextShopify, m as jekyll, h as laravel, l as lingui, u as nextInternational, C as nextIntl, d as nextTranslate, A as ngxTranslate, w as nuxtI18n, g as phpGettext, _ as phpJoomla, f as polyglot, t as presets, v as railsLazyKey, T as reactI18next, E as reactIntl, y as rubyRails, D as svelteI18n, j as transloco, p as ui5, O as vscodeExtension, k as vueI18n } from "./presets-DNnE_2MQ.mjs";

package/dist/regex-B9TBGgXC.mjs

@@ -0,0 +1,97 @@
+//#region src/scanners/regex.ts
+/** The key part of i18n-ally `usageMatchRegex` patterns. */
+const keyPattern = "[\\w\\d\\. \\-\\[\\]\\/:]+?";
+/** Turns a pattern with a `{key}` placeholder into a regex whose first group is the key. */
+function compileUsagePattern(pattern) {
+	const source = pattern.includes("{key}") ? pattern.replace("{key}", keyPattern) : pattern;
+	return new RegExp(source, "dg");
+}
+function scanWithRegex(text, regexes) {
+	const out = [];
+	for (const regex of regexes) {
+		regex.lastIndex = 0;
+		for (const match of text.matchAll(regex)) {
+			const indices = match.indices?.[1];
+			const raw = match[1];
+			if (!indices || raw === void 0) continue;
+			out.push({
+				raw,
+				range: {
+					start: indices[0],
+					end: indices[1]
+				},
+				kind: "call",
+				dynamic: false
+			});
+		}
+	}
+	return out;
+}
+/** The `regex` scanner over `usage.regex` specs, plus extra specs given here (YAML plugins). */
+function regex(specs = [], id = "regex") {
+	const cache = /* @__PURE__ */ new Map();
+	const regexesFor = (extension, all) => {
+		const key = `${extension}\0${all.length}`;
+		let list = cache.get(key);
+		if (!list) {
+			list = all.filter((spec) => spec.extensions.includes(extension)).flatMap((spec) => spec.patterns.map(compileUsagePattern));
+			cache.set(key, list);
+		}
+		return list;
+	};
+	let extensions = [...new Set(specs.flatMap((spec) => spec.extensions))];
+	const scanner = {
+		id,
+		get extensions() {
+			return extensions;
+		},
+		scan(file, ctx) {
+			const all = [...specs, ...ctx.config.usage.regex];
+			const usages = scanWithRegex(file.text, regexesFor(file.extension, all));
+			return {
+				usages,
+				keySlots: usages.map((usage) => usage.range)
+			};
+		}
+	};
+	return {
+		name: `x18n:scanner-${id}`,
+		configResolved(config) {
+			extensions = [...new Set([...specs, ...config.usage.regex].flatMap((spec) => spec.extensions))];
+		},
+		scanners: [scanner]
+	};
+}
+/**
+* Regions after each match of `pattern` (group 1 = namespace, or key prefix with `as: 'keyPrefix'`),
+* up to the next match: i18n-ally `scopeRangeRegex`. With `wholeFile`, the first match scopes the whole file.
+*/
+function regexScopes(pattern, id = "scopes", options = {}) {
+	const re = new RegExp(pattern, "g");
+	return {
+		name: `x18n:scanner-${id}`,
+		scanners: [{
+			id,
+			extensions: options.extensions ?? ["*"],
+			scan(file) {
+				const matches = [...file.text.matchAll(re)];
+				if (options.wholeFile) matches.splice(1);
+				return {
+					usages: [],
+					scopes: matches.map((match, i) => ({
+						range: options.wholeFile ? {
+							start: 0,
+							end: file.text.length
+						} : {
+							start: match.index + match[0].length,
+							end: matches[i + 1]?.index ?? file.text.length
+						},
+						...options.as === "keyPrefix" ? { keyPrefix: match[1] } : { namespace: match[1] }
+					}))
+				};
+			}
+		}]
+	};
+}
+//#endregion
+export { scanWithRegex as i, regex as n, regexScopes as r, compileUsagePattern as t };

package/dist/reporters.d.mts

@@ -0,0 +1,14 @@
+import { Plugin, Reporter } from "@x18n/core";
+//#region src/reporters/index.d.ts
+/** tsc-style output: `path:line:col - error code: message`, code frames, then a summary. */
+export declare const prettyReporter: Reporter;
+/** The versioned JSON contract of `x18n check --json`. */
+export declare const jsonReporter: Reporter;
+/** Summary and tables for PR comments and agent context. */
+export declare const markdownReporter: Reporter;
+/** GitHub Actions workflow commands, which become annotations on the PR. */
+export declare const githubReporter: Reporter;
+/** SARIF 2.1.0 for code scanning. */
+export declare const sarifReporter: Reporter;
+export declare function reporters(): Plugin;
+//#endregion

package/dist/reporters.mjs

@@ -0,0 +1,204 @@
+import { createLineIndex, envelope, toWireDiagnostic } from "@x18n/core";
+//#region src/reporters/index.ts
+const codes = {
+	red: 31,
+	yellow: 33,
+	cyan: 36,
+	gray: 90,
+	blue: 34,
+	bold: 1
+};
+function paint(ctx, color, text) {
+	return ctx.color ? `\u001B[${codes[color]}m${text}\u001B[0m` : text;
+}
+function plural(count, word) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+function totals(inputs) {
+	return inputs.reduce((sum, input) => ({
+		errors: sum.errors + input.summary.errors,
+		warnings: sum.warnings + input.summary.warnings,
+		infos: sum.infos + input.summary.infos,
+		files: sum.files + input.summary.files
+	}), {
+		errors: 0,
+		warnings: 0,
+		infos: 0,
+		files: 0
+	});
+}
+const severityColor = {
+	error: "red",
+	warning: "yellow",
+	info: "blue",
+	hint: "gray"
+};
+function codeFrame(text, start, end, ctx) {
+	const index = createLineIndex(text);
+	const from = index.position(start);
+	const to = index.position(end);
+	const number = String(from.line + 1);
+	const line = index.line(from.line);
+	const width = Math.max(1, (to.line === from.line ? to.character : line.length) - from.character);
+	const gutter = " ".repeat(number.length);
+	return `${paint(ctx, "gray", number)} ${line}\n${gutter} ${" ".repeat(from.character)}${paint(ctx, "red", "~".repeat(width))}`;
+}
+/** tsc-style output: `path:line:col - error code: message`, code frames, then a summary. */
+const prettyReporter = {
+	id: "pretty",
+	report(inputs, ctx) {
+		const out = [];
+		for (const input of inputs) for (const d of input.diagnostics) {
+			const head = `${paint(ctx, severityColor[d.severity], d.severity)} ${paint(ctx, "gray", d.code)}: ${d.message}`;
+			if (!d.location) {
+				out.push(`${head}\n`);
+				continue;
+			}
+			const text = input.text(d.location.path);
+			const position = createLineIndex(text ?? "").position(d.location.range.start);
+			const where = `${paint(ctx, "cyan", ctx.displayPath(d.location.path, input.project))}:${paint(ctx, "yellow", String(position.line + 1))}:${paint(ctx, "yellow", String(position.character + 1))}`;
+			const frame = text !== void 0 && d.location.range.end > d.location.range.start ? `\n${codeFrame(text, d.location.range.start, d.location.range.end, ctx)}\n` : "";
+			out.push(`${where} - ${head}${frame}`);
+		}
+		const sum = totals(inputs);
+		if (sum.errors + sum.warnings === 0) out.push(paint(ctx, "gray", "Found no errors."));
+		else {
+			const parts = [sum.errors ? plural(sum.errors, "error") : "", sum.warnings ? plural(sum.warnings, "warning") : ""].filter(Boolean);
+			out.push(`${out.length && !out.at(-1).endsWith("\n") ? "\n" : ""}Found ${parts.join(" and ")} in ${plural(sum.files, "file")}.`);
+		}
+		return `${out.join("\n")}\n`;
+	}
+};
+/** The versioned JSON contract of `x18n check --json`. */
+const jsonReporter = {
+	id: "json",
+	report(inputs) {
+		const diagnostics = inputs.flatMap((input) => input.diagnostics.map((d) => toWireDiagnostic(input.project, d, input.text)));
+		const data = { projects: inputs.map((input) => ({
+			name: input.project,
+			summary: input.summary,
+			coverage: input.coverage.map((c) => ({
+				locale: c.locale,
+				total: c.total,
+				translated: c.translated,
+				missing: c.missing.length,
+				empty: c.empty.length,
+				outdated: c.outdated.length
+			}))
+		})) };
+		return `${JSON.stringify(envelope("check", data, diagnostics), null, 2)}\n`;
+	}
+};
+function escapeCell(text) {
+	return text.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+/** Summary and tables for PR comments and agent context. */
+const markdownReporter = {
+	id: "markdown",
+	report(inputs, ctx) {
+		const sum = totals(inputs);
+		const out = [
+			"## x18n check",
+			"",
+			`**${plural(sum.errors, "error")}**, ${plural(sum.warnings, "warning")} in ${plural(sum.files, "file")}.`,
+			""
+		];
+		for (const input of inputs) {
+			if (inputs.length > 1) out.push(`### ${input.project}`, "");
+			out.push("| Locale | Translated | Missing | Empty |", "| --- | --- | --- | --- |");
+			for (const c of input.coverage) out.push(`| ${c.locale} | ${c.translated}/${c.total} | ${c.missing.length} | ${c.empty.length} |`);
+			out.push("");
+			if (input.diagnostics.length === 0) continue;
+			out.push("| Severity | Check | Location | Message |", "| --- | --- | --- | --- |");
+			for (const d of input.diagnostics.slice(0, 200)) {
+				const line = d.location ? createLineIndex(input.text(d.location.path) ?? "").position(d.location.range.start).line + 1 : void 0;
+				const where = d.location ? `\`${ctx.displayPath(d.location.path, input.project)}:${line}\`` : "";
+				out.push(`| ${d.severity} | \`${d.code}\` | ${where} | ${escapeCell(d.message)} |`);
+			}
+			if (input.diagnostics.length > 200) out.push("", `_${input.diagnostics.length - 200} more not shown._`);
+			out.push("");
+		}
+		return `${out.join("\n")}\n`;
+	}
+};
+function escapeProperty(text) {
+	return text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
+}
+function escapeData(text) {
+	return text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+/** GitHub Actions workflow commands, which become annotations on the PR. */
+const githubReporter = {
+	id: "github",
+	report(inputs, ctx) {
+		const out = [];
+		for (const input of inputs) for (const d of input.diagnostics) {
+			const level = d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "notice";
+			const props = [`title=${escapeProperty(`x18n ${d.code}`)}`];
+			if (d.location) {
+				const wire = toWireDiagnostic(input.project, d, input.text).range;
+				props.unshift(`file=${escapeProperty(ctx.displayPath(d.location.path, input.project))}`, `line=${wire.line}`, `col=${wire.column}`, `endLine=${wire.endLine}`, `endColumn=${wire.endColumn}`);
+			}
+			out.push(`::${level} ${props.join(",")}::${escapeData(d.message)}`);
+		}
+		return out.length ? `${out.join("\n")}\n` : "";
+	}
+};
+/** SARIF 2.1.0 for code scanning. */
+const sarifReporter = {
+	id: "sarif",
+	report(inputs, ctx) {
+		const all = inputs.flatMap((input) => input.diagnostics.map((d) => ({
+			input,
+			d
+		})));
+		const rules = [...new Set(all.map(({ d }) => d.code))].sort();
+		const results = all.map(({ input, d }) => {
+			const wire = toWireDiagnostic(input.project, d, input.text);
+			return {
+				ruleId: d.code,
+				level: d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "note",
+				message: { text: d.message },
+				locations: d.location && wire.range ? [{ physicalLocation: {
+					artifactLocation: { uri: ctx.displayPath(d.location.path, input.project) },
+					region: {
+						startLine: wire.range.line,
+						startColumn: wire.range.column,
+						endLine: wire.range.endLine,
+						endColumn: wire.range.endColumn
+					}
+				} }] : []
+			};
+		});
+		const log = {
+			$schema: "https://json.schemastore.org/sarif-2.1.0.json",
+			version: "2.1.0",
+			runs: [{
+				tool: { driver: {
+					name: "x18n",
+					informationUri: "https://x18n.antfu.dev",
+					rules: rules.map((id) => ({
+						id,
+						helpUri: `https://x18n.antfu.dev/checks/${id}`
+					}))
+				} },
+				results
+			}]
+		};
+		return `${JSON.stringify(log, null, 2)}\n`;
+	}
+};
+function reporters() {
+	return {
+		name: "x18n:reporters",
+		reporters: [
+			prettyReporter,
+			jsonReporter,
+			markdownReporter,
+			githubReporter,
+			sarifReporter
+		]
+	};
+}
+//#endregion
+export { githubReporter, jsonReporter, markdownReporter, prettyReporter, reporters, sarifReporter };

package/dist/scanners-B27IEH4_.mjs

@@ -0,0 +1,119 @@
+import { a as loadParser, o as scanSource } from "./vue-5GFR5hft.mjs";
+//#region src/scanners/svelte.ts
+let compiler;
+function isSvelteNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
+}
+const expressionTypes = /* @__PURE__ */ new Set([
+	"ExpressionTag",
+	"HtmlTag",
+	"ConstTag",
+	"RenderTag",
+	"IfBlock",
+	"EachBlock",
+	"AwaitBlock",
+	"KeyBlock"
+]);
+const ignoredAttributes = /* @__PURE__ */ new Set([
+	"class",
+	"style",
+	"id",
+	"name",
+	"type",
+	"href",
+	"src",
+	"for",
+	"role",
+	"lang",
+	"rel",
+	"target"
+]);
+function textHardString(node, data, attribute, out) {
+	const text = data.trim();
+	const name = typeof attribute?.name === "string" ? attribute.name : void 0;
+	if (!text || !/\p{L}/u.test(text) || name !== void 0 && ignoredAttributes.has(name)) return;
+	if (attribute) {
+		out.push({
+			text,
+			range: {
+				start: attribute.start,
+				end: attribute.end
+			},
+			kind: "svelte-attribute",
+			...name ? { attribute: name } : {}
+		});
+		return;
+	}
+	const start = node.start + data.indexOf(text);
+	out.push({
+		text,
+		range: {
+			start,
+			end: start + text.length
+		},
+		kind: "svelte-text"
+	});
+}
+/** Svelte components: `<script>` and template expressions through the `js` scanner. Node only at first. */
+function svelte() {
+	return {
+		name: "x18n:scanner-svelte",
+		runtime: "node",
+		scanners: [{
+			id: "svelte",
+			extensions: ["svelte"],
+			runtime: "node",
+			async scan(file, ctx) {
+				compiler ??= import("svelte/compiler");
+				const [{ parse }, parseJs] = await Promise.all([compiler, loadParser()]);
+				const usages = [];
+				const keySlots = [];
+				const hardStrings = [];
+				const add = (result) => {
+					usages.push(...result.usages);
+					keySlots.push(...result.keySlots ?? []);
+					hardStrings.push(...result.hardStrings ?? []);
+				};
+				const ast = parse(file.text, { modern: true });
+				const scan = (text, offset, expression) => {
+					try {
+						add(scanSource(parseJs, text, {
+							calls: ctx.calls,
+							offset,
+							filename: "component.ts",
+							expression,
+							hardStrings: !expression
+						}));
+					} catch {}
+				};
+				const visit = (node, parentType, attribute) => {
+					if (Array.isArray(node)) {
+						node.forEach((child) => visit(child, parentType, attribute));
+						return;
+					}
+					if (typeof node !== "object" || node === null) return;
+					if (!isSvelteNode(node)) {
+						for (const child of Object.values(node)) visit(child, parentType, attribute);
+						return;
+					}
+					if (node.type === "Script" && "content" in node && isSvelteNode(node.content)) {
+						scan(file.text.slice(node.content.start, node.content.end), node.content.start, false);
+						return;
+					}
+					if (expressionTypes.has(node.type) && "expression" in node && isSvelteNode(node.expression)) scan(file.text.slice(node.expression.start, node.expression.end), node.expression.start, true);
+					if (node.type === "Text" && "data" in node && typeof node.data === "string") textHardString(node, node.data, parentType === "Attribute" ? attribute : void 0, hardStrings);
+					const owner = node.type === "Attribute" ? node : attribute;
+					for (const [key, child] of Object.entries(node)) if (key !== "expression" && typeof child === "object") visit(child, node.type, owner);
+				};
+				visit(ast, "", void 0);
+				return {
+					usages,
+					keySlots,
+					hardStrings
+				};
+			}
+		}]
+	};
+}
+//#endregion
+export { svelte as t };

package/dist/scanners.d.mts

@@ -0,0 +1,49 @@
+import { CallSpec, Plugin, RegexScannerSpec, ScanResult, UsageCandidate } from "@x18n/core";
+import { Node } from "oxc-parser";
+//#region src/scanners/js.d.ts
+/** `a.b.c` for identifier and member chains, `this.` dropped; undefined for anything else. */
+export declare function calleeName(node: Node): string | undefined;
+type ParseSync = typeof import("oxc-parser").parseSync;
+/** Loads oxc lazily: native in Node, WASM through the package's browser export. */
+export declare function loadParser(): Promise<ParseSync>;
+interface ScanSourceOptions {
+  readonly calls: readonly CallSpec[];
+  /** Offset of `text` in the file, for embedded code such as Vue `<script>`. */
+  readonly offset?: number;
+  readonly hardStrings?: boolean;
+  /** File name for the parser; picks JS, TS or JSX. */
+  readonly filename: string;
+  /** Parse `text` as one expression (template interpolations). */
+  readonly expression?: boolean;
+  /** Callees whose string arguments are never hard strings (`extract.ignoreCallees`). */
+  readonly ignoreCallees?: readonly string[] | undefined;
+}
+export declare function scanSource(parse: ParseSync, text: string, options: ScanSourceOptions): ScanResult;
+/** The AST scanner for JS and TS, driven by call specs (`usage.calls`). */
+export declare function js(): Plugin;
+//#endregion
+//#region src/scanners/regex.d.ts
+/** Turns a pattern with a `{key}` placeholder into a regex whose first group is the key. */
+export declare function compileUsagePattern(pattern: string): RegExp;
+export declare function scanWithRegex(text: string, regexes: readonly RegExp[]): UsageCandidate[];
+/** The `regex` scanner over `usage.regex` specs, plus extra specs given here (YAML plugins). */
+export declare function regex(specs?: readonly RegexScannerSpec[], id?: string): Plugin;
+/**
+ * Regions after each match of `pattern` (group 1 = namespace, or key prefix with `as: 'keyPrefix'`),
+ * up to the next match: i18n-ally `scopeRangeRegex`. With `wholeFile`, the first match scopes the whole file.
+ */
+export declare function regexScopes(pattern: string, id?: string, options?: {
+  readonly as?: "namespace" | "keyPrefix";
+  readonly extensions?: readonly string[];
+  readonly wholeFile?: boolean;
+}): Plugin;
+//#endregion
+//#region src/scanners/svelte.d.ts
+/** Svelte components: `<script>` and template expressions through the `js` scanner. Node only at first. */
+export declare function svelte(): Plugin;
+//#endregion
+//#region src/scanners/vue.d.ts
+/** Vue SFCs: `<script>` through the `js` scanner, template expressions, `v-t`, `<i18n-t keypath>`. */
+export declare function vue(): Plugin;
+//#endregion
+export type { ScanSourceOptions };

package/dist/scanners.mjs

@@ -0,0 +1,4 @@
+import { a as loadParser, i as js, n as vue, o as scanSource, r as calleeName } from "./vue-5GFR5hft.mjs";
+import { i as scanWithRegex, n as regex, r as regexScopes, t as compileUsagePattern } from "./regex-B9TBGgXC.mjs";
+import { t as svelte } from "./scanners-B27IEH4_.mjs";
+export { calleeName, compileUsagePattern, js, loadParser, regex, regexScopes, scanSource, scanWithRegex, svelte, vue };