@fuzdev/gro 0.192.0

package/src/lib/gro_plugin_gen.ts

@@ -0,0 +1,149 @@
+import type {Args} from '@fuzdev/fuz_util/args.js';
+import {UnreachableError} from '@fuzdev/fuz_util/error.js';
+import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
+import {throttle} from '@fuzdev/fuz_util/throttle.js';
+
+import type {Plugin} from './plugin.ts';
+import {paths} from './paths.ts';
+import {find_genfiles, is_gen_path} from './gen.ts';
+import {filter_dependents} from './filer.ts';
+import {should_trigger_gen} from './gen_helpers.ts';
+import {spawn_cli} from './cli.ts';
+
+const FLUSH_DEBOUNCE_DELAY = 500;
+
+// TODO is cache busting a good idea here to speed up and run in-process?
+// 	await invoke_task('gen', {_: files, bust_cache: true});
+const gen = (files: Array<string> = []) => spawn_cli('gro', ['gen', ...files]);
+
+export interface TaskArgs extends Args {
+	watch?: boolean;
+}
+
+export interface GroPluginGenOptions {
+	input_paths?: Array<string>;
+	root_dirs?: Array<string>;
+	flush_debounce_delay?: number;
+}
+
+export const gro_plugin_gen = ({
+	input_paths = [paths.source],
+	root_dirs = [paths.source],
+	flush_debounce_delay = FLUSH_DEBOUNCE_DELAY,
+}: GroPluginGenOptions = EMPTY_OBJECT): Plugin => {
+	const queued_files: Set<string> = new Set();
+
+	let cleanup_watch: (() => void) | undefined;
+
+	return {
+		name: 'gro_plugin_gen',
+		setup: async ({watch, dev, log, config, filer, invoke_task, timings}) => {
+			// 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;
+
+			// Do we need to just generate everything once and exit?
+			if (!watch) {
+				// 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 a full `gen` here even if it's usually wasteful.
+				const found = await find_genfiles(input_paths, root_dirs, config);
+				if (found.ok && found.value.resolved_input_files.length > 0) {
+					await gen();
+				}
+				return;
+			}
+
+			const queue_gen = (gen_file_id: string) => {
+				queued_files.add(gen_file_id);
+				void flush_gen_queue();
+			};
+
+			const flush_gen_queue = throttle(
+				async () => {
+					const files = Array.from(queued_files);
+					log.info(
+						files.length === 0
+							? '[gen] generating all files'
+							: `[gen] generating ${files.length} file${files.length === 1 ? '' : 's'}`,
+					);
+					queued_files.clear();
+					await gen(files);
+
+					// run again?
+					if (queued_files.size > 0) {
+						log.info(
+							`[gen] re-running for ${queued_files.size} more queued file${queued_files.size === 1 ? '' : 's'}`,
+						);
+						setTimeout(flush_gen_queue); // setTimeout is needed bc of throttle behavior
+					} else {
+						log.info('[gen] queue empty, done');
+					}
+				},
+				{delay: flush_debounce_delay, when: 'trailing'},
+			);
+
+			// When a file builds, check it and its tree of dependents
+			// for any `.gen.` files that need to run.
+			cleanup_watch = await filer.watch(async (change, source_file) => {
+				if (source_file.external) return;
+				switch (change.type) {
+					case 'add':
+					case 'update': {
+						// Queue the gen file itself if it changed
+						if (is_gen_path(source_file.id)) {
+							queue_gen(source_file.id);
+						}
+
+						// Find all current gen files and check their dependencies
+						const gen_files = filer.filter((d) => !d.external && is_gen_path(d.id));
+						if (gen_files) {
+							for (const gen_file of gen_files) {
+								// eslint-disable-next-line no-await-in-loop
+								const should_trigger = await should_trigger_gen(
+									gen_file.id,
+									source_file.id,
+									config,
+									filer,
+									log,
+									timings,
+									invoke_task,
+								);
+								if (should_trigger) {
+									queue_gen(gen_file.id);
+								}
+							}
+						}
+
+						// Check import-based dependents
+						const dependent_gen_file_ids = filter_dependents(
+							source_file,
+							filer.get_by_id,
+							is_gen_path,
+							undefined,
+							undefined,
+							log,
+						);
+						for (const dependent_gen_file_id of dependent_gen_file_ids) {
+							queue_gen(dependent_gen_file_id);
+						}
+						break;
+					}
+					case 'delete': {
+						// I think for the gen plugin this is best as a no-op? avoids broken attempts
+						break;
+					}
+					default:
+						throw new UnreachableError(change.type);
+				}
+			});
+		},
+		teardown: () => {
+			if (cleanup_watch) {
+				cleanup_watch();
+				cleanup_watch = undefined;
+			}
+		},
+	};
+};

package/src/lib/gro_plugin_server.ts

@@ -0,0 +1,288 @@
+import {spawn_restartable_process, type RestartableProcess} from '@fuzdev/fuz_util/process.js';
+import * as esbuild from 'esbuild';
+import type {Config as SvelteConfig} from '@sveltejs/kit';
+import {join, resolve} from 'node:path';
+import {identity} from '@fuzdev/fuz_util/function.js';
+import {strip_before, strip_end} from '@fuzdev/fuz_util/string.js';
+import type {Result} from '@fuzdev/fuz_util/result.js';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
+import {throttle} from '@fuzdev/fuz_util/throttle.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+
+import type {Plugin} from './plugin.ts';
+import {base_path_to_path_id, LIB_DIRNAME, paths} from './paths.ts';
+import {GRO_DEV_DIRNAME, SERVER_DIST_PATH} from './constants.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';
+import {print_build_result, to_define_import_meta_env} from './esbuild_helpers.ts';
+import {esbuild_plugin_sveltekit_shim_alias} from './esbuild_plugin_sveltekit_shim_alias.ts';
+import {esbuild_plugin_external_worker} from './esbuild_plugin_external_worker.ts';
+import {esbuild_plugin_sveltekit_local_imports} from './esbuild_plugin_sveltekit_local_imports.ts';
+import {esbuild_plugin_svelte} from './esbuild_plugin_svelte.ts';
+
+// TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
+
+export const SERVER_SOURCE_ID = base_path_to_path_id(LIB_DIRNAME + '/server/server.ts');
+
+export const has_server = async (
+	path = SERVER_SOURCE_ID,
+): Promise<Result<object, {message: string}>> => {
+	if (!(await fs_exists(path))) {
+		return {ok: false, message: `no server file found at ${path}`};
+	}
+	return {ok: true};
+};
+
+export interface GroPluginServerOptions {
+	/**
+	 * same as esbuild's `entryPoints`
+	 */
+	entry_points?: Array<string>;
+	/**
+	 * @default cwd
+	 */
+	dir?: string;
+	/**
+	 * Returns the `Outpaths` given a `dev` param.
+	 * Decoupling this from plugin creation allows it to be created generically,
+	 * so the build and dev tasks can be the source of truth for `dev`.
+	 */
+	outpaths?: CreateOutpaths;
+	/**
+	 * @default ```SvelteKit's `.env`, `.env.development`, and `.env.production````
+	 */
+	env_files?: Array<string>;
+	/**
+	 * @default process.env
+	 */
+	ambient_env?: Record<string, string>;
+	/**
+	 * @default ```loaded from `${cwd}/${SVELTE_CONFIG_FILENAME}````
+	 */
+	svelte_config?: SvelteConfig;
+	/**
+	 * @default 'esnext'
+	 */
+	target?: string;
+	/**
+	 * Optionally map the esbuild options.
+	 * @default identity
+	 */
+	esbuild_build_options?: (base_options: esbuild.BuildOptions) => esbuild.BuildOptions;
+	/**
+	 * Milliseconds to throttle rebuilds.
+	 * Should be longer than it takes to build to avoid backpressure.
+	 * @default 1000
+	 */
+	rebuild_throttle_delay?: number; // TODO could detect the backpressure problem and at least warn, shouldn't be a big deal
+	/**
+	 * The CLI command to run the server, like `'node'` or `'bun'` or `'deno'`.
+	 * Receives the path to the server js file as its argument.
+	 * @default 'node'
+	 */
+	cli_command?: string;
+	/**
+	 * Whether to run the server or not after building.
+	 * @default dev
+	 */
+	run?: boolean;
+}
+
+export interface Outpaths {
+	/**
+	 * @default '.gro/dev' or 'dist_server'
+	 */
+	outdir: string;
+	/**
+	 * @default 'src/lib'
+	 */
+	outbase: string;
+	/**
+	 * @default 'server.js'
+	 */
+	outname: string;
+}
+
+export type CreateOutpaths = (dev: boolean) => Outpaths;
+
+export const gro_plugin_server = ({
+	entry_points = [SERVER_SOURCE_ID],
+	dir = process.cwd(),
+	outpaths = (dev) => ({
+		outdir: join(dir, dev ? GRO_DEV_DIRNAME : SERVER_DIST_PATH),
+		outbase: paths.lib,
+		outname: 'server/server.js',
+	}),
+	env_files,
+	ambient_env,
+	svelte_config,
+	target = 'esnext',
+	esbuild_build_options = identity,
+	rebuild_throttle_delay = 1000,
+	cli_command,
+	run, // `dev` default is not available in this scope
+}: GroPluginServerOptions = {}): Plugin => {
+	let build_ctx: esbuild.BuildContext | undefined;
+	let cleanup_watch: (() => void) | undefined;
+	let server_process: RestartableProcess | undefined;
+	let deps: Set<PathId> | undefined;
+
+	return {
+		name: 'gro_plugin_server',
+		setup: async ({dev, watch, timings, log, config, filer}) => {
+			const parsed_svelte_config =
+				!svelte_config && strip_end(dir, '/') === process.cwd()
+					? default_svelte_config
+					: await parse_svelte_config({
+							dir_or_config: svelte_config ?? dir,
+							config_filename: config.svelte_config_filename,
+						});
+			const {
+				alias,
+				base_url,
+				assets_url,
+				env_dir,
+				private_prefix,
+				public_prefix,
+				svelte_compile_options,
+				svelte_compile_module_options,
+				svelte_preprocessors,
+			} = parsed_svelte_config;
+
+			const {outbase, outdir, outname} = outpaths(dev);
+
+			const server_outpath = join(outdir, outname);
+
+			const timing_to_esbuild_create_context = timings.start('create build context');
+
+			const build_options = esbuild_build_options({
+				outdir,
+				outbase,
+				format: 'esm',
+				platform: 'node',
+				packages: 'external',
+				bundle: true,
+				target,
+				metafile: watch,
+			});
+
+			build_ctx = await esbuild.context({
+				entryPoints: entry_points.map((path) => resolve(dir, path)),
+				plugins: [
+					esbuild_plugin_sveltekit_shim_app({dev, base_url, assets_url}),
+					esbuild_plugin_sveltekit_shim_env({
+						dev,
+						public_prefix,
+						private_prefix,
+						env_dir,
+						env_files,
+						ambient_env,
+					}),
+					esbuild_plugin_sveltekit_shim_alias({dir, alias}),
+					esbuild_plugin_external_worker({
+						dev,
+						build_options,
+						dir,
+						svelte_compile_options,
+						svelte_compile_module_options,
+						svelte_preprocessors,
+						alias,
+						base_url,
+						public_prefix,
+						private_prefix,
+						env_dir,
+						env_files,
+						ambient_env,
+						log,
+					}),
+					esbuild_plugin_svelte({
+						dev,
+						base_url,
+						dir,
+						svelte_compile_options,
+						svelte_compile_module_options,
+						svelte_preprocessors,
+					}),
+					esbuild_plugin_sveltekit_local_imports(),
+				],
+				define: to_define_import_meta_env(dev, base_url),
+				...build_options,
+			});
+
+			timing_to_esbuild_create_context();
+
+			const rebuild = throttle(
+				async () => {
+					let build_result;
+					try {
+						build_result = await build_ctx!.rebuild();
+					} catch (error) {
+						log.error('[gro_plugin_server] build failed', error);
+						return;
+					}
+					const {metafile} = build_result;
+					if (!metafile) return;
+					print_build_result(log, build_result);
+					deps = parse_deps(metafile.inputs, dir);
+					void server_process?.restart();
+				},
+				{delay: rebuild_throttle_delay},
+			);
+
+			await rebuild();
+
+			if (watch) {
+				cleanup_watch = await filer.watch((change) => {
+					if (!deps?.has(change.path)) {
+						return;
+					}
+					void rebuild();
+				});
+			}
+
+			if (!(await fs_exists(server_outpath))) {
+				throw Error(`Node server failed to start due to missing file: ${server_outpath}`);
+			}
+
+			if (run || dev) {
+				const cli_args = [];
+				if (dev) {
+					cli_args.push('-C', 'development'); // same as `--conditions`
+				}
+				cli_args.push(server_outpath);
+				server_process = spawn_restartable_process(cli_command ?? config.js_cli, cli_args);
+			}
+		},
+		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 = undefined;
+				await s.kill();
+			}
+
+			if (build_ctx) {
+				await build_ctx.dispose();
+				build_ctx = undefined;
+			}
+		},
+	};
+};
+
+/**
+ * The esbuild metafile contains the paths in `entryPoints` relative to the `dir`
+ * even though we're resolving them to absolute paths before passing them to esbuild,
+ * so we resolve them here relative to the `dir`.
+ */
+const parse_deps = (metafile_inputs: Record<string, unknown>, dir: string): Set<string> => {
+	const deps: Set<string> = new Set();
+	for (const key in metafile_inputs) {
+		deps.add(resolve(dir, strip_before(key, ':')));
+	}
+	return deps;
+};

package/src/lib/gro_plugin_sveltekit_app.ts

@@ -0,0 +1,58 @@
+import {args_serialize} from '@fuzdev/fuz_util/args.js';
+import {spawn_result_to_message, type SpawnedProcess} from '@fuzdev/fuz_util/process.js';
+
+import {to_forwarded_args} from './args.ts';
+import {find_cli, spawn_cli, spawn_cli_process} from './cli.ts';
+import {VITE_CLI} from './constants.ts';
+import type {Plugin} from './plugin.ts';
+import {TaskError} from './task.ts';
+
+export interface GroPluginSveltekitAppOptions {
+	/**
+	 * The Vite CLI to use.
+	 */
+	vite_cli?: string;
+}
+
+export const gro_plugin_sveltekit_app = ({
+	vite_cli = VITE_CLI,
+}: GroPluginSveltekitAppOptions = {}): Plugin => {
+	let sveltekit_process: SpawnedProcess | undefined = undefined;
+	return {
+		name: 'gro_plugin_sveltekit_app',
+		setup: async ({dev, watch, log, config}) => {
+			const found_vite_cli = await find_cli(vite_cli);
+			if (!found_vite_cli)
+				throw Error(
+					`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`${config.pm_cli} i\`?`,
+				);
+			if (dev) {
+				// `vite dev` in development mode
+				if (watch) {
+					const serialized_args = ['dev', ...args_serialize(to_forwarded_args(vite_cli))];
+					sveltekit_process = await spawn_cli_process(found_vite_cli, serialized_args, log);
+				} else {
+					log.debug(
+						`the SvelteKit app plugin is loaded but will not output anything` +
+							' because `dev` is true and `watch` is false',
+					);
+				}
+			} else {
+				// `vite build` in production mode
+				const serialized_args = ['build', ...args_serialize(to_forwarded_args(vite_cli))];
+				const spawned = await spawn_cli(found_vite_cli, serialized_args, log);
+				if (!spawned?.ok) {
+					throw new TaskError(
+						`${vite_cli} build failed: ${spawned ? spawn_result_to_message(spawned) : 'unknown error'}`,
+					);
+				}
+			}
+		},
+		teardown: async () => {
+			if (sveltekit_process) {
+				sveltekit_process.child.kill();
+				await sveltekit_process.closed;
+			}
+		},
+	};
+};

package/src/lib/gro_plugin_sveltekit_library.ts

@@ -0,0 +1,63 @@
+import {print_spawn_result, spawn, spawn_result_to_message} from '@fuzdev/fuz_util/process.js';
+
+import type {Plugin} from './plugin.ts';
+import {TaskError} from './task.ts';
+import {package_json_load} from './package_json.ts';
+import {run_svelte_package, type SveltePackageOptions} from './sveltekit_helpers.ts';
+import {SVELTE_PACKAGE_CLI} from './constants.ts';
+
+export interface GroPluginSveltekitLibraryOptions {
+	/**
+	 * The options passed to the SvelteKit packaging CLI.
+	 * @see https://kit.svelte.dev/docs/packaging#options
+	 */
+	svelte_package_options?: SveltePackageOptions;
+	/**
+	 * The SvelteKit packaging CLI to use. Defaults to `svelte-package`.
+	 * @see https://kit.svelte.dev/docs/packaging
+	 */
+	svelte_package_cli?: string;
+}
+
+export const gro_plugin_sveltekit_library = ({
+	svelte_package_options,
+	svelte_package_cli = SVELTE_PACKAGE_CLI,
+}: GroPluginSveltekitLibraryOptions = {}): Plugin => {
+	return {
+		name: 'gro_plugin_sveltekit_library',
+		setup: async ({dev, log, config}) => {
+			if (!dev) {
+				const package_json = await package_json_load();
+				await run_svelte_package(
+					package_json,
+					svelte_package_options,
+					svelte_package_cli,
+					log,
+					config.pm_cli,
+				);
+			}
+		},
+		adapt: async ({log, timings, config}) => {
+			const package_json = await package_json_load();
+			// link the CLI binaries if they exist
+			if (package_json.bin) {
+				const timing_to_link = timings.start(`${config.pm_cli} link`);
+				await Promise.all(
+					Object.values(package_json.bin).map(async (bin_path) => {
+						const chmod_result = await spawn('chmod', ['+x', bin_path]);
+						if (!chmod_result.ok)
+							log.error(
+								`chmod on bin path ${bin_path} failed: ${spawn_result_to_message(chmod_result)}`,
+							);
+					}),
+				);
+				log.info(`linking`);
+				const link_result = await spawn(config.pm_cli, ['link', '-f']); // TODO don't use `-f` unless necessary or at all?
+				if (!link_result.ok) {
+					throw new TaskError(`Failed to link. ${print_spawn_result(link_result)}`);
+				}
+				timing_to_link();
+			}
+		},
+	};
+};

package/src/lib/index.ts

@@ -0,0 +1,8 @@
+/** @nodocs */
+export type {GroConfig, CreateGroConfig, RawGroConfig} from './gro_config.ts';
+/** @nodocs */
+export {type Plugin, plugin_replace} from './plugin.ts';
+/** @nodocs */
+export type {Gen, GenContext} from './gen.ts';
+/** @nodocs */
+export {type Task, type TaskContext, TaskError} from './task.ts';