@x18n/builtins 0.0.3 → 0.0.6

package/dist/checks.d.mts

@@ -2,6 +2,7 @@ import { Check, Plugin } from "@x18n/core";
 //#region src/checks/index.d.ts
 export declare const missingKey: Check;
 export declare const missingTranslation: Check;
+export declare const staleTranslation: Check;
 export declare const emptyTranslation: Check;
 export declare const keyConflict: Check;
 export declare const localeCodeConflict: Check;

package/dist/checks.mjs

@@ -1,4 +1,4 @@
-import { shouldExtract } from "./extractors.mjs";
+import { extractableHardStrings } from "./extractors.mjs";
 import { createPlaceholderComparer, localeSpellingKey } from "@x18n/core";
 //#region src/checks/index.ts
 function list(items) {
@@ -70,6 +70,23 @@ const missingTranslation = {
 		}
 	}
 };
+function changed(change) {
+	if (!Number.isFinite(change.updatedAt)) return "changed locally";
+	const revision = change.revision ? ` in ${change.revision.slice(0, 7)}` : "";
+	return `changed ${new Date(change.updatedAt).toISOString().slice(0, 10)}${revision}`;
+}
+const staleTranslation = {
+	id: "stale-translation",
+	defaultSeverity: "warning",
+	description: "A translation that last changed before its source message, by the history providers (git).",
+	*run(ctx) {
+		for (const coverage of ctx.coverage()) for (const key of coverage.outdated) yield {
+			key,
+			locale: coverage.locale,
+			message: `"${key}" in ${coverage.locale} is older than ${ctx.sourceLocale} (source ${changed(ctx.history(key, ctx.sourceLocale))}).`
+		};
+	}
+};
 const emptyTranslation = {
 	id: "empty-translation",
 	defaultSeverity: "warning",
@@ -265,7 +282,7 @@ const hardString = {
 	description: "A hard-coded string that should probably be a message. On with `extract.autoDetect`.",
 	*run(ctx) {
 		if (!ctx.config.extract.autoDetect && ctx.config.checks["hard-string"] === void 0) return;
-		for (const hard of ctx.hardStrings()) if (shouldExtract(hard.text, hard.kind)) yield {
+		for (const hard of extractableHardStrings(ctx.config.extract, ctx.hardStrings(), ctx.text)) yield {
 			location: {
 				path: hard.path,
 				range: hard.range
@@ -274,9 +291,14 @@ const hardString = {
 		};
 	}
 };
-/** A term as a whole word, so "Home" does not match "Homepage". */
+const unspaced = "\\p{scx=Han}\\p{scx=Hiragana}\\p{scx=Katakana}\\p{scx=Hangul}\\p{scx=Thai}\\p{scx=Lao}\\p{scx=Khmer}\\p{scx=Myanmar}";
+const startsUnspaced = new RegExp(`^[${unspaced}]`, "u");
+const endsUnspaced = new RegExp(`[${unspaced}]$`, "u");
+/** A term as a whole word, so "Home" does not match "Homepage"; a plain substring at edges in unspaced scripts. */
 function wordPattern(term) {
-	return new RegExp(`(?<![\\p{L}\\p{N}])${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\p{L}\\p{N}])`, "iu");
+	const before = startsUnspaced.test(term) ? "" : "(?<![\\p{L}\\p{N}])";
+	const after = endsUnspaced.test(term) ? "" : "(?![\\p{L}\\p{N}])";
+	return new RegExp(`${before}${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}${after}`, "iu");
 }
 function* glossaryDiagnostics(ctx, entry) {
 	const term = wordPattern(entry.term);
@@ -309,6 +331,7 @@ const allChecks = [
 	placeholderMismatch,
 	keyConflict,
 	missingTranslation,
+	staleTranslation,
 	emptyTranslation,
 	unusedKey,
 	localeCodeConflict,
@@ -326,4 +349,4 @@ function recommended() {
 	};
 }
 //#endregion
-export { allChecks, dynamicKey, emptyTranslation, glossary, hardString, identicalToSource, invalidSyntax, keyConflict, keyStyle, localeCodeConflict, missingKey, missingTranslation, placeholderMismatch, recommended, unusedKey };
+export { allChecks, dynamicKey, emptyTranslation, glossary, hardString, identicalToSource, invalidSyntax, keyConflict, keyStyle, localeCodeConflict, missingKey, missingTranslation, placeholderMismatch, recommended, staleTranslation, unusedKey };

package/dist/extractors.d.mts

@@ -1,4 +1,4 @@
-import { ExtractItem, ExtractTemplate, KeyString, Project, TextRange } from "@x18n/core";
+import { ExtractItem, ExtractOptions, ExtractTemplate, HardString, KeyString, Project, TextRange } from "@x18n/core";
 //#region src/extractors/index.d.ts
 export type Score = "must-include" | "should-include" | "none" | "should-exclude" | "must-exclude";
 export interface ExtractionRule {
@@ -38,6 +38,12 @@ export interface FindOptions {
   /** Only these files (globs). */
   readonly files?: readonly string[] | undefined;
 }
+/** Hard strings worth extracting: they pass the rules and no non-UI file, config ignore or control comment skips them. */
+export declare function extractableHardStrings(options: ExtractOptions, hardStrings: Iterable<HardString & {
+  readonly path: string;
+}>, textOf: (path: string) => string | undefined): Generator<HardString & {
+  readonly path: string;
+}>;
 /** Hard strings worth extracting, with proposed keys, values and replacements. */
 export declare function findCandidates(project: Project, options?: FindOptions): ExtractCandidate[];
 export interface ExtractPlanFile {

package/dist/extractors.mjs

@@ -30,7 +30,18 @@ const rules = [
 	},
 	{
 		id: "markup",
-		test: (text) => /^<[^>]+>$/.test(text.trim()) ? "must-exclude" : "none"
+		test: (text) => /^<.*>$/s.test(text.trim()) && !/\p{L}/u.test(text.replace(/<[^>]*>|\{\d+\}/g, "")) ? "must-exclude" : "none"
+	},
+	{
+		id: "svg-path",
+		test: (text) => /^\s*M\s*-?[\d.]/i.test(text) && /^[MLHVCSQTAZ\d\s.,-]+$/i.test(text) ? "must-exclude" : "none"
+	},
+	{
+		id: "class-list",
+		test: (text) => {
+			const tokens = text.trim().split(/\s+/);
+			return tokens.every((t) => /^!?[a-z][\w:/[\].#%!-]*$/.test(t)) && tokens.filter((t) => /[-:!/[\d]/.test(t)).length * 2 > tokens.length ? "must-exclude" : "none";
+		}
 	},
 	{
 		id: "non-ascii",
@@ -57,6 +68,17 @@ const rules = [
 		test: (text) => /^[a-z]+(?:[A-Z][a-z\d]*)+$/.test(text) || /^[A-Z\d]+(?:_[A-Z\d]+)+$/.test(text) || /^[a-z\d]+(?:[-_.:][a-z\d]+)+$/.test(text) ? "should-exclude" : "none"
 	}
 ];
+/** Files whose strings users never see, by the naming conventions of common languages and test runners. */
+const nonUiFiles = [
+	/(?:^|\/)(?:tests?|specs?|e2e|cypress|fixtures?|mocks?|testdata|__(?:tests|mocks|snapshots|fixtures)__)\//i,
+	/[._-](?:tests?|specs?|e2e|cy|stories|story|config|conf)\.\w+$/i,
+	/(?:^|\/)(?:test_[^/]+|(?:tests?|specs?|conftest|config)\.\w+)$/i,
+	/[a-z\d](?:Tests?|Spec|IT)\.(?:java|kt|kts|scala|groovy|cs|fs|vb|php|swift|m|mm)$/,
+	/\.d\.[cm]?ts$/
+];
+function isExtractableFile(path) {
+	return !nonUiFiles.some((pattern) => pattern.test(path));
+}
 /** Folds rule scores the i18n-ally way (`shouldExtract`). */
 function shouldExtract(text, kind, list = rules) {
 	let result = "none";
@@ -166,18 +188,43 @@ var KeyAllocator = class {
 		};
 	}
 };
-function isIgnored(project, hard, text) {
-	const options = project.config.extract;
+function ignoredByConfig(options, hard) {
 	const matches = (rule) => {
 		const regex = /^\/(.+)\/([a-z]*)$/.exec(rule);
 		return regex ? new RegExp(regex[1], regex[2]).test(hard.text) : rule === hard.text;
 	};
 	if (options.ignore?.some(matches)) return true;
 	for (const [glob, list] of Object.entries(options.ignoreByFile ?? {})) if (pathMatcher([glob])(hard.path) && list.some(matches)) return true;
-	if (hard.attribute && options.ignoreAttributes?.includes(hard.attribute)) return true;
+	return hard.attribute !== void 0 && options.ignoreAttributes?.includes(hard.attribute) === true;
+}
+const ignoreLine = /x18n-ignore(?![-\w])/;
+/**
+* Offsets silenced by control comments: `x18n-ignore-file` anywhere, inside `x18n-ignore-start` ... `x18n-ignore-end`
+* (to the end of the file when unclosed), or on the line of, or the line after, `x18n-ignore`.
+*/
+function commentIgnores(text) {
+	if (text.includes("x18n-ignore-file")) return () => true;
+	const regions = [...text.matchAll(/x18n-ignore-start[\s\S]*?(?:x18n-ignore-end|$)/g)].map((m) => [m.index, m.index + m[0].length]);
 	const index = createLineIndex(text);
-	const line = index.position(hard.range.start).line;
-	return index.line(line).includes("x18n-ignore") || line > 0 && index.line(line - 1).includes("x18n-ignore");
+	return (offset) => {
+		if (regions.some(([start, end]) => offset >= start && offset < end)) return true;
+		const line = index.position(offset).line;
+		return ignoreLine.test(index.line(line)) || line > 0 && ignoreLine.test(index.line(line - 1));
+	};
+}
+/** Hard strings worth extracting: they pass the rules and no non-UI file, config ignore or control comment skips them. */
+function* extractableHardStrings(options, hardStrings, textOf) {
+	const ignores = /* @__PURE__ */ new Map();
+	for (const hard of hardStrings) {
+		if (!isExtractableFile(hard.path) || !shouldExtract(hard.text, hard.kind) || ignoredByConfig(options, hard)) continue;
+		let ignored = ignores.get(hard.path);
+		if (!ignored) {
+			const text = textOf(hard.path);
+			ignored = text === void 0 ? () => true : commentIgnores(text);
+			ignores.set(hard.path, ignored);
+		}
+		if (!ignored(hard.range.start)) yield hard;
+	}
 }
 /** Placeholder shape of the project's first placeholder syntax, `{name}` by default. */
 function placeholderShape(project) {
@@ -211,10 +258,10 @@ function findCandidates(project, options = {}) {
 	const keys = new KeyAllocator(project);
 	const shape = placeholderShape(project);
 	const out = [];
-	for (const hard of project.hardStrings()) {
-		if (inFiles && !inFiles(hard.path)) continue;
+	const inScope = [...project.hardStrings()].filter((hard) => !inFiles || inFiles(hard.path));
+	for (const hard of extractableHardStrings(project.config.extract, inScope, (path) => project.text(path))) {
 		const text = project.text(hard.path);
-		if (text === void 0 || !shouldExtract(hard.text, hard.kind) || isIgnored(project, hard, text)) continue;
+		if (text === void 0) continue;
 		const value = hard.kind === "js-template" ? hard.text.replace(/\{(\d+)\}/g, (_, i) => shape(hard.args?.[Number(i)]?.name ?? `arg${i}`)) : hard.text;
 		const { key, reused } = keys.allocate(value, hard.path, hard.text.replace(/\{\d+\}/g, " "));
 		const templates = templatesFor(project, hard.kind, hard.path);
@@ -266,4 +313,4 @@ function extractItems(project, items) {
 	});
 }
 //#endregion
-export { defaultTemplates, extractItems, findCandidates, rules, shouldExtract, slugify, toPlanFile };
+export { defaultTemplates, extractItems, extractableHardStrings, findCandidates, rules, shouldExtract, slugify, toPlanFile };

package/dist/reporters.mjs

@@ -82,7 +82,8 @@ const jsonReporter = {
 				total: c.total,
 				translated: c.translated,
 				missing: c.missing.length,
-				empty: c.empty.length
+				empty: c.empty.length,
+				outdated: c.outdated.length
 			}))
 		})) };
 		return `${JSON.stringify(envelope("check", data, diagnostics), null, 2)}\n`;

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@x18n/builtins",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Built-in x18n plugins and presets: formats, locale finders, scanners, checks and reporters",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
-  "homepage": "https://github.com/antfu/x18n#readme",
+  "homepage": "https://github.com/x18n-dev/x18n#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/antfu/x18n.git",
+    "url": "git+https://github.com/x18n-dev/x18n.git",
     "directory": "packages/builtins"
   },
-  "bugs": "https://github.com/antfu/x18n/issues",
+  "bugs": "https://github.com/x18n-dev/x18n/issues",
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.mjs",
@@ -33,10 +33,10 @@
   ],
   "dependencies": {
     "@vue/compiler-sfc": "^3.5.44",
-    "@x18n/core": "0.0.3",
+    "@x18n/core": "0.0.6",
     "json5": "^2.2.3",
     "jsonc-parser": "^3.3.1",
-    "oxc-parser": "^0.154.0",
+    "oxc-parser": "^0.155.0",
     "svelte": "^5.57.2",
     "yaml": "^2.9.1"
   },