@ryanatkn/gro 0.161.2 → 0.162.0

package/src/lib/filer.ts

@@ -21,31 +21,15 @@ import {paths} from './paths.ts';
 import {parse_imports} from './parse_imports.ts';
 import {resolve_specifier} from './resolve_specifier.ts';
 import {default_svelte_config} from './svelte_config.ts';
-import {map_sveltekit_aliases, SVELTEKIT_GLOBAL_SPECIFIER} from './sveltekit_helpers.ts';
+import {map_sveltekit_aliases} from './sveltekit_helpers.ts';
+import {SVELTEKIT_GLOBAL_SPECIFIER} from './constants.ts';
+import type {Disknode} from './disknode.ts';
 
 const aliases = Object.entries(default_svelte_config.alias);
 
-export interface Source_File {
-	id: Path_Id;
-	// TODO figure out the best API that makes this lazy
-	/**
-	 * `null` contents means it doesn't exist.
-	 * We create the file in memory to track its dependents regardless of its existence on disk.
-	 */
-	contents: string | null;
-	/**
-	 * Is the source file outside of the `root_dir` or excluded by `watch_dir_options.filter`?
-	 */
-	external: boolean;
-	ctime: number | null;
-	mtime: number | null;
-	dependents: Map<Path_Id, Source_File>;
-	dependencies: Map<Path_Id, Source_File>;
-}
-
 export type Cleanup_Watch = () => Promise<void>;
 
-export type On_Filer_Change = (change: Watcher_Change, source_file: Source_File) => void;
+export type On_Filer_Change = (change: Watcher_Change, source_file: Disknode) => void;
 
 export interface Filer_Options {
 	watch_dir?: typeof watch_dir;
@@ -57,7 +41,7 @@ export interface Filer_Options {
 export class Filer {
 	readonly root_dir: Path_Id;
 
-	readonly files: Map<Path_Id, Source_File> = new Map();
+	readonly files: Map<Path_Id, Disknode> = new Map();
 
 	#watch_dir: typeof watch_dir;
 	#watch_dir_options: Partial<Watch_Dir_Options>;
@@ -68,6 +52,10 @@ export class Filer {
 		this.#watch_dir = options.watch_dir ?? watch_dir;
 		this.#watch_dir_options = options.watch_dir_options ?? EMPTY_OBJECT;
 		this.root_dir = resolve(options.watch_dir_options?.dir ?? paths.source);
+		// TODO for package.json maybe another array of files/dirs to watch to invalidate everything?
+		// or instead of that, think of taking an array of config objects that can specify invalidation rules,
+		// so package.json would be configured differently than ./src, and we could add a default with
+		// package.json/gro.config.ts/tsconfig.json/svelte.config.js/vite.config.ts to invalidate everything
 		this.#log = options.log;
 	}
 
@@ -76,14 +64,14 @@ export class Filer {
 
 	#ready = false;
 
-	get_by_id = (id: Path_Id): Source_File | undefined => {
+	get_by_id = (id: Path_Id): Disknode | undefined => {
 		return this.files.get(id);
 	};
 
-	get_or_create = (id: Path_Id): Source_File => {
+	get_or_create = (id: Path_Id): Disknode => {
 		const existing = this.get_by_id(id);
 		if (existing) return existing;
-		const file: Source_File = {
+		const file: Disknode = {
 			id,
 			contents: null,
 			external: this.#is_external(id), // TODO maybe filter externals by default? the user needs to configure the filer then
@@ -100,14 +88,14 @@ export class Filer {
 		return file;
 	};
 
-	#update(id: Path_Id): Source_File | null {
+	#update(id: Path_Id): Disknode | null {
 		const file = this.get_or_create(id);
 
 		const stats = existsSync(id) ? statSync(id) : null;
 		file.ctime = stats?.ctimeMs ?? null;
 		file.mtime = stats?.mtimeMs ?? null;
 
-		const new_contents = stats ? readFileSync(id, 'utf8') : null; // TODO need to lazily load contents, probably turn `Source_File` into a class
+		const new_contents = stats ? readFileSync(id, 'utf8') : null; // TODO need to lazily load contents, probably turn `Disknode` into a class
 
 		if (file.contents === new_contents) {
 			return null;
@@ -159,7 +147,7 @@ export class Filer {
 		return file;
 	}
 
-	#remove(id: Path_Id): Source_File | null {
+	#remove(id: Path_Id): Disknode | null {
 		const file = this.get_by_id(id);
 		if (!file) return null; // this is safe because the object would exist if any other file referenced it as a dependency or dependent
 
@@ -177,14 +165,14 @@ export class Filer {
 		return file;
 	}
 
-	#notify_listener(listener: On_Filer_Change): void {
+	#sync_listener_with_files(listener: On_Filer_Change): void {
 		if (!this.#ready) return;
 		for (const source_file of this.files.values()) {
 			listener({type: 'add', path: source_file.id, is_directory: false}, source_file);
 		}
 	}
 
-	#notify_change(change: Watcher_Change, source_file: Source_File): void {
+	#notify_change(change: Watcher_Change, source_file: Disknode): void {
 		if (!this.#ready) return;
 		for (const listener of this.#listeners) {
 			listener(change, source_file);
@@ -197,7 +185,7 @@ export class Filer {
 			// if already watching, call the listener for all existing files after init
 			await this.#watching.init();
 			await wait(); // wait a tick to ensure the `this.#ready` value is updated below first
-			this.#notify_listener(listener);
+			this.#sync_listener_with_files(listener);
 			return;
 		}
 		this.#watching = this.#watch_dir({
@@ -207,7 +195,7 @@ export class Filer {
 		});
 		await this.#watching.init();
 		this.#ready = true;
-		this.#notify_listener(listener);
+		this.#sync_listener_with_files(listener);
 	}
 
 	async #remove_listener(listener: On_Filer_Change): Promise<void> {
@@ -219,7 +207,7 @@ export class Filer {
 
 	#on_change: Watcher_Change_Callback = (change) => {
 		if (change.is_directory) return; // TODO manage directories?
-		let source_file: Source_File | null;
+		let source_file: Disknode | null;
 		switch (change.type) {
 			case 'add':
 			case 'update': {
@@ -258,10 +246,10 @@ export class Filer {
 	}
 }
 
-// TODO maybe `Source_File` class?
+// TODO maybe `Disknode` class?
 export const filter_dependents = (
-	source_file: Source_File,
-	get_by_id: (id: Path_Id) => Source_File | undefined,
+	source_file: Disknode,
+	get_by_id: (id: Path_Id) => Disknode | undefined,
 	filter?: File_Filter,
 	results: Set<string> = new Set(),
 	searched: Set<string> = new Set(),

package/src/lib/format_directory.ts

@@ -8,7 +8,7 @@ import {
 	SVELTE_CONFIG_FILENAME,
 	VITE_CONFIG_FILENAME,
 	TSCONFIG_FILENAME,
-	GRO_CONFIG_PATH,
+	GRO_CONFIG_FILENAME,
 	PM_CLI_DEFAULT,
 	PRETTIER_CLI_DEFAULT,
 } from './constants.ts';
@@ -18,7 +18,7 @@ import {spawn_cli, to_cli_name, type Cli} from './cli.ts';
 const EXTENSIONS_DEFAULT = 'ts,js,json,svelte,html,css,md,yml';
 const ROOT_PATHS_DEFAULT = `${[
 	README_FILENAME,
-	GRO_CONFIG_PATH,
+	GRO_CONFIG_FILENAME,
 	SVELTE_CONFIG_FILENAME,
 	VITE_CONFIG_FILENAME,
 	TSCONFIG_FILENAME,

package/src/lib/gen.task.ts

@@ -9,7 +9,14 @@ import {Raw_Input_Path, to_input_paths} from './input_path.ts';
 import {format_file} from './format_file.ts';
 import {print_path} from './paths.ts';
 import {log_error_reasons} from './task_logging.ts';
-import {write_gen_results, analyze_gen_results, find_genfiles, load_genfiles} from './gen.ts';
+import {
+	write_gen_results,
+	analyze_gen_results,
+	find_genfiles,
+	load_genfiles,
+	type Analyzed_Gen_Result,
+	type Gen_Results,
+} from './gen.ts';
 import {SOURCE_DIRNAME} from './constants.ts';
 
 export const Args = z.strictObject({
@@ -106,31 +113,16 @@ export const task: Task<Args> = {
 			timing_to_output_results();
 		}
 
-		// TODO these final printed results could be improved showing a breakdown per file id
+		// collect and format output with summary
+		const output_lines = collect_output_lines(gen_results, analyzed_gen_results);
 		const new_count = analyzed_gen_results.filter((r) => r.is_new).length;
-		const changed_count = analyzed_gen_results.filter((r) => r.has_changed).length;
+		const changed_count = analyzed_gen_results.filter((r) => r.has_changed && !r.is_new).length;
 		const unchanged_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
-		let log_result = st('green', 'gen results:');
-		log_result += `\n\t${new_count} ` + st('gray', 'new');
-		log_result += `\n\t${changed_count} ` + st('gray', 'changed');
-		log_result += `\n\t${unchanged_count} ` + st('gray', 'unchanged');
-		for (const result of gen_results.results) {
-			log_result += `\n\t${result.ok ? st('green', '✓') : st('red', '🞩')}  ${
-				result.ok ? result.files.length : 0
-			} ${st('gray', 'in')} ${print_ms(result.elapsed)} ${st('gray', '←')} ${print_path(
-				result.id,
-			)} ${st('gray', '→')} ${
-				result.ok ? result.files.map((f) => print_path(f.id)).join(', ') : print_error(result.error)
-			}`;
-		}
-		log.info(log_result);
+		const error_count = gen_results.failures.length;
+
 		log.info(
-			st(
-				'green',
-				`generated ${gen_results.output_count} file${plural(gen_results.output_count)} from ${
-					gen_results.successes.length
-				} input file${plural(gen_results.successes.length)}`,
-			),
+			format_gen_output(output_lines) +
+				`\n\n\t${new_count} ${st(new_count > 0 ? 'green' : 'gray', 'new')}, ${changed_count} ${st(changed_count > 0 ? 'cyan' : 'gray', 'changed')}, ${unchanged_count} ${st('gray', 'unchanged')}${error_count ? `, ${error_count} ${st('red', 'error' + plural(error_count))}` : ''} from ${gen_results.input_count} input file${plural(gen_results.input_count)}`,
 		);
 
 		if (fail_count) {
@@ -141,3 +133,71 @@ export const task: Task<Args> = {
 		}
 	},
 };
+
+interface Gen_Status {
+	symbol: string;
+	color: Parameters<typeof st>[0];
+	text: string;
+}
+
+const format_gen_status = (analyzed: Analyzed_Gen_Result | undefined): Gen_Status => {
+	if (!analyzed) return {symbol: '?', color: 'gray', text: 'unknown'};
+	if (analyzed.is_new) return {symbol: '●', color: 'green', text: 'new'};
+	if (analyzed.has_changed) return {symbol: '◐', color: 'cyan', text: 'changed'};
+	return {symbol: '○', color: 'gray', text: 'unchanged'};
+};
+
+interface Output_Line {
+	status: Gen_Status;
+	elapsed: string;
+	source: string;
+	target: string;
+	is_error: boolean;
+}
+
+const collect_output_lines = (
+	gen_results: Gen_Results,
+	analyzed_gen_results: Array<Analyzed_Gen_Result>,
+): Array<Output_Line> => {
+	const output_lines: Array<Output_Line> = [];
+
+	for (const result of gen_results.results) {
+		if (result.ok) {
+			for (const file of result.files) {
+				const analyzed = analyzed_gen_results.find((a) => a.file.id === file.id);
+				output_lines.push({
+					status: format_gen_status(analyzed),
+					elapsed: print_ms(result.elapsed),
+					source: print_path(result.id),
+					target: print_path(file.id),
+					is_error: false,
+				});
+			}
+		} else {
+			output_lines.push({
+				status: {symbol: '🞩', color: 'red', text: 'error'},
+				elapsed: print_ms(result.elapsed),
+				source: print_path(result.id),
+				target: st('red', result.error.stack || result.error.message || 'error'),
+				is_error: true,
+			});
+		}
+	}
+
+	return output_lines;
+};
+
+const format_gen_output = (output_lines: Array<Output_Line>): string => {
+	// calculate column widths for alignment
+	const max_elapsed_length = Math.max(...output_lines.map((l) => l.elapsed.length));
+	const max_source_length = Math.max(...output_lines.map((l) => l.source.length));
+
+	// format the output lines
+	let log_result = 'gen results:';
+	for (const line of output_lines) {
+		const elapsed_text = line.elapsed.padStart(max_elapsed_length);
+		const source_text = line.source.padEnd(max_source_length);
+		log_result += `\n\t${st(line.status.color, line.status.symbol)}  ${elapsed_text}  ${source_text} → ${line.target}`;
+	}
+	return log_result;
+};

package/src/lib/git.ts

@@ -20,7 +20,7 @@ export type Git_Branch = Flavored<string, 'Git_Branch'>;
 export const git_current_branch_name = async (options?: SpawnOptions): Promise<Git_Branch> => {
 	const {stdout} = await spawn_out('git', ['rev-parse', '--abbrev-ref', 'HEAD'], options);
 	if (!stdout) throw Error('git_current_branch_name failed');
-	const branch_name = stdout.toString().trim() as Git_Branch;
+	const branch_name = stdout.trim() as Git_Branch;
 	return branch_name;
 };
 
@@ -251,7 +251,7 @@ export const git_current_commit_hash = async (
 	const final_branch = branch ?? (await git_current_branch_name(options));
 	const {stdout} = await spawn_out('git', ['show-ref', '-s', final_branch], options);
 	if (!stdout) return null; // TODO hack for CI
-	return stdout.toString().split('\n')[0].trim();
+	return stdout.split('\n')[0].trim();
 };
 
 /**
@@ -266,7 +266,7 @@ export const git_current_branch_first_commit_hash = async (
 		options,
 	);
 	if (!stdout) throw Error('git_current_branch_first_commit_hash failed');
-	return stdout.toString().trim();
+	return stdout.trim();
 };
 
 /**

package/src/lib/gro.config.default.ts

@@ -33,7 +33,8 @@ const config: Create_Gro_Config = async (cfg, svelte_config) => {
 
 	const local_moss_plugin_path = find_first_existing_file([
 		'./src/lib/gro_plugin_moss.ts',
-		'./src/routes/gro_plugin_moss.ts',
+		'./src/gro_plugin_moss.ts',
+		'./src/routes/gro_plugin_moss.ts', // TODO probably remove this
 	]);
 
 	// put things that generate files before SvelteKit so it can see them

package/src/lib/gro_config.ts

@@ -3,7 +3,7 @@ import {existsSync} from 'node:fs';
 
 import {GRO_DIST_DIR, IS_THIS_GRO, paths} from './paths.ts';
 import {
-	GRO_CONFIG_PATH,
+	GRO_CONFIG_FILENAME,
 	JS_CLI_DEFAULT,
 	NODE_MODULES_DIRNAME,
 	PM_CLI_DEFAULT,
@@ -121,8 +121,9 @@ export const EXPORTS_EXCLUDER_DEFAULT = /(\.md|\.(test|ignore)\.|\/(test|fixture
  * Transforms a `Raw_Gro_Config` to the more strict `Gro_Config`.
  * This allows users to provide a more relaxed config.
  */
-export const normalize_gro_config = (raw_config: Raw_Gro_Config): Gro_Config => {
+export const cook_gro_config = (raw_config: Raw_Gro_Config): Gro_Config => {
 	const empty_config = create_empty_gro_config();
+
 	// All of the raw config properties are optional,
 	// so fall back to the empty values when `undefined`.
 	const {
@@ -133,6 +134,7 @@ export const normalize_gro_config = (raw_config: Raw_Gro_Config): Gro_Config =>
 		js_cli = empty_config.js_cli,
 		pm_cli = empty_config.pm_cli,
 	} = raw_config;
+
 	return {
 		plugins,
 		map_package_json,
@@ -152,18 +154,20 @@ export interface Gro_Config_Module {
 }
 
 export const load_gro_config = async (dir = paths.root): Promise<Gro_Config> => {
-	const default_config = normalize_gro_config(
-		await create_default_config(create_empty_gro_config()),
-	);
-	const config_path = join(dir, GRO_CONFIG_PATH);
+	const default_config = cook_gro_config(await create_default_config(create_empty_gro_config()));
+
+	const config_path = join(dir, GRO_CONFIG_FILENAME);
 	if (!existsSync(config_path)) {
 		// No user config file found, so return the default.
 		return default_config;
 	}
+
 	// Import the user's `gro.config.ts`.
 	const config_module = await import(config_path);
+
 	validate_gro_config_module(config_module, config_path);
-	return normalize_gro_config(
+
+	return cook_gro_config(
 		typeof config_module.default === 'function'
 			? await config_module.default(default_config)
 			: config_module.default,

package/src/lib/gro_plugin_gen.ts

@@ -45,9 +45,11 @@ export const gro_plugin_gen = ({
 		},
 		{delay: flush_debounce_delay},
 	);
+
+	// TODO do this in-process - will it cause caching issues with the current impl?
 	const gen = (files: Array<string> = []) => spawn_cli('gro', ['gen', ...files]);
 
-	let cleanup: Cleanup_Watch | undefined;
+	let cleanup_watch: Cleanup_Watch | undefined;
 
 	return {
 		name: 'gro_plugin_gen',
@@ -73,7 +75,7 @@ export const gro_plugin_gen = ({
 
 			// When a file builds, check it and its tree of dependents
 			// for any `.gen.` files that need to run.
-			cleanup = await filer.watch((change, source_file) => {
+			cleanup_watch = await filer.watch((change, source_file) => {
 				if (source_file.external) return;
 				switch (change.type) {
 					case 'add':
@@ -95,7 +97,7 @@ export const gro_plugin_gen = ({
 						break;
 					}
 					case 'delete': {
-						// TODO delete the generated file(s)? option?
+						// TODO delete the generated file(s)? option? because it may be surprising
 						break;
 					}
 					default:
@@ -104,9 +106,9 @@ export const gro_plugin_gen = ({
 			});
 		},
 		teardown: async () => {
-			if (cleanup !== undefined) {
-				await cleanup();
-				cleanup = undefined;
+			if (cleanup_watch) {
+				await cleanup_watch();
+				cleanup_watch = undefined;
 			}
 		},
 	};

package/src/lib/gro_plugin_server.ts

@@ -12,7 +12,6 @@ import type {Plugin} from './plugin.ts';
 import {base_path_to_path_id, LIB_DIRNAME, paths} from './paths.ts';
 import type {Path_Id} from './path.ts';
 import {GRO_DEV_DIRNAME, SERVER_DIST_PATH} from './constants.ts';
-import {watch_dir, type Watch_Node_Fs} from './watch_dir.ts';
 import {parse_svelte_config, default_svelte_config} from './svelte_config.ts';
 import {esbuild_plugin_sveltekit_shim_app} from './esbuild_plugin_sveltekit_shim_app.ts';
 import {esbuild_plugin_sveltekit_shim_env} from './esbuild_plugin_sveltekit_shim_env.ts';
@@ -122,14 +121,14 @@ export const gro_plugin_server = ({
 	cli_command,
 	run, // `dev` default is not available in this scope
 }: Gro_Plugin_Server_Options = {}): Plugin => {
-	let build_ctx: esbuild.BuildContext | null = null;
-	let watcher: Watch_Node_Fs | null = null;
-	let server_process: Restartable_Process | null = null;
-	let deps: Set<Path_Id> | null = null;
+	let build_ctx: esbuild.BuildContext | undefined;
+	let cleanup_watch: (() => void) | undefined;
+	let server_process: Restartable_Process | undefined;
+	let deps: Set<Path_Id> | undefined;
 
 	return {
 		name: 'gro_plugin_server',
-		setup: async ({dev, watch, timings, log, config}) => {
+		setup: async ({dev, watch, timings, log, config, filer}) => {
 			const parsed_svelte_config =
 				!svelte_config && strip_end(dir, '/') === process.cwd()
 					? default_svelte_config
@@ -231,22 +230,13 @@ export const gro_plugin_server = ({
 
 			await rebuild();
 
-			// uses chokidar instead of esbuild's watcher for efficiency
 			if (watch) {
-				let watcher_ready = false;
-				// TODO maybe reuse this watcher globally via an option,
-				// because it watches all of `$lib`, and that means it excludes `$routes`
-				// while also including a lot of client files we don't care about,
-				// but we can't discern which of `$lib` to watch ahead of time
-				watcher = watch_dir({
-					dir: paths.lib,
-					on_change: (change) => {
-						if (!watcher_ready || !deps?.has(change.path)) return;
-						void rebuild();
-					},
+				cleanup_watch = await filer.watch((change) => {
+					if (!deps?.has(change.path)) {
+						return;
+					}
+					void rebuild();
 				});
-				await watcher.init();
-				watcher_ready = true;
 			}
 
 			if (!existsSync(server_outpath)) {
@@ -263,16 +253,20 @@ export const gro_plugin_server = ({
 			}
 		},
 		teardown: async () => {
+			if (cleanup_watch) {
+				cleanup_watch();
+				cleanup_watch = undefined;
+			}
+
 			if (server_process) {
 				const s = server_process; // avoid possible issue where a build is in progress, don't want to issue a restart, could be fixed upstream in `spawn_restartable_process`
-				server_process = null;
+				server_process = undefined;
 				await s.kill();
 			}
-			if (watcher) {
-				await watcher.close();
-			}
+
 			if (build_ctx) {
 				await build_ctx.dispose();
+				build_ctx = undefined;
 			}
 		},
 	};

package/src/lib/gro_plugin_sveltekit_app.ts

@@ -10,8 +10,7 @@ import {find_cli, spawn_cli, spawn_cli_process} from './cli.ts';
 import {type Map_Src_Json, serialize_src_json, create_src_json} from './src_json.ts';
 import {EXPORTS_EXCLUDER_DEFAULT} from './gro_config.ts';
 import {default_svelte_config} from './svelte_config.ts';
-import {SOURCE_DIRNAME} from './constants.ts';
-import {VITE_CLI} from './sveltekit_helpers.ts';
+import {SOURCE_DIRNAME, VITE_CLI} from './constants.ts';
 
 export interface Gro_Plugin_Sveltekit_App_Options {
 	/**

package/src/lib/gro_plugin_sveltekit_library.ts

@@ -3,11 +3,8 @@ import {print_spawn_result, spawn} from '@ryanatkn/belt/process.js';
 import type {Plugin} from './plugin.ts';
 import {Task_Error} from './task.ts';
 import {load_package_json} from './package_json.ts';
-import {
-	SVELTE_PACKAGE_CLI,
-	run_svelte_package,
-	type Svelte_Package_Options,
-} from './sveltekit_helpers.ts';
+import {run_svelte_package, type Svelte_Package_Options} from './sveltekit_helpers.ts';
+import {SVELTE_PACKAGE_CLI} from './constants.ts';
 
 export interface Gro_Plugin_Sveltekit_Library_Options {
 	/**

package/src/lib/invoke.ts

@@ -1,7 +1,6 @@
 import {attach_process_error_handlers} from '@ryanatkn/belt/process.js';
 import {configure_log_colors} from '@ryanatkn/belt/log.js';
-import {set_colors} from '@ryanatkn/belt/print.js';
-import {styleText} from 'node:util';
+import {configure_print_colors} from '@ryanatkn/belt/print.js';
 
 import {invoke_task} from './invoke_task.ts';
 import {to_task_args} from './args.ts';
@@ -25,8 +24,11 @@ attach_process_error_handlers(
 	(err) => (err.constructor.name === 'Silent_Error' ? '' : null),
 );
 
-configure_log_colors(styleText);
-set_colors(styleText);
+if (!process.env.NO_COLOR) {
+	const {styleText} = await import('node:util');
+	configure_log_colors(styleText);
+	configure_print_colors(styleText);
+}
 
 await sveltekit_sync_if_obviously_needed();
 

package/src/lib/package.gen.ts

@@ -13,6 +13,10 @@ import type {Gen} from './gen.ts';
  */
 export const gen: Gen = ({origin_path}) => {
 	const package_json = load_package_json();
+	// TODO this can error with bad json data, do we need to update the package.json here first?
+	// similarly do this in other places too?
+	// part of the problem is that the package_json actually has a dependency on each of its exports and their deps,
+	// but only when they're added/removed right? see gro_plugin_gen for details
 	const src_json = create_src_json(package_json, undefined);
 
 	const is_this_belt = package_json.name === '@ryanatkn/belt'; // TODO more robust?