@kanso-labs/unplugin-style-dictionary 0.10.12 → 0.10.14

package/dist/index.js

@@ -1,14 +1,25 @@
 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 { createScheduler } from "./scheduler.js";
-import { isWatchedSource } from "./watch-filter.js";
+import { isWatchedSource, registeredSpellingOf } from "./watch-filter.js";
 import fs from "node:fs";
 import path from "node:path";
 import { createUnplugin } from "unplugin";
 //#region src/index.ts
+function appendChokidarIgnored(watch, negations) {
+	if (negations.length === 0) return;
+	const chokidar = Reflect.get(watch, "chokidar");
+	const options = typeof chokidar === "object" && chokidar !== null ? chokidar : {};
+	const existing = Reflect.get(options, "ignored");
+	const previous = Array.isArray(existing) ? existing : existing === void 0 ? [] : [existing];
+	Reflect.set(watch, "chokidar", {
+		...options,
+		ignored: [...previous, ...negations]
+	});
+}
 function discardTemporaryFile(temporary) {
 	try {
 		fs.rmSync(temporary, { force: true });
@@ -35,25 +46,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,
@@ -106,14 +185,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;
@@ -124,32 +208,122 @@ 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 compiledFingerprints = /* @__PURE__ */ new Set();
+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";
 	const { cache = true, errorOverlay = true, failOnError = "build", logLevel, onBuildEnd, onBuildError, onBuildStart, platforms: platformsOption, report = true, root: rootOption, silent = false } = options;
@@ -173,6 +347,26 @@ const unpluginFactory = (options = {}, meta) => {
 	let root = rootOption ? path.resolve(process.cwd(), rootOption) : process.cwd();
 	const generatedDestinations = /* @__PURE__ */ new Set();
 	let cachedPatterns;
+	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;
@@ -210,13 +404,26 @@ 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 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 resolveConfigs = async () => {
+		const resolved = await resolveConfigOption({
+			config: options.config,
+			configContext,
+			discovery,
+			log,
+			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 getWatchTargets = async (resolvedConfigs) => {
 		const patterns = await watchPatternsOf({
 			log,
@@ -231,27 +438,36 @@ const unpluginFactory = (options = {}, meta) => {
 	};
 	const instance = {
 		cache,
-		compiledFingerprints,
+		destinationRecords,
 		failOnError,
 		generatedDestinations,
 		log,
+		logTable,
 		notifyBuildOutcome: (error) => {
 			notifyBuildOutcome?.(error);
 		},
 		onBuildEnd,
 		onBuildError,
 		onBuildStart,
+		persistedRecordFiles,
 		platformsOption,
 		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;
@@ -308,25 +524,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 (!cachedPatterns || watchedDirectories.has(id.replace(/\\/g, "/")) || isWatchedSource(id, cachedPatterns, 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() {
@@ -336,13 +582,12 @@ 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;
-			if (watchRebuild && hasCompiled) {
-				watchRebuild = false;
-				return;
-			}
+			const reentry = watchRebuild && hasCompiled && hostCommand !== "serve";
+			watchRebuild = false;
+			if (reentry) return;
 			await compileOnceAcrossInstances(resolved);
 			hasCompiled = true;
 		},
@@ -367,11 +612,26 @@ const unpluginFactory = (options = {}, meta) => {
 						config.logger.info(message);
 					}
 				};
-				if (config.command !== "serve") return;
+				if (config.command !== "serve") {
+					if (config.build.watch) {
+						isWatching = true;
+						try {
+							const resolved = await resolveConfigs();
+							if (resolved.length > 0) {
+								const { paths } = await getWatchTargets(resolved);
+								appendChokidarIgnored(config.build.watch, nodeModulesNegations(paths));
+							}
+						} catch (err) {
+							log(`Could not read the configuration while preparing the watch list: ${errorMessage(err)}`, "error");
+						}
+					}
+					return;
+				}
 				isWatching = true;
 				try {
 					startupResolved = await resolveConfigs();
 					if (startupResolved.length === 0) return;
+					if (config.server.watch === null) return;
 					const { paths } = await getWatchTargets(startupResolved);
 					const negations = nodeModulesNegations(paths);
 					if (negations.length === 0) return;
@@ -393,7 +653,9 @@ const unpluginFactory = (options = {}, meta) => {
 				let targets = await getWatchTargets(resolved);
 				server.watcher.add(targets.paths);
 				const ownWatchers = /* @__PURE__ */ new Map();
+				const watcherDisabled = server.config.server.watch === null;
 				const watchNodeModules = (forPaths) => {
+					if (watcherDisabled) return;
 					const wanted = new Set(nodeModulesWatchDirectories(forPaths));
 					for (const [directory, watcher] of ownWatchers) {
 						if (wanted.has(directory)) continue;
@@ -453,18 +715,19 @@ const unpluginFactory = (options = {}, meta) => {
 				});
 			}
 		},
-		async watchChange(id) {
+		async watchChange(changed) {
 			adoptHost(this);
 			adoptWatchMode(this);
 			if (hostClosed) return;
 			watchRebuild = true;
+			const id = registeredSpellingOf(changed, linkedPaths);
 			if (cachedPatterns && !isWatchedSource(id, cachedPatterns, generatedDestinations)) return;
 			const resolved = await resolveConfigs();
 			if (resolved.length === 0) return;
 			const { patterns } = await getWatchTargets(resolved);
 			if (!isWatchedSource(id, patterns, generatedDestinations)) return;
 			if (!isWebpack) await schedule(path.basename(id));
-			for (const file of await expandPatterns(patterns, log)) this.addWatchFile(file);
+			addWatchFiles(this, await expandPatterns(patterns, log));
 		},
 		webpack: adoptCompiler
 	};