@x18n/node 0.0.2 → 0.0.3

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+import { Builtins, Host, JsonObject, Logger, Plugin, Preset, Project, UserConfig } from "@x18n/core";
+//#region src/config.d.ts
+export declare const configFileNames: readonly string[];
+/** The config file in `dir`, if any. */
+export declare function findConfigFile(dir: string): string | undefined;
+/** The nearest config file at or above `cwd`, stopping at the git root. */
+export declare function findConfigUpward(cwd: string): string | undefined;
+/** Imports a JS or TS module (config, plugin, executed resource). */
+export declare function importModule(file: string): Promise<unknown>;
+export declare function loadConfigFile(file: string): Promise<UserConfig>;
+/** Loads a YAML plugin file (`*.x18n-plugin.yml`). */
+export declare function loadYamlPlugin(file: string): Promise<Plugin | Preset>;
+/** Resolves a plugin specifier relative to the config directory: a YAML file, a module path, or a package name. */
+export declare function createPluginLoader(dir: string): (specifier: string, options: JsonObject | undefined) => Promise<Plugin | Preset>;
+//#endregion
+//#region src/host.d.ts
+interface NodeHostOptions {
+  /** Directory of the persistent cache, or false to disable it. Default `node_modules/.cache/x18n` under the root. */
+  readonly cacheDir?: string | false | undefined;
+  readonly logger?: Logger | undefined;
+}
+interface NodeHost extends Host {
+  /** Writes the persistent cache to disk. */
+  readonly flush: () => Promise<void>;
+}
+export declare const stderrLogger: Logger;
+/** The directory holding `.git`, at or above `start`. */
+export declare function findGitRoot(start: string): string | undefined;
+export declare function createNodeHost(root: string, options?: NodeHostOptions): NodeHost;
+//#endregion
+//#region src/load.d.ts
+interface LoadOptions {
+  /** Where to look for a config file (upward). Default: the process cwd. */
+  readonly cwd: string;
+  /** Explicit config file. */
+  readonly configFile?: string | undefined;
+  /** Look for a config in parent directories too. Default true. */
+  readonly upward?: boolean | undefined;
+  /** Only this project of a monorepo. */
+  readonly project?: string | undefined;
+  /** Disable the persistent cache. */
+  readonly cache?: boolean | undefined;
+  readonly builtins?: Builtins | undefined;
+  readonly logger?: NodeHost["logger"];
+  /** Wraps each project's host, for example with an overlay of unsaved editor buffers. */
+  readonly wrapHost?: ((host: NodeHost) => Host) | undefined;
+}
+interface LoadedProject {
+  readonly name: string;
+  /** Absolute project root. */
+  readonly root: string;
+  readonly configFile: string | undefined;
+  readonly host: NodeHost;
+  readonly project: Project;
+}
+interface Workspace {
+  /** Absolute root of the workspace (the directory of the root config, or the cwd). */
+  readonly root: string;
+  readonly configFile: string | undefined;
+  readonly projects: readonly LoadedProject[];
+}
+/** Finds the config, resolves every project and waits until each is indexed. */
+export declare function loadWorkspace(options: LoadOptions): Promise<Workspace>;
+//#endregion
+//#region src/migrate.d.ts
+interface MigrationFile {
+  /** Path relative to the project root. */
+  readonly path: string;
+  readonly content: string;
+}
+interface MigrationResult {
+  readonly files: readonly MigrationFile[];
+  /** What was dropped or needs attention, for the report. */
+  readonly notes: readonly string[];
+  /** i18n-ally settings that can be removed after the migration. */
+  readonly removable: readonly string[];
+}
+interface MigrateOptions {
+  readonly format?: "ts" | "yml" | "json" | undefined;
+}
+/** Converts i18n-ally settings, custom framework and reviews into x18n files. Never deletes i18n-ally files. */
+export declare function migrateI18nAlly(root: string, options?: MigrateOptions): Promise<MigrationResult>;
+//#endregion
+export type { LoadOptions, LoadedProject, MigrateOptions, MigrationFile, MigrationResult, NodeHost, NodeHostOptions, Workspace };

package/dist/index.mjs

@@ -0,0 +1,845 @@
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { compileYamlPlugin } from "@x18n/builtins/yaml-plugin";
+import { PluginFileSchema, X18nError, createProject, hashText, isX18nError, resolveConfig, validate } from "@x18n/core";
+import { createJiti } from "jiti";
+import { glob } from "tinyglobby";
+import { parse, stringify } from "yaml";
+import process from "node:process";
+import { watch } from "chokidar";
+import ignore from "ignore";
+import { createBuiltins } from "@x18n/builtins";
+import { applyEdits, modify, parse as parse$1 } from "jsonc-parser";
+//#region src/config.ts
+const configFileNames = [
+	"x18n.config.ts",
+	"x18n.config.mts",
+	"x18n.config.js",
+	"x18n.config.mjs",
+	"x18n.config.yml",
+	"x18n.config.yaml",
+	"x18n.config.json"
+];
+/** The config file in `dir`, if any. */
+function findConfigFile(dir) {
+	for (const name of configFileNames) {
+		const file = join(dir, name);
+		if (existsSync(file)) return file;
+	}
+}
+/** The nearest config file at or above `cwd`, stopping at the git root. */
+function findConfigUpward(cwd) {
+	let dir = resolve(cwd);
+	while (true) {
+		const found = findConfigFile(dir);
+		if (found) return found;
+		const parent = dirname(dir);
+		if (parent === dir || existsSync(join(dir, ".git"))) return void 0;
+		dir = parent;
+	}
+}
+const core = fileURLToPath(import.meta.resolve("@x18n/core"));
+const presets = fileURLToPath(import.meta.resolve("@x18n/builtins/presets"));
+const jiti = createJiti(import.meta.url, {
+	moduleCache: false,
+	interopDefault: true,
+	alias: {
+		"@x18n/core": core,
+		"@x18n/cli/presets": presets,
+		"@x18n/cli": core,
+		"@x18n/builtins/presets": presets
+	}
+});
+/** Imports a JS or TS module (config, plugin, executed resource). */
+async function importModule(file) {
+	return jiti.import(pathToFileURL(file).href, { default: true });
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+async function loadConfigFile(file) {
+	try {
+		if (/\.ya?ml$/.test(file)) return parse(await readFile(file, "utf8")) ?? {};
+		if (file.endsWith(".json")) return JSON.parse(await readFile(file, "utf8"));
+		const loaded = await importModule(file);
+		const config = typeof loaded === "function" ? await loaded() : loaded;
+		if (!isObject(config)) throw new X18nError("X18N0002", `${file} does not export a config object`);
+		return config;
+	} catch (error) {
+		if (isX18nError(error)) throw error;
+		throw new X18nError("X18N0002", `${file}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/** Loads a YAML plugin file (`*.x18n-plugin.yml`). */
+async function loadYamlPlugin(file) {
+	const data = parse(await readFile(file, "utf8"));
+	const result = validate(PluginFileSchema, data);
+	if (!result.success) throw new X18nError("X18N1004", `${file}: ${result.issues.map((i) => `${i.path || "(root)"}: ${i.message}`).join("; ")}`);
+	return compileYamlPlugin(result.output);
+}
+function isPluginLike(value) {
+	return isObject(value) && "name" in value && typeof value.name === "string";
+}
+/** Resolves a plugin specifier relative to the config directory: a YAML file, a module path, or a package name. */
+function createPluginLoader(dir) {
+	return async (specifier, options) => {
+		try {
+			const file = specifier.startsWith(".") || isAbsolute(specifier) ? resolve(dir, specifier) : createRequire(join(dir, "package.json")).resolve(specifier);
+			if (/\.ya?ml$/.test(file)) return await loadYamlPlugin(file);
+			const loaded = await importModule(file);
+			const plugin = typeof loaded === "function" ? loaded(options) : loaded;
+			if (!isPluginLike(plugin)) throw new Error("the module does not export a plugin or a plugin factory");
+			return plugin;
+		} catch (error) {
+			if (isX18nError(error)) throw error;
+			throw new X18nError("X18N1001", `${specifier}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	};
+}
+/** Workspace package directories of `root`, from `pnpm-workspace.yaml` or the `workspaces` field of `package.json`. */
+async function workspacePackages(root) {
+	const pnpm = parse(await readFile(join(root, "pnpm-workspace.yaml"), "utf8").catch(() => "") || "{}");
+	const manifest = JSON.parse(await readFile(join(root, "package.json"), "utf8").catch(() => "{}"));
+	const field = (value, key) => typeof value === "object" && value !== null && key in value ? new Map(Object.entries(value)).get(key) : void 0;
+	const workspaces = field(manifest, "workspaces");
+	const patterns = [
+		field(pnpm, "packages"),
+		workspaces,
+		field(workspaces, "packages")
+	].flatMap((list) => Array.isArray(list) ? list.filter((item) => typeof item === "string") : []);
+	if (patterns.length === 0) return [];
+	return (await glob(patterns.filter((p) => !p.startsWith("!")).map((p) => `${p.replace(/\/$/, "")}/package.json`), {
+		cwd: root,
+		ignore: ["**/node_modules/**", ...patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1))]
+	})).map((file) => dirname(file)).sort();
+}
+/**
+* Directories, relative to `root`, whose manifests count for preset detection: the parents up to the
+* git root (`..`, `../..`), and the workspace packages of a monorepo root, where the i18n library is often listed.
+*/
+async function manifestRootsOf(root, gitRoot) {
+	const out = [];
+	const top = gitRoot ?? resolve(root);
+	let dir = resolve(root);
+	while (dir !== top && dir.startsWith(top)) {
+		dir = dirname(dir);
+		out.push(relative(root, dir).replace(/\\/g, "/"));
+	}
+	return [...out, ...await workspacePackages(root)];
+}
+//#endregion
+//#region src/host.ts
+const toPosix = (path) => sep === "\\" ? path.replace(/\\/g, "/") : path;
+function isNotFound(error) {
+	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR");
+}
+const stderrLogger = {
+	info: (message) => process.stderr.write(`${message}\n`),
+	warn: (message) => process.stderr.write(`warning: ${message}\n`),
+	error: (message) => process.stderr.write(`error: ${message}\n`)
+};
+/** The directory holding `.git`, at or above `start`. */
+function findGitRoot(start) {
+	let dir = resolve(start);
+	while (true) {
+		if (existsSync(join(dir, ".git"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+/** Every `.gitignore` that applies under `root`: the ones above it up to the git root, and nested ones. */
+async function loadGitignore(root) {
+	const rules = [];
+	const gitRoot = findGitRoot(root) ?? root;
+	const add = async (dir) => {
+		const text = await readFile(join(dir, ".gitignore"), "utf8").catch(() => void 0);
+		if (text !== void 0) rules.push({
+			base: dir,
+			ig: ignore().add(text)
+		});
+	};
+	let dir = root;
+	const chain = [];
+	while (dir.startsWith(gitRoot)) {
+		chain.push(dir);
+		if (dir === gitRoot) break;
+		dir = dirname(dir);
+	}
+	for (const item of chain.reverse()) await add(item);
+	const nested = await glob(["**/.gitignore"], {
+		cwd: root,
+		ignore: ["**/node_modules/**", ".gitignore"],
+		dot: true
+	});
+	for (const file of nested) await add(join(root, dirname(file)));
+	return (path) => {
+		const absolute = join(root, path);
+		return rules.some(({ base, ig }) => {
+			const rel = toPosix(relative(base, absolute));
+			return rel !== "" && !rel.startsWith("..") && ig.ignores(rel);
+		});
+	};
+}
+/** A persistent cache in one JSON file. Only entries used in this session are written back, so it stays bounded. */
+function createFileCache(dir) {
+	const file = join(dir, "cache.json");
+	let entries;
+	const used = /* @__PURE__ */ new Map();
+	let dirty = false;
+	const load = () => {
+		entries ??= readFile(file, "utf8").then((text) => {
+			const data = JSON.parse(text);
+			return new Map(typeof data === "object" && data !== null ? Object.entries(data).filter((e) => typeof e[1] === "string") : []);
+		}).catch(() => /* @__PURE__ */ new Map());
+		return entries;
+	};
+	return {
+		async get(key) {
+			const value = (await load()).get(key);
+			if (value !== void 0) used.set(key, value);
+			return value;
+		},
+		async set(key, value) {
+			used.set(key, value);
+			dirty = true;
+		},
+		async flush() {
+			if (!dirty) return;
+			await mkdir(dir, { recursive: true });
+			await writeFile(file, JSON.stringify(Object.fromEntries(used)));
+			dirty = false;
+		}
+	};
+}
+function createNodeHost(root, options = {}) {
+	const absoluteRoot = resolve(root);
+	let gitignore;
+	const cacheDir = options.cacheDir === false ? void 0 : options.cacheDir ?? join(absoluteRoot, "node_modules/.cache/x18n");
+	const cache = cacheDir ? createFileCache(join(cacheDir, hashText(absoluteRoot))) : void 0;
+	const full = (path) => resolve(absoluteRoot, path);
+	return {
+		root: absoluteRoot,
+		logger: options.logger,
+		cache,
+		async readFile(path) {
+			try {
+				return await readFile(full(path), "utf8");
+			} catch (error) {
+				if (isNotFound(error)) return void 0;
+				throw error;
+			}
+		},
+		async writeFile(path, content) {
+			const file = full(path);
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(file, content, "utf8");
+		},
+		async deleteFile(path) {
+			await rm(full(path), { force: true });
+		},
+		async glob(patterns, globOptions = {}) {
+			const paths = (await glob([...patterns], {
+				cwd: absoluteRoot,
+				ignore: [...globOptions.ignore ?? []],
+				dot: false,
+				followSymbolicLinks: false
+			})).map(toPosix);
+			if (!globOptions.gitignore) return paths.sort();
+			gitignore ??= loadGitignore(absoluteRoot);
+			const ignored = await gitignore;
+			return paths.filter((path) => !ignored(path)).sort();
+		},
+		watch(_patterns, onChange) {
+			let pending = [];
+			let timer;
+			const push = (type) => (file) => {
+				const path = toPosix(relative(absoluteRoot, file));
+				if (path.startsWith("..") || path.includes("node_modules/") || path.startsWith(".git/")) return;
+				pending.push({
+					type,
+					path
+				});
+				clearTimeout(timer);
+				timer = setTimeout(() => {
+					const events = pending;
+					pending = [];
+					onChange(events);
+				}, 50);
+			};
+			const watcher = watch(absoluteRoot, {
+				ignoreInitial: true,
+				ignored: (path) => /[/\\](?:node_modules|\.git)(?:[/\\]|$)/.test(path)
+			});
+			watcher.on("add", push("create")).on("change", push("change")).on("unlink", push("delete"));
+			return { dispose: () => {
+				clearTimeout(timer);
+				watcher.close();
+			} };
+		},
+		flush: async () => cache?.flush()
+	};
+}
+//#endregion
+//#region src/migrate.ts
+const frameworkPresets = {
+	"vue": "vue-i18n",
+	"vue-sfc": "vue-i18n",
+	"vuex": "vue-i18n",
+	"nuxt": "nuxt-i18n",
+	"react": "react-intl",
+	"react-i18next": "react-i18next",
+	"next-i18next": "react-i18next",
+	"i18next": "i18next",
+	"i18next-shopify": "i18next-shopify",
+	"next-intl": "next-intl",
+	"next-international": "next-international",
+	"next-translate": "next-translate",
+	"svelte": "svelte-i18n",
+	"vscode": "vscode-extension",
+	"ngx-translate": "ngx-translate",
+	"transloco": "transloco",
+	"flutter": "flutter",
+	"ember": "ember-intl",
+	"i18n-tag": "i18n-tag",
+	"fluent-vue": "fluent-vue",
+	"fluent-vue-sfc": "fluent-vue",
+	"php-joomla": "php-joomla",
+	"php-gettext": "php-gettext",
+	"laravel": "laravel",
+	"chrome-ext": "chrome-extension",
+	"ruby-rails": "ruby-rails",
+	"polyglot": "polyglot",
+	"globalize": "globalize",
+	"ui5": "ui5",
+	"lingui": "lingui",
+	"jekyll": "jekyll",
+	"i18n-js": "i18n-js"
+};
+const languageExtensions = {
+	javascript: [
+		"js",
+		"mjs",
+		"cjs"
+	],
+	typescript: [
+		"ts",
+		"mts",
+		"cts"
+	],
+	javascriptreact: ["jsx"],
+	typescriptreact: ["tsx"],
+	vue: ["vue"],
+	html: ["html"],
+	svelte: ["svelte"],
+	php: ["php"],
+	blade: ["blade.php"],
+	ruby: ["rb"],
+	erb: ["erb"],
+	dart: ["dart"],
+	json: ["json"],
+	yaml: ["yml", "yaml"],
+	handlebars: ["hbs"]
+};
+const keygenStyles = {
+	"camelCase": "camel",
+	"snake_case": "snake",
+	"kebab-case": "kebab"
+};
+const editorSettings = {
+	annotations: "x18n.annotations",
+	annotationInPlace: "x18n.inPlace",
+	annotationMaxLength: "x18n.annotationMaxLength",
+	displayLanguage: "x18n.displayLocale"
+};
+const handledByDefaults = [
+	"readonly",
+	"encoding",
+	"fullReloadOnChanged",
+	"includeSubfolders",
+	"ignoreFiles",
+	"editor.preferEditor",
+	"showFlags",
+	"annotationDelimiter",
+	"languageTagSystem",
+	"targetPickingStrategy",
+	"extract.targetPickingStrategy"
+];
+async function readText(path) {
+	return readFile(path, "utf8").catch(() => void 0);
+}
+/** The first of `paths` that exists; the i18n-ally-next name comes first. */
+async function readFirst(root, paths) {
+	for (const path of paths) {
+		const text = await readText(join(root, path));
+		if (text !== void 0) return {
+			path,
+			text
+		};
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const asStrings = (value) => (Array.isArray(value) ? value : value === void 0 ? [] : [value]).filter((v) => typeof v === "string");
+/** Setting prefixes by priority: the i18n-ally-next fork renames `i18n-ally.*` keys, so its value is the newest. */
+const settingPrefixes = [
+	"i18n-ally-next",
+	"i18n-ally",
+	"vue-i18n-ally"
+];
+/** `i18n-ally-next.*`, `i18n-ally.*` and legacy `vue-i18n-ally.*` keys from `.vscode/settings.json` and `*.code-workspace` files. */
+async function readSettings(root) {
+	const settings = /* @__PURE__ */ new Map();
+	const ranks = /* @__PURE__ */ new Map();
+	const keys = [];
+	const sources = [];
+	const vscode = await readText(join(root, ".vscode/settings.json"));
+	if (vscode !== void 0) sources.push(parse$1(vscode));
+	for (const file of await readdir(root).catch(() => [])) if (file.endsWith(".code-workspace")) {
+		const data = parse$1(await readText(join(root, file)) ?? "{}");
+		if (isRecord(data)) sources.push(data.settings);
+	}
+	for (const source of sources) {
+		if (!isRecord(source)) continue;
+		for (const [key, value] of Object.entries(source)) {
+			const match = /^(i18n-ally-next|i18n-ally|vue-i18n-ally)\.(.+)$/.exec(key);
+			if (!match) continue;
+			keys.push(key);
+			const rank = settingPrefixes.indexOf(match[1]);
+			if (rank < (ranks.get(match[2]) ?? Infinity)) {
+				settings.set(match[2], value);
+				ranks.set(match[2], rank);
+			}
+		}
+	}
+	return {
+		settings,
+		keys
+	};
+}
+/** `localesPaths` + `pathMatcher` + `dirStructure` + `namespace` as resource patterns with the same tokens. */
+function resourcesOf(settings, executed) {
+	const paths = asStrings(settings.get("localesPaths")).map((path) => path.replace(/^\.\//, "").replace(/\/$/, ""));
+	const matcher = settings.get("pathMatcher");
+	const structure = settings.get("dirStructure");
+	const namespace = settings.get("namespace") === true;
+	return paths.flatMap((dir) => {
+		if (typeof matcher === "string") return [`${dir}/${matcher}`];
+		if (structure === "file") return [`${dir}/{locale}.{ext}`];
+		if (structure === "dir") return [namespace ? `${dir}/{locale}/{namespaces}.{ext}` : `${dir}/{locale}/**/*.{ext}`];
+		return [`${dir}/{locale}.{ext}`, namespace ? `${dir}/{locale}/{namespaces}.{ext}` : `${dir}/{locale}/**/*.{ext}`];
+	}).map((pattern) => executed && /\.(?:[jt]s|\{ext\})$/.test(pattern) ? {
+		pattern,
+		execute: true
+	} : { pattern });
+}
+function templatesOf(value) {
+	return (Array.isArray(value) ? value : []).flatMap((entry) => {
+		if (typeof entry === "string") return [{ template: entry.replace(/\$1/g, "{key}") }];
+		if (!isRecord(entry)) return [];
+		const files = asStrings(entry.include);
+		return asStrings(entry.templates ?? entry.template).map((template) => ({
+			template: template.replace(/\$1/g, "{key}"),
+			...files.length ? { files } : {}
+		}));
+	});
+}
+function flagOf(country) {
+	return String.fromCodePoint(...[...country.toUpperCase()].map((c) => 127462 + c.charCodeAt(0) - 65));
+}
+/** `.vscode/i18n-ally-custom-framework.yml` into YAML plugin parts. */
+function customFramework(data, parts) {
+	if (!isRecord(data)) return;
+	const extensions = asStrings(data.languageIds).flatMap((id) => languageExtensions[id] ?? [id]);
+	const patterns = asStrings(data.usageMatchRegex);
+	if (patterns.length) parts.regex.push({
+		extensions: extensions.length ? extensions : [
+			"js",
+			"jsx",
+			"ts",
+			"tsx",
+			"vue"
+		],
+		patterns
+	});
+	const scope = asStrings(data.scopeRangeRegex)[0];
+	if (scope) parts.scopes = scope;
+	parts.templates.push(...templatesOf(data.refactorTemplates));
+	if (data.monopoly === true) parts.exclusive = true;
+}
+function configFile(config, format) {
+	if (format === "yml") return {
+		path: "x18n.config.yml",
+		content: `# yaml-language-server: $schema=https://x18n.antfu.dev/schema/config.json\n${stringify(config)}`
+	};
+	if (format === "json") return {
+		path: "x18n.config.json",
+		content: `${JSON.stringify({
+			$schema: "https://x18n.antfu.dev/schema/config.json",
+			...config
+		}, null, 2)}\n`
+	};
+	return {
+		path: "x18n.config.ts",
+		content: `import { defineConfig } from '@x18n/core'\n\n// Migrated from i18n-ally by \`x18n migrate i18n-ally\`.\nexport default defineConfig(${JSON.stringify(config, null, 2).replace(/"([a-z_$][\w$]*)":/gi, "$1:").replace(/'/g, "\\'").replace(/"/g, "'")})\n`
+	};
+}
+function readerOf(settings) {
+	const get = (key) => settings.get(key);
+	return {
+		get,
+		str: (key) => {
+			const value = get(key);
+			return typeof value === "string" ? value : void 0;
+		},
+		num: (key) => {
+			const value = get(key);
+			return typeof value === "number" ? value : void 0;
+		},
+		list: (key) => asStrings(get(key)),
+		pick: (key, values) => values.find((value) => value === get(key))
+	};
+}
+function formatsOf(r) {
+	const formats = {};
+	for (const parser of r.list("enabledParsers")) formats[parser === "yaml" ? "yml" : parser] = parser;
+	const extend = r.get("parsers.extendFileExtensions");
+	if (isRecord(extend)) {
+		for (const [ext, parser] of Object.entries(extend)) if (typeof parser === "string") formats[ext.replace(/^\./, "")] = parser;
+	}
+	return formats;
+}
+function extractOf(r) {
+	const keygen = r.pick("extract.keygenStrategy", [
+		"slug",
+		"random",
+		"empty",
+		"source"
+	]);
+	const keyCase = keygenStyles[r.str("extract.keygenStyle") ?? ""];
+	const byFiles = r.get("extract.ignoredByFiles");
+	return {
+		...keygen ? { keygen } : {},
+		...keyCase ? { keyCase } : {},
+		...r.str("extract.keyPrefix") ? { keyPrefix: r.str("extract.keyPrefix") } : {},
+		...r.num("extract.keyMaxLength") !== void 0 ? { keyMaxLength: r.num("extract.keyMaxLength") } : {},
+		...r.list("extract.ignored").length ? { ignore: r.list("extract.ignored") } : {},
+		...isRecord(byFiles) ? { ignoreByFile: Object.fromEntries(Object.entries(byFiles).map(([glob, list]) => [glob, asStrings(list)])) } : {},
+		...r.get("extract.autoDetect") === true ? { autoDetect: true } : {}
+	};
+}
+function writeOf(r) {
+	const sort = r.get("sortKeys") === true ? r.get("sortCompare") === "locale" ? "locale" : "binary" : void 0;
+	const indent = r.get("tabStyle") === "tab" ? "tab" : r.num("indent");
+	const keepFilled = r.get("keepFulfilled") === true;
+	if (!sort && indent === void 0 && !keepFilled) return void 0;
+	return {
+		...sort ? { sort } : {},
+		...indent !== void 0 ? { indent } : {},
+		...keepFilled ? { keepFilled } : {}
+	};
+}
+function presetsOf(r, notes) {
+	return r.list("enabledFrameworks").flatMap((id) => {
+		if (id === "general" || id === "custom") return [];
+		const preset = frameworkPresets[id];
+		if (!preset) notes.push(`Framework "${id}" has no built-in preset yet; it was left out.`);
+		return preset ? [preset] : [];
+	});
+}
+function notesOf(settings, notes) {
+	if ([...settings.keys()].some((key) => key.startsWith("translate."))) notes.push("`translate.*` settings were dropped: x18n writes translate prompts instead (`x18n prompt translate --to <locale>`).");
+	if ([...settings.keys()].some((key) => key.startsWith("review."))) notes.push("Review settings move to `review.*` once reviews ship (1.x); they were not migrated yet.");
+	for (const key of handledByDefaults) if (settings.has(key)) notes.push(`\`i18n-ally.${key}\` is handled by defaults or dropped.`);
+}
+function mapConfig(settings, parts, notes) {
+	const r = readerOf(settings);
+	const presets = presetsOf(r, notes);
+	const formats = formatsOf(r);
+	const executed = r.get("parsers.typescript.compilerOptions") !== void 0 || r.get("parsers.typescript.tsNodePath") !== void 0;
+	if (executed) notes.push("JS/TS locale files were executed by i18n-ally; their patterns get `execute: true` and become read-only.");
+	const keyStyle = r.get("disablePathParsing") === true ? "flat" : r.pick("keystyle", ["flat", "nested"]);
+	const usage = {
+		...r.list("keysInUse").length ? { keysInUse: r.list("keysInUse") } : {},
+		...r.list("usage.derivedKeyRules").length ? { derivedKeys: r.list("usage.derivedKeyRules") } : {},
+		...r.list("usage.scanningIgnore").length ? { exclude: r.list("usage.scanningIgnore") } : {}
+	};
+	const extract = extractOf(r);
+	const write = writeOf(r);
+	parts.templates.push(...templatesOf(r.get("refactor.templates")));
+	const regexPatterns = [...r.list("regex.usageMatch"), ...r.list("regex.usageMatchAppend")];
+	if (regexPatterns.length) parts.regex.push({
+		extensions: [
+			"js",
+			"jsx",
+			"ts",
+			"tsx",
+			"vue",
+			"html",
+			"svelte"
+		],
+		patterns: regexPatterns
+	});
+	const countries = r.get("localeCountryMap");
+	if (isRecord(countries)) {
+		for (const [locale, country] of Object.entries(countries)) if (typeof country === "string" && /^[a-z]{2}$/i.test(country)) parts.localeInfo[locale] = { flag: flagOf(country) };
+	}
+	notesOf(settings, notes);
+	const resources = resourcesOf(settings, executed);
+	return {
+		...r.str("sourceLanguage") ? { sourceLocale: r.str("sourceLanguage") } : {},
+		...r.list("ignoredLocales").length ? { ignoreLocales: r.list("ignoredLocales") } : {},
+		...presets.length || parts.exclusive ? { presets: parts.exclusive ? [] : presets } : {},
+		...resources.length ? { resources } : {},
+		...Object.keys(formats).length ? { formats } : {},
+		...keyStyle ? { keyStyle } : {},
+		...r.str("defaultNamespace") ? { namespace: { default: r.str("defaultNamespace") } } : {},
+		...Object.keys(usage).length ? { usage } : {},
+		...write ? { write } : {},
+		...Object.keys(extract).length ? { extract } : {}
+	};
+}
+/** The x18n config that a project's i18n-ally settings and custom framework mean, or undefined without any. */
+async function readI18nAllyConfig(root) {
+	const { settings, keys } = await readSettings(root);
+	return configOf(root, settings, keys);
+}
+async function configOf(root, settings, keys) {
+	const custom = await readFirst(root, [".vscode/i18n-ally-next-custom-framework.yml", ".vscode/i18n-ally-custom-framework.yml"]);
+	const customText = custom?.text;
+	if (keys.length === 0 && customText === void 0) return void 0;
+	const notes = [];
+	const parts = {
+		regex: [],
+		scopes: void 0,
+		templates: [],
+		localeInfo: {},
+		exclusive: false
+	};
+	if (customText !== void 0) customFramework(parse(customText), parts);
+	const config = mapConfig(settings, parts, notes);
+	if (parts.exclusive) notes.push("The custom framework was exclusive (`monopoly`), so built-in presets are turned off (`presets: []`).");
+	return {
+		config,
+		plugin: parts.regex.length > 0 || parts.scopes !== void 0 || parts.templates.length > 0 || Object.keys(parts.localeInfo).length > 0 ? {
+			name: "custom",
+			...parts.regex.length ? { scanners: { regex: parts.regex } } : {},
+			...parts.scopes ? { scopes: { regex: parts.scopes } } : {},
+			...parts.templates.length ? { extract: { templates: parts.templates } } : {},
+			...Object.keys(parts.localeInfo).length ? { localeInfo: parts.localeInfo } : {}
+		} : void 0,
+		notes,
+		keys,
+		customFramework: custom?.path
+	};
+}
+/** Converts i18n-ally settings, custom framework and reviews into x18n files. Never deletes i18n-ally files. */
+async function migrateI18nAlly(root, options = {}) {
+	const { settings, keys } = await readSettings(root);
+	const found = await configOf(root, settings, keys);
+	if (!found) return {
+		files: [],
+		notes: ["No i18n-ally settings found."],
+		removable: []
+	};
+	const { config, plugin } = found;
+	const notes = [...found.notes];
+	const reviews = (await readFirst(root, [".vscode/i18n-ally-next-reviews.yml", ".vscode/i18n-ally-reviews.yml"]))?.text;
+	const files = [];
+	const finalConfig = plugin !== void 0 ? {
+		...config,
+		plugins: ["./x18n/custom.x18n-plugin.yml"]
+	} : config;
+	files.push(configFile(finalConfig, options.format ?? "ts"));
+	if (plugin) files.push({
+		path: "x18n/custom.x18n-plugin.yml",
+		content: `# yaml-language-server: $schema=../node_modules/@x18n/core/schema/plugin.json\n${stringify(plugin)}`
+	});
+	let vscodeText = await readText(join(root, ".vscode/settings.json"));
+	if (vscodeText !== void 0) {
+		let changed = false;
+		for (const [from, to] of Object.entries(editorSettings)) if (settings.has(from)) {
+			vscodeText = applyEdits(vscodeText, modify(vscodeText, [to], settings.get(from), { formattingOptions: {
+				insertSpaces: true,
+				tabSize: 2
+			} }));
+			changed = true;
+		}
+		if (changed) files.push({
+			path: ".vscode/settings.json",
+			content: vscodeText
+		});
+	}
+	if (reviews !== void 0 && !existsSync(join(root, ".x18n/reviews.yml"))) {
+		files.push({
+			path: ".x18n/reviews.yml",
+			content: reviews
+		});
+		notes.push("Reviews were copied to `.x18n/reviews.yml`; x18n reads them once reviews ship (1.x).");
+	}
+	return {
+		files,
+		notes,
+		removable: [...keys, ...found.customFramework ? [found.customFramework] : []]
+	};
+}
+//#endregion
+//#region src/load.ts
+/** The nearest directory at or above `cwd`, up to the git root, whose `.vscode/settings.json` has i18n-ally settings. */
+function findI18nAllyRoot(cwd, upward) {
+	let dir = resolve(cwd);
+	while (true) {
+		const settings = join(dir, ".vscode/settings.json");
+		if (existsSync(settings) && /"(?:i18n-ally-next|i18n-ally|vue-i18n-ally)\./.test(readFileSync(settings, "utf8"))) return dir;
+		const parent = dirname(dir);
+		if (!upward || parent === dir || existsSync(join(dir, ".git"))) return void 0;
+		dir = parent;
+	}
+}
+/**
+* Without an x18n config, the project's i18n-ally settings act as defaults, so an i18n-ally project
+* works as it did in the editor. A plugin applies them, so detection and the locale guess still fill gaps.
+*/
+async function i18nAllyFallback(root) {
+	const found = await readI18nAllyConfig(root);
+	if (!found) return void 0;
+	const { presets, plugins: _plugins, ...defaults } = found.config;
+	const settingsPlugin = {
+		name: "x18n:i18n-ally-settings",
+		config: (draft) => applyDefaults(draft, defaults)
+	};
+	return {
+		...presets ? { presets } : {},
+		plugins: [settingsPlugin, ...found.plugin ? [compileYamlPlugin(found.plugin)] : []]
+	};
+}
+function applyDefaults(draft, config) {
+	if (config.sourceLocale) draft.sourceLocale = config.sourceLocale;
+	if (config.ignoreLocales) draft.ignoreLocales = [...draft.ignoreLocales, ...config.ignoreLocales];
+	if (config.resources) draft.resources = [...draft.resources, ...config.resources];
+	if (config.formats) draft.formats = {
+		...draft.formats,
+		...config.formats
+	};
+	if (config.keyStyle) draft.keyStyle = config.keyStyle;
+	if (config.namespace?.default) draft.namespace = {
+		...draft.namespace,
+		default: config.namespace.default
+	};
+	if (config.usage) draft.usage = {
+		...draft.usage,
+		keysInUse: [...draft.usage.keysInUse, ...config.usage.keysInUse ?? []],
+		derivedKeys: [...draft.usage.derivedKeys, ...config.usage.derivedKeys ?? []],
+		exclude: [...draft.usage.exclude, ...config.usage.exclude ?? []]
+	};
+	if (config.write) draft.write = {
+		sort: config.write.sort ?? draft.write.sort,
+		indent: config.write.indent ?? draft.write.indent,
+		keepFilled: config.write.keepFilled ?? draft.write.keepFilled
+	};
+	if (config.extract) draft.extract = {
+		...draft.extract,
+		...config.extract
+	};
+}
+async function projectSpecs(rootConfigFile, cwd, upward) {
+	if (!rootConfigFile) {
+		const settingsRoot = findI18nAllyRoot(cwd, upward);
+		const fallback = settingsRoot && await i18nAllyFallback(settingsRoot);
+		if (settingsRoot && fallback) return {
+			root: settingsRoot,
+			specs: [{
+				root: settingsRoot,
+				config: fallback,
+				parent: void 0,
+				configFile: join(settingsRoot, ".vscode/settings.json")
+			}]
+		};
+	}
+	const configDir = rootConfigFile ? dirname(rootConfigFile) : resolve(cwd);
+	const rootConfig = rootConfigFile ? await loadConfigFile(rootConfigFile) : {};
+	const root = resolve(configDir, rootConfig.root ?? ".");
+	if (!rootConfig.projects?.length) return {
+		root,
+		specs: [{
+			root,
+			config: rootConfig,
+			parent: void 0,
+			configFile: rootConfigFile
+		}]
+	};
+	const { projects, ...parent } = rootConfig;
+	const dirs = await glob([...projects], {
+		cwd: root,
+		onlyDirectories: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const specs = [];
+	for (const dir of dirs.sort()) {
+		const projectRoot = resolve(root, dir);
+		const file = findConfigFile(projectRoot);
+		const config = file ? await loadConfigFile(file) : {};
+		specs.push({
+			root: resolve(projectRoot, config.root ?? "."),
+			config,
+			parent,
+			configFile: file
+		});
+	}
+	return {
+		root,
+		specs
+	};
+}
+/** Finds the config, resolves every project and waits until each is indexed. */
+async function loadWorkspace(options) {
+	const configFile = options.configFile ? resolve(options.cwd, options.configFile) : options.upward === false ? findConfigFile(resolve(options.cwd)) : findConfigUpward(options.cwd);
+	const { root, specs } = await projectSpecs(configFile, options.cwd, options.upward !== false);
+	const builtins = options.builtins ?? createBuiltins();
+	const gitRoot = findGitRoot(root);
+	const loaded = [];
+	for (const spec of specs) {
+		const name = spec.config.name ?? (spec.root === root ? relative(dirname(root), root) : relative(root, spec.root)).replace(/\\/g, "/");
+		if (options.project !== void 0 && options.project !== name) continue;
+		const host = createNodeHost(spec.root, {
+			cacheDir: options.cache === false ? false : void 0,
+			logger: options.logger
+		});
+		const projectHost = options.wrapHost?.(host) ?? host;
+		const setup = await resolveConfig({
+			host: projectHost,
+			config: spec.config,
+			parent: spec.parent,
+			builtins,
+			name,
+			runtime: "node",
+			loadPlugin: createPluginLoader(spec.configFile ? dirname(spec.configFile) : spec.root),
+			manifestRoots: await manifestRootsOf(spec.root, gitRoot)
+		});
+		const project = createProject({
+			host: projectHost,
+			setup
+		});
+		await project.ready;
+		await host.flush();
+		loaded.push({
+			name,
+			root: spec.root,
+			configFile: spec.configFile,
+			host,
+			project
+		});
+	}
+	if (options.project !== void 0 && loaded.length === 0) throw new X18nError("X18N0003", options.project);
+	return {
+		root,
+		configFile,
+		projects: loaded
+	};
+}
+//#endregion
+export { configFileNames, createNodeHost, createPluginLoader, findConfigFile, findConfigUpward, findGitRoot, importModule, loadConfigFile, loadWorkspace, loadYamlPlugin, migrateI18nAlly, stderrLogger };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@x18n/node",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Node.js host for x18n: file system access, config and plugin loading",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -25,8 +25,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@x18n/builtins": "0.0.2",
-    "@x18n/core": "0.0.2",
+    "@x18n/builtins": "0.0.3",
+    "@x18n/core": "0.0.3",
     "chokidar": "^5.0.0",
     "ignore": "^7.0.12",
     "jiti": "^2.6.1",