@ryanatkn/gro 0.175.0 → 0.177.0

package/src/lib/run.task.ts

@@ -2,20 +2,28 @@ import {z} from 'zod';
 import {styleText as st} from 'node:util';
 import {existsSync} from 'node:fs';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {resolve_gro_module_path, spawn_with_loader} from './gro_helpers.ts';
+import {serialize_args} from './args.ts';
 
-// TODO maybe delete this? if misused is a security risk,
-// and I'm not using it for anything that couldn't be done with Node directly atm.
-// It could potentially be more useful if I keep building on the task system.
+/**
+ * Runs a TypeScript file with Gro's loader, forwarding all args to the script.
+ * Useful for scripts that need SvelteKit shims ($lib, $env, etc).
+ */
 
 /** @nodocs */
-export const Args = z.strictObject({
-	_: z
-		.array(z.string())
-		.meta({description: 'the file path to run and other node CLI args'})
-		.default([]),
-});
+export const Args = z
+	.object({
+		_: z.array(z.string()).meta({description: 'the file path to run'}).default([]),
+	})
+	.catchall(
+		z.union([
+			z.string(),
+			z.number(),
+			z.boolean(),
+			z.array(z.union([z.string(), z.number(), z.boolean()])),
+		]),
+	);
 export type Args = z.infer<typeof Args>;
 
 /** @nodocs */
@@ -23,24 +31,27 @@ export const task: Task<Args> = {
 	summary: 'execute a file with the loader, like `node` but works for TypeScript',
 	Args,
 	run: async ({args, log}) => {
-		const {
-			_: [path, ...argv],
-		} = args;
+		const {_, ...forwarded_args} = args;
+		const [path, ...positional_argv] = _;
 
 		if (!path) {
-			log.info(st('green', '\n\nUsage: ') + st('cyan', 'gro run path/to/file.ts [...node_args]\n'));
+			log.info(st('green', '\n\nUsage: ') + st('cyan', 'gro run path/to/file.ts [...args]\n'));
 			return;
 		}
 
 		if (!existsSync(path)) {
-			throw new Task_Error('Cannot find file to run at path: ' + path);
+			throw new TaskError('Cannot find file to run at path: ' + path);
 		}
 
+		// Reconstruct argv: positional args + serialized named args
+		const named_argv = serialize_args(forwarded_args);
+		const full_argv = [...positional_argv, ...named_argv];
+
 		const loader_path = resolve_gro_module_path('loader.js');
 
-		const spawned = await spawn_with_loader(loader_path, path, argv);
+		const spawned = await spawn_with_loader(loader_path, path, full_argv);
 		if (!spawned.ok) {
-			throw new Task_Error(`\`gro run ${path}\` failed with exit code ${spawned.code}`);
+			throw new TaskError(`\`gro run ${path}\` failed with exit code ${spawned.code}`);
 		}
 	},
 };

package/src/lib/run_gen.ts

@@ -4,43 +4,43 @@ import type {Timings} from '@ryanatkn/belt/timings.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 
 import {
-	type Gen_Results,
-	type Genfile_Module_Result,
-	type Gen_Context,
-	type Genfile_Module_Meta,
+	type GenResults,
+	type GenfileModuleResult,
+	type GenContext,
+	type GenfileModuleMeta,
 	to_gen_result,
-	type Raw_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 {Gro_Config} from './gro_config.ts';
+import type {GroConfig} from './gro_config.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import type {Filer} from './filer.ts';
-import type {Invoke_Task} from './task.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<Genfile_Module_Meta>,
-	config: Gro_Config,
+	gen_modules: Array<GenfileModuleMeta>,
+	config: GroConfig,
 	filer: Filer,
 	log: Logger,
 	timings: Timings,
-	invoke_task: Invoke_Task,
+	invoke_task: InvokeTask,
 	format_file?: typeof base_format_file,
-): Promise<Gen_Results> => {
+): Promise<GenResults> => {
 	let input_count = 0;
 	let output_count = 0;
 	const timing_for_run_gen = timings.start('run_gen');
 	const results = await Promise.all(
-		gen_modules.map(async (module_meta): Promise<Genfile_Module_Result> => {
+		gen_modules.map(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: Gen_Context = {
+			const gen_ctx: GenContext = {
 				config,
 				svelte_config: default_svelte_config,
 				filer,
@@ -51,7 +51,7 @@ export const run_gen = async (
 				origin_path: to_root_path(id),
 				changed_file_id: undefined,
 			};
-			let raw_gen_result: Raw_Gen_Result;
+			let raw_gen_result: RawGenResult;
 			try {
 				raw_gen_result = await gen_config.generate(gen_ctx);
 			} catch (err) {

package/src/lib/run_task.ts

@@ -6,12 +6,12 @@ import {z} from 'zod';
 import {parse_args, type Args} from './args.ts';
 import type {invoke_task as base_invoke_task} from './invoke_task.ts';
 import {log_task_help} from './task_logging.ts';
-import type {Gro_Config} from './gro_config.ts';
-import {Task_Error, type Task_Module_Meta} from './task.ts';
+import type {GroConfig} from './gro_config.ts';
+import {TaskError, type TaskModuleMeta} from './task.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import type {Filer} from './filer.ts';
 
-export type Run_Task_Result =
+export type RunTaskResult =
 	| {
 			ok: true;
 			output: unknown;
@@ -23,14 +23,14 @@ export type Run_Task_Result =
 	  };
 
 export const run_task = async (
-	task_meta: Task_Module_Meta,
+	task_meta: TaskModuleMeta,
 	unparsed_args: Args,
 	invoke_task: typeof base_invoke_task,
-	config: Gro_Config,
+	config: GroConfig,
 	filer: Filer,
 	log: Logger,
 	timings: Timings,
-): Promise<Run_Task_Result> => {
+): Promise<RunTaskResult> => {
 	const {task} = task_meta.mod;
 
 	if (unparsed_args.help) {
@@ -43,7 +43,7 @@ export const run_task = async (
 	if (task.Args) {
 		const parsed = parse_args(unparsed_args, task.Args);
 		if (!parsed.success) {
-			throw new Task_Error(
+			throw new TaskError(
 				`Failed task args validation for task '${task_meta.name}':\n${z.prettifyError(parsed.error)}`,
 			);
 		}
@@ -68,7 +68,7 @@ export const run_task = async (
 			ok: false,
 			reason: st(
 				'red',
-				err?.constructor?.name === 'Task_Error'
+				err?.constructor?.name === 'TaskError'
 					? (err.message as string)
 					: `Unexpected error running task ${st(
 							'cyan',

package/src/lib/search_fs.ts

@@ -3,21 +3,21 @@ import {to_array} from '@ryanatkn/belt/array.js';
 import {ensure_end} from '@ryanatkn/belt/string.js';
 import {isAbsolute, join} from 'node:path';
 import {existsSync, readdirSync} from 'node:fs';
-import type {File_Filter, Resolved_Path, Path_Filter} from '@ryanatkn/belt/path.js';
+import type {FileFilter, ResolvedPath, PathFilter} from '@ryanatkn/belt/path.js';
 
-export interface Search_Fs_Options {
+export interface SearchFsOptions {
 	/**
 	 * One or more filter functions, any of which can short-circuit the search by returning `false`.
 	 */
-	filter?: Path_Filter | Array<Path_Filter>;
+	filter?: PathFilter | Array<PathFilter>;
 	/**
 	 * One or more file filter functions. Every filter must pass for a file to be included.
 	 */
-	file_filter?: File_Filter | Array<File_Filter>;
+	file_filter?: FileFilter | Array<FileFilter>;
 	/**
 	 * Pass `null` or `false` to speed things up at the cost of volatile ordering.
 	 */
-	sort?: boolean | null | ((a: Resolved_Path, b: Resolved_Path) => number);
+	sort?: boolean | null | ((a: ResolvedPath, b: ResolvedPath) => number);
 	/**
 	 * Set to `true` to include directories. Defaults to `false`.
 	 */
@@ -30,8 +30,8 @@ export interface Search_Fs_Options {
 
 export const search_fs = (
 	dir: string,
-	options: Search_Fs_Options = EMPTY_OBJECT,
-): Array<Resolved_Path> => {
+	options: SearchFsOptions = EMPTY_OBJECT,
+): Array<ResolvedPath> => {
 	const {
 		filter,
 		file_filter,
@@ -51,22 +51,22 @@ export const search_fs = (
 
 	if (!existsSync(final_dir)) return [];
 
-	const paths: Array<Resolved_Path> = [];
+	const paths: Array<ResolvedPath> = [];
 	crawl(final_dir, paths, filters, file_filters, include_directories, null);
 
 	return sort ? paths.sort(typeof sort === 'boolean' ? default_sort : sort) : paths;
 };
 
-const default_sort = (a: Resolved_Path, b: Resolved_Path): number => a.path.localeCompare(b.path);
+const default_sort = (a: ResolvedPath, b: ResolvedPath): number => a.path.localeCompare(b.path);
 
 const crawl = (
 	dir: string,
-	paths: Array<Resolved_Path>,
-	filters: Array<Path_Filter> | undefined,
-	file_filter: Array<File_Filter> | undefined,
+	paths: Array<ResolvedPath>,
+	filters: Array<PathFilter> | undefined,
+	file_filter: Array<FileFilter> | undefined,
 	include_directories: boolean,
 	base_dir: string | null,
-): Array<Resolved_Path> => {
+): Array<ResolvedPath> => {
 	// This sync version is significantly faster than using the `fs/promises` version -
 	// it doesn't parallelize but that's not the common case in Gro.
 	const dirents = readdirSync(dir, {withFileTypes: true});

package/src/lib/src_json.ts

@@ -2,8 +2,8 @@ import {join} from 'node:path';
 import {ensure_end, strip_start} from '@ryanatkn/belt/string.js';
 import {existsSync} from 'node:fs';
 import ts from 'typescript';
-import type {Package_Json, Package_Json_Exports} from '@ryanatkn/belt/package_json.js';
-import {Src_Json, type Module_Json, type Identifier_Kind} from '@ryanatkn/belt/src_json.js';
+import type {PackageJson, PackageJsonExports} from '@ryanatkn/belt/package_json.js';
+import {SrcJson, type ModuleJson, type IdentifierKind} from '@ryanatkn/belt/src_json.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 
 import {paths, replace_extension} from './paths.ts';
@@ -11,29 +11,29 @@ import {parse_exports} from './parse_exports.ts';
 import {TS_MATCHER, SVELTE_MATCHER, JSON_MATCHER, CSS_MATCHER} from './constants.ts';
 import {search_fs} from './search_fs.ts';
 
-export type Src_Json_Mapper = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
+export type SrcJsonMapper = (src_json: SrcJson) => SrcJson | null | Promise<SrcJson | null>;
 
 export const src_json_create = (
-	package_json: Package_Json,
+	package_json: PackageJson,
 	lib_path?: string,
 	log?: Logger,
-): Src_Json =>
-	Src_Json.parse({
+): SrcJson =>
+	SrcJson.parse({
 		name: package_json.name,
 		version: package_json.version,
 		modules: src_modules_create(package_json.exports, lib_path, log),
 	});
 
-export const src_json_serialize = (src_json: Src_Json): string => {
-	const parsed = Src_Json.parse(src_json);
+export const src_json_serialize = (src_json: SrcJson): string => {
+	const parsed = SrcJson.parse(src_json);
 	return JSON.stringify(parsed, null, 2) + '\n';
 };
 
 export const src_modules_create = (
-	exports: Package_Json_Exports | undefined,
+	exports: PackageJsonExports | undefined,
 	lib_path = paths.lib,
 	log?: Logger,
-): Array<Module_Json> | undefined => {
+): Array<ModuleJson> | undefined => {
 	if (!exports) return;
 
 	const file_paths = collect_file_paths(exports, lib_path);
@@ -58,14 +58,14 @@ export const src_modules_create = (
 		);
 	}
 
-	const result: Array<Module_Json> = [];
+	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 identifiers = parse_exports(file_path, program, undefined, log)
-			.filter((d): d is {name: string; kind: Identifier_Kind} => d.kind !== null) // TODO maybe dont filter out?
+			.filter((d): d is {name: string; kind: IdentifierKind} => d.kind !== null) // TODO maybe dont filter out?
 			.map(({name, kind}) => ({name, kind}));
 
 		result.push(
@@ -84,7 +84,7 @@ export const src_modules_create = (
 };
 
 const collect_file_paths = (
-	exports: Package_Json_Exports,
+	exports: PackageJsonExports,
 	lib_path: string,
 ): Array<{export_key: string; file_path: string}> => {
 	const file_paths: Array<{export_key: string; file_path: string}> = [];

package/src/lib/svelte_config.ts

@@ -37,7 +37,7 @@ export const load_svelte_config = async ({
  * 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 Parsed_Svelte_Config {
+export interface ParsedSvelteConfig {
 	// TODO probably fill these out with defaults
 	svelte_config: SvelteConfig | null;
 	alias: Record<string, string>;
@@ -78,7 +78,7 @@ export const parse_svelte_config = async ({
 }: {
 	dir_or_config?: string | SvelteConfig;
 	config_filename?: string;
-} = EMPTY_OBJECT): Promise<Parsed_Svelte_Config> => {
+} = EMPTY_OBJECT): Promise<ParsedSvelteConfig> => {
 	const svelte_config =
 		typeof dir_or_config === 'string'
 			? await load_svelte_config({dir: dir_or_config, config_filename})

package/src/lib/sveltekit_helpers.ts

@@ -1,11 +1,11 @@
 import type {Result} from '@ryanatkn/belt/result.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {join} from 'node:path';
-import type {Package_Json} from '@ryanatkn/belt/package_json.js';
+import type {PackageJson} from '@ryanatkn/belt/package_json.js';
 import {fs_exists} from '@ryanatkn/belt/fs.js';
 
 import {has_dep} from './package_json.ts';
-import {default_svelte_config, type Parsed_Svelte_Config} from './svelte_config.ts';
+import {default_svelte_config, type ParsedSvelteConfig} from './svelte_config.ts';
 import {
 	SVELTE_CONFIG_FILENAME,
 	SVELTEKIT_DEV_DIRNAME,
@@ -14,7 +14,7 @@ import {
 	SVELTEKIT_CLI,
 } from './constants.ts';
 import {find_cli, spawn_cli, to_cli_name, type Cli} from './cli.ts';
-import {Task_Error} from './task.ts';
+import {TaskError} from './task.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 
 export const has_sveltekit_app = async (
@@ -28,8 +28,8 @@ export const has_sveltekit_app = async (
 };
 
 export const has_sveltekit_library = async (
-	package_json: Package_Json,
-	svelte_config: Parsed_Svelte_Config = default_svelte_config,
+	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();
@@ -57,11 +57,11 @@ export const sveltekit_sync = async (
 ): Promise<void> => {
 	const result = await spawn_cli(sveltekit_cli, ['sync']);
 	if (!result) {
-		throw new Task_Error(
+		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 Task_Error(`Failed ${to_cli_name(sveltekit_cli)} sync`);
+		throw new TaskError(`Failed ${to_cli_name(sveltekit_cli)} sync`);
 	}
 };
 
@@ -100,7 +100,7 @@ export const sveltekit_sync_if_obviously_needed = async (
  * Options to the SvelteKit packaging CLI.
  * @see https://kit.svelte.dev/docs/packaging#options
  */
-export interface Svelte_Package_Options {
+export interface SveltePackageOptions {
 	/**
 	 * Watch files in src/lib for changes and rebuild the package
 	 */
@@ -147,22 +147,22 @@ export interface Svelte_Package_Options {
 }
 
 export const run_svelte_package = async (
-	package_json: Package_Json,
-	options: Svelte_Package_Options | undefined,
+	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 Task_Error(
+		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 ? find_cli(cli) : (cli as Cli);
 	if (found_svelte_package_cli?.kind !== 'local') {
-		throw new Task_Error(
+		throw new TaskError(
 			`Failed to find SvelteKit packaging CLI \`${cli_name}\`, do you need to run \`${pm_cli} install\`?`,
 		);
 	}

package/src/lib/sveltekit_shim_app.ts

@@ -1,4 +1,4 @@
-import type {Parsed_Svelte_Config} from './svelte_config.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
 
 export const SVELTEKIT_SHIM_APP_PATHS_MATCHER = /\/util\/sveltekit_shim_app_paths\.js$/;
 export const SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER = /\/util\/sveltekit_shim_app_environment\.js$/;
@@ -16,8 +16,8 @@ export const sveltekit_shim_app_specifiers = new Map([
 ]);
 
 export const render_sveltekit_shim_app_paths = (
-	base_url: Parsed_Svelte_Config['base_url'] = '',
-	assets_url: Parsed_Svelte_Config['assets_url'] = '',
+	base_url: ParsedSvelteConfig['base_url'] = '',
+	assets_url: ParsedSvelteConfig['assets_url'] = '',
 ): string => `// shim for $app/paths
 // @see https://github.com/sveltejs/kit/issues/1485
 

package/src/lib/sync.task.ts

@@ -1,7 +1,7 @@
 import {z} from 'zod';
 import {spawn} from '@ryanatkn/belt/process.js';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {sync_package_json} from './package_json.ts';
 import {sveltekit_sync} from './sveltekit_helpers.ts';
 
@@ -27,7 +27,7 @@ export const task: Task<Args> = {
 		if (install) {
 			const result = await spawn(config.pm_cli, ['install']);
 			if (!result.ok) {
-				throw new Task_Error(`Failed \`${config.pm_cli} install\``);
+				throw new TaskError(`Failed \`${config.pm_cli} install\``);
 			}
 		}