@ryanatkn/gro 0.175.0 → 0.177.0

package/src/lib/task.ts

@@ -5,57 +5,57 @@ import type {Timings} from '@ryanatkn/belt/timings.js';
 import {styleText as st} from 'node:util';
 import type {Result} from '@ryanatkn/belt/result.js';
 import {isAbsolute, join, relative} from 'node:path';
-import type {Path_Id} from '@ryanatkn/belt/path.js';
+import type {PathId} from '@ryanatkn/belt/path.js';
 
 import type {Args} from './args.ts';
-import type {Gro_Config} from './gro_config.ts';
-import type {Parsed_Svelte_Config} from './svelte_config.ts';
+import type {GroConfig} from './gro_config.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
 import {
 	resolve_input_files,
 	resolve_input_paths,
-	type Input_Path,
-	type Resolved_Input_File,
-	type Resolved_Input_Path,
+	type InputPath,
+	type ResolvedInputFile,
+	type ResolvedInputPath,
 } from './input_path.ts';
 import {GRO_DIST_DIR, print_path} from './paths.ts';
 import {search_fs} from './search_fs.ts';
-import {load_modules, type Load_Modules_Failure, type Module_Meta} from './modules.ts';
+import {load_modules, type LoadModulesFailure, type ModuleMeta} from './modules.ts';
 import type {Filer} from './filer.ts';
 
 export interface Task<
-	T_Args = Args,
-	T_Args_Schema extends z.ZodType<Args, Args> = z.ZodType<Args, Args>, // TODO improve type? separate input/output?
-	T_Return = unknown,
+	TArgs = Args,
+	TArgsSchema extends z.ZodType<Args, Args> = z.ZodType<Args, Args>, // TODO improve type? separate input/output?
+	TReturn = unknown,
 > {
-	run: (ctx: Task_Context<T_Args>) => T_Return | Promise<T_Return>; // TODO unused return value
+	run: (ctx: TaskContext<TArgs>) => TReturn | Promise<TReturn>; // TODO unused return value
 	summary?: string;
-	Args?: T_Args_Schema;
+	Args?: TArgsSchema;
 }
 
-export interface Task_Context<T_Args = object> {
-	args: T_Args;
-	config: Gro_Config;
-	svelte_config: Parsed_Svelte_Config;
+export interface TaskContext<TArgs = object> {
+	args: TArgs;
+	config: GroConfig;
+	svelte_config: ParsedSvelteConfig;
 	filer: Filer;
 	log: Logger;
 	timings: Timings;
-	invoke_task: Invoke_Task;
+	invoke_task: InvokeTask;
 }
 
-export type Invoke_Task = (task_name: string, args?: Args, config?: Gro_Config) => Promise<void>;
+export type InvokeTask = (task_name: string, args?: Args, config?: GroConfig) => Promise<void>;
 
 export const TASK_FILE_SUFFIX_TS = '.task.ts';
 export const TASK_FILE_SUFFIX_JS = '.task.js';
-export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `Gro_Config`, but needs to be used everywhere the constants are
+export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `GroConfig`, but needs to be used everywhere the constants are
 
 export const is_task_path = (path: string): boolean =>
 	path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
 
 export const to_task_name = (
-	id: Path_Id,
-	task_root_dir: Path_Id,
-	input_path: Input_Path,
-	root_path: Path_Id,
+	id: PathId,
+	task_root_dir: PathId,
+	input_path: InputPath,
+	root_path: PathId,
 ): string => {
 	let task_name = id.startsWith(task_root_dir)
 		? strip_start(strip_start(id, task_root_dir), '/')
@@ -80,46 +80,46 @@ export const to_task_name = (
  * It's useful for cleaning up logging because
  * we usually don't need their stack trace.
  */
-export class Task_Error extends Error {}
+export class TaskError extends Error {}
 
 /**
  * This is used to tell Gro to exit silently, usually still with with a non-zero exit code.
  * Using it means error logging is handled by the code that threw it.
  */
-export class Silent_Error extends Error {}
+export class SilentError extends Error {}
 
-export interface Found_Task {
-	input_path: Input_Path;
-	id: Path_Id;
-	task_root_dir: Path_Id;
+export interface FoundTask {
+	input_path: InputPath;
+	id: PathId;
+	task_root_dir: PathId;
 }
 
-export interface Found_Tasks {
-	resolved_input_files: Array<Resolved_Input_File>;
-	resolved_input_files_by_root_dir: Map<Path_Id, Array<Resolved_Input_File>>;
-	resolved_input_paths: Array<Resolved_Input_Path>;
-	input_paths: Array<Input_Path>;
-	task_root_dirs: Array<Path_Id>;
+export interface FoundTasks {
+	resolved_input_files: Array<ResolvedInputFile>;
+	resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+	resolved_input_paths: Array<ResolvedInputPath>;
+	input_paths: Array<InputPath>;
+	task_root_dirs: Array<PathId>;
 }
 
-export type Find_Tasks_Result = Result<{value: Found_Tasks}, Find_Modules_Failure>;
-export type Find_Modules_Failure =
+export type FindTasksResult = Result<{value: FoundTasks}, FindModulesFailure>;
+export type FindModulesFailure =
 	| {
 			type: 'unmapped_input_paths';
-			unmapped_input_paths: Array<Input_Path>;
-			resolved_input_paths: Array<Resolved_Input_Path>;
-			input_paths: Array<Input_Path>;
-			task_root_dirs: Array<Path_Id>;
+			unmapped_input_paths: Array<InputPath>;
+			resolved_input_paths: Array<ResolvedInputPath>;
+			input_paths: Array<InputPath>;
+			task_root_dirs: Array<PathId>;
 			reasons: Array<string>;
 	  }
 	| {
 			type: 'input_directories_with_no_files';
-			input_directories_with_no_files: Array<Input_Path>;
-			resolved_input_files: Array<Resolved_Input_File>;
-			resolved_input_files_by_root_dir: Map<Path_Id, Array<Resolved_Input_File>>;
-			resolved_input_paths: Array<Resolved_Input_Path>;
-			input_paths: Array<Input_Path>;
-			task_root_dirs: Array<Path_Id>;
+			input_directories_with_no_files: Array<InputPath>;
+			resolved_input_files: Array<ResolvedInputFile>;
+			resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+			resolved_input_paths: Array<ResolvedInputPath>;
+			input_paths: Array<InputPath>;
+			task_root_dirs: Array<PathId>;
 			reasons: Array<string>;
 	  };
 
@@ -127,11 +127,11 @@ export type Find_Modules_Failure =
  * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
  */
 export const find_tasks = (
-	input_paths: Array<Input_Path>,
-	task_root_dirs: Array<Path_Id>,
-	config: Gro_Config,
+	input_paths: Array<InputPath>,
+	task_root_dirs: Array<PathId>,
+	config: GroConfig,
 	timings?: Timings,
-): Find_Tasks_Result => {
+): FindTasksResult => {
 	// Check which extension variation works - if it's a directory, prefer others first!
 	const timing_to_resolve_input_paths = timings?.start('resolve input paths');
 	const {resolved_input_paths, unmapped_input_paths} = resolve_input_paths(
@@ -196,30 +196,30 @@ export const find_tasks = (
 	};
 };
 
-export interface Loaded_Tasks {
-	modules: Array<Task_Module_Meta>;
-	found_tasks: Found_Tasks;
+export interface LoadedTasks {
+	modules: Array<TaskModuleMeta>;
+	found_tasks: FoundTasks;
 }
 
-export interface Task_Module {
+export interface TaskModule {
 	task: Task;
 }
 
-export interface Task_Module_Meta extends Module_Meta<Task_Module> {
+export interface TaskModuleMeta extends ModuleMeta<TaskModule> {
 	name: string;
 }
 
-export type Load_Tasks_Result = Result<{value: Loaded_Tasks}, Load_Tasks_Failure>;
-export type Load_Tasks_Failure = Load_Modules_Failure<Task_Module_Meta>;
+export type LoadTasksResult = Result<{value: LoadedTasks}, LoadTasksFailure>;
+export type LoadTasksFailure = LoadModulesFailure<TaskModuleMeta>;
 
 export const load_tasks = async (
-	found_tasks: Found_Tasks,
-	root_path: Path_Id = process.cwd(), // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
-): Promise<Load_Tasks_Result> => {
+	found_tasks: FoundTasks,
+	root_path: PathId = process.cwd(), // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
+): Promise<LoadTasksResult> => {
 	const loaded_modules = await load_modules(
 		found_tasks.resolved_input_files,
 		validate_task_module,
-		(resolved_input_file, mod): Task_Module_Meta => ({
+		(resolved_input_file, mod): TaskModuleMeta => ({
 			id: resolved_input_file.id,
 			mod,
 			name: to_task_name(
@@ -240,5 +240,5 @@ export const load_tasks = async (
 	};
 };
 
-export const validate_task_module = (mod: Record<string, any>): mod is Task_Module =>
+export const validate_task_module = (mod: Record<string, any>): mod is TaskModule =>
 	!!mod.task && typeof mod.task.run === 'function';

package/src/lib/task_logging.ts

@@ -4,11 +4,11 @@ import {plural} from '@ryanatkn/belt/string.js';
 import {print_value} from '@ryanatkn/belt/print.js';
 import {z} from 'zod';
 
-import type {Arg_Schema} from './args.ts';
-import type {Loaded_Tasks, Task_Module_Meta} from './task.ts';
+import type {ArgSchema} from './args.ts';
+import type {LoadedTasks, TaskModuleMeta} from './task.ts';
 import {print_path} from './paths.ts';
 
-export const log_tasks = (log: Logger, loaded_tasks: Loaded_Tasks, log_intro = true): void => {
+export const log_tasks = (log: Logger, loaded_tasks: LoadedTasks, log_intro = true): void => {
 	const {modules, found_tasks} = loaded_tasks;
 	const {resolved_input_files_by_root_dir} = found_tasks;
 
@@ -52,7 +52,7 @@ export const log_error_reasons = (log: Logger, reasons: Array<string>): void =>
 
 const ARGS_PROPERTY_NAME = '[...args]';
 
-export const log_task_help = (log: Logger, meta: Task_Module_Meta): void => {
+export const log_task_help = (log: Logger, meta: TaskModuleMeta): void => {
 	const {
 		name,
 		mod: {task},
@@ -92,17 +92,17 @@ export const log_task_help = (log: Logger, meta: Task_Module_Meta): void => {
 // The following Zod helpers only need to support single-depth schemas for CLI args,
 // but there's generic recursion to handle things like `ZodOptional` and `ZodDefault`.
 
-interface Arg_Schema_Property {
+interface ArgSchemaProperty {
 	name: string;
-	schema: Arg_Schema;
+	schema: ArgSchema;
 }
 
 // TODO this blocks many usecases like unions, and it's only implemented for CLI arg types, need better support for arbitrary schemas
 const to_arg_properties = (
 	schema: z.ZodType,
-	meta: Task_Module_Meta,
+	meta: TaskModuleMeta,
 	log: Logger,
-): Array<Arg_Schema_Property> => {
+): Array<ArgSchemaProperty> => {
 	const {def} = schema;
 
 	// TODO overly restrictive, support optional objects and/or unions?
@@ -112,11 +112,11 @@ const to_arg_properties = (
 	}
 	const shape = (def as z.core.$ZodObjectDef).shape;
 
-	const properties: Array<Arg_Schema_Property> = [];
+	const properties: Array<ArgSchemaProperty> = [];
 	for (const name in shape) {
 		if ('no-' + name in shape) continue;
 		const s = shape[name] as z.ZodType;
-		const schema: Arg_Schema = {
+		const schema: ArgSchema = {
 			type: to_args_schema_type(s),
 			description: to_args_schema_description(s) || '',
 			default: to_args_schema_default(s),
@@ -129,7 +129,7 @@ const to_arg_properties = (
 const to_max_length = <T>(items: Array<T>, toString: (item: T) => string) =>
 	items.reduce((max, m) => Math.max(toString(m).length, max), 0);
 
-const to_args_schema_type = (schema: z.ZodType): Arg_Schema['type'] => {
+const to_args_schema_type = (schema: z.ZodType): ArgSchema['type'] => {
 	const {def} = schema._zod;
 	switch (def.type) {
 		case 'string':

package/src/lib/test.task.ts

@@ -1,7 +1,7 @@
 import {z} from 'zod';
 import {spawn_cli} from '@ryanatkn/gro/cli.js';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {find_cli} from './cli.ts';
 import {has_dep} from './package_json.ts';
 import {serialize_args, to_implicit_forwarded_args} from './args.ts';
@@ -31,11 +31,11 @@ export const task: Task<Args> = {
 		const {_: patterns, dir, fail_without_tests, t} = args;
 
 		if (!has_dep(VITEST_CLI)) {
-			throw new Task_Error('no test runner found, install vitest');
+			throw new TaskError('no test runner found, install vitest');
 		}
 
 		if (!find_cli(VITEST_CLI)) {
-			throw new Task_Error('vitest is a dependency but not installed; run `npm i`?');
+			throw new TaskError('vitest is a dependency but not installed; run `npm i`?');
 		}
 
 		const vitest_args = ['run', ...patterns];
@@ -52,7 +52,7 @@ export const task: Task<Args> = {
 
 		const spawned = await spawn_cli(VITEST_CLI, vitest_args);
 		if (!spawned?.ok) {
-			throw new Task_Error(`vitest failed with exit code ${spawned?.code}`);
+			throw new TaskError(`vitest failed with exit code ${spawned?.code}`);
 		}
 	},
 };

package/src/lib/typecheck.task.ts

@@ -1,7 +1,7 @@
 import {print_spawn_result} from '@ryanatkn/belt/process.js';
 import {z} from 'zod';
 
-import {Task_Error, type Task} from './task.ts';
+import {TaskError, type Task} from './task.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 import {find_cli, spawn_cli, spawn_cli_process} from './cli.ts';
 import {sveltekit_sync_if_available} from './sveltekit_helpers.ts';
@@ -53,7 +53,7 @@ export const task: Task<Args> = {
 				const svelte_check_result = await spawned.closed;
 
 				if (!svelte_check_result.ok) {
-					throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
+					throw new TaskError(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
 				}
 			}
 
@@ -68,12 +68,12 @@ export const task: Task<Args> = {
 			const serialized = serialize_args(forwarded);
 			const svelte_check_result = await spawn_cli(found_typescript_cli, serialized, log);
 			if (!svelte_check_result?.ok) {
-				throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result!)}`);
+				throw new TaskError(`Failed to typecheck. ${print_spawn_result(svelte_check_result!)}`);
 			}
 			return;
 		}
 
-		throw new Task_Error(
+		throw new TaskError(
 			`Failed to typecheck because neither \`${svelte_check_cli}\` nor \`${typescript_cli}\` was found`,
 		);
 	},

package/src/lib/upgrade.task.ts

@@ -1,10 +1,10 @@
 import {spawn} from '@ryanatkn/belt/process.js';
 import {z} from 'zod';
 import {rmSync} from 'node:fs';
-import {Git_Origin, git_pull} from '@ryanatkn/belt/git.js';
+import {GitOrigin, git_pull} from '@ryanatkn/belt/git.js';
 
-import {Task_Error, type Task} from './task.ts';
-import {extract_deps, load_package_json, type Package_Json_Dep} from './package_json.ts';
+import {TaskError, type Task} from './task.ts';
+import {extract_deps, load_package_json, type PackageJsonDep} from './package_json.ts';
 import {spawn_cli} from './cli.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 import {NODE_MODULES_DIRNAME} from './constants.ts';
@@ -22,7 +22,7 @@ export const Args = z.strictObject({
 		})
 		.default([])
 		.transform((v) => (Array.isArray(v) ? v : [v])),
-	origin: Git_Origin.describe('git origin to deploy to').default('origin'),
+	origin: GitOrigin.describe('git origin to deploy to').default('origin'),
 	force: z.boolean().meta({description: 'if true, print out the planned upgrades'}).default(false),
 	pull: z.boolean().meta({description: 'dual of no-pull'}).default(true),
 	'no-pull': z.boolean().meta({description: 'opt out of git pull'}).default(false),
@@ -65,7 +65,7 @@ export const task: Task<Args> = {
 		} = args;
 
 		if (_.length && only.length) {
-			throw new Task_Error('Cannot call `gro upgrade` with both rest args and --only.');
+			throw new TaskError('Cannot call `gro upgrade` with both rest args and --only.');
 		}
 
 		// TODO maybe a different task that pulls and does other things, like `gro ready`
@@ -92,7 +92,7 @@ export const task: Task<Args> = {
 			: all_deps.filter((d) => !_.includes(d.name));
 
 		if (only.length && only.length !== deps.length) {
-			throw new Task_Error(
+			throw new TaskError(
 				`Some deps to upgrade were not found: ${only.filter((o) => !deps.find((d) => d.name === o)).join(', ')}`,
 			);
 		}
@@ -130,7 +130,7 @@ const CUSTOM_TAG_MATCHER = /^[\^~><=]*.+-(.+)/;
 
 // TODO hacky and limited
 // TODO probably want to pass through exact deps as well, e.g. @foo/bar@1
-const to_upgrade_items = (deps: Array<Package_Json_Dep>): Array<string> =>
+const to_upgrade_items = (deps: Array<PackageJsonDep>): Array<string> =>
 	deps.map((dep) => {
 		if (EXACT_VERSION_MATCHER.test(dep.name)) {
 			return dep.name;

package/src/lib/watch_dir.ts

@@ -2,30 +2,30 @@ import {watch, type ChokidarOptions, type FSWatcher, type Matcher} from 'chokida
 import {relative} from 'node:path';
 import {statSync} from 'node:fs';
 import {create_deferred, type Deferred} from '@ryanatkn/belt/async.js';
-import type {Path_Filter} from '@ryanatkn/belt/path.js';
+import type {PathFilter} from '@ryanatkn/belt/path.js';
 import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
 
 const TMP_FILE_PATTERN = /\.tmp\./;
 
 // TODO pretty hacky
 
-export interface Watch_Node_Fs {
+export interface WatchNodeFs {
 	init: () => Promise<void>;
 	close: () => Promise<void>;
 }
 
-export interface Watcher_Change {
-	type: Watcher_Change_Type;
+export interface WatcherChange {
+	type: WatcherChangeType;
 	path: string;
 	is_directory: boolean;
 }
-export type Watcher_Change_Type = 'add' | 'update' | 'delete';
-export type Watcher_Change_Callback = (change: Watcher_Change) => void;
+export type WatcherChangeType = 'add' | 'update' | 'delete';
+export type WatcherChangeCallback = (change: WatcherChange) => void;
 
-export interface Watch_Dir_Options {
+export interface WatchDirOptions {
 	dir: string;
-	on_change: Watcher_Change_Callback;
-	filter?: Path_Filter | null | undefined;
+	on_change: WatcherChangeCallback;
+	filter?: PathFilter | null | undefined;
 	chokidar?: ChokidarOptions;
 	/**
 	 * When `false`, returns the `path` relative to `dir`.
@@ -51,7 +51,7 @@ export const watch_dir = ({
 	absolute = true,
 	chokidar,
 	ignored = TMP_FILE_PATTERN,
-}: Watch_Dir_Options): Watch_Node_Fs => {
+}: WatchDirOptions): WatchNodeFs => {
 	let watcher: FSWatcher | undefined;
 	let initing: Deferred<void> | undefined;