@ryanatkn/gro 0.135.1 → 0.135.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.135.1",
+  "version": "0.135.3",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -56,7 +56,7 @@
     "esm-env": "^1.0.0",
     "mri": "^1.2.0",
     "prettier": "^3.3.3",
-    "prettier-plugin-svelte": "^3.2.6",
+    "prettier-plugin-svelte": "^3.2.7",
     "ts-morph": "^23.0.0",
     "tslib": "^2.7.0",
     "zod": "^3.23.8"
@@ -68,22 +68,22 @@
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.0",
     "@changesets/types": "^6.0.0",
-    "@ryanatkn/eslint-config": "^0.5.3",
-    "@ryanatkn/fuz": "^0.124.4",
+    "@ryanatkn/eslint-config": "^0.5.4",
+    "@ryanatkn/fuz": "^0.129.0",
     "@ryanatkn/moss": "^0.16.1",
     "@sveltejs/adapter-static": "^3.0.5",
-    "@sveltejs/kit": "^2.5.28",
+    "@sveltejs/kit": "^2.6.1",
     "@sveltejs/package": "^2.3.5",
     "@sveltejs/vite-plugin-svelte": "^3.1.2",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.5.5",
+    "@types/node": "^22.7.4",
     "esbuild": "^0.21.5",
-    "eslint": "^9.11.0",
-    "eslint-plugin-svelte": "^2.44.0",
-    "svelte": "^5.0.0-next.257",
-    "svelte-check": "^4.0.2",
+    "eslint": "^9.11.1",
+    "eslint-plugin-svelte": "^2.44.1",
+    "svelte": "^5.0.0-next.260",
+    "svelte-check": "^4.0.4",
     "typescript": "^5.6.2",
-    "typescript-eslint": "^8.6.0",
+    "typescript-eslint": "^8.7.0",
     "uvu": "^0.5.6"
   },
   "prettier": {
@@ -198,6 +198,10 @@
       "types": "./dist/esbuild_plugin_sveltekit_shim_env.d.ts",
       "default": "./dist/esbuild_plugin_sveltekit_shim_env.js"
     },
+    "./filer.js": {
+      "types": "./dist/filer.d.ts",
+      "default": "./dist/filer.js"
+    },
     "./format_directory.js": {
       "types": "./dist/format_directory.d.ts",
       "default": "./dist/format_directory.js"
@@ -310,6 +314,10 @@
       "types": "./dist/package.d.ts",
       "default": "./dist/package.js"
     },
+    "./parse_imports.js": {
+      "types": "./dist/parse_imports.d.ts",
+      "default": "./dist/parse_imports.js"
+    },
     "./path_constants.js": {
       "types": "./dist/path_constants.d.ts",
       "default": "./dist/path_constants.js"

package/src/lib/filer.ts

@@ -0,0 +1,212 @@
+import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
+import {existsSync, readFileSync} from 'node:fs';
+import {dirname, resolve} from 'node:path';
+import type {Omit_Strict} from '@ryanatkn/belt/types.js';
+import {wait} from '@ryanatkn/belt/async.js';
+
+import type {Path_Id} from './path.js';
+import {
+	watch_dir,
+	type Watch_Node_Fs,
+	type Watcher_Change,
+	type Options as Watch_Dir_Options,
+	type Watcher_Change_Callback,
+} from './watch_dir.js';
+import {default_file_filter, paths} from './paths.js';
+import {parse_imports} from './parse_imports.js';
+import {resolve_specifier} from './resolve_specifier.js';
+import {default_sveltekit_config} from './sveltekit_config.js';
+import {map_sveltekit_aliases} from './sveltekit_helpers.js';
+import {Unreachable_Error} from '@ryanatkn/belt/error.js';
+
+const aliases = Object.entries(default_sveltekit_config.alias);
+
+export interface Source_File {
+	id: Path_Id;
+	/**
+	 * `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;
+	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 interface Options {
+	watch_dir?: typeof watch_dir;
+	watch_dir_options?: Partial<Omit_Strict<Watch_Dir_Options, 'on_change'>>;
+}
+
+export class Filer {
+	files: Map<Path_Id, Source_File> = new Map();
+
+	#watch_dir: typeof watch_dir;
+	#watch_dir_options: Partial<Watch_Dir_Options>;
+
+	constructor(options: Options = EMPTY_OBJECT) {
+		this.#watch_dir = options.watch_dir ?? watch_dir;
+		this.#watch_dir_options = options.watch_dir_options ?? EMPTY_OBJECT;
+	}
+
+	#watching: Watch_Node_Fs | undefined;
+	#listeners: Set<On_Filer_Change> = new Set();
+
+	#ready = false;
+
+	get_by_id = (id: Path_Id): Source_File | undefined => {
+		return this.files.get(id);
+	};
+
+	get_or_create = (id: Path_Id): Source_File => {
+		const existing = this.get_by_id(id);
+		if (existing) return existing;
+		const file: Source_File = {
+			id,
+			contents: null,
+			dependents: new Map(),
+			dependencies: new Map(),
+		};
+		this.files.set(id, file);
+		return file;
+	};
+
+	#update(id: Path_Id): Source_File {
+		const file = this.get_or_create(id);
+		const new_contents = existsSync(id) ? readFileSync(id, 'utf8') : null;
+		const contents_changed = file.contents !== new_contents;
+		file.contents = new_contents;
+
+		if (contents_changed) {
+			const dir = dirname(file.id);
+
+			const dependencies_before = new Set(file.dependencies.keys());
+			const dependencies_removed = new Set(dependencies_before);
+
+			const imported = file.contents ? parse_imports(file.id, file.contents) : [];
+			for (const specifier of imported) {
+				// TODO logic is duplicated from loader
+				const path = map_sveltekit_aliases(specifier, aliases);
+
+				// The specifier `path` has now been mapped to its final form, so we can inspect it.
+				if (path[0] === '.' || path[0] === '/') {
+					const {path_id} = resolve_specifier(path, dir);
+					dependencies_removed.delete(path_id);
+					if (!dependencies_before.has(path_id)) {
+						const d = this.get_or_create(path_id);
+						file.dependencies.set(d.id, d);
+						d.dependents.set(file.id, file);
+					}
+				}
+			}
+
+			// update any removed dependencies
+			for (const dependency_removed of dependencies_removed) {
+				const deleted1 = file.dependencies.delete(dependency_removed);
+				if (!deleted1) throw Error('expected to delete1 ' + file.id); // TODO @many delete if correct
+				const dependency_removed_file = this.get_or_create(dependency_removed);
+				const deleted2 = dependency_removed_file.dependents.delete(file.id);
+				if (!deleted2) throw Error('expected to delete2 ' + file.id); // TODO @many delete if correct
+			}
+		}
+
+		return file;
+	}
+
+	#remove(id: Path_Id): Source_File | undefined {
+		const file = this.get_by_id(id);
+		if (!file) return; // this is safe because the object would exist if any other file referenced it as a dependency or dependent
+
+		file.contents = null; // clear contents in case it gets re-added later, we want the change to be detected
+
+		let found = false;
+		for (const d of this.files.values()) {
+			if (d.dependencies.has(file.id)) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) this.files.delete(id);
+
+		return file;
+	}
+
+	#notify_listener(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 {
+		if (!this.#ready) return;
+		for (const listener of this.#listeners) {
+			listener(change, source_file);
+		}
+	}
+
+	async #add_listener(listener: On_Filer_Change): Promise<void> {
+		this.#listeners.add(listener);
+		if (this.#watching) {
+			// 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);
+			return;
+		}
+		this.#watching = this.#watch_dir({
+			filter: (path, is_directory) => (is_directory ? true : default_file_filter(path)),
+			...this.#watch_dir_options,
+			dir: resolve(this.#watch_dir_options.dir ?? paths.source),
+			on_change: this.#on_change,
+		});
+		await this.#watching.init();
+		this.#ready = true;
+		this.#notify_listener(listener);
+	}
+
+	async #remove_listener(listener: On_Filer_Change): Promise<void> {
+		this.#listeners.delete(listener);
+		if (this.#listeners.size === 0) {
+			await this.close(); // TODO is this right? should `watch` be async?
+		}
+	}
+
+	#on_change: Watcher_Change_Callback = (change) => {
+		if (change.is_directory) return;
+		let source_file: Source_File | undefined;
+		switch (change.type) {
+			case 'add':
+			case 'update': {
+				source_file = this.#update(change.path);
+				break;
+			}
+			case 'delete': {
+				source_file = this.#remove(change.path);
+				break;
+			}
+			default:
+				throw new Unreachable_Error(change.type);
+		}
+		if (source_file) {
+			this.#notify_change(change, source_file);
+		}
+	};
+
+	async watch(listener: On_Filer_Change): Promise<Cleanup_Watch> {
+		await this.#add_listener(listener);
+		return () => this.#remove_listener(listener);
+	}
+
+	async close(): Promise<void> {
+		this.#ready = false;
+		this.#listeners.clear();
+		if (this.#watching) {
+			await this.#watching.close();
+			this.#watching = undefined;
+		}
+	}
+}

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

@@ -3,6 +3,7 @@ import {gro_plugin_sveltekit_library} from './gro_plugin_sveltekit_library.js';
 import {has_server, gro_plugin_server} from './gro_plugin_server.js';
 import {gro_plugin_sveltekit_app} from './gro_plugin_sveltekit_app.js';
 import {has_sveltekit_app, has_sveltekit_library} from './sveltekit_helpers.js';
+import {gro_plugin_gen} from './gro_plugin_gen.js';
 
 /**
  * This is the default config that's passed to `gro.config.ts`
@@ -23,9 +24,7 @@ const config: Create_Gro_Config = async (cfg) => {
 		has_sveltekit_app_result.ok
 			? gro_plugin_sveltekit_app({host_target: has_server_result.ok ? 'node' : 'github_pages'})
 			: null,
-		// TODO replace with an esbuild plugin, see the module for more
-		// import {gro_plugin_gen} from './gro_plugin_gen.js';
-		// gro_plugin_gen(),
+		gro_plugin_gen(),
 	];
 
 	return cfg;

package/src/lib/gro_plugin_gen.ts

@@ -1,13 +1,14 @@
-// TODO this became unused with https://github.com/ryanatkn/gro/pull/382
-// because we no longer have a normal system build - replace with an esbuild plugin
-// @ts-nocheck
+import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
 
-import type {Plugin, Plugin_Context} from './plugin.js';
+import type {Plugin} from './plugin.js';
 import type {Args} from './args.js';
-import {path_id_to_base_path} from './paths.js';
+import {paths} from './paths.js';
 import {find_genfiles, is_gen_path} from './gen.js';
-import {filter_dependents} from './build/source_file.js';
 import {throttle} from './throttle.js';
+import {spawn_cli} from './cli.js';
+import type {File_Filter, Path_Id} from './path.js';
+import type {Cleanup_Watch, Source_File} from './filer.js';
+import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 
 const FLUSH_DEBOUNCE_DELAY = 500;
 
@@ -15,14 +16,28 @@ export interface Task_Args extends Args {
 	watch?: boolean;
 }
 
-export const plugin = (): Plugin<Plugin_Context<Task_Args>> => {
+export interface Options {
+	root_dirs?: string[];
+	flush_debounce_delay?: number;
+}
+
+export const gro_plugin_gen = ({
+	root_dirs = [paths.source],
+	flush_debounce_delay = FLUSH_DEBOUNCE_DELAY,
+}: Options = EMPTY_OBJECT): Plugin => {
+	const input_path = paths.source; // TODO option?
 	let generating = false;
 	let regen = false;
-	let on_filer_build: ((e: Filer_Events['build']) => void) | undefined;
+	let flushing_timeout: NodeJS.Timeout | undefined;
 	const queued_files: Set<string> = new Set();
-	const queue_gen = (gen_file_name: string) => {
-		queued_files.add(gen_file_name);
-		void flush_gen_queue();
+	const queue_gen = (gen_file_id: string) => {
+		queued_files.add(gen_file_id);
+		if (flushing_timeout === undefined) {
+			flushing_timeout = setTimeout(() => {
+				flushing_timeout = undefined;
+				void flush_gen_queue();
+			}); // the timeout batches synchronously
+		}
 	};
 	const flush_gen_queue = throttle(async () => {
 		// hacky way to avoid concurrent `gro gen` calls
@@ -39,57 +54,89 @@ export const plugin = (): Plugin<Plugin_Context<Task_Args>> => {
 			regen = false;
 			void flush_gen_queue();
 		}
-	}, FLUSH_DEBOUNCE_DELAY);
+	}, flush_debounce_delay);
 	const gen = (files: string[] = []) => spawn_cli('gro', ['gen', ...files]);
 
+	let cleanup: Cleanup_Watch | undefined;
+
 	return {
 		name: 'gro_plugin_gen',
-		setup: async ({args: {watch}, dev, log, config}) => {
+		setup: async ({watch, dev, log, config, filer}) => {
 			// For production builds, we assume `gen` is already fresh,
 			// which should be checked by CI via `gro check` which calls `gro gen --check`.
 			if (!dev) return;
 
-			// Run `gen`, first checking if there are any modules to avoid a console error.
-			// Some parts of the build may have already happened,
-			// making us miss `build` events for gen dependencies,
-			// so we run `gen` here even if it's usually wasteful.
-			const found = find_genfiles([paths.source], root_dirs, config);
-			if (found.ok && found.value.resolved_input_files.size > 0) {
-				await gen();
-			}
-
 			// Do we need to just generate everything once and exit?
 			// TODO could we have an esbuild context here? problem is watching the right files, maybe a plugin that tracks deps
-			if (!filer || !watch) {
+			if (!watch) {
 				log.info('generating and exiting early');
+
+				// Run `gen`, first checking if there are any modules to avoid a console error.
+				// Some parts of the build may have already happened,
+				// making us miss `build` events for gen dependencies,
+				// so we run `gen` here even if it's usually wasteful.
+				const found = find_genfiles([input_path], root_dirs, config);
+				if (found.ok && found.value.resolved_input_files.length > 0) {
+					await gen();
+				}
 				return;
 			}
 
 			// When a file builds, check it and its tree of dependents
 			// for any `.gen.` files that need to run.
-			on_filer_build = ({source_file, build_config}) => {
-				// TODO how to handle this now? the loader traces deps for us with `parentPath`,
-				// but we probably want to make this an esbuild plugin instead
-				// if (build_config.name !== 'system') return;
-				if (is_gen_path(source_file.id)) {
-					queue_gen(path_id_to_base_path(source_file.id));
-				}
-				const dependent_gen_file_ids = filter_dependents(
-					source_file,
-					build_config,
-					filer.find_by_id as any, // cast because we can assume they're all `SourceFile`s
-					is_gen_path,
-				);
-				for (const dependent_gen_file_id of dependent_gen_file_ids) {
-					queue_gen(path_id_to_base_path(dependent_gen_file_id));
+			cleanup = await filer.watch((change, source_file) => {
+				switch (change.type) {
+					case 'add':
+					case 'update': {
+						// TODO how to handle this now? the loader traces deps for us with `parentPath`,
+						// but we probably want to make this an esbuild plugin instead
+						if (is_gen_path(source_file.id)) {
+							queue_gen(source_file.id);
+						}
+						const dependent_gen_file_ids = filter_dependents(
+							source_file,
+							filer.get_by_id,
+							is_gen_path,
+						);
+						for (const dependent_gen_file_id of dependent_gen_file_ids) {
+							queue_gen(dependent_gen_file_id);
+						}
+						break;
+					}
+					case 'delete': {
+						// TODO delete the generated file(s)? option?
+						break;
+					}
+					default:
+						throw new Unreachable_Error(change.type);
 				}
-			};
-			filer.on('build', on_filer_build);
+			});
 		},
-		teardown: ({filer}) => {
-			if (on_filer_build && filer) {
-				filer.off('build', on_filer_build);
+		teardown: async () => {
+			if (cleanup !== undefined) {
+				await cleanup();
+				cleanup = undefined;
 			}
 		},
 	};
 };
+
+export const filter_dependents = (
+	source_file: Source_File,
+	get_by_id: (id: Path_Id) => Source_File | undefined,
+	filter?: File_Filter,
+	results: Set<string> = new Set(),
+	searched: Set<string> = new Set(),
+): Set<string> => {
+	const {dependents} = source_file;
+	for (const dependent_id of dependents.keys()) {
+		if (searched.has(dependent_id)) continue;
+		searched.add(dependent_id);
+		if (!filter || filter(dependent_id)) {
+			results.add(dependent_id);
+		}
+		const dependent_source_File = get_by_id(dependent_id)!;
+		filter_dependents(dependent_source_File, get_by_id, filter, results, searched);
+	}
+	return results;
+};

package/src/lib/gro_plugin_sveltekit_library.ts

@@ -3,11 +3,9 @@ import {print_spawn_result, spawn} from '@ryanatkn/belt/process.js';
 import type {Plugin} from './plugin.js';
 import {Task_Error} from './task.js';
 import {load_package_json} from './package_json.js';
-import {serialize_args, to_forwarded_args} from './args.js';
-import {find_cli, spawn_cli} from './cli.js';
 import {
 	SVELTE_PACKAGE_CLI,
-	has_sveltekit_library,
+	run_svelte_package,
 	type Svelte_Package_Options,
 } from './sveltekit_helpers.js';
 
@@ -30,24 +28,10 @@ export const gro_plugin_sveltekit_library = ({
 }: Options = {}): Plugin => {
 	return {
 		name: 'gro_plugin_sveltekit_library',
-		setup: async ({log}) => {
-			const has_sveltekit_library_result = has_sveltekit_library();
-			if (!has_sveltekit_library_result.ok) {
-				throw new Task_Error(
-					'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,
-				);
-			}
-			const found_svelte_package_cli = find_cli(svelte_package_cli);
-			if (found_svelte_package_cli?.kind !== 'local') {
-				throw new Task_Error(
-					`Failed to find SvelteKit packaging CLI \`${svelte_package_cli}\`, do you need to run \`npm i\`?`,
-				);
+		setup: async ({dev, log}) => {
+			if (!dev) {
+				await run_svelte_package(svelte_package_options, svelte_package_cli, log);
 			}
-			const serialized_args = serialize_args({
-				...svelte_package_options,
-				...to_forwarded_args(svelte_package_cli),
-			});
-			await spawn_cli(found_svelte_package_cli, serialized_args, log);
 		},
 		adapt: async ({log, timings}) => {
 			const package_json = load_package_json();

package/src/lib/invoke_task.ts

@@ -10,6 +10,7 @@ import {find_tasks, load_tasks, Silent_Error} from './task.js';
 import {load_gro_package_json} from './package_json.js';
 import {log_tasks, log_error_reasons} from './task_logging.js';
 import type {Gro_Config} from './gro_config.js';
+import {Filer} from './filer.js';
 
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
@@ -37,11 +38,14 @@ export const invoke_task = async (
 	task_name: Raw_Input_Path,
 	args: Args | undefined,
 	config: Gro_Config,
-	initial_timings: Timings | null = null,
+	initial_filer?: Filer,
+	initial_timings?: Timings | null,
 ): Promise<void> => {
 	const log = new System_Logger(print_log_label(task_name || 'gro'));
 	log.info('invoking', task_name ? st('cyan', task_name) : 'gro');
 
+	const filer = initial_filer ?? new Filer();
+
 	const timings = initial_timings ?? new Timings();
 
 	const total_timing = create_stopwatch();
@@ -104,6 +108,7 @@ export const invoke_task = async (
 		{...args, ...to_forwarded_args(`gro ${task.name}`)},
 		invoke_task,
 		config,
+		filer,
 		timings,
 	);
 	timing_to_run_task();

package/src/lib/loader.ts

@@ -22,6 +22,7 @@ import {to_define_import_meta_env, default_ts_transform_options} from './esbuild
 import {resolve_specifier} from './resolve_specifier.js';
 import {resolve_node_specifier} from './resolve_node_specifier.js';
 import type {Package_Json} from './package_json.js';
+import {map_sveltekit_aliases} from './sveltekit_helpers.js';
 
 /*
 
@@ -73,7 +74,7 @@ const ts_transform_options: esbuild.TransformOptions = {
 	sourcemap: 'inline',
 };
 
-const aliases = Object.entries({$lib: 'src/lib', ...alias});
+const aliases = Object.entries(alias);
 
 const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
@@ -197,15 +198,7 @@ export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
 		return nextResolve(shimmed, context);
 	}
 
-	let path = specifier;
-
-	// Map the path with the SvelteKit aliases.
-	for (const [from, to] of aliases) {
-		if (path.startsWith(from)) {
-			path = join(dir, to, path.substring(from.length));
-			break;
-		}
-	}
+	const path = map_sveltekit_aliases(specifier, aliases);
 
 	// The specifier `path` has now been mapped to its final form, so we can inspect it.
 	if (path[0] !== '.' && path[0] !== '/') {