@ryanatkn/gro 0.160.0 → 0.161.1

package/src/lib/task_logging.ts

@@ -2,7 +2,7 @@ import {styleText as st} from 'node:util';
 import type {Logger} from '@ryanatkn/belt/log.js';
 import {plural} from '@ryanatkn/belt/string.js';
 import {print_value} from '@ryanatkn/belt/print.js';
-import {ZodFirstPartyTypeKind, type ZodObjectDef, type ZodTypeAny, type ZodTypeDef} from 'zod';
+import {z} from 'zod';
 
 import type {Arg_Schema} from './args.ts';
 import type {Loaded_Tasks, Task_Module_Meta} from './task.ts';
@@ -64,7 +64,7 @@ export const log_task_help = (log: Logger, meta: Task_Module_Meta): void => {
 		st('cyan', `\n\ngro ${name}`) + `: ${task.summary ?? '(no summary available)'}\n`,
 	);
 	if (task.Args) {
-		const properties = to_arg_properties(task.Args._def, meta);
+		const properties = to_arg_properties(task.Args, meta, log);
 		// TODO hacky padding for some quick and dirty tables
 		const longest_task_name = Math.max(
 			ARGS_PROPERTY_NAME.length,
@@ -88,26 +88,37 @@ export const log_task_help = (log: Logger, meta: Task_Module_Meta): void => {
 	log.info(...logged, '\n');
 };
 
+// TODO rework all of this
+// 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 {
 	name: string;
 	schema: Arg_Schema;
 }
 
-const to_arg_properties = (def: ZodTypeDef, meta: Task_Module_Meta): Array<Arg_Schema_Property> => {
-	const type_name = to_type_name(def);
-	if (type_name !== ZodFirstPartyTypeKind.ZodObject) {
-		throw Error(
-			`Expected Args for task "${meta.name}" to be a ZodObject schema but got ${type_name}`,
-		);
+// 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,
+	log: Logger,
+): Array<Arg_Schema_Property> => {
+	const {def} = schema;
+
+	// TODO overly restrictive, support optional objects and/or unions?
+	if (!('shape' in def)) {
+		log.error(`Expected Args for task "${meta.name}" to be an object schema but got ${def.type}`);
+		return [];
 	}
-	const shape = (def as ZodObjectDef).shape();
+	const shape = (def as z.core.$ZodObjectDef).shape;
+
 	const properties: Array<Arg_Schema_Property> = [];
 	for (const name in shape) {
 		if ('no-' + name in shape) continue;
-		const s = shape[name];
+		const s = shape[name] as z.ZodType;
 		const schema: Arg_Schema = {
 			type: to_args_schema_type(s),
-			description: to_args_schema_description(s),
+			description: to_args_schema_description(s) || '',
 			default: to_args_schema_default(s),
 		};
 		properties.push({name, schema});
@@ -118,61 +129,128 @@ const to_arg_properties = (def: ZodTypeDef, meta: Task_Module_Meta): Array<Arg_S
 const to_max_length = <T>(items: Array<T>, toString: (item: T) => string) =>
 	items.reduce((max, m) => Math.max(toString(m).length, max), 0);
 
-// 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`.
-const to_type_name = (def: ZodTypeDef): ZodFirstPartyTypeKind => (def as any).typeName;
-const to_args_schema_type = ({_def}: ZodTypeAny): Arg_Schema['type'] => {
-	const t = to_type_name(_def);
-	switch (t) {
-		case ZodFirstPartyTypeKind.ZodBoolean:
-			return 'boolean';
-		case ZodFirstPartyTypeKind.ZodString:
+const to_args_schema_type = (schema: z.ZodType): Arg_Schema['type'] => {
+	const {def} = schema._zod;
+	switch (def.type) {
+		case 'string':
 			return 'string';
-		case ZodFirstPartyTypeKind.ZodNumber:
+		case 'number':
 			return 'number';
-		case ZodFirstPartyTypeKind.ZodArray:
-			return 'Array<string>'; // TODO support arrays of arbitrary types, or more hardcoded ones as needed
-		case ZodFirstPartyTypeKind.ZodEnum:
-			return _def.values.map((v: string) => `'${v}'`).join(' | ');
-		case ZodFirstPartyTypeKind.ZodUnion:
-			return 'string | Array<string>'; // TODO support unions of arbitrary types, or more hardcoded ones as needed
+		case 'int':
+			return 'int';
+		case 'boolean':
+			return 'boolean';
+		case 'bigint':
+			return 'bigint';
+		case 'symbol':
+			return 'symbol';
+		case 'null':
+			return 'null';
+		case 'undefined':
+			return 'undefined';
+		case 'void':
+			return 'void';
+		case 'never':
+			return 'never';
+		case 'any':
+			return 'any';
+		case 'unknown':
+			return 'unknown';
+		case 'date':
+			return 'date';
+		case 'object':
+			return 'object';
+		case 'record':
+			return 'record';
+		case 'file':
+			return 'file';
+		case 'array':
+			// TODO other types, only handling a subset of CLI arg cases
+			return 'Array<string>';
+		case 'tuple':
+			return 'tuple';
+		case 'union':
+			// TODO fix, this is a hacky way to handle unions for CLI args
+			return 'string | Array<string>';
+		case 'intersection':
+			return 'intersection';
+		case 'map':
+			return 'map';
+		case 'set':
+			return 'set';
+		case 'enum':
+			return (schema as unknown as {options: Array<string>}).options
+				.map((v) => `'${v}'`)
+				.join(' | ');
+		case 'literal':
+			return (def as unknown as {values: Array<any>}).values.map((v) => print_value(v)).join(' | ');
+		case 'nullable': {
+			const subschema = to_subschema(def);
+			return subschema ? to_args_schema_type(subschema) + ' | null' : 'nullable';
+		}
+		case 'optional': {
+			const subschema = to_subschema(def);
+			return subschema ? to_args_schema_type(subschema) + ' | undefined' : 'optional';
+		}
+		case 'success':
+			return 'success';
+		case 'catch':
+			return 'catch';
+		case 'nan':
+			return 'NaN';
+		case 'readonly':
+			return 'readonly';
+		case 'template_literal':
+			return 'template_literal';
+		case 'promise':
+			return 'promise';
+		case 'lazy':
+			return 'lazy';
+		case 'custom':
+			return 'custom';
+		// Unwrap these:
+		// case 'nonoptional':
+		// case 'transform':
+		// case 'default':
+		// case 'prefault':
+		// case 'pipe':
 		default: {
-			const subschema = to_subschema(_def);
-			if (subschema) {
-				return to_args_schema_type(subschema);
-			} else {
-				throw Error('Unknown zod type ' + t);
-			}
+			const subschema = to_subschema(def);
+			return subschema ? to_args_schema_type(subschema) : def.type;
 		}
 	}
 };
-const to_args_schema_description = ({_def}: ZodTypeAny): string => {
-	if (_def.description) {
-		return _def.description;
+
+const to_args_schema_description = (schema: z.ZodType): string | null => {
+	const meta = schema.meta();
+	if (meta?.description) {
+		return meta.description;
 	}
-	const subschema = to_subschema(_def);
+	const subschema = to_subschema(schema.def);
 	if (subschema) {
 		return to_args_schema_description(subschema);
 	}
-	return '';
+	return null;
 };
-const to_args_schema_default = ({_def}: ZodTypeAny): any => {
-	if (_def.defaultValue) {
-		return _def.defaultValue();
+
+const to_args_schema_default = (schema: z.ZodType): any => {
+	const {def} = schema._zod;
+	if ('defaultValue' in def) {
+		return def.defaultValue;
 	}
-	const subschema = to_subschema(_def);
+	const subschema = to_subschema(def);
 	if (subschema) {
 		return to_args_schema_default(subschema);
 	}
 };
 
-const to_subschema = (_def: any): ZodTypeAny | undefined => {
-	if ('type' in _def) {
-		return _def.type;
-	} else if ('innerType' in _def) {
-		return _def.innerType;
-	} else if ('schema' in _def) {
-		return _def.schema;
+const to_subschema = (def: z.core.$ZodTypeDef): z.ZodType | undefined => {
+	if ('innerType' in def) {
+		return def.innerType as any;
+	} else if ('in' in def) {
+		return def.in as any;
+	} else if ('schema' in def) {
+		return def.schema as any;
 	}
 	return undefined;
 };

package/src/lib/test.task.ts

@@ -5,18 +5,18 @@ import {Task_Error, type Task} from './task.ts';
 import {paths} from './paths.ts';
 import {find_cli} from './cli.ts';
 
-export const Args = z
-	.object({
-		_: z.array(z.string(), {description: 'file patterns to test'}).default([`\\.test\\.ts$`]), // TODO maybe use uvu's default instead of being restrictive?
-		bail: z
-			.boolean({description: 'the bail option to uvu run, exit immediately on failure'})
-			.default(false),
-		cwd: z.string({description: 'the cwd option to uvu parse'}).optional(),
-		ignore: z
-			.union([z.string(), z.array(z.string())], {description: 'the ignore option to uvu parse'})
-			.optional(),
-	})
-	.strict();
+export const Args = z.strictObject({
+	_: z.array(z.string()).meta({description: 'file patterns to test'}).default([`\\.test\\.ts$`]), // TODO maybe use uvu's default instead of being restrictive?
+	bail: z
+		.boolean()
+		.meta({description: 'the bail option to uvu run, exit immediately on failure'})
+		.default(false),
+	cwd: z.string().meta({description: 'the cwd option to uvu parse'}).optional(),
+	ignore: z
+		.union([z.string(), z.array(z.string())])
+		.meta({description: 'the ignore option to uvu parse'})
+		.optional(),
+});
 export type Args = z.infer<typeof Args>;
 
 export const task: Task<Args> = {

package/src/lib/typecheck.task.ts

@@ -8,24 +8,25 @@ import {SVELTE_CHECK_CLI, sveltekit_sync_if_available} from './sveltekit_helpers
 import {configure_colored_output_with_path_replacement} from './child_process_logging.ts';
 import {paths} from './paths.ts';
 
-export const Args = z
-	.object({
-		svelte_check_cli: z
-			.string({description: 'the svelte-check CLI to use'})
-			.default(SVELTE_CHECK_CLI),
-		typescript_cli: z
-			.string({description: 'the TypeScript CLI to use as a fallback to svelte-check'})
-			.default('tsc'),
-		path_replacement: z
-			.string({description: 'replacement string for current working directory in output'})
-			.default('.'),
-		cwd: z.string({description: 'current working directory'}).default(paths.root),
-	})
-	.strict();
+export const Args = z.strictObject({
+	svelte_check_cli: z
+		.string()
+		.meta({description: 'the svelte-check CLI to use'})
+		.default(SVELTE_CHECK_CLI),
+	typescript_cli: z
+		.string()
+		.meta({description: 'the TypeScript CLI to use as a fallback to svelte-check'})
+		.default('tsc'),
+	path_replacement: z
+		.string()
+		.meta({description: 'replacement string for current working directory in output'})
+		.default('.'),
+	cwd: z.string().meta({description: 'current working directory'}).default(paths.root),
+});
 export type Args = z.infer<typeof Args>;
 
 export const task: Task<Args> = {
-	summary: 'run tsc on the project without emitting any files',
+	summary: 'run svelte-check or tsc on the project without emitting any files',
 	Args,
 	run: async ({args, log}): Promise<void> => {
 		const {svelte_check_cli, typescript_cli, path_replacement, cwd} = args;

package/src/lib/upgrade.task.ts

@@ -9,34 +9,40 @@ import {spawn_cli} from './cli.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 import {NODE_MODULES_DIRNAME} from './constants.ts';
 
-export const Args = z
-	.object({
-		_: z.array(z.string(), {description: 'names of deps to exclude from the upgrade'}).default([]),
-		only: z
-			.union([z.string(), z.array(z.string())], {
-				description: 'names of deps to include in the upgrade',
-			})
-			.default([])
-			.transform((v) => (Array.isArray(v) ? v : [v])),
-		origin: Git_Origin.describe('git origin to deploy to').default('origin'),
-		force: z.boolean({description: 'if true, print out the planned upgrades'}).default(false),
-		pull: z.boolean({description: 'dual of no-pull'}).default(true),
-		'no-pull': z.boolean({description: 'opt out of git pull'}).default(false),
-		delete_node_modules: z
-			.boolean({description: 'if true, deletes node_modules before upgrading'})
-			.default(false),
-		node_modules_path: z // TODO maybe configured globally instead
-			.string({description: 'path to modules directory to delete'})
-			.default(NODE_MODULES_DIRNAME),
-		delete_lockfile: z
-			.boolean({description: 'if true, deletes the lockfile before upgrading'})
-			.default(false),
-		lockfile_path: z
-			.string({description: 'path to the lockfile to delete'})
-			.default('package-lock.json'),
-		dry: z.boolean({description: 'if true, print out the planned upgrades'}).default(false),
-	})
-	.strict();
+export const Args = z.strictObject({
+	_: z
+		.array(z.string())
+		.meta({description: 'names of deps to exclude from the upgrade'})
+		.default([]),
+	only: z
+		.union([z.string(), z.array(z.string())])
+		.meta({
+			description: 'names of deps to include in the upgrade',
+		})
+		.default([])
+		.transform((v) => (Array.isArray(v) ? v : [v])),
+	origin: Git_Origin.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),
+	delete_node_modules: z
+		.boolean()
+		.meta({description: 'if true, deletes node_modules before upgrading'})
+		.default(false),
+	node_modules_path: z // TODO maybe configured globally instead
+		.string()
+		.meta({description: 'path to modules directory to delete'})
+		.default(NODE_MODULES_DIRNAME),
+	delete_lockfile: z
+		.boolean()
+		.meta({description: 'if true, deletes the lockfile before upgrading'})
+		.default(false),
+	lockfile_path: z
+		.string()
+		.meta({description: 'path to the lockfile to delete'})
+		.default('package-lock.json'),
+	dry: z.boolean().meta({description: 'if true, print out the planned upgrades'}).default(false),
+});
 export type Args = z.infer<typeof Args>;
 
 export const task: Task<Args> = {

package/dist/package_meta.d.ts

@@ -1,23 +0,0 @@
-import type { Package_Json, Url } from './package_json.ts';
-import type { Src_Json } from './src_json.ts';
-export interface Package_Meta {
-    repo_url: Url;
-    package_json: Package_Json;
-    src_json: Src_Json;
-    name: string;
-    repo_name: string;
-    /**
-     * The github user/org.
-     */
-    owner_name: string | null;
-    homepage_url: Url | null;
-    logo_url: Url | null;
-    logo_alt: string;
-    npm_url: Url | null;
-    changelog_url: Url | null;
-    published: boolean;
-}
-export declare const parse_package_meta: (package_json: Package_Json, src_json: Src_Json) => Package_Meta;
-export declare const parse_repo_name: (name: string) => string;
-export declare const parse_org_url: (pkg: Package_Meta) => string | null;
-//# sourceMappingURL=package_meta.d.ts.map

package/dist/package_meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"package_meta.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/package_meta.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,YAAY,EAAE,GAAG,EAAC,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AAG5C,MAAM,WAAW,YAAY;IAC5B,QAAQ,EAAE,GAAG,CAAC;IACd,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,GAAG,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IACpB,aAAa,EAAE,GAAG,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,kBAAkB,GAC9B,cAAc,YAAY,EAC1B,UAAU,QAAQ,KAChB,YAuDF,CAAC;AAGF,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MACH,CAAC;AAE7C,eAAO,MAAM,aAAa,GAAI,KAAK,YAAY,KAAG,MAAM,GAAG,IAQ1D,CAAC"}

package/dist/package_meta.js

@@ -1,56 +0,0 @@
-import { strip_start, strip_end, ensure_end } from '@ryanatkn/belt/string.js';
-export const parse_package_meta = (package_json, src_json) => {
-    const { name } = package_json;
-    // TODO hacky
-    const parse_repo = (r) => {
-        if (!r)
-            return null;
-        return strip_end(strip_start(strip_end(r, '.git'), 'git+'), '/');
-    };
-    const repo_url = parse_repo(package_json.repository
-        ? typeof package_json.repository === 'string'
-            ? package_json.repository
-            : package_json.repository.url
-        : null);
-    if (!repo_url) {
-        throw Error('failed to parse package_meta - `repo_url` is required in package_json');
-    }
-    const homepage_url = package_json.homepage ?? null;
-    const published = !package_json.private && !!package_json.exports && package_json.version !== '0.0.1';
-    // TODO generic registries
-    const npm_url = published ? 'https://www.npmjs.com/package/' + package_json.name : null;
-    const changelog_url = published && repo_url ? repo_url + '/blob/main/CHANGELOG.md' : null;
-    const repo_name = parse_repo_name(name);
-    const owner_name = repo_url ? strip_start(repo_url, 'https://github.com/').split('/')[0] : null;
-    const logo_url = homepage_url
-        ? ensure_end(homepage_url, '/') +
-            (package_json.logo ? strip_start(package_json.logo, '/') : 'favicon.png')
-        : null;
-    const logo_alt = package_json.logo_alt ?? `logo for ${repo_name}`;
-    return {
-        package_json,
-        src_json,
-        name,
-        repo_name,
-        repo_url,
-        owner_name,
-        homepage_url,
-        logo_url,
-        logo_alt,
-        npm_url,
-        changelog_url,
-        published,
-    };
-};
-// TODO proper parsing
-export const parse_repo_name = (name) => name[0] === '@' ? name.split('/')[1] : name;
-export const parse_org_url = (pkg) => {
-    const { repo_name, repo_url } = pkg;
-    if (!repo_url)
-        return null;
-    const suffix = '/' + repo_name;
-    if (repo_url.endsWith(suffix)) {
-        return strip_end(repo_url, suffix);
-    }
-    return null;
-};

package/src/lib/package_meta.ts

@@ -1,97 +0,0 @@
-import {strip_start, strip_end, ensure_end} from '@ryanatkn/belt/string.js';
-
-import type {Package_Json, Url} from './package_json.ts';
-import type {Src_Json} from './src_json.ts';
-
-// TODO needs refactoring, more clarity
-export interface Package_Meta {
-	repo_url: Url; // 'https://github.com/ryanatkn/fuz'
-	package_json: Package_Json;
-	src_json: Src_Json;
-	name: string; // '@ryanatkn/fuz_library'
-	repo_name: string; // fuz_library
-	/**
-	 * The github user/org.
-	 */
-	owner_name: string | null; // 'fuz-dev'
-	homepage_url: Url | null; // 'https://www.fuz.dev/'
-	logo_url: Url | null; // 'https://www.fuz.dev/logo.svg' falling back to 'https://www.fuz.dev/favicon.png'
-	logo_alt: string; // 'icon for gro'
-	npm_url: Url | null; // 'https://npmjs.com/package/@ryanatkn/fuz_library'
-	changelog_url: Url | null;
-	published: boolean;
-}
-
-export const parse_package_meta = (
-	package_json: Package_Json,
-	src_json: Src_Json,
-): Package_Meta => {
-	const {name} = package_json;
-
-	// TODO hacky
-	const parse_repo = (r: string | null | undefined) => {
-		if (!r) return null;
-		return strip_end(strip_start(strip_end(r, '.git'), 'git+'), '/');
-	};
-
-	const repo_url = parse_repo(
-		package_json.repository
-			? typeof package_json.repository === 'string'
-				? package_json.repository
-				: package_json.repository.url
-			: null,
-	);
-	if (!repo_url) {
-		throw Error('failed to parse package_meta - `repo_url` is required in package_json');
-	}
-
-	const homepage_url = package_json.homepage ?? null;
-
-	const published =
-		!package_json.private && !!package_json.exports && package_json.version !== '0.0.1';
-
-	// TODO generic registries
-	const npm_url = published ? 'https://www.npmjs.com/package/' + package_json.name : null;
-
-	const changelog_url = published && repo_url ? repo_url + '/blob/main/CHANGELOG.md' : null;
-
-	const repo_name = parse_repo_name(name);
-
-	const owner_name = repo_url ? strip_start(repo_url, 'https://github.com/').split('/')[0] : null;
-
-	const logo_url = homepage_url
-		? ensure_end(homepage_url, '/') +
-			(package_json.logo ? strip_start(package_json.logo, '/') : 'favicon.png')
-		: null;
-
-	const logo_alt = package_json.logo_alt ?? `logo for ${repo_name}`;
-
-	return {
-		package_json,
-		src_json,
-		name,
-		repo_name,
-		repo_url,
-		owner_name,
-		homepage_url,
-		logo_url,
-		logo_alt,
-		npm_url,
-		changelog_url,
-		published,
-	};
-};
-
-// TODO proper parsing
-export const parse_repo_name = (name: string): string =>
-	name[0] === '@' ? name.split('/')[1] : name;
-
-export const parse_org_url = (pkg: Package_Meta): string | null => {
-	const {repo_name, repo_url} = pkg;
-	if (!repo_url) return null;
-	const suffix = '/' + repo_name;
-	if (repo_url.endsWith(suffix)) {
-		return strip_end(repo_url, suffix);
-	}
-	return null;
-};