@ryanatkn/gro 0.129.3 → 0.129.5

package/src/lib/esbuild_plugin_sveltekit_shim_app.ts

@@ -0,0 +1,41 @@
+import type * as esbuild from 'esbuild';
+
+import {
+	render_sveltekit_shim_app_environment,
+	render_sveltekit_shim_app_paths,
+	sveltekit_shim_app_specifiers,
+} from './sveltekit_shim_app.js';
+import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
+
+export interface Options {
+	dev: boolean;
+	base_url: Parsed_Sveltekit_Config['base_url'];
+	assets_url: Parsed_Sveltekit_Config['assets_url'];
+}
+
+export const esbuild_plugin_sveltekit_shim_app = ({
+	dev,
+	base_url,
+	assets_url,
+}: Options): esbuild.Plugin => ({
+	name: 'sveltekit_shim_app',
+	setup: (build) => {
+		build.onResolve({filter: /^\$app\/(forms|navigation|stores)$/u}, ({path, ...rest}) =>
+			build.resolve(sveltekit_shim_app_specifiers.get(path)!, rest),
+		);
+		build.onResolve({filter: /^\$app\/paths$/u}, ({path}) => ({
+			path: sveltekit_shim_app_specifiers.get(path)!,
+			namespace: 'sveltekit_shim_app_paths',
+		}));
+		build.onLoad({filter: /.*/u, namespace: 'sveltekit_shim_app_paths'}, () => ({
+			contents: render_sveltekit_shim_app_paths(base_url, assets_url),
+		}));
+		build.onResolve({filter: /^\$app\/environment$/u}, ({path}) => ({
+			path: sveltekit_shim_app_specifiers.get(path)!,
+			namespace: 'sveltekit_shim_app_environment',
+		}));
+		build.onLoad({filter: /.*/u, namespace: 'sveltekit_shim_app_environment'}, () => ({
+			contents: render_sveltekit_shim_app_environment(dev),
+		}));
+	},
+});

package/src/lib/esbuild_plugin_sveltekit_shim_env.ts

@@ -0,0 +1,46 @@
+import type * as esbuild from 'esbuild';
+
+import {render_env_shim_module} from './sveltekit_shim_env.js';
+
+export interface Options {
+	dev: boolean;
+	public_prefix?: string;
+	private_prefix?: string;
+	env_dir?: string;
+	env_files?: string[];
+	ambient_env?: Record<string, string>;
+}
+
+export const esbuild_plugin_sveltekit_shim_env = ({
+	dev,
+	public_prefix,
+	private_prefix,
+	env_dir,
+	env_files,
+	ambient_env,
+}: Options): esbuild.Plugin => ({
+	name: 'sveltekit_shim_env',
+	setup: (build) => {
+		const namespace = 'sveltekit_shim_env';
+		const filter = /^\$env\/(static|dynamic)\/(public|private)$/u;
+		build.onResolve({filter}, ({path}) => ({path, namespace}));
+		build.onLoad({filter: /.*/u, namespace}, ({path}) => {
+			const matches = filter.exec(path);
+			const mode = matches![1] as 'static' | 'dynamic';
+			const visibility = matches![2] as 'public' | 'private';
+			return {
+				loader: 'ts',
+				contents: render_env_shim_module(
+					dev,
+					mode,
+					visibility,
+					public_prefix,
+					private_prefix,
+					env_dir,
+					env_files,
+					ambient_env,
+				),
+			};
+		});
+	},
+});

package/src/lib/format.task.ts

@@ -0,0 +1,30 @@
+import {print_spawn_result} from '@ryanatkn/belt/process.js';
+import {z} from 'zod';
+
+import {Task_Error, type Task} from './task.js';
+import {format_directory} from './format_directory.js';
+import {paths} from './paths.js';
+
+export const Args = z
+	.object({
+		check: z
+			.boolean({description: 'exit with a nonzero code if any files are unformatted'})
+			.default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'format source files',
+	Args,
+	run: async ({args, log}) => {
+		const {check} = args;
+		// TODO forward prettier args
+		const format_result = await format_directory(log, paths.source, check);
+		if (!format_result.ok) {
+			throw new Task_Error(
+				`Failed ${check ? 'formatting check' : 'to format'}. ${print_spawn_result(format_result)}`,
+			);
+		}
+	},
+};

package/src/lib/format_directory.ts

@@ -0,0 +1,55 @@
+import type {Spawn_Result} from '@ryanatkn/belt/process.js';
+import type {Logger} from '@ryanatkn/belt/log.js';
+
+import {paths} from './paths.js';
+import {
+	GITHUB_DIRNAME,
+	README_FILENAME,
+	SVELTEKIT_CONFIG_FILENAME,
+	VITE_CONFIG_FILENAME,
+	TSCONFIG_FILENAME,
+	GRO_CONFIG_PATH,
+} from './path_constants.js';
+import {serialize_args, to_forwarded_args} from './args.js';
+import {spawn_cli, to_cli_name, type Cli} from './cli.js';
+
+const PRETTIER_CLI = 'prettier';
+
+const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
+const DEFAULT_ROOT_PATHS = `${[
+	README_FILENAME,
+	GRO_CONFIG_PATH,
+	SVELTEKIT_CONFIG_FILENAME,
+	VITE_CONFIG_FILENAME,
+	TSCONFIG_FILENAME,
+	GITHUB_DIRNAME,
+].join(',')}/**/*`;
+
+/**
+ * Formats a directory on the filesystem.
+ * If the source directory is given, it also formats all of the root directory files.
+ * This is separated from `./format_file` to avoid importing all of the `prettier` code
+ * inside modules that import this one. (which has a nontrivial cost)
+ */
+export const format_directory = async (
+	log: Logger,
+	dir: string,
+	check = false,
+	extensions = DEFAULT_EXTENSIONS,
+	root_paths = DEFAULT_ROOT_PATHS,
+	prettier_cli: string | Cli = PRETTIER_CLI,
+): Promise<Spawn_Result> => {
+	const forwarded_args = to_forwarded_args(to_cli_name(prettier_cli));
+	forwarded_args[check ? 'check' : 'write'] = true;
+	const serialized_args = serialize_args(forwarded_args);
+	serialized_args.push(`${dir}**/*.{${extensions}}`);
+	if (dir === paths.source) {
+		serialized_args.push(`${paths.root}{${root_paths}}`);
+	}
+	const spawned = await spawn_cli(prettier_cli, serialized_args, log);
+	if (!spawned)
+		throw new Error(
+			`failed to find \`${to_cli_name(prettier_cli)}\` CLI locally or globally, do you need to run \`npm i\`?`,
+		);
+	return spawned;
+};

package/src/lib/format_file.test.ts

@@ -0,0 +1,20 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {format_file} from './format_file.js';
+
+test('format ts', async () => {
+	const ts_unformatted = 'hey (1)';
+	const ts_formatted = 'hey(1);\n';
+	assert.is(await format_file(ts_unformatted, {filepath: 'foo.ts'}), ts_formatted);
+	assert.is(await format_file(ts_unformatted, {parser: 'typescript'}), ts_formatted);
+});
+
+test('format svelte', async () => {
+	const svelte_unformatted = '<style>a{color: red}</style>';
+	const svelte_formatted = '<style>\n\ta {\n\t\tcolor: red;\n\t}\n</style>\n';
+	assert.is(await format_file(svelte_unformatted, {filepath: 'foo.svelte'}), svelte_formatted);
+	assert.is(await format_file(svelte_unformatted, {parser: 'svelte'}), svelte_formatted);
+});
+
+test.run();

package/src/lib/format_file.ts

@@ -0,0 +1,49 @@
+import prettier from 'prettier';
+import {extname} from 'node:path';
+
+import {load_package_json} from './package_json.js';
+
+let cached_base_options: prettier.Options | undefined;
+
+/**
+ * Formats a file with Prettier.
+ * @param content
+ * @param options
+ * @param base_options - defaults to the the cwd's package.json `prettier` value
+ */
+export const format_file = async (
+	content: string,
+	options: prettier.Options,
+	base_options: prettier.Options | null | undefined = cached_base_options,
+): Promise<string> => {
+	const final_base_options =
+		base_options !== undefined
+			? base_options
+			: (cached_base_options = load_package_json().prettier as any);
+	let final_options = options;
+	if (options.filepath && !options.parser) {
+		const {filepath, ...rest} = options;
+		const parser = infer_parser(filepath);
+		if (parser) final_options = {...rest, parser};
+	}
+	try {
+		return await prettier.format(content, {...final_base_options, ...final_options});
+	} catch (_err) {
+		return content;
+	}
+};
+
+// This is just a simple convenience for callers so they can pass a file path.
+// They can provide the Prettier `options.parser` for custom extensions.
+const infer_parser = (path: string): string | null => {
+	const extension = extname(path).substring(1);
+	switch (extension) {
+		case 'svelte':
+		case 'xml': {
+			return extension;
+		}
+		default: {
+			return null;
+		}
+	}
+};

package/src/lib/fs.ts

@@ -0,0 +1,18 @@
+import {rm} from 'node:fs/promises';
+import {readdirSync, type RmOptions} from 'node:fs';
+import {join} from 'node:path';
+
+/**
+ * Empties a directory with an optional `filter`.
+ */
+export const empty_dir = async (
+	dir: string,
+	filter?: (path: string) => boolean,
+	options?: RmOptions,
+): Promise<void> => {
+	await Promise.all(
+		readdirSync(dir).map((path) =>
+			filter && !filter(path) ? null : rm(join(dir, path), {...options, recursive: true}),
+		),
+	);
+};

package/src/lib/gen.task.ts

@@ -0,0 +1,134 @@
+import {red, green, gray} from '@ryanatkn/belt/styletext.js';
+import {print_ms, print_error} from '@ryanatkn/belt/print.js';
+import {plural} from '@ryanatkn/belt/string.js';
+import {z} from 'zod';
+
+import {Task_Error, type Task} from './task.js';
+import {run_gen} from './run_gen.js';
+import {Raw_Input_Path, to_input_paths} from './input_path.js';
+import {format_file} from './format_file.js';
+import {print_path} from './paths.js';
+import {log_error_reasons} from './task_logging.js';
+import {write_gen_results, analyze_gen_results, find_genfiles, load_genfiles} from './gen.js';
+import {SOURCE_DIRNAME} from './path_constants.js';
+
+export const Args = z
+	.object({
+		_: z.array(Raw_Input_Path, {description: 'input paths to generate'}).default([SOURCE_DIRNAME]),
+		root_dirs: z
+			.array(z.string(), {description: 'root directories to resolve input paths against'}) // TODO `Path_Id` schema
+			.default([process.cwd()]),
+		check: z
+			.boolean({description: 'exit with a nonzero code if any files need to be generated'})
+			.default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+// TODO test - especially making sure nothing gets genned
+// if there's any validation or import errors
+export const task: Task<Args> = {
+	summary: 'run code generation scripts',
+	Args,
+	run: async ({args, log, timings, config}): Promise<void> => {
+		const {_: raw_input_paths, root_dirs, check} = args;
+
+		const input_paths = to_input_paths(raw_input_paths);
+
+		// load all of the gen modules
+		const found = find_genfiles(input_paths, root_dirs, config, timings);
+		if (!found.ok) {
+			if (found.type === 'input_directories_with_no_files') {
+				// TODO maybe let this error like the normal case, but only call `gro gen` if we find gen files? problem is the args would need to be hoisted to callers like `gro sync`
+				log.info('no gen modules found in ' + input_paths.join(', '));
+				return;
+			} else {
+				log_error_reasons(log, found.reasons);
+				throw new Task_Error('Failed to find gen modules.');
+			}
+		}
+		const found_genfiles = found.value;
+		log.info(
+			'gen files',
+			found_genfiles.resolved_input_files.map((f) => f.id),
+		);
+		const loaded = await load_genfiles(found_genfiles, timings);
+		if (!loaded.ok) {
+			log_error_reasons(log, loaded.reasons);
+			throw new Task_Error('Failed to load gen modules.');
+		}
+		const loaded_genfiles = loaded.value;
+
+		// run `gen` on each of the modules
+		const timing_to_generate_code = timings.start('generate code'); // TODO this ignores `gen_results.elapsed` - should it return `Timings` instead?
+		const gen_results = await run_gen(loaded_genfiles.modules, config, log, timings, format_file);
+		timing_to_generate_code();
+
+		const fail_count = gen_results.failures.length;
+		const analyzed_gen_results = await analyze_gen_results(gen_results);
+		if (check) {
+			// check if any files changed, and if so, throw errors,
+			// but if there are gen failures, skip the check and defer to their errors
+			if (!fail_count) {
+				log.info('checking generated files for changes');
+				const timing_to_check_results = timings.start('check results for changes');
+				timing_to_check_results();
+
+				let has_unexpected_changes = false;
+				for (const analyzed of analyzed_gen_results) {
+					if (!analyzed.has_changed) continue;
+					has_unexpected_changes = true;
+					log.error(
+						red(
+							`Generated file ${print_path(analyzed.file.id)} via ${print_path(
+								analyzed.file.origin_id,
+							)} ${analyzed.is_new ? 'is new' : 'has changed'}.`,
+						),
+					);
+				}
+				if (has_unexpected_changes) {
+					throw new Task_Error(
+						'Failed gen check. Some generated files have unexpectedly changed.' +
+							' Run `gro gen` and try again.',
+					);
+				}
+				log.info('check passed, no files have changed');
+			}
+		} else {
+			// write generated files to disk
+			log.info('writing generated files to disk');
+			const timing_to_output_results = timings.start('output results');
+			await write_gen_results(gen_results, analyzed_gen_results, log);
+			timing_to_output_results();
+		}
+
+		// TODO these final printed results could be improved showing a breakdown per file id
+		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 unchanged_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
+		let log_result = green('gen results:');
+		log_result += `\n\t${new_count} ` + gray('new');
+		log_result += `\n\t${changed_count} ` + gray('changed');
+		log_result += `\n\t${unchanged_count} ` + gray('unchanged');
+		for (const result of gen_results.results) {
+			log_result += `\n\t${result.ok ? green('✓') : red('🞩')}  ${
+				result.ok ? result.files.length : 0
+			} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
+		}
+		log.info(log_result);
+		log.info(
+			green(
+				`generated ${gen_results.output_count} file${plural(gen_results.output_count)} from ${
+					gen_results.successes.length
+				} input file${plural(gen_results.successes.length)}`,
+			),
+		);
+
+		if (fail_count) {
+			for (const result of gen_results.failures) {
+				log.error(result.reason, '\n', print_error(result.error));
+			}
+			throw new Task_Error(`Failed to generate ${fail_count} file${plural(fail_count)}.`);
+		}
+	},
+};