@x18n/builtins 0.0.0-stage → 0.0.0

package/dist/extractors.mjs

@@ -0,0 +1,247 @@
+import { X18nError, createLineIndex, pathMatcher } from "@x18n/core";
+//#region src/extractors/index.ts
+const textKinds = /* @__PURE__ */ new Set([
+	"jsx-text",
+	"vue-template-text",
+	"svelte-text",
+	"html-text"
+]);
+/** Built-in rules, applied in order. A `must-*` wins at once; otherwise the last `should-*` decides. */
+const rules = [
+	{
+		id: "letters",
+		test: (text) => /\p{L}/u.test(text) ? "none" : "must-exclude"
+	},
+	{
+		id: "digits",
+		test: (text) => /^[\d\s.,:%+-]+$/.test(text) ? "must-exclude" : "none"
+	},
+	{
+		id: "url",
+		test: (text) => /^(?:[a-z][\w+.-]*:\/\/|mailto:|#|\/\/)/i.test(text.trim()) ? "must-exclude" : "none"
+	},
+	{
+		id: "path",
+		test: (text) => /^(?:\.{0,2}\/|~\/|@\/)[\w./@-]*$/.test(text.trim()) || /^[\w-]+\.[a-z]{2,4}$/i.test(text.trim()) ? "must-exclude" : "none"
+	},
+	{
+		id: "translate-call",
+		test: (text) => /\$?t\(['"`]/.test(text) || text.includes("{{") ? "must-exclude" : "none"
+	},
+	{
+		id: "markup",
+		test: (text) => /^<[^>]+>$/.test(text.trim()) ? "must-exclude" : "none"
+	},
+	{
+		id: "non-ascii",
+		test: (text) => /\P{ASCII}/u.test(text) && /\p{L}/u.test(text) ? "must-include" : "none"
+	},
+	{
+		id: "sentence",
+		test: (text) => /\p{L}\s+\p{L}/u.test(text) ? "should-include" : "none"
+	},
+	{
+		id: "text-node",
+		test: (text, kind) => textKinds.has(kind) || kind.endsWith("attribute") ? "should-include" : "none"
+	},
+	{
+		id: "single-word",
+		test: (text, kind) => !textKinds.has(kind) && !kind.endsWith("attribute") && !/\s/.test(text.trim()) ? "should-exclude" : "none"
+	},
+	{
+		id: "identifier",
+		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"
+	}
+];
+/** Folds rule scores the i18n-ally way (`shouldExtract`). */
+function shouldExtract(text, kind, list = rules) {
+	let result = "none";
+	for (const rule of list) {
+		const score = rule.test(text, kind);
+		if (score === "must-include") return true;
+		if (score === "must-exclude") return false;
+		if (score !== "none") result = score;
+	}
+	return result === "should-include";
+}
+/** Words of a text for slugs: letters and digits only. */
+function words(text) {
+	return text.normalize("NFKD").replace(/[\u0300-\u036F]/g, "").split(/[^\p{L}\d]+/u).filter(Boolean);
+}
+/** "Forgot password?" becomes `forgotPassword` (camel), `forgot_password`, `forgot-password` or `forgot.password`. */
+function slugify(text, keyCase = "camel", maxLength = 40) {
+	const parts = [];
+	let length = 0;
+	for (const word of words(text).map((w) => w.toLowerCase())) {
+		if (length + word.length > maxLength && parts.length > 0) break;
+		parts.push(word);
+		length += word.length + 1;
+	}
+	if (parts.length === 0) return "text";
+	switch (keyCase) {
+		case "snake": return parts.join("_");
+		case "kebab": return parts.join("-");
+		case "dot": return parts.join(".");
+		default: return parts.map((word, i) => i === 0 ? word : word[0].toUpperCase() + word.slice(1)).join("");
+	}
+}
+/** Fallback templates per kind, used after config and preset templates. */
+const defaultTemplates = [
+	{
+		template: "{t('{key}'{args})}",
+		kinds: ["jsx-text"]
+	},
+	{
+		template: "{attr}={t('{key}'{args})}",
+		kinds: ["jsx-attribute"]
+	},
+	{
+		template: "{{ $t('{key}'{args}) }}",
+		kinds: ["vue-template-text", "html-text"]
+	},
+	{
+		template: ":{attr}=\"$t('{key}'{args})\"",
+		kinds: ["vue-attribute"]
+	},
+	{
+		template: "{$t('{key}'{args})}",
+		kinds: ["svelte-text"]
+	},
+	{
+		template: "{attr}={$t('{key}'{args})}",
+		kinds: ["svelte-attribute"]
+	},
+	{ template: "t('{key}'{args})" }
+];
+function prefixFor(template, path) {
+	if (!template) return "";
+	const base = path.slice(path.lastIndexOf("/") + 1).replace(/\.[^.]+$/, "");
+	const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")).split("/").at(-1) : "";
+	return template.replace("{fileName}", slugify(base)).replace("{dirName}", slugify(dir)).replace("{component}", base.replace(/(?:^|[-_])(\w)/g, (_, c) => c.toUpperCase()));
+}
+function randomKey() {
+	return Math.random().toString(36).slice(2, 10);
+}
+var KeyAllocator = class {
+	project;
+	byValue = /* @__PURE__ */ new Map();
+	taken = /* @__PURE__ */ new Map();
+	constructor(project) {
+		this.project = project;
+		const options = project.config.extract;
+		for (const key of project.keys()) {
+			const value = project.message(key, project.sourceLocale)?.value;
+			if (typeof value === "string") {
+				this.taken.set(key, value);
+				if (options.reuseExisting !== false && !this.byValue.has(value)) this.byValue.set(value, key);
+			}
+		}
+	}
+	allocate(value, path, slugText) {
+		const options = this.project.config.extract;
+		const reused = this.byValue.get(value);
+		if (reused) return {
+			key: reused,
+			reused: this.taken.has(reused)
+		};
+		const strategy = options.keygen ?? "slug";
+		const prefix = prefixFor(options.keyPrefix, path);
+		let base;
+		if (strategy === "source") base = value;
+		else if (strategy === "random") base = randomKey();
+		else if (strategy === "empty") base = "";
+		else base = slugify(slugText, options.keyCase ?? "camel", options.keyMaxLength ?? 40);
+		const raw = prefix ? `${prefix}.${base}` : base;
+		let key = this.project.parseKey(raw);
+		for (let i = 2; this.taken.has(key) && this.taken.get(key) !== value; i++) key = this.project.parseKey(`${raw}${i}`);
+		this.taken.set(key, value);
+		this.byValue.set(value, key);
+		return {
+			key,
+			reused: false
+		};
+	}
+};
+function isIgnored(project, hard, text) {
+	const options = project.config.extract;
+	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;
+	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");
+}
+/** Placeholder shape of the project's first placeholder syntax, `{name}` by default. */
+function placeholderShape(project) {
+	const example = project.placeholderSyntaxes.find((s) => s.example?.includes("name"))?.example ?? "{name}";
+	return (name) => example.replace("name", name);
+}
+function templatesFor(project, kind, path) {
+	return [...project.extractTemplates, ...defaultTemplates].filter((t) => (!t.kinds || t.kinds.includes(kind)) && (!t.files || pathMatcher(t.files)(path))).map((t) => t.template);
+}
+function rawKeyFor(project, key) {
+	const ns = project.config.namespace.default;
+	return project.namespaced && ns && key.startsWith(`${ns}:`) ? key.slice(ns.length + 1) : key;
+}
+/** Hard strings worth extracting, with proposed keys, values and replacements. */
+function findCandidates(project, options = {}) {
+	const inFiles = options.files?.length ? pathMatcher(options.files) : void 0;
+	const keys = new KeyAllocator(project);
+	const shape = placeholderShape(project);
+	const out = [];
+	for (const hard of project.hardStrings()) {
+		if (inFiles && !inFiles(hard.path)) continue;
+		const text = project.text(hard.path);
+		if (text === void 0 || !shouldExtract(hard.text, hard.kind) || isIgnored(project, hard, text)) 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);
+		const chosen = templates[0];
+		const args = hard.args?.length ? `, { ${hard.args.map((a) => a.name === a.expression ? a.name : `${a.name}: ${a.expression}`).join(", ")} }` : "";
+		const template = project.extractTemplates.find((t) => t.template === chosen);
+		out.push({
+			path: hard.path,
+			line: createLineIndex(text).position(hard.range.start).line + 1,
+			kind: hard.kind,
+			text: hard.text,
+			original: text.slice(hard.range.start, hard.range.end),
+			range: hard.range,
+			attribute: hard.attribute,
+			key,
+			reused,
+			value,
+			replacement: chosen.replace("{key}", rawKeyFor(project, key)).replace("{attr}", hard.attribute ?? "").replace("{args}", args),
+			imports: template?.imports ?? [],
+			alternatives: templates.slice(1)
+		});
+	}
+	return out;
+}
+function toPlanFile(project, candidates) {
+	return {
+		x18n: 1,
+		project: project.name,
+		items: candidates
+	};
+}
+/** Turns plan items (maybe edited by a human or agent) into edit items, after checking the files did not change. */
+function extractItems(project, items) {
+	return items.map((item) => {
+		const text = project.text(item.path);
+		if (text === void 0 || text.slice(item.range.start, item.range.end) !== item.original) throw new X18nError("X18N4004", `${item.path} changed since the plan was made`);
+		return {
+			path: item.path,
+			range: item.range,
+			key: project.parseKey(item.key),
+			value: item.value,
+			replacement: item.replacement,
+			imports: item.imports
+		};
+	});
+}
+//#endregion
+export { defaultTemplates, extractItems, findCandidates, rules, shouldExtract, slugify, toPlanFile };

package/dist/finders-Cf-IEaDm.mjs

@@ -0,0 +1,188 @@
+//#region src/finders/pattern.ts
+const localeLike = /^[a-z]{2,3}(?:[-_][a-z\d]{2,8})*$/i;
+function isLocaleCode(text) {
+	if (!localeLike.test(text)) return false;
+	try {
+		return Intl.getCanonicalLocales(text.replace(/_/g, "-")).length === 1;
+	} catch {
+		return false;
+	}
+}
+function escapeRegExp(text) {
+	return text.replace(/[.+^$()|[\]\\]/g, "\\$&");
+}
+/**
+* Compiles a resource pattern. Tokens: `{locale}`, `{locale?}`, `{namespace}`,
+* `{namespaces}` (several segments, joined with `.`), `{ext}`; plus `*` and `**`.
+*/
+function compilePattern(pattern, extensions) {
+	const normalized = pattern.replace(/^\.\//, "");
+	const ext = `(?<ext>${extensions.map(escapeRegExp).join("|")})`;
+	let source = "";
+	let glob = "";
+	const tokens = /\{[^}]*\}|\*\*\/|\*\*|\*|\?/g;
+	let last = 0;
+	for (const match of normalized.matchAll(tokens)) {
+		const literal = normalized.slice(last, match.index);
+		source += escapeRegExp(literal);
+		glob += literal;
+		last = match.index + match[0].length;
+		switch (match[0]) {
+			case "{locale}":
+				source += "(?<locale>[\\w-]+)";
+				glob += "*";
+				break;
+			case "{locale?}":
+				source += "(?<locale>[\\w-]+)?";
+				glob += "*";
+				break;
+			case "{namespace}":
+				source += "(?<namespace>[^/]+)";
+				glob += "*";
+				break;
+			case "{namespaces}":
+				source += "(?<namespace>.+)";
+				glob += "**";
+				break;
+			case "{ext}":
+				source += ext;
+				glob += extensions.length === 1 ? extensions[0] : `{${extensions.join(",")}}`;
+				break;
+			case "**/":
+				source += "(?:.*/)?";
+				glob += "**/";
+				break;
+			case "**":
+				source += ".*";
+				glob += "**";
+				break;
+			case "*":
+				source += "[^/]*";
+				glob += "*";
+				break;
+			case "?":
+				source += "[^/]";
+				glob += "?";
+				break;
+			default: {
+				const options = match[0].slice(1, -1).split(",");
+				source += `(?:${options.map(escapeRegExp).join("|")})`;
+				glob += match[0];
+			}
+		}
+	}
+	source += escapeRegExp(normalized.slice(last));
+	glob += normalized.slice(last);
+	const regex = new RegExp(`^${source}$`);
+	return {
+		glob,
+		match(path) {
+			const found = regex.exec(path);
+			if (!found) return void 0;
+			const groups = found.groups ?? {};
+			const extension = groups.ext ?? path.slice(path.lastIndexOf(".") + 1);
+			return {
+				locale: groups.locale,
+				namespace: groups.namespace?.replace(/\//g, "."),
+				ext: extension
+			};
+		}
+	};
+}
+const localeDirNames = [
+	"locales",
+	"locale",
+	"i18n",
+	"lang",
+	"langs",
+	"language",
+	"languages",
+	"translations",
+	"messages",
+	"_locales",
+	"l10n"
+];
+/** Guesses resource patterns from directories named like `locales`, as i18n-ally did without `localesPaths`. */
+async function guessResources(ctx) {
+	const exts = ctx.extensions.length === 1 ? ctx.extensions[0] : `{${ctx.extensions.join(",")}}`;
+	const files = await ctx.host.glob([`**/{${localeDirNames.join(",")}}/**/*.${exts}`], {
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.git/**",
+			"**/.nuxt/**",
+			"**/.output/**",
+			"**/build/**"
+		],
+		gitignore: true
+	});
+	const dirs = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const segments = file.split("/");
+		const index = segments.findLastIndex((segment) => localeDirNames.includes(segment));
+		const dir = segments.slice(0, index + 1).join("/");
+		const list = dirs.get(dir) ?? [];
+		dirs.set(dir, list);
+		list.push(segments.slice(index + 1).join("/"));
+	}
+	const specs = [];
+	for (const [dir, rest] of dirs) {
+		const stem = (file) => file.slice(0, file.lastIndexOf("."));
+		const fileLayout = rest.filter((file) => !file.includes("/") && isLocaleCode(stem(file))).length;
+		const dirLayout = rest.filter((file) => file.includes("/") && isLocaleCode(file.split("/")[0])).length;
+		if (fileLayout === 0 && dirLayout === 0) continue;
+		specs.push({ pattern: fileLayout >= dirLayout ? `${dir}/{locale}.{ext}` : `${dir}/{locale}/{namespaces}.{ext}` });
+	}
+	return specs;
+}
+async function findBySpecs(ctx, specs, guessed) {
+	const out = [];
+	for (const spec of specs) {
+		const compiled = compilePattern(spec.pattern, ctx.extensions);
+		const fixed = spec.locale ?? (spec.pattern.includes("{locale") ? void 0 : ctx.config.sourceLocale);
+		const paths = await ctx.host.glob([compiled.glob], {
+			ignore: ["**/node_modules/**"],
+			gitignore: false
+		});
+		for (const path of paths) {
+			const matched = compiled.match(path);
+			if (!matched) continue;
+			const locale = fixed ?? matched.locale ?? (spec.pattern.includes("{locale?}") ? ctx.config.sourceLocale : void 0);
+			if (!locale || guessed && !isLocaleCode(locale)) continue;
+			out.push({
+				path,
+				locale,
+				namespace: spec.namespace ?? matched.namespace,
+				format: spec.format,
+				readonly: spec.execute === true
+			});
+		}
+	}
+	return out;
+}
+const patternFinder = {
+	id: "pattern",
+	resolveNew(target, ctx) {
+		for (const spec of ctx.config.resources) {
+			if (/\{namespaces?\}/.test(spec.pattern) !== (target.namespace !== void 0) || spec.execute || !spec.pattern.includes("{locale")) continue;
+			const path = spec.pattern.replace(/^\.\//, "").replace(/\{locale\??\}/g, target.locale).replace("{namespaces}", (target.namespace ?? "").replace(/\./g, "/")).replace("{namespace}", target.namespace ?? "").replace("{ext}", spec.format === "yaml" ? "yml" : spec.format ?? "json");
+			if (!/[*?{}[\]]/.test(path)) return path;
+		}
+	},
+	async find(ctx) {
+		const configured = ctx.config.resources;
+		const found = configured.length > 0 ? await findBySpecs(ctx, configured, false) : [];
+		const fromUser = ctx.config.origins.resources === "user" || ctx.config.origins.resources === "parent";
+		if (found.length > 0 || fromUser) return found;
+		return findBySpecs(ctx, await guessResources(ctx), true);
+	}
+};
+/** The `pattern` locale finder: files that match `resources[].pattern`, or guessed locale directories. */
+function pattern() {
+	return {
+		name: "x18n:finder-pattern",
+		localeFinders: [patternFinder]
+	};
+}
+//#endregion
+export { patternFinder as i, guessResources as n, pattern as r, compilePattern as t };

package/dist/finders.d.mts

@@ -0,0 +1,29 @@
+import { FinderContext, LocaleFinder, Plugin, ResourceSpec } from "@x18n/core";
+//#region src/finders/pattern.d.ts
+interface CompiledPattern {
+  /** Glob for the host. */
+  readonly glob: string;
+  readonly match: (path: string) => {
+    locale: string | undefined;
+    namespace: string | undefined;
+    ext: string;
+  } | undefined;
+}
+/**
+ * Compiles a resource pattern. Tokens: `{locale}`, `{locale?}`, `{namespace}`,
+ * `{namespaces}` (several segments, joined with `.`), `{ext}`; plus `*` and `**`.
+ */
+export declare function compilePattern(pattern: string, extensions: readonly string[]): CompiledPattern;
+/** Guesses resource patterns from directories named like `locales`, as i18n-ally did without `localesPaths`. */
+export declare function guessResources(ctx: FinderContext): Promise<ResourceSpec[]>;
+export declare const patternFinder: LocaleFinder;
+/** The `pattern` locale finder: files that match `resources[].pattern`, or guessed locale directories. */
+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). */
+export declare function sfcBlocks(): Plugin;
+/** fluent-vue `<fluent locale="en">` blocks in Vue SFCs, read with the `ftl` format. */
+export declare function sfcFluentBlocks(): Plugin;
+//#endregion
+export type { CompiledPattern };

package/dist/finders.mjs

@@ -0,0 +1,3 @@
+import { i as patternFinder, n as guessResources, r as pattern, t as compilePattern } from "./finders-Cf-IEaDm.mjs";
+import { n as sfcFluentBlocks, t as sfcBlocks } from "./sfc-blocks-CQhgEeT6.mjs";
+export { compilePattern, guessResources, pattern, patternFinder, sfcBlocks, sfcFluentBlocks };