@x18n/builtins 0.0.2 → 0.0.3

package/dist/finders-CqTGh4OJ.mjs

@@ -0,0 +1,197 @@
+//#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,
+				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;
+}
+/** A namespace from a path in the style of `namespace.fromPath`. Transloco camelCases scope folders, as its `toCamelCase`. */
+function namespaceFromPath(path, style) {
+	if (style === "slash") return path;
+	if (style === "camel") return path.replace(/[-_/\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toLowerCase());
+	return path.replace(/\//g, ".");
+}
+async function findBySpecs(ctx, specs, strictLocales) {
+	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 || strictLocales && !isLocaleCode(locale)) continue;
+			const namespace = spec.namespace ?? (matched.namespace === void 0 ? void 0 : namespaceFromPath(matched.namespace, ctx.config.namespace.fromPath));
+			out.push({
+				path,
+				locale,
+				namespace,
+				format: spec.format,
+				readonly: spec.execute === true
+			});
+		}
+	}
+	return out;
+}
+const patternFinder = {
+	id: "pattern",
+	resolveNew(target, ctx) {
+		const style = ctx.config.namespace.fromPath;
+		for (const spec of ctx.config.resources) {
+			const wantsNamespace = /\{namespaces?\}/.test(spec.pattern);
+			if (wantsNamespace !== (target.namespace !== void 0) || wantsNamespace && style === "camel" || spec.execute || !spec.pattern.includes("{locale")) continue;
+			const path = spec.pattern.replace(/^\.\//, "").replace(/\{locale\??\}/g, target.locale).replace("{namespaces}", style === "slash" ? target.namespace ?? "" : (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 fromUser = ctx.config.origins.resources === "user" || ctx.config.origins.resources === "parent";
+		const found = configured.length > 0 ? await findBySpecs(ctx, configured, !fromUser) : [];
+		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 a, pattern as i, guessResources as n, namespaceFromPath as r, compilePattern as t };

package/dist/finders.d.mts

@@ -0,0 +1,31 @@
+import { FinderContext, LocaleFinder, NamespaceFromPath, 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[]>;
+/** A namespace from a path in the style of `namespace.fromPath`. Transloco camelCases scope folders, as its `toCamelCase`. */
+export declare function namespaceFromPath(path: string, style: NamespaceFromPath): string;
+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 { 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-BwJwCUka.mjs";
+export { compilePattern, guessResources, namespaceFromPath, pattern, patternFinder, sfcBlocks, sfcFluentBlocks };