@dialexjs/cli 0.6.0 → 0.7.1

package/dist/{project-DquSNdz8.mjs → project-Dz0FbydQ.mjs}

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import fg from "fast-glob";
 import pc from "picocolors";
 import { pathToFileURL } from "node:url";
 import { generateCode, parseExpression, parseModule, writeFile } from "magicast";
+import fg from "fast-glob";
+import ignore from "ignore";
 import { argumentSignature, findPlurals, getArguments, isIcuStructured, parseMessage } from "dialexjs/icu";
 import { createHash } from "node:crypto";
 import { DEFAULT_CONFIG } from "dialexjs";
@@ -272,6 +273,100 @@ function getLeafSource(df, locale, path) {
 	return generateCode(prop.type === "ObjectMethod" ? prop : prop.value).code;
 }
 //#endregion
+//#region src/utils/files.ts
+/** Folders that never hold project dictionaries or sources, in every scanner. */
+const BUILTIN_IGNORE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.next/**",
+	"**/dialex.locales/**"
+];
+/** What the source scan skips on top: other tools' output, declarations, generated and config files. */
+const SOURCE_BUILTIN_IGNORE = [
+	...BUILTIN_IGNORE,
+	"**/.nuxt/**",
+	"**/.output/**",
+	"**/.svelte-kit/**",
+	"**/.astro/**",
+	"**/.turbo/**",
+	"**/coverage/**",
+	"**/graphify-out/**",
+	"**/*.d.ts",
+	"**/dialex.generated.*",
+	"**/dialex.config.*",
+	"**/i18n.config.*"
+];
+/** The nearest directory at or above `root` that contains `.git`, or `root` itself. */
+function repositoryRoot(root) {
+	for (let dir = root;; dir = path.dirname(dir)) {
+		if (fs.existsSync(path.join(dir, ".git"))) return dir;
+		if (path.dirname(dir) === dir) return root;
+	}
+}
+function readScope(dir) {
+	try {
+		const text = fs.readFileSync(path.join(dir, ".gitignore"), "utf-8");
+		return {
+			dir,
+			matcher: ignore().add(text)
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* A function that says whether an absolute path is ignored by Git. It reads the `.gitignore`
+* files of the project folder, of every folder above it up to the repository root (monorepo
+* packages inherit the root's rules), and of nested folders.
+*/
+function createGitignoreFilter(root) {
+	const base = path.resolve(root);
+	const top = repositoryRoot(base);
+	const scopes = [];
+	for (let dir = base;; dir = path.dirname(dir)) {
+		const scope = readScope(dir);
+		if (scope) scopes.push(scope);
+		if (dir === top || path.dirname(dir) === dir) break;
+	}
+	const nested = fg.sync("**/.gitignore", {
+		cwd: base,
+		absolute: true,
+		dot: true,
+		ignore: ["**/node_modules/**", "**/.git/**"]
+	});
+	for (const file of nested) {
+		const dir = path.dirname(file);
+		if (dir === base) continue;
+		const scope = readScope(dir);
+		if (scope) scopes.push(scope);
+	}
+	if (scopes.length === 0) return () => false;
+	return (absolutePath) => {
+		for (const { dir, matcher } of scopes) {
+			const relative = path.relative(dir, absolutePath);
+			if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) continue;
+			if (matcher.ignores(relative.split(path.sep).join("/"))) return true;
+		}
+		return false;
+	};
+}
+/** Finds files under `root`, skipping build output, configured excludes and Git-ignored paths. */
+function scanFiles(root, patterns, options = {}) {
+	const builtin = options.kind === "source" ? SOURCE_BUILTIN_IGNORE : BUILTIN_IGNORE;
+	const files = fg.sync(patterns, {
+		cwd: root,
+		absolute: true,
+		ignore: [
+			...builtin,
+			...options.exclude ?? [],
+			...options.ignore ?? []
+		]
+	});
+	if (options.gitignore === false) return files;
+	const ignored = options.gitignoreFilter ?? createGitignoreFilter(root);
+	return files.filter((file) => !ignored(file));
+}
+//#endregion
 //#region src/utils/icu-check.ts
 /** CLDR order. `resolvedOptions().pluralCategories` order differs between Node versions. */
 const CATEGORY_ORDER = [
@@ -423,26 +518,18 @@ function lockFor(root, sourceLocale) {
 }
 //#endregion
 //#region src/analysis.ts
-const DICTIONARY_IGNORE$1 = [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/.next/**",
-	"**/dialex.locales/**"
-];
+function createAnalysisCache() {
+	return {
+		dictionaries: /* @__PURE__ */ new Map(),
+		sources: /* @__PURE__ */ new Map(),
+		gitignore: /* @__PURE__ */ new Map()
+	};
+}
+/** Forget the cached `.gitignore` rules, for example after a `.gitignore` file changed. */
+function clearGitignore(cache) {
+	cache.gitignore.clear();
+}
 const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
-const SOURCE_IGNORE = [
-	...DICTIONARY_IGNORE$1,
-	"**/.nuxt/**",
-	"**/.output/**",
-	"**/.svelte-kit/**",
-	"**/.astro/**",
-	"**/coverage/**",
-	"**/graphify-out/**",
-	"**/*.d.ts",
-	"**/dialex.generated.*",
-	"**/dialex.config.*",
-	"**/i18n.config.*"
-];
 /** `getDictionary("x")`, `useDictionary("x")`, `@DialexDictionary("x")` */
 const DICTIONARY_CALL = /\b(?:getDictionary|useDictionary|DialexDictionary)\(\s*(["'`])([^"'`$\n]+)\1/dg;
 /** `t("dictionary.path.to.key")` */
@@ -577,22 +664,61 @@ async function loadDictionaryData(file, runtime) {
 		message: "This dictionary uses spreads, computed keys, imported values, or a computed name, so it cannot be analyzed statically."
 	};
 }
+function stampOf(file) {
+	try {
+		const stat = fs.statSync(file);
+		return `${stat.mtimeMs}:${stat.size}`;
+	} catch {
+		return;
+	}
+}
+async function cachedDictionary(file, runtime, cache) {
+	const stamp = cache ? stampOf(file) : void 0;
+	const hit = stamp ? cache.dictionaries.get(file) : void 0;
+	if (hit && hit.stamp === stamp) return hit.loaded;
+	const loaded = await loadDictionaryData(file, runtime);
+	if (cache && stamp) cache.dictionaries.set(file, {
+		stamp,
+		loaded
+	});
+	return loaded;
+}
+function scanSource(text) {
+	const starts = lineStarts(text);
+	const rangeOf = (start, end) => ({
+		start: positionAt(starts, start),
+		end: positionAt(starts, end)
+	});
+	return {
+		tokens: [...new Set(text.match(/[\w$-]+/g) ?? [])],
+		refs: scanReferences(text).map((ref) => ({
+			ref,
+			range: rangeOf(ref.start, ref.end)
+		}))
+	};
+}
 async function analyzeProject(options) {
 	const { root, config } = options;
 	const include = config.include || "**/*.content.ts";
 	const configuredLocales = config.locales || [];
 	const defaultLocale = config.defaultLocale || "en";
 	const extraIgnore = options.ignore ?? [];
-	const files = fg.sync(include, {
-		cwd: root,
-		absolute: true,
-		ignore: [...DICTIONARY_IGNORE$1, ...extraIgnore]
+	const cache = options.runtime ? void 0 : options.cache;
+	let gitignore = cache?.gitignore.get(root);
+	if (cache && !gitignore) {
+		gitignore = createGitignoreFilter(root);
+		cache.gitignore.set(root, gitignore);
+	}
+	const files = scanFiles(root, include, {
+		exclude: config.exclude,
+		ignore: extraIgnore,
+		gitignoreFilter: gitignore
 	});
 	const issues = [];
 	const dictionaries = [];
 	const lock = options.lock === false ? void 0 : readLock(root);
 	for (const file of files) {
-		const loaded = await loadDictionaryData(file, options.runtime === true);
+		const loaded = await cachedDictionary(file, options.runtime === true, cache);
 		if (!loaded.ok) {
 			for (const message of loaded.message.split("\n")) issues.push({
 				file,
@@ -699,34 +825,39 @@ async function analyzeProject(options) {
 	const known = new Map(dictionaries.map((d) => [d.name, d]));
 	const dictionaryFiles = new Set(files);
 	const sourceGlobs = options.src ?? ["**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}"];
-	const sourceFiles = sourceGlobs.length === 0 ? [] : fg.sync(sourceGlobs, {
-		cwd: root,
-		absolute: true,
-		ignore: [...SOURCE_IGNORE, ...extraIgnore]
+	const sourceFiles = sourceGlobs.length === 0 ? [] : scanFiles(root, sourceGlobs, {
+		kind: "source",
+		exclude: config.exclude,
+		ignore: extraIgnore,
+		gitignoreFilter: gitignore
 	}).filter((f) => !dictionaryFiles.has(f));
 	if (sourceFiles.length > 0) {
 		const tokens = /* @__PURE__ */ new Set();
 		for (const file of sourceFiles) {
-			let text;
-			try {
-				text = fs.readFileSync(file, "utf-8");
-			} catch {
-				continue;
+			const stamp = cache ? stampOf(file) : void 0;
+			let scan = stamp ? cache.sources.get(file) : void 0;
+			if (!scan || scan.stamp !== stamp) {
+				let text;
+				try {
+					text = fs.readFileSync(file, "utf-8");
+				} catch {
+					continue;
+				}
+				scan = {
+					stamp: stamp ?? "",
+					scan: scanSource(text)
+				};
+				if (cache && stamp) cache.sources.set(file, scan);
 			}
-			for (const token of text.match(/[\w$-]+/g) ?? []) tokens.add(token);
-			const starts = lineStarts(text);
-			const rangeOf = (start, end) => ({
-				start: positionAt(starts, start),
-				end: positionAt(starts, end)
-			});
-			for (const ref of scanReferences(text)) {
+			for (const token of scan.scan.tokens) tokens.add(token);
+			for (const { ref, range } of scan.scan.refs) {
 				if (ref.kind === "dictionary") {
 					if (!known.has(ref.value)) issues.push({
 						file,
 						level: "error",
 						code: "unknown-dictionary",
 						message: `Unknown dictionary "${ref.value}"`,
-						range: rangeOf(ref.start, ref.end),
+						range,
 						dictionary: ref.value
 					});
 					continue;
@@ -740,7 +871,7 @@ async function analyzeProject(options) {
 					level: "error",
 					code: "unknown-path",
 					message: `Unknown translation path "${ref.value}"`,
-					range: rangeOf(ref.start, ref.end),
+					range,
 					dictionary: name,
 					path: rest
 				});
@@ -774,6 +905,10 @@ async function analyzeProject(options) {
 			}
 		}
 	}
+	if (cache) {
+		const live = /* @__PURE__ */ new Set([...files, ...sourceFiles]);
+		for (const map of [cache.dictionaries, cache.sources]) for (const key of map.keys()) if (key.startsWith(root) && !live.has(key)) map.delete(key);
+	}
 	return {
 		issues,
 		dictionaries,
@@ -1132,6 +1267,7 @@ const DEFAULT_STATIC_CONFIG = {
 	defaultLocale: "en",
 	locales: [],
 	include: "**/*.content.ts",
+	exclude: [],
 	fallbacks: {},
 	prefixDefault: true,
 	lazy: false
@@ -1179,6 +1315,7 @@ function apply(object, config, notes) {
 	accept("defaultLocale", (v) => typeof v === "string" && v !== "", "a string literal");
 	accept("locales", isStringArray, "an array of string literals");
 	accept("include", (v) => typeof v === "string" || isStringArray(v), "a string or array of strings");
+	accept("exclude", isStringArray, "an array of string literals");
 	accept("fallbacks", (v) => typeof v === "object" && v !== null && Object.values(v).every((list) => isStringArray(list)), "an object of string arrays");
 	accept("prefixDefault", (v) => typeof v === "boolean", "true or false");
 	accept("lazy", (v) => typeof v === "boolean" || v === "locale", "true, false or \"locale\"");
@@ -1210,6 +1347,7 @@ function parseStaticConfig(text, file = "dialex.config.ts") {
 				"defaultLocale",
 				"locales",
 				"include",
+				"exclude",
 				"fallbacks",
 				"prefixDefault",
 				"lazy"
@@ -1308,12 +1446,6 @@ function relativeImportExtension(root) {
 }
 //#endregion
 //#region src/commands/generate.ts
-const DICTIONARY_IGNORE = [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/.next/**",
-	"**/dialex.locales/**"
-];
 /** The folder, next to `dialex.generated.ts`, that holds the per-locale modules. */
 const LOCALES_DIR = "dialex.locales";
 const safeName = (text) => text.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -1328,12 +1460,7 @@ function renderGenerated(root, options = {}) {
 	const inlineConfig = options.config ? { configFile: options.config } : {};
 	const staticRead = readStaticConfig(root, options.config);
 	const config = options.static ? staticRead.config : resolveDialexConfig(root, inlineConfig);
-	const include = config.include || DEFAULT_CONFIG.include;
-	const found = fg.sync(include, {
-		cwd: root,
-		absolute: true,
-		ignore: DICTIONARY_IGNORE
-	}).sort();
+	const found = scanFiles(root, config.include || DEFAULT_CONFIG.include, { exclude: config.exclude }).sort();
 	const srcDir = fs.existsSync(path.join(root, "src")) ? path.join(root, "src") : root;
 	const outputPath = options.output ? path.resolve(root, options.output) : path.join(srcDir, "dialex.generated.ts");
 	const outputDir = path.dirname(outputPath);
@@ -1507,7 +1634,7 @@ const CONFIG_FILE = /(^|[\\/])(dialex|i18n)\.config\.[cm]?[jt]s(on)?$/;
 * understands globs, so this watches the project directory and decides for itself which events
 * matter, using the same `include` glob as `generate`.
 */
-function startGenerateWatcher(root, options, regenerate, delay = 100) {
+function startGenerateWatcher(root, options, regenerate, delay = 100, log = (message) => logger.info(message)) {
 	const dictionaryFiles = () => new Set(renderGenerated(root, options).files);
 	let known = dictionaryFiles();
 	let outputs = /* @__PURE__ */ new Set();
@@ -1523,9 +1650,10 @@ function startGenerateWatcher(root, options, regenerate, delay = 100) {
 			} catch {}
 		}, delay);
 	};
+	const gitIgnored = createGitignoreFilter(root);
 	const watcher = chokidar.watch(root, {
 		ignoreInitial: true,
-		ignored: (file) => WATCH_IGNORED.test(file)
+		ignored: (file) => WATCH_IGNORED.test(file) || gitIgnored(path.resolve(root, file))
 	});
 	watcher.on("all", (event, filePath) => {
 		const file = path.resolve(root, filePath);
@@ -1542,7 +1670,7 @@ function startGenerateWatcher(root, options, regenerate, delay = 100) {
 			}
 			if (!(now.size !== known.size || [...now].some((f) => !known.has(f))) && !isConfig) return;
 		} else return;
-		logger.info(`[${event}] ${path.relative(root, file)} changed, regenerating...`);
+		log(`[${event}] ${path.relative(root, file)} changed, regenerating...`);
 		trigger();
 	});
 	return watcher;
@@ -1550,17 +1678,7 @@ function startGenerateWatcher(root, options, regenerate, delay = 100) {
 //#endregion
 //#region src/utils/project.ts
 async function loadDictionaries(root, config) {
-	const include = config.include || "**/*.content.ts";
-	const files = fg.sync(include, {
-		cwd: root,
-		absolute: true,
-		ignore: [
-			"**/node_modules/**",
-			"**/dist/**",
-			"**/.next/**",
-			"**/dialex.locales/**"
-		]
-	});
+	const files = scanFiles(root, config.include || "**/*.content.ts", { exclude: config.exclude });
 	const dictionaries = [];
 	const unsupported = [];
 	for (const file of files) {
@@ -1611,6 +1729,6 @@ async function loadStaticProject(root, configFile) {
 /** `home` + `["nav", "about"]` -> `home.nav.about` */
 const toKey = (dictionary, keyPath) => [dictionary, ...keyPath].join(".");
 //#endregion
-export { listLeaves as A, writeLock as C, getLeafSource as D, dictionaryLocation as E, renderDictionaryFile as F, saveDictionaryFile as I, setString as L, loadDictionaryFile as M, locationOf as N, getString as O, parseDictionaryText as P, record as S, copyLeaf as T, hashSource as _, renderGenerated as a, lockPath as b, parseStaticConfig as c, logger as d, DEFAULT_SOURCE_GLOB as f, LOCK_FILE as g, scanReferences as h, generateDictionaries as i, listLocales as j, hasPath as k, readStaticConfig as l, relativeFile as m, loadStaticProject as n, runGenerate as o, analyzeProject as p, toKey as r, DEFAULT_STATIC_CONFIG as s, loadProject as t, resolveDialexConfig as u, isStale as v, TODO_PREFIX as w, readLock as x, lockFor as y };
+export { scanFiles as A, locationOf as B, lockPath as C, BUILTIN_IGNORE as D, writeLock as E, getString as F, renderDictionaryFile as H, hasPath as I, listLeaves as L, copyLeaf as M, dictionaryLocation as N, SOURCE_BUILTIN_IGNORE as O, getLeafSource as P, listLocales as R, lockFor as S, record as T, saveDictionaryFile as U, parseDictionaryText as V, setString as W, relativeFile as _, renderGenerated as a, hashSource as b, DEFAULT_STATIC_CONFIG as c, resolveDialexConfig as d, logger as f, createAnalysisCache as g, clearGitignore as h, generateDictionaries as i, TODO_PREFIX as j, createGitignoreFilter as k, parseStaticConfig as l, analyzeProject as m, loadStaticProject as n, runGenerate as o, DEFAULT_SOURCE_GLOB as p, toKey as r, startGenerateWatcher as s, loadProject as t, readStaticConfig as u, scanReferences as v, readLock as w, isStale as x, LOCK_FILE as y, loadDictionaryFile as z };
 
-//# sourceMappingURL=project-DquSNdz8.mjs.map
+//# sourceMappingURL=project-Dz0FbydQ.mjs.map