@fuzdev/gro 0.192.0

package/src/lib/run_gen.ts

@@ -0,0 +1,110 @@
+import {styleText as st} from 'node:util';
+import {print_error} from '@fuzdev/fuz_util/print.js';
+import type {Timings} from '@fuzdev/fuz_util/timings.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {map_concurrent} from '@fuzdev/fuz_util/async.js';
+
+import {
+	type GenResults,
+	type GenfileModuleResult,
+	type GenContext,
+	type GenfileModuleMeta,
+	to_gen_result,
+	type RawGenResult,
+	normalize_gen_config,
+} from './gen.ts';
+import {print_path, to_root_path} from './paths.ts';
+import type {format_file as base_format_file} from './format_file.ts';
+import type {GroConfig} from './gro_config.ts';
+import {default_svelte_config} from './svelte_config.ts';
+import type {Filer} from './filer.ts';
+import type {InvokeTask} from './task.ts';
+
+export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
+
+export const run_gen = async (
+	gen_modules: Array<GenfileModuleMeta>,
+	config: GroConfig,
+	filer: Filer,
+	log: Logger,
+	timings: Timings,
+	invoke_task: InvokeTask,
+	format_file?: typeof base_format_file,
+): Promise<GenResults> => {
+	let input_count = 0;
+	let output_count = 0;
+	const timing_for_run_gen = timings.start('run_gen');
+	const results = await map_concurrent(
+		gen_modules,
+		async (module_meta): Promise<GenfileModuleResult> => {
+			input_count++;
+			const {id} = module_meta;
+			const timing_for_module = timings.start(id);
+
+			const gen_config = normalize_gen_config(module_meta.mod.gen);
+			const gen_ctx: GenContext = {
+				config,
+				svelte_config: default_svelte_config,
+				filer,
+				log,
+				timings,
+				invoke_task,
+				origin_id: id,
+				origin_path: to_root_path(id),
+				changed_file_id: undefined,
+			};
+			let raw_gen_result: RawGenResult;
+			try {
+				raw_gen_result = await gen_config.generate(gen_ctx);
+			} catch (error) {
+				return {
+					ok: false,
+					id,
+					error,
+					reason: st('red', `Error generating ${print_path(id)}`),
+					elapsed: timing_for_module(),
+				};
+			}
+
+			// Convert the module's return value to a normalized form.
+			const gen_result = to_gen_result(id, raw_gen_result);
+
+			// Format the files if needed.
+			const files = format_file
+				? await map_concurrent(
+						gen_result.files,
+						async (file) => {
+							if (!file.format) return file;
+							try {
+								return {...file, content: await format_file(file.content, {filepath: file.id})};
+							} catch (error) {
+								log.error(
+									st('red', `Error formatting ${print_path(file.id)} via ${print_path(id)}`),
+									print_error(error),
+								);
+								return file;
+							}
+						},
+						10,
+					)
+				: gen_result.files;
+
+			output_count += files.length;
+			return {
+				ok: true,
+				id,
+				files,
+				elapsed: timing_for_module(),
+			};
+		},
+		10,
+	);
+	return {
+		results,
+		successes: results.filter((r) => r.ok),
+		failures: results.filter((r) => !r.ok),
+		input_count,
+		output_count,
+		elapsed: timing_for_run_gen(),
+	};
+};

package/src/lib/run_task.ts

@@ -0,0 +1,82 @@
+import {args_parse, type Args} from '@fuzdev/fuz_util/args.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {Timings} from '@fuzdev/fuz_util/timings.js';
+import {styleText as st} from 'node:util';
+import {z} from 'zod';
+
+import type {Filer} from './filer.ts';
+import type {GroConfig} from './gro_config.ts';
+import type {invoke_task as base_invoke_task} from './invoke_task.ts';
+import {default_svelte_config} from './svelte_config.ts';
+import {TaskError, type TaskModuleMeta} from './task.ts';
+import {log_task_help} from './task_logging.ts';
+
+export type RunTaskResult =
+	| {
+			ok: true;
+			output: unknown;
+	  }
+	| {
+			ok: false;
+			reason: string;
+			error: Error;
+	  };
+
+export const run_task = async (
+	task_meta: TaskModuleMeta,
+	unparsed_args: Args,
+	invoke_task: typeof base_invoke_task,
+	config: GroConfig,
+	filer: Filer,
+	log: Logger,
+	timings: Timings,
+): Promise<RunTaskResult> => {
+	const {task} = task_meta.mod;
+
+	if (unparsed_args.help) {
+		log_task_help(log, task_meta);
+		return {ok: true, output: null};
+	}
+
+	// Parse and validate args.
+	let args = unparsed_args;
+	if (task.Args) {
+		const parsed = args_parse(unparsed_args, task.Args);
+		if (!parsed.success) {
+			throw new TaskError(
+				`Failed task args validation for task '${task_meta.name}':\n${z.prettifyError(parsed.error)}`,
+			);
+		}
+		args = parsed.data;
+	}
+
+	// Run the task.
+	let output: unknown; // TODO generic
+	try {
+		output = await task.run({
+			args,
+			config,
+			svelte_config: default_svelte_config,
+			filer,
+			log,
+			timings,
+			invoke_task: (invoked_task_name, invoked_args, invoked_config) =>
+				invoke_task(invoked_task_name, invoked_args, invoked_config ?? config, filer, timings, log),
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			reason: st(
+				'red',
+				error?.constructor?.name === 'TaskError'
+					? (error.message as string)
+					: `Unexpected error running task ${st(
+							'cyan',
+							task_meta.name,
+						)}. If this is unexpected try running \`${config.pm_cli} install\` and \`gro clean\`.`,
+			),
+			error,
+		};
+	}
+	return {ok: true, output};
+};

package/src/lib/source_json.ts

@@ -0,0 +1,183 @@
+import {join} from 'node:path';
+import {ensure_end, strip_start} from '@fuzdev/fuz_util/string.js';
+import {fs_exists, fs_search} from '@fuzdev/fuz_util/fs.js';
+import ts from 'typescript';
+import type {PackageJson, PackageJsonExports} from '@fuzdev/fuz_util/package_json.js';
+import {SourceJson, type ModuleJson, type DeclarationKind} from '@fuzdev/fuz_util/source_json.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+
+import {paths, replace_extension} from './paths.ts';
+import {parse_exports} from './parse_exports.ts';
+import {TS_MATCHER, SVELTE_MATCHER, JSON_MATCHER, CSS_MATCHER} from './constants.ts';
+
+export type SourceJsonMapper = (
+	source_json: SourceJson,
+) => SourceJson | null | Promise<SourceJson | null>;
+
+export const source_json_create = async (
+	package_json: PackageJson,
+	lib_path?: string,
+	log?: Logger,
+): Promise<SourceJson> =>
+	SourceJson.parse({
+		name: package_json.name,
+		version: package_json.version,
+		modules: await source_json_modules_create(package_json.exports, lib_path, log),
+	});
+
+export const source_json_modules_create = async (
+	exports: PackageJsonExports | undefined,
+	lib_path = paths.lib,
+	log?: Logger,
+): Promise<Array<ModuleJson> | undefined> => {
+	if (!exports) return;
+
+	const file_paths = await collect_file_paths(exports, lib_path);
+
+	// Create a TypeScript program for all TypeScript files
+	const ts_files = file_paths
+		.filter(({file_path}) => TS_MATCHER.test(file_path))
+		.map(({file_path}) => file_path);
+
+	let program: ts.Program | undefined;
+	if (ts_files.length > 0) {
+		program = ts.createProgram(
+			ts_files,
+			// TODO get from tsconfig?
+			{
+				target: ts.ScriptTarget.ESNext,
+				module: ts.ModuleKind.ESNext,
+				moduleResolution: ts.ModuleResolutionKind.NodeNext,
+				verbatimModuleSyntax: true,
+				isolatedModules: true,
+			},
+		);
+	}
+
+	const result: Array<ModuleJson> = [];
+
+	// Process each file
+	for (const {file_path} of file_paths) {
+		const relative_path = file_path.replace(ensure_end(lib_path, '/'), '');
+
+		const declarations = parse_exports(file_path, program, undefined, log)
+			.filter((d): d is {name: string; kind: DeclarationKind} => d.kind !== null) // TODO maybe dont filter out?
+			.map(({name, kind}) => ({name, kind}));
+
+		result.push(
+			declarations.length
+				? {
+						path: relative_path,
+						declarations,
+					}
+				: {
+						path: relative_path,
+					},
+		);
+	}
+
+	return result;
+};
+
+const collect_file_paths = async (
+	exports: PackageJsonExports,
+	lib_path: string,
+): Promise<Array<{export_key: string; file_path: string}>> => {
+	const file_paths: Array<{export_key: string; file_path: string}> = [];
+
+	// Handle string exports (single default export)
+	if (typeof exports === 'string') {
+		const source_file = await infer_source_from_export(exports, lib_path);
+		if (source_file) {
+			file_paths.push({export_key: '.', file_path: source_file});
+		} else {
+			throw Error(
+				`Failed to infer source file from package.json string export "${exports}" - no matching file found in ${lib_path}`,
+			);
+		}
+		return file_paths;
+	}
+
+	// Handle object exports
+	for (const k in exports) {
+		// Skip package.json
+		if (k === './package.json') continue;
+
+		// Check if this is a pattern export
+		if (k.includes('*')) {
+			// Handle pattern exports by finding matching files in lib
+			// eslint-disable-next-line no-await-in-loop
+			const matching_files = await fs_search(lib_path, {
+				file_filter: (path) => {
+					const p = path.replace(ensure_end(lib_path, '/'), '');
+					// Only match files in the root directory (no subdirectories)
+					if (p.includes('/')) return false;
+
+					// Match based on the export pattern
+					if (k === './*.js') {
+						return TS_MATCHER.test(p) && !p.endsWith('.d.ts') && !p.endsWith('.test.ts');
+					} else if (k === './*.svelte') {
+						return SVELTE_MATCHER.test(p);
+					} else if (k === './*.json') {
+						return JSON_MATCHER.test(p);
+					} else if (k === './*.css') {
+						return CSS_MATCHER.test(p);
+					}
+					return false;
+				},
+			});
+
+			// Add each matching file
+			for (const file of matching_files) {
+				let export_path: string;
+				if (file.path.endsWith('.ts')) {
+					export_path = './' + file.path.replace('.ts', '.js');
+				} else {
+					export_path = './' + file.path;
+				}
+				file_paths.push({export_key: export_path, file_path: file.id});
+			}
+		} else {
+			// Handle explicit exports (non-patterns)
+			// eslint-disable-next-line no-await-in-loop
+			const source_file = await infer_source_from_export(k, lib_path);
+			if (source_file) {
+				file_paths.push({export_key: k, file_path: source_file});
+			} else {
+				throw Error(
+					`Failed to infer source file from package.json export path ${k} - no matching file found in ${lib_path}`,
+				);
+			}
+		}
+	}
+
+	return file_paths;
+};
+
+const infer_source_from_export = async (
+	export_path: string,
+	lib_path: string,
+): Promise<string | null> => {
+	// Handle index specially
+	if (export_path === '.' || export_path === './') {
+		const index_ts = join(lib_path, 'index.ts');
+		if (await fs_exists(index_ts)) return index_ts;
+		const index_js = join(lib_path, 'index.js');
+		if (await fs_exists(index_js)) return index_js;
+		return null;
+	}
+
+	const clean_path = strip_start(export_path, './');
+
+	// For .js exports, try .ts first
+	if (clean_path.endsWith('.js')) {
+		const ts_path = join(lib_path, replace_extension(clean_path, '.ts'));
+		if (await fs_exists(ts_path)) return ts_path;
+	}
+
+	// Try the exact path
+	const exact_path = join(lib_path, clean_path);
+	if (await fs_exists(exact_path)) return exact_path;
+
+	return null;
+};

package/src/lib/svelte_config.ts

@@ -0,0 +1,140 @@
+import type {Config as SvelteConfig} from '@sveltejs/kit';
+import type {CompileOptions, ModuleCompileOptions, PreprocessorGroup} from 'svelte/compiler';
+import {join} from 'node:path';
+import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
+
+import {SVELTE_CONFIG_FILENAME} from './constants.ts';
+
+/* eslint-disable @typescript-eslint/no-deprecated */
+// see https://github.com/sveltejs/kit/discussions/14240
+
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
+
+/**
+ * Loads a SvelteKit config at `dir`.
+ * @returns `null` if no config is found
+ */
+export const load_svelte_config = async ({
+	dir = process.cwd(),
+	config_filename = SVELTE_CONFIG_FILENAME,
+}: {dir?: string; config_filename?: string} = EMPTY_OBJECT): Promise<SvelteConfig | null> => {
+	try {
+		return (await import(join(dir, config_filename))).default;
+	} catch (_err) {
+		return null;
+	}
+};
+
+/**
+ * A subset of SvelteKit's config in a form that Gro uses
+ * because SvelteKit doesn't expose its config resolver.
+ * Flattens things out to keep them simple and easy to pass around,
+ * and doesn't deal with most properties, but includes the full `svelte_config`.
+ * The `base` and `assets` in particular are renamed for clarity with Gro's internal systems,
+ * so these properties become first-class vocabulary inside Gro.
+ */
+export interface ParsedSvelteConfig {
+	// TODO probably fill these out with defaults
+	svelte_config: SvelteConfig | null;
+	alias: Record<string, string>;
+	base_url: '' | `/${string}` | undefined;
+	assets_url: '' | `http://${string}` | `https://${string}` | undefined;
+
+	// TODO others, but maybe replace with a Zod schema? https://kit.svelte.dev/docs/configuration
+	/**
+	 * Same as the SvelteKit `files.assets`.
+	 */
+	assets_path: string;
+	/**
+	 * Same as the SvelteKit `files.lib`.
+	 */
+	lib_path: string;
+	/**
+	 * Same as the SvelteKit `files.routes`.
+	 */
+	routes_path: string;
+
+	env_dir: string | undefined;
+	private_prefix: string | undefined;
+	public_prefix: string | undefined;
+	svelte_compile_options: CompileOptions;
+	svelte_compile_module_options: ModuleCompileOptions;
+	svelte_preprocessors: PreprocessorGroup | Array<PreprocessorGroup> | undefined;
+}
+
+// TODO currently incomplete and hack - maybe rethink
+/**
+ * Returns Gro-relevant properties of a SvelteKit config
+ * as a convenience wrapper around `load_svelte_config`.
+ * Needed because SvelteKit doesn't expose its config resolver.
+ */
+export const parse_svelte_config = async ({
+	dir_or_config = process.cwd(), // TODO maybe not the best API, maybe a type union? `({svelte_config} | {dir}) & {config_filename}`
+	config_filename = SVELTE_CONFIG_FILENAME,
+}: {
+	dir_or_config?: string | SvelteConfig;
+	config_filename?: string;
+} = EMPTY_OBJECT): Promise<ParsedSvelteConfig> => {
+	const svelte_config =
+		typeof dir_or_config === 'string'
+			? await load_svelte_config({dir: dir_or_config, config_filename})
+			: dir_or_config;
+
+	const kit = svelte_config?.kit;
+
+	const alias = {$lib: 'src/lib', ...kit?.alias};
+
+	const base_url = kit?.paths?.base;
+	const assets_url = kit?.paths?.assets;
+
+	// TODO probably a Zod schema instead
+	const assets_path = kit?.files?.assets ?? 'static';
+	const lib_path = kit?.files?.lib ?? 'src/lib';
+	const routes_path = kit?.files?.routes ?? 'src/routes';
+
+	const env_dir = kit?.env?.dir;
+	const private_prefix = kit?.env?.privatePrefix;
+	const public_prefix = kit?.env?.publicPrefix;
+
+	const svelte_compile_options: CompileOptions = svelte_config?.compilerOptions ?? {};
+	// Change the default to `generate: 'server'`,
+	// because SvelteKit handles the client in the normal cases.
+	if (svelte_compile_options.generate === undefined) {
+		svelte_compile_options.generate = 'server';
+	}
+	const svelte_compile_module_options = to_default_compile_module_options(svelte_compile_options); // TODO will kit have these separately?
+	const svelte_preprocessors = svelte_config?.preprocess;
+
+	return {
+		svelte_config,
+		alias,
+		base_url,
+		assets_url,
+		assets_path,
+		lib_path,
+		routes_path,
+		env_dir,
+		private_prefix,
+		public_prefix,
+		svelte_compile_options,
+		svelte_compile_module_options,
+		svelte_preprocessors,
+	};
+};
+
+export const to_default_compile_module_options = ({
+	dev,
+	generate,
+	filename,
+	rootDir,
+	warningFilter,
+}: CompileOptions): ModuleCompileOptions => ({dev, generate, filename, rootDir, warningFilter});
+
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export const default_svelte_config = await parse_svelte_config(); // always load it to keep things simple ahead

package/src/lib/sveltekit_helpers.ts

@@ -0,0 +1,193 @@
+import {args_serialize} from '@fuzdev/fuz_util/args.js';
+import {fs_exists} from '@fuzdev/fuz_util/fs.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {PackageJson} from '@fuzdev/fuz_util/package_json.js';
+import type {Result} from '@fuzdev/fuz_util/result.js';
+import {join} from 'node:path';
+
+import {to_forwarded_args} from './args.ts';
+import {find_cli, spawn_cli, to_cli_name, type Cli} from './cli.ts';
+import {
+	PM_CLI_DEFAULT,
+	SVELTE_CONFIG_FILENAME,
+	SVELTE_PACKAGE_DEP_NAME,
+	SVELTEKIT_CLI,
+	SVELTEKIT_DEV_DIRNAME,
+} from './constants.ts';
+import {package_json_has_dependency} from './package_json.ts';
+import {default_svelte_config, type ParsedSvelteConfig} from './svelte_config.ts';
+import {TaskError} from './task.ts';
+
+export const has_sveltekit_app = async (
+	svelte_config_path: string = SVELTE_CONFIG_FILENAME,
+): Promise<Result<object, {message: string}>> => {
+	if (!(await fs_exists(svelte_config_path))) {
+		return {ok: false, message: `no SvelteKit config found at ${SVELTE_CONFIG_FILENAME}`};
+	}
+	// TODO check for routes?
+	return {ok: true};
+};
+
+export const has_sveltekit_library = async (
+	package_json: PackageJson,
+	svelte_config: ParsedSvelteConfig = default_svelte_config,
+	dep_name = SVELTE_PACKAGE_DEP_NAME,
+): Promise<Result<object, {message: string}>> => {
+	const has_sveltekit_app_result = await has_sveltekit_app();
+	if (!has_sveltekit_app_result.ok) {
+		return has_sveltekit_app_result;
+	}
+
+	if (!(await fs_exists(svelte_config.lib_path))) {
+		return {ok: false, message: `no SvelteKit lib directory found at ${svelte_config.lib_path}`};
+	}
+
+	if (!package_json_has_dependency(dep_name, package_json)) {
+		return {
+			ok: false,
+			message: `no dependency found in package.json for ${dep_name}`,
+		};
+	}
+
+	return {ok: true};
+};
+
+export const sveltekit_sync = async (
+	sveltekit_cli: string | Cli = SVELTEKIT_CLI,
+	pm_cli = PM_CLI_DEFAULT, // TODO source from config when possible, is just needed for error messages
+): Promise<void> => {
+	const result = await spawn_cli(sveltekit_cli, ['sync']);
+	if (!result) {
+		throw new TaskError(
+			`Failed to find SvelteKit CLI \`${to_cli_name(sveltekit_cli)}\`, do you need to run \`${pm_cli} install\`?`,
+		);
+	} else if (!result.ok) {
+		throw new TaskError(`Failed ${to_cli_name(sveltekit_cli)} sync`);
+	}
+};
+
+// TODO maybe this shouldn't exist, instead error if `package.json` has SvelteKit but it's not found (with install message above)
+/**
+ * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
+ */
+export const sveltekit_sync_if_available = async (
+	sveltekit_cli: string | Cli = SVELTEKIT_CLI,
+): Promise<void> => {
+	const found_sveltekit_cli =
+		typeof sveltekit_cli === 'string' ? await find_cli(sveltekit_cli) : sveltekit_cli;
+	if (found_sveltekit_cli) {
+		return sveltekit_sync(found_sveltekit_cli);
+	}
+};
+
+/**
+ * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
+ */
+export const sveltekit_sync_if_obviously_needed = async (
+	sveltekit_cli: string | Cli = SVELTEKIT_CLI,
+): Promise<void> => {
+	if (await fs_exists(SVELTEKIT_DEV_DIRNAME)) {
+		return;
+	}
+	const found_sveltekit_cli =
+		typeof sveltekit_cli === 'string' ? await find_cli(sveltekit_cli) : sveltekit_cli;
+	if (!found_sveltekit_cli) {
+		return;
+	}
+	return sveltekit_sync(found_sveltekit_cli);
+};
+
+/**
+ * Options to the SvelteKit packaging CLI.
+ * @see https://kit.svelte.dev/docs/packaging#options
+ */
+export interface SveltePackageOptions {
+	/**
+	 * Watch files in src/lib for changes and rebuild the package
+	 */
+	watch?: boolean;
+	/**
+	 * Alias for `watch`.
+	 */
+	w?: boolean;
+	/**
+	 * The input directory which contains all the files of the package.
+	 * Defaults to src/lib
+	 */
+	input?: string;
+	/**
+	 * Alias for `input`.
+	 */
+	i?: string;
+	/**
+	 * The output directory where the processed files are written to.
+	 * Your package.json's exports should point to files inside there,
+	 * and the files array should include that folder.
+	 * Defaults to dist
+	 */
+	output?: string;
+	/**
+	 * Alias for `output`.
+	 */
+	o?: string;
+	/**
+	 * Whether or not to create type definitions (d.ts files).
+	 * We strongly recommend doing this as it fosters ecosystem library quality.
+	 * Defaults to true
+	 */
+	types?: boolean;
+	/**
+	 * Alias for `types`.
+	 */
+	t?: boolean;
+	/**
+	 * The path to a tsconfig or jsconfig.
+	 * When not provided, searches for the next upper tsconfig/jsconfig in the workspace path.
+	 */
+	tsconfig?: string;
+}
+
+export const run_svelte_package = async (
+	package_json: PackageJson,
+	options: SveltePackageOptions | undefined,
+	cli: string | Cli,
+	log: Logger,
+	pm_cli: string,
+): Promise<void> => {
+	const has_sveltekit_library_result = await has_sveltekit_library(package_json);
+	if (!has_sveltekit_library_result.ok) {
+		throw new TaskError(
+			'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,
+		);
+	}
+	const cli_name = typeof cli === 'string' ? cli : cli.name;
+	const found_svelte_package_cli = cli === cli_name ? await find_cli(cli) : (cli as Cli);
+	if (found_svelte_package_cli?.kind !== 'local') {
+		throw new TaskError(
+			`Failed to find SvelteKit packaging CLI \`${cli_name}\`, do you need to run \`${pm_cli} install\`?`,
+		);
+	}
+	const serialized_args = args_serialize({
+		...options,
+		...to_forwarded_args(cli_name),
+	});
+	await spawn_cli(found_svelte_package_cli, serialized_args, log);
+};
+
+//
+/**
+ * Map an import specifier with the SvelteKit aliases.
+ */
+export const map_sveltekit_aliases = (
+	specifier: string,
+	aliases: Array<[string, string]>,
+): string => {
+	let path = specifier;
+	for (const [from, to] of aliases) {
+		if (path.startsWith(from)) {
+			path = join(process.cwd(), to, path.substring(from.length));
+			break;
+		}
+	}
+	return path;
+};