@kanso-labs/unplugin-style-dictionary 0.10.13 → 0.10.15

package/dist/index.js

@@ -1,10 +1,11 @@
 import { colourAllowed, paint } from "./colour.js";
 import { asError, errorMessage } from "./errors.js";
 import { resolveConfigOption } from "./config.js";
-import { expandPatterns, watchPatternsOf } from "./patterns.js";
+import { expandPatterns, realpathOf, watchOptionPatterns, watchPatternsOf } from "./patterns.js";
 import { runBuilds } from "./compile.js";
+import { checkOptions } from "./options.js";
 import { createScheduler } from "./scheduler.js";
-import { isWatchedSource } from "./watch-filter.js";
+import { compileWatchPatterns, isWatchedSource, matchesWatchedFile, registeredSpellingOf } from "./watch-filter.js";
 import fs from "node:fs";
 import path from "node:path";
 import { createUnplugin } from "unplugin";
@@ -28,11 +29,14 @@ function discardTemporaryFile(temporary) {
 function isMessageChannel(value) {
 	return typeof value === "function";
 }
-function nodeModulesNegations(paths) {
-	const negations = /* @__PURE__ */ new Set();
+function nodeModulesNegations(patterns, paths) {
+	const reaching = [...patterns.globs, ...patterns.literals].filter((pattern) => pattern.includes("/node_modules/"));
+	const negations = new Set(reaching.map((pattern) => `!${pattern}`));
 	for (const file of paths) {
 		const normalised = file.replace(/\\/g, "/");
-		if (normalised.includes("/node_modules/")) negations.add(`!${normalised}`);
+		if (!normalised.includes("/node_modules/") || isDirectory(file)) continue;
+		if (matchesWatchedFile(normalised, reaching)) continue;
+		negations.add(`!${normalised}`);
 	}
 	return Array.from(negations);
 }
@@ -46,25 +50,93 @@ function nodeModulesWatchDirectories(paths) {
 	return Array.from(directories);
 }
 let temporaryFileCounter = 0;
-async function rendersWhatIsAlreadyThere(temporary, destination) {
+const sweptTemporaryPrefixes = /* @__PURE__ */ new Set();
+const ABANDONED_TEMPORARY_AGE_MS = 36e5;
+async function alreadyHolds(destination, rendered) {
 	try {
-		const [existing, rendered] = await Promise.all([fs.promises.readFile(destination), fs.promises.readFile(temporary)]);
-		return existing.equals(rendered);
+		return (await fs.promises.readFile(destination)).equals(rendered);
 	} catch {
 		return false;
 	}
 }
-function rendersWhatIsAlreadyThereSync(temporary, destination) {
+function alreadyHoldsSync(destination, rendered) {
 	try {
-		return fs.readFileSync(destination).equals(fs.readFileSync(temporary));
+		return fs.readFileSync(destination).equals(rendered);
 	} catch {
 		return false;
 	}
 }
+function atomicTargetOf(destination) {
+	try {
+		return fs.realpathSync(destination);
+	} catch {
+		try {
+			return path.resolve(path.dirname(destination), fs.readlinkSync(destination));
+		} catch {
+			return destination;
+		}
+	}
+}
+function bytesToWrite(data, options) {
+	if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+	if (typeof data !== "string") return void 0;
+	const encoding = typeof options === "string" ? options : options?.encoding;
+	return Buffer.from(data, encoding ?? "utf8");
+}
+function isOlderThan(file, ageMs) {
+	try {
+		return Date.now() - fs.statSync(file).mtimeMs > ageMs;
+	} catch {
+		return false;
+	}
+}
+function isRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return !(typeof err === "object" && err !== null && "code" in err && err.code === "ESRCH");
+	}
+}
+function keepExistingMode(temporary, target) {
+	let existing;
+	try {
+		existing = fs.statSync(target);
+	} catch {
+		return;
+	}
+	fs.chmodSync(temporary, existing.mode & 4095);
+	if (process.getuid?.() === 0) fs.chownSync(temporary, existing.uid, existing.gid);
+}
+function sweepAbandonedTemporaries(destination) {
+	const directory = path.dirname(destination);
+	const stem = path.basename(destination, path.extname(destination));
+	const prefix = path.join(directory, `.${stem}.`);
+	if (sweptTemporaryPrefixes.has(prefix)) return;
+	sweptTemporaryPrefixes.add(prefix);
+	let names;
+	try {
+		names = fs.readdirSync(directory);
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		const writer = temporaryWriterOf(name, stem);
+		if (writer === void 0) continue;
+		const file = path.join(directory, name);
+		if (isRunning(writer) && !isOlderThan(file, ABANDONED_TEMPORARY_AGE_MS)) continue;
+		discardTemporaryFile(file);
+	}
+}
 function temporaryPathFor(destination) {
 	const extension = path.extname(destination);
 	return path.join(path.dirname(destination), `.${path.basename(destination, extension)}.${process.pid}.${temporaryFileCounter++}.tmp`);
 }
+function temporaryWriterOf(name, stem) {
+	if (!name.startsWith(`.${stem}.`) || !name.endsWith(".tmp")) return void 0;
+	const numbers = /^(\d+)\.\d+$/.exec(name.slice(stem.length + 2, -4));
+	return numbers ? Number(numbers[1]) : void 0;
+}
 const RENAME_RETRY_CODES = /* @__PURE__ */ new Set(["EBUSY", "EPERM"]);
 const RENAME_RETRY_DELAYS_MS = [
 	1,
@@ -117,14 +189,19 @@ function renameWithRetrySync(temporary, destination) {
 }
 const writeFileAtomic = async (file, data, options) => {
 	if (typeof file !== "string") return fs.promises.writeFile(file, data, options);
-	const temporary = temporaryPathFor(file);
+	const target = atomicTargetOf(file);
+	sweepAbandonedTemporaries(target);
+	const bytes = bytesToWrite(data, options);
+	if (bytes && await alreadyHolds(target, bytes)) return;
+	const temporary = temporaryPathFor(target);
 	try {
 		await fs.promises.writeFile(temporary, data, options);
-		if (await rendersWhatIsAlreadyThere(temporary, file)) {
+		if (!bytes && await alreadyHolds(target, await fs.promises.readFile(temporary))) {
 			discardTemporaryFile(temporary);
 			return;
 		}
-		await renameWithRetry(temporary, file);
+		keepExistingMode(temporary, target);
+		await renameWithRetry(temporary, target);
 	} catch (err) {
 		discardTemporaryFile(temporary);
 		throw err;
@@ -135,35 +212,125 @@ const writeFileSyncAtomic = (file, data, options) => {
 		fs.writeFileSync(file, data, options);
 		return;
 	}
-	const temporary = temporaryPathFor(file);
+	const target = atomicTargetOf(file);
+	sweepAbandonedTemporaries(target);
+	const bytes = bytesToWrite(data, options);
+	if (bytes && alreadyHoldsSync(target, bytes)) return;
+	const temporary = temporaryPathFor(target);
 	try {
 		fs.writeFileSync(temporary, data, options);
-		if (rendersWhatIsAlreadyThereSync(temporary, file)) {
-			discardTemporaryFile(temporary);
-			return;
-		}
-		renameWithRetrySync(temporary, file);
+		keepExistingMode(temporary, target);
+		renameWithRetrySync(temporary, target);
+	} catch (err) {
+		discardTemporaryFile(temporary);
+		throw err;
+	}
+};
+const copyFileAtomic = async (source, destination, mode) => {
+	if (typeof destination !== "string" || excludesExisting(mode)) return fs.promises.copyFile(source, destination, mode);
+	const target = atomicTargetOf(destination);
+	sweepAbandonedTemporaries(target);
+	if (await alreadyHolds(target, await fs.promises.readFile(source))) return;
+	const temporary = temporaryPathFor(target);
+	try {
+		await fs.promises.copyFile(source, temporary, mode);
+		await renameWithRetry(temporary, target);
+	} catch (err) {
+		discardTemporaryFile(temporary);
+		throw err;
+	}
+};
+const copyFileSyncAtomic = (source, destination, mode) => {
+	if (typeof destination !== "string" || excludesExisting(mode)) {
+		fs.copyFileSync(source, destination, mode);
+		return;
+	}
+	const target = atomicTargetOf(destination);
+	sweepAbandonedTemporaries(target);
+	if (alreadyHoldsSync(target, fs.readFileSync(source))) return;
+	const temporary = temporaryPathFor(target);
+	try {
+		fs.copyFileSync(source, temporary, mode);
+		renameWithRetrySync(temporary, target);
 	} catch (err) {
 		discardTemporaryFile(temporary);
 		throw err;
 	}
 };
+function excludesExisting(mode) {
+	return mode !== void 0 && (mode & fs.constants.COPYFILE_EXCL) !== 0;
+}
+const cpAtomic = async (source, destination, options) => {
+	if (typeof source !== "string" || typeof destination !== "string" || !walksCopy(options) || isWithin(destination, source)) return fs.promises.cp(source, destination, options);
+	await fs.promises.mkdir(path.dirname(path.resolve(destination)), { recursive: true });
+	await copyTreeAtomic(source, destination, options);
+};
+async function copyTreeAtomic(source, destination, options) {
+	const stat = await fs.promises.lstat(source);
+	const existing = await fs.promises.lstat(destination).catch(() => void 0);
+	if (stat.isFile() && !existing?.isDirectory()) {
+		await copyFileAtomic(source, destination, options?.mode);
+		return;
+	}
+	if (!stat.isDirectory() || !options?.recursive || existing && !existing.isDirectory()) {
+		await fs.promises.cp(source, destination, options);
+		return;
+	}
+	const created = await fs.promises.mkdir(destination, { recursive: true });
+	for (const entry of await fs.promises.readdir(source)) await copyTreeAtomic(path.join(source, entry), path.join(destination, entry), options);
+	if (created !== void 0) await fs.promises.chmod(destination, stat.mode);
+}
+function isWithin(candidate, directory) {
+	const relative = path.relative(path.resolve(directory), path.resolve(candidate));
+	return !(relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative));
+}
+function walksCopy(options) {
+	return Object.entries(options ?? {}).every(([key, value]) => value === void 0 || key === "mode" || key === "recursive" || key === "force" && value === true);
+}
 const atomicVolume = Object.create(fs, {
-	promises: { value: Object.create(fs.promises, { writeFile: { value: writeFileAtomic } }) },
+	copyFileSync: { value: copyFileSyncAtomic },
+	promises: { value: Object.create(fs.promises, {
+		copyFile: { value: copyFileAtomic },
+		cp: { value: cpAtomic },
+		writeFile: { value: writeFileAtomic }
+	}) },
 	writeFileSync: { value: writeFileSyncAtomic }
 });
 const destinationRecords = /* @__PURE__ */ new Map();
 const persistedRecordFiles = /* @__PURE__ */ new Map();
 const compilesInFlight = /* @__PURE__ */ new Map();
-function buildKey(root, resolved) {
+function buildKey(root, resolved, settings) {
 	try {
-		return JSON.stringify([root, resolved.map((item) => item.file ?? item.config)], (_key, value) => typeof value === "function" ? `[fn]${String(value)}` : value);
+		return JSON.stringify([
+			root,
+			resolved.map((item) => item.file ?? item.config),
+			settings
+		], (_key, value) => typeof value === "function" ? `[fn]${String(value)}` : value);
 	} catch {
 		return null;
 	}
 }
+function contextDependenciesOf(context) {
+	const native = context.getNativeBuildContext?.();
+	const compilation = typeof native === "object" && native !== null && "compilation" in native ? native.compilation : void 0;
+	const dependencies = typeof compilation === "object" && compilation !== null && "contextDependencies" in compilation ? compilation.contextDependencies : void 0;
+	if (typeof dependencies !== "object" || dependencies === null || !("add" in dependencies)) return;
+	const add = dependencies.add;
+	if (typeof add !== "function") return void 0;
+	return { add: (entry) => {
+		Reflect.apply(add, dependencies, [entry]);
+	} };
+}
+function isDirectory(file) {
+	try {
+		return fs.statSync(file).isDirectory();
+	} catch {
+		return false;
+	}
+}
 const unpluginFactory = (options = {}, meta) => {
 	const isWebpack = meta.framework === "webpack" || meta.framework === "rspack";
+	checkOptions(options);
 	const { cache = true, errorOverlay = true, failOnError = "build", logLevel, onBuildEnd, onBuildError, onBuildStart, platforms: platformsOption, report = true, root: rootOption, silent = false } = options;
 	const level = logLevel ?? (silent ? "silent" : void 0);
 	const quiet = level === "silent" || level === "warn";
@@ -184,7 +351,27 @@ const unpluginFactory = (options = {}, meta) => {
 	};
 	let root = rootOption ? path.resolve(process.cwd(), rootOption) : process.cwd();
 	const generatedDestinations = /* @__PURE__ */ new Set();
-	let cachedPatterns;
+	let cachedMatcher;
+	const linkedPaths = /* @__PURE__ */ new Map();
+	const addWatchFiles = (context, paths) => {
+		const contextDependencies = isWebpack ? contextDependenciesOf(context) : void 0;
+		const register = (file) => {
+			if (contextDependencies && isDirectory(file)) {
+				contextDependencies.add(path.resolve(file));
+				watchedDirectories.add(file);
+				return;
+			}
+			context.addWatchFile(file);
+		};
+		for (const file of paths) {
+			register(file);
+			const real = realpathOf(file);
+			if (real === void 0 || real === file) continue;
+			linkedPaths.set(real, file);
+			register(real);
+		}
+	};
+	const watchedDirectories = /* @__PURE__ */ new Set();
 	let watchRebuild = false;
 	let hasCompiled = false;
 	let hostClosed = false;
@@ -222,21 +409,49 @@ const unpluginFactory = (options = {}, meta) => {
 		}
 		console.log(paint(type === "success" ? "32" : "36", `${prefix} ${message}`, stdoutColour));
 	};
-	const resolveConfigs = async () => resolveConfigOption({
-		config: options.config,
-		configContext,
-		discovery,
-		log,
-		root
-	});
-	const getWatchTargets = async (resolvedConfigs) => {
+	const logTable = (render) => {
+		if (host?.info) {
+			for (const line of render(false)) host.info(line);
+			return;
+		}
+		for (const line of render(stdoutColour)) console.log(line);
+	};
+	const saidAboutConfig = /* @__PURE__ */ new Set();
+	const logConfig = (message, type) => {
+		if (saidAboutConfig.has(message)) return;
+		saidAboutConfig.add(message);
+		log(message, type);
+	};
+	const resolveConfigs = async () => {
+		const resolved = await resolveConfigOption({
+			config: options.config,
+			configContext,
+			discovery,
+			log: logConfig,
+			root
+		});
+		if (!options.watch) return resolved;
+		const watched = (await expandPatterns(watchOptionPatterns(root, options.watch), log)).filter((file) => !isDirectory(file));
+		for (const item of resolved) if (item.file) item.watched = watched;
+		return resolved;
+	};
+	const deriveWatchPatterns = async (resolvedConfigs) => {
 		const patterns = await watchPatternsOf({
-			log,
+			log: logConfig,
 			root,
 			watch: options.watch
 		}, resolvedConfigs);
-		cachedPatterns = patterns;
+		const matcher = compileWatchPatterns(patterns);
+		cachedMatcher = matcher;
+		return {
+			matcher,
+			patterns
+		};
+	};
+	const getWatchTargets = async (resolvedConfigs) => {
+		const { matcher, patterns } = await deriveWatchPatterns(resolvedConfigs);
 		return {
+			matcher,
 			paths: await expandPatterns(patterns, log),
 			patterns
 		};
@@ -247,7 +462,9 @@ const unpluginFactory = (options = {}, meta) => {
 		failOnError,
 		generatedDestinations,
 		log,
+		logTable,
 		notifyBuildOutcome: (error) => {
+			if (!error) saidAboutConfig.clear();
 			notifyBuildOutcome?.(error);
 		},
 		onBuildEnd,
@@ -258,13 +475,20 @@ const unpluginFactory = (options = {}, meta) => {
 		quiet,
 		report,
 		root: () => root,
-		stdoutColour,
 		verbosity,
 		volume: atomicVolume,
 		watch: options.watch
 	};
 	const compileOnceAcrossInstances = async (resolvedConfigs) => {
-		const key = buildKey(root, resolvedConfigs);
+		const key = buildKey(root, resolvedConfigs, {
+			cache,
+			failOnError,
+			onBuildEnd,
+			onBuildError,
+			onBuildStart,
+			platforms: platformsOption,
+			watch: options.watch
+		});
 		if (key === null) {
 			await runBuilds(instance, resolvedConfigs);
 			return;
@@ -321,25 +545,55 @@ const unpluginFactory = (options = {}, meta) => {
 		host = { error: (message) => {
 			pending.push(message);
 		} };
+		let heldFailure;
 		compiler.hooks.compilation.tap("unplugin-style-dictionary", (compilation) => {
 			for (const message of pending.splice(0)) {
 				const reported = new Error(message);
 				reported.name = "UnpluginStyleDictionaryWarning";
 				compilation.warnings.push(reported);
 			}
+			if (heldFailure) {
+				compilation.errors.push(heldFailure);
+				heldFailure = void 0;
+			}
 		});
 		const drainToConsole = () => {
 			for (const message of pending.splice(0)) console.error(paint("31", message, stderrColour));
 		};
 		compiler.hooks.failed.tap("unplugin-style-dictionary", drainToConsole);
 		compiler.hooks.done.tap("unplugin-style-dictionary", drainToConsole);
-		compiler.hooks.beforeCompile.tapPromise("unplugin-style-dictionary", async () => {
+		const compileTokens = async () => {
 			isWatching = compiler.watchMode;
 			const resolved = await resolveConfigs();
 			if (resolved.length === 0) return;
 			await compileOnceAcrossInstances(resolved);
 			hasCompiled = true;
-		});
+		};
+		const changedSource = () => {
+			const changed = [...compiler.modifiedFiles ?? [], ...compiler.removedFiles ?? []];
+			for (const file of changed) {
+				const id = registeredSpellingOf(file, linkedPaths);
+				if (!cachedMatcher || watchedDirectories.has(id.replace(/\\/g, "/")) || isWatchedSource(id, cachedMatcher, generatedDestinations)) return id;
+			}
+		};
+		const rebuildTokens = async () => {
+			if (!hasCompiled || compiler.modifiedFiles === void 0) {
+				await compileTokens();
+				return;
+			}
+			isWatching = compiler.watchMode;
+			const changed = changedSource();
+			if (changed === void 0) return;
+			const resolved = await resolveConfigs();
+			if (resolved.length === 0) return;
+			try {
+				await runBuilds(instance, resolved, path.basename(changed));
+			} catch (err) {
+				heldFailure = asError(err);
+			}
+		};
+		compiler.hooks.run.tapPromise("unplugin-style-dictionary", compileTokens);
+		compiler.hooks.watchRun.tapPromise("unplugin-style-dictionary", rebuildTokens);
 	};
 	return {
 		async buildStart() {
@@ -349,7 +603,7 @@ const unpluginFactory = (options = {}, meta) => {
 			if (resolved.length === 0) return;
 			if (!hostClosed) {
 				const { paths } = await getWatchTargets(resolved);
-				for (const file of paths) this.addWatchFile(file);
+				addWatchFiles(this, paths);
 			}
 			if (isWebpack) return;
 			const reentry = watchRebuild && hasCompiled && hostCommand !== "serve";
@@ -385,8 +639,8 @@ const unpluginFactory = (options = {}, meta) => {
 						try {
 							const resolved = await resolveConfigs();
 							if (resolved.length > 0) {
-								const { paths } = await getWatchTargets(resolved);
-								appendChokidarIgnored(config.build.watch, nodeModulesNegations(paths));
+								const { paths, patterns } = await getWatchTargets(resolved);
+								appendChokidarIgnored(config.build.watch, nodeModulesNegations(patterns, paths));
 							}
 						} catch (err) {
 							log(`Could not read the configuration while preparing the watch list: ${errorMessage(err)}`, "error");
@@ -399,8 +653,8 @@ const unpluginFactory = (options = {}, meta) => {
 					startupResolved = await resolveConfigs();
 					if (startupResolved.length === 0) return;
 					if (config.server.watch === null) return;
-					const { paths } = await getWatchTargets(startupResolved);
-					const negations = nodeModulesNegations(paths);
+					const { paths, patterns } = await getWatchTargets(startupResolved);
+					const negations = nodeModulesNegations(patterns, paths);
 					if (negations.length === 0) return;
 					const existing = config.server.watch?.ignored;
 					config.server.watch = {
@@ -435,7 +689,7 @@ const unpluginFactory = (options = {}, meta) => {
 							const watcher = fs.watch(directory, (_event, filename) => {
 								if (filename === null) return;
 								const changed = path.posix.join(directory, filename);
-								if (!isWatchedSource(changed, targets.patterns, generatedDestinations)) return;
+								if (!isWatchedSource(changed, targets.matcher, generatedDestinations)) return;
 								schedule(path.basename(changed)).catch(() => {});
 							});
 							watcher.unref();
@@ -449,8 +703,10 @@ const unpluginFactory = (options = {}, meta) => {
 					ownWatchers.clear();
 				};
 				refreshServerWatchList = async (rebuilt) => {
+					const previous = new Set(targets.paths);
 					targets = await getWatchTargets(rebuilt);
-					server.watcher.add(targets.paths);
+					const adding = targets.paths.filter((file) => !previous.has(file) || !fs.existsSync(file));
+					if (adding.length > 0) server.watcher.add(adding);
 					watchNodeModules(targets.paths);
 				};
 				if (errorOverlay) {
@@ -477,23 +733,25 @@ const unpluginFactory = (options = {}, meta) => {
 					};
 				}
 				server.watcher.on("all", (_event, file) => {
-					if (!isWatchedSource(file, targets.patterns, generatedDestinations)) return;
+					if (!isWatchedSource(file, targets.matcher, generatedDestinations)) return;
 					schedule(path.basename(file)).catch(() => {});
 				});
 			}
 		},
-		async watchChange(id) {
+		async watchChange(changed) {
 			adoptHost(this);
 			adoptWatchMode(this);
 			if (hostClosed) return;
 			watchRebuild = true;
-			if (cachedPatterns && !isWatchedSource(id, cachedPatterns, generatedDestinations)) return;
+			const id = registeredSpellingOf(changed, linkedPaths);
+			if (cachedMatcher && !isWatchedSource(id, cachedMatcher, generatedDestinations)) return;
 			const resolved = await resolveConfigs();
 			if (resolved.length === 0) return;
-			const { patterns } = await getWatchTargets(resolved);
-			if (!isWatchedSource(id, patterns, generatedDestinations)) return;
+			const { matcher, patterns } = await deriveWatchPatterns(resolved);
+			if (!isWatchedSource(id, matcher, generatedDestinations)) return;
 			if (!isWebpack) await schedule(path.basename(id));
-			for (const file of await expandPatterns(patterns, log)) this.addWatchFile(file);
+			if (refreshServerWatchList) return;
+			addWatchFiles(this, await expandPatterns(patterns, log));
 		},
 		webpack: adoptCompiler
 	};