Init.

regar.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env -S deno run -A
+
+import { exists } from "https://deno.land/std@0.224.0/fs/exists.ts";
+import { Command } from "https://deno.land/x/cliffy@v1.0.0-rc.4/command/mod.ts";
+import { Channel } from "https://git.barnulf.net/mb/barnulf_ts/raw/branch/master/mod.ts";
+
+async function main() {
+	const { do_clear, command, extensions, files, strategy } = await parse_args();
+	const channel = new Channel<Event>();
+	files.map((path) => new Watcher(path, extensions).spin(channel));
+	new Runner(command, strategy, do_clear).spin(channel);
+}
+
+async function parse_args() {
+	const { args, options } = await new Command()
+		.name("regar")
+		.description("File watcher development utility.")
+		.arguments("<command> [...files]")
+		.option("-r, --hard", "Ends the child process by killing it.")
+		.option("-s, --soft", "Ends the child process by sending an interuption and waiting for it to shut down.")
+		.option("-w, --wait", "Wait for the child process to complete without terminating it. (default)")
+		.option("-e, --extensions <extentions>", "Comma separated whitelist of extensions to whatch.")
+		.option("-c, --clear", "Clear the terminal on restart").parse();
+	const [command, ...files] = args;
+	let strategy: ShutdownStrategy = new WaitStrategy();
+	if (options.soft) strategy = new SoftStrategy();
+	if (options.hard) strategy = new HardStrategy();
+	if (options.wait) strategy = new WaitStrategy();
+	const extensions = options.extensions?.split(",");
+	const do_clear = options.clear ?? false;
+	return { command, files, strategy, extensions, do_clear };
+}
+
+class Watcher {
+	public constructor(
+		private path: string,
+		private extension_whitelist: string[] | undefined,
+	) {}
+
+	public async spin(channel: Channel<Event>) {
+		const relevant_events: Deno.FsEvent["kind"][] = ["create", "modify", "remove", "rename"];
+		for await (const event of Deno.watchFs(this.path, { recursive: true })) {
+			if (!relevant_events.includes(event.kind)) continue;
+			if (!this.matches_whitelist(event.paths[0])) continue;
+			for (const path of event.paths) channel.send(new Event(path, Date.now()));
+		}
+	}
+
+	private matches_whitelist(path: string) {
+		if (this.extension_whitelist === undefined) return true;
+		for (const ext of this.extension_whitelist) if (path.endsWith(ext)) return true;
+		return false;
+	}
+}
+
+class Runner {
+	public constructor(
+		private command: string,
+		private strategy: ShutdownStrategy,
+		private do_clear: boolean,
+	) {}
+
+	public async spin(channel: Channel<Event>) {
+		this.could_clear();
+		let process = this.launch();
+		while (true) {
+			const event = await channel.receive();
+			if (this.debouncing(event)) continue;
+			const shotdown = await this.strategy.shutdown(process);
+			if (!shotdown) continue;
+			this.could_clear();
+			log("changed", event.path);
+			process = this.launch();
+		}
+	}
+
+	private launch() {
+		const args = ["-c", this.command];
+		log("running", this.command);
+		const process = new Deno.Command("sh", { args }).spawn();
+		process.status.then(this.on_end());
+		return process;
+	}
+
+	private could_clear() {
+		const clear_term_sequence = "\x1bc";
+		if (this.do_clear) console.log(clear_term_sequence);
+	}
+
+	private last_event_date_ms = 0;
+	private debouncing(event: Event) {
+		const delay_ms = event.date_ms - this.last_event_date_ms;
+		const threshold_ms = 100;
+		if (delay_ms < threshold_ms) return true;
+		this.last_event_date_ms = event.date_ms;
+		return false;
+	}
+
+	private on_end() {
+		const start_ms = Date.now();
+		return () => {
+			const end_ms = Date.now();
+			const time_ms = end_ms - start_ms;
+			const secs = time_ms / 1000;
+			log("terminated", `${secs} s`);
+		};
+	}
+}
+
+interface ShutdownStrategy {
+	// Returns wether the child has been shutdown.
+	shutdown(process_: Deno.ChildProcess): Promise<boolean>;
+}
+
+class WaitStrategy implements ShutdownStrategy {
+	async shutdown(process_: Deno.ChildProcess) {
+		if (await process_exists(process_.pid)) return false;
+		else return true;
+	}
+}
+
+class SoftStrategy implements ShutdownStrategy {
+	async shutdown(process_: Deno.ChildProcess) {
+		Deno.kill(process_.pid, "SIGINT");
+		await process_.output();
+		return true;
+	}
+}
+
+class HardStrategy implements ShutdownStrategy {
+	async shutdown(process_: Deno.ChildProcess) {
+		Deno.kill(process_.pid, "SIGKILL");
+		return await true;
+	}
+}
+
+class Event {
+	constructor(
+		public path: string,
+		public date_ms: number,
+	) {}
+}
+
+async function process_exists(pid: number) {
+	return await exists(`/proc/${pid}`);
+}
+
+function log(verb: string, value: unknown) {
+	const yellow = "\x1b[0;33m";
+	const bold = "\x1b[1m";
+	const reset = "\x1b[0m";
+	console.log(
+		`` +
+			`${yellow}${bold}${verb.padStart(12)}${reset}` +
+			` ` +
+			`${yellow}${value}${reset}`,
+	);
+}
+
+if (import.meta.main) await main();