@ryanatkn/gro 0.129.4 → 0.129.6

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.129.4',
+    version: '0.129.6',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -82,7 +82,7 @@ export const package_json = {
         overrides: [{ files: 'package.json', options: { useTabs: false } }],
     },
     sideEffects: ['**/*.css'],
-    files: ['dist'],
+    files: ['dist', 'src/lib'],
     exports: {
         '.': { types: './dist/index.d.ts', default: './dist/index.js' },
         './package.json': './package.json',
@@ -266,7 +266,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.129.4',
+    version: '0.129.6',
     modules: {
         '.': {
             path: 'index.ts',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.129.4",
+  "version": "0.129.6",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -107,7 +107,8 @@
     "**/*.css"
   ],
   "files": [
-    "dist"
+    "dist",
+    "src/lib"
   ],
   "exports": {
     ".": {

package/src/lib/args.test.ts

@@ -0,0 +1,59 @@
+import mri from 'mri';
+import {suite} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {
+	serialize_args,
+	to_forwarded_args,
+	to_forwarded_args_by_command,
+	to_raw_rest_args,
+} from './args.js';
+
+/* test__serialize_args */
+const test__serialize_args = suite('serialize_args');
+
+test__serialize_args('basic behavior', () => {
+	const raw = ['a', '-i', '1', 'b', 'c', '-i', '-i', 'three'];
+	const parsed = mri(raw);
+	assert.equal(parsed, {_: ['a', 'b', 'c'], i: [1, true, 'three']});
+	const serialized = serialize_args(parsed);
+	assert.equal(serialized, ['a', 'b', 'c', '-i', '1', '-i', '-i', 'three']); // sorted
+});
+
+test__serialize_args.run();
+/* test__serialize_args */
+
+/* test__to_forwarded_args_by_command */
+const test__to_forwarded_args_by_command = suite('to_forwarded_args_by_command');
+
+test__to_forwarded_args_by_command('basic behavior', () => {
+	const raw_rest_args = to_raw_rest_args(
+		(
+			'gro taskname a b c --d -e 1 --     --    ' +
+			'eslint  a  --b    c --  ' +
+			'gro  a --a  --   ' +
+			'tsc  -b  --    ' +
+			'gro b -t2 t2a --t2 t2b --t222 2 --     --      --    ' +
+			'groc --m --n nn -- ' +
+			'gro d -b a --c 4 -- ' +
+			'gro d -b a --c 5 -- '
+		).split(' '),
+	);
+	assert.equal(to_forwarded_args_by_command(raw_rest_args), {
+		eslint: {_: ['a'], b: 'c'},
+		'gro a': {a: true},
+		tsc: {b: true},
+		'gro b': {'2': 't2a', t: true, t2: 't2b', t222: 2},
+		groc: {m: true, n: 'nn'},
+		'gro d': {b: 'a', c: 5},
+	});
+	assert.equal(to_forwarded_args('gro b', raw_rest_args), {
+		'2': 't2a',
+		t: true,
+		t2: 't2b',
+		t222: 2,
+	});
+});
+
+test__to_forwarded_args_by_command.run();
+/* test__to_forwarded_args_by_command */

package/src/lib/args.ts

@@ -0,0 +1,169 @@
+import {gray, magenta} from '@ryanatkn/belt/styletext.js';
+import mri from 'mri';
+import type {z} from 'zod';
+
+/**
+ * These extend the CLI args for tasks.
+ * Anything can be assigned to a task's `args`. It's just a mutable POJO dictionary.
+ * Downstream tasks will see args that upstream events mutate,
+ * unless `invoke_task` is called with modified args.
+ * Upstream tasks can use listeners to respond to downstream events and values.
+ * It's a beautiful mutable spaghetti mess. cant get enough
+ * The raw CLI ares are handled by `mri` - https://github.com/lukeed/mri
+ */
+export interface Args {
+	_?: string[];
+	help?: boolean;
+	[key: string]: Arg_Value;
+}
+
+export type Arg_Value = string | number | boolean | undefined | Array<string | number | boolean>;
+
+export interface Arg_Schema {
+	type: string;
+	default: Arg_Value;
+	description: string;
+}
+
+/**
+ * Parses user input args with a Zod schema.
+ * Sets the correct source of truth for `no-` versions of args,
+ * to the opposite of the unprefixed versions when not included in `unparsed_args`.
+ * This is needed because CLI args don't have a normal way of setting falsy values,
+ * so instead the args parser `mri` will pass through the truthy versions of args
+ * without the `no-` prefix.
+ * When we declare task args schemas,
+ * we need include both versions with their defaults to get correct `--help` output.
+ * Parsing like this also ensures data consistency for both versions because `mri` only creates one.
+ * A simpler implementation could replace `mri`, but it handles some finicky details well.
+ */
+export const parse_args = <
+	TOutput extends Record<string, Arg_Value> = Args,
+	TInput extends Record<string, Arg_Value> = Args,
+>(
+	unparsed_args: TInput,
+	schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>,
+): z.SafeParseReturnType<TInput, TOutput> => {
+	const parsed = schema.safeParse(unparsed_args);
+	if (parsed.success) {
+		// mutate `data` with the correct source of truth for `no-` prefixed args
+		const {data} = parsed;
+		for (const key in parsed.data) {
+			if (key.startsWith('no-')) {
+				const base_key = key.substring(3);
+				if (!(key in unparsed_args)) {
+					(data as any)[key] = !data[base_key];
+				} else if (!(base_key in unparsed_args)) {
+					(data as any)[base_key] = !data[key];
+				}
+			}
+		}
+	}
+	return parsed;
+};
+
+/**
+ * Serializes parsed `Args` for CLI commands.
+ */
+export const serialize_args = (args: Args): string[] => {
+	const result: string[] = [];
+	const add_value = (name: string, value: string | number | boolean | undefined): void => {
+		if (value === undefined) return;
+		result.push(name);
+		if (typeof value !== 'boolean') {
+			result.push(value + '');
+		}
+	};
+	let _: string[] | null = null;
+	for (const [key, value] of Object.entries(args)) {
+		if (key === '_') {
+			_ = value ? (value as any[]).map((v) => (v === undefined ? '' : v + '')) : [];
+		} else {
+			const name = `${key.length === 1 ? '-' : '--'}${key}`;
+			if (Array.isArray(value)) {
+				for (const v of value) add_value(name, v);
+			} else {
+				add_value(name, value);
+			}
+		}
+	}
+	return _ ? [..._, ...result] : result;
+};
+
+/**
+ * Parses `task_name` and `args` from `process.argv` using `mri`,
+ * ignoring anything after any `--`.
+ */
+export const to_task_args = (argv = process.argv): {task_name: string; args: Args} => {
+	const forwarded_index = argv.indexOf('--');
+	const args = mri(forwarded_index === -1 ? argv.slice(2) : argv.slice(2, forwarded_index));
+	const task_name = args._.shift() ?? '';
+	if (!args._.length) delete (args as Args)._; // enable schema defaults
+	return {task_name, args};
+};
+
+/**
+ * Gets the array of raw string args starting with the first `--`, if any.
+ */
+export const to_raw_rest_args = (argv = process.argv): string[] => {
+	const forwarded_index = argv.indexOf('--');
+	return forwarded_index === -1 ? [] : argv.slice(forwarded_index);
+};
+
+/**
+ * Parses `process.argv` for the specified `command`, so given
+ * `gro taskname arg1 --arg2 -- eslint eslintarg1 --eslintarg2 -- tsc --tscarg1 --tscarg2`
+ * the `command` `'eslint'` returns `eslintarg1 --eslintarg2`
+ * and `'tsc'` returns `--tscarg1` and `--tscarg2`.
+ */
+export const to_forwarded_args = (
+	command: string,
+	raw_rest_args?: string[],
+	cache = to_forwarded_args_by_command(raw_rest_args),
+): Args => cache[command] ?? {};
+
+export const to_forwarded_args_by_command = (
+	raw_rest_args = to_raw_rest_args(),
+): Record<string, Args | undefined> => {
+	// Parse each segment of `argv` separated by `--`.
+	const argvs: string[][] = [];
+	let arr: string[] | undefined;
+	for (const arg of raw_rest_args) {
+		if (arg === '--') {
+			if (arr?.length) argvs.push(arr);
+			arr = [];
+		} else if (!arr) {
+			continue;
+		} else if (arg) {
+			arr.push(arg);
+		}
+	}
+	if (arr?.length) argvs.push(arr);
+	// Add each segment of parsed `argv` keyed by the first rest arg,
+	// which is assumed to be the CLI command that gets forwarded the args.
+	const forwarded_args_by_command: Record<string, Args> = {};
+	for (const argv of argvs) {
+		const args = mri(argv);
+		let command = args._.shift();
+		if (!command) {
+			throw Error(
+				`Malformed args following a \`--\`. Expected a rest arg command: \`${argv.join(' ')}\``,
+			);
+		}
+		// Gro commands get combined with their task name.
+		if (command === 'gro') {
+			if (!args._.length) {
+				throw Error(
+					`Malformed args following a \`--\`. Expected gro taskname: \`${argv.join(' ')}\``,
+				);
+			}
+			command += ' ' + args._.shift();
+		}
+		if (!args._.length) delete (args as Args)._;
+		forwarded_args_by_command[command] = args;
+	}
+	return forwarded_args_by_command;
+};
+
+export const print_command_args = (serialized_args: string[]): string =>
+	gray('[') + magenta('running command') + gray(']') + ' ' + serialized_args.join(' ');

package/src/lib/build.task.ts

@@ -0,0 +1,37 @@
+import {z} from 'zod';
+
+import type {Task} from './task.js';
+import {Plugins} from './plugin.js';
+import {clean_fs} from './clean_fs.js';
+
+export const Args = z
+	.object({
+		install: z.boolean({description: 'dual of no-install'}).default(true),
+		'no-install': z
+			.boolean({description: 'opt out of npm installing before building'})
+			.default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'build the project',
+	Args,
+	run: async (ctx): Promise<void> => {
+		const {args, invoke_task} = ctx;
+		const {install} = args;
+
+		// By default `gro build` installs, opposite of `gro sync`, so that arg needs special handling.
+		await invoke_task('sync', {install});
+
+		// TODO possibly detect if the git workspace is clean, and ask for confirmation if not,
+		// because we're not doing things like `gro gen` here because that's a dev/CI concern
+
+		await clean_fs({build_dist: true});
+
+		const plugins = await Plugins.create({...ctx, dev: false, watch: false});
+		await plugins.setup();
+		await plugins.adapt();
+		await plugins.teardown();
+	},
+};

package/src/lib/changelog.test.ts

@@ -0,0 +1,138 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {Logger} from '@ryanatkn/belt/log.js';
+import {readFile, writeFile} from 'node:fs/promises';
+import type {Fetch_Value_Cache} from '@ryanatkn/belt/fetch.js';
+
+import {update_changelog} from './changelog.js';
+import {load_from_env} from './env.js';
+
+const log = new Logger();
+
+const token = load_from_env('GITHUB_TOKEN_SECRET');
+if (!token) {
+	log.warn('the env var GITHUB_TOKEN_SECRET was not found, so API calls with be unauthorized');
+}
+
+const fixture_path = 'src/fixtures/changelog_example.md';
+
+// TODO ideally this is just a ts file, but there's a problem where building outputs a `.d.ts` file
+// when importing from src/fixtures (fix in SvelteKit/Vite/tsconfig?) and I want to keep it in src/fixtures
+const changelog_cache_fixture: Fetch_Value_Cache = new Map(
+	JSON.parse(await readFile('src/fixtures/changelog_cache.json', 'utf8')),
+);
+
+test('update_changelog', async () => {
+	const original = await readFile(fixture_path, 'utf8');
+	const result = await update_changelog(
+		'ryanatkn',
+		'gro',
+		fixture_path,
+		token,
+		log,
+		changelog_cache_fixture,
+	);
+	const updated = await readFile(fixture_path, 'utf8');
+	await writeFile(fixture_path, original, 'utf8');
+	assert.ok(result);
+	assert.is(
+		updated,
+		`# @ryanatkn/gro
+
+## 0.6.0
+
+### Minor Changes
+
+- duplicate 1 ([#429](https://github.com/ryanatkn/gro/pull/429))
+- duplicate 2 ([#429](https://github.com/ryanatkn/gro/pull/429))
+- abc ([#437](https://github.com/ryanatkn/gro/pull/437))
+
+  - 123
+  - 123
+  - 123
+
+### Patch Changes
+
+- abc ([5e94cd4](https://github.com/ryanatkn/gro/commit/5e94cd4))
+
+## 0.5.2
+
+### Patch Changes
+
+- abc ([e345eaa](https://github.com/ryanatkn/gro/commit/e345eaa))
+
+## 0.5.1
+
+### Patch Changes
+
+- abc ([094279d](https://github.com/ryanatkn/gro/commit/094279d))
+
+## 0.5.0
+
+### Minor Changes
+
+- abc ([f6133f7](https://github.com/ryanatkn/gro/commit/f6133f7))
+
+## 0.4.3
+
+### Patch Changes
+
+- abc ([54b65ec](https://github.com/ryanatkn/gro/commit/54b65ec))
+
+## 0.4.2
+
+### Patch Changes
+
+- abc ([80365d0](https://github.com/ryanatkn/gro/commit/80365d0))
+
+## 0.4.1
+
+### Patch Changes
+
+- abc ([3d84dfd](https://github.com/ryanatkn/gro/commit/3d84dfd))
+- abc ([fc64b77](https://github.com/ryanatkn/gro/commit/fc64b77))
+
+## 0.4.0
+
+### Minor Changes
+
+- abc ([#434](https://github.com/ryanatkn/gro/pull/434))
+  - 123
+  - 123
+
+### Patch Changes
+
+- abc ([#434](https://github.com/ryanatkn/gro/pull/434))
+
+## 0.3.1
+
+- e
+
+## 0.3.0
+
+- b2
+- c2
+- d2
+
+## 0.2.0
+
+- a2
+
+## 0.1.2
+
+- e
+
+## 0.1.1
+
+- b
+- c
+- d
+
+## 0.1.0
+
+- a
+`,
+	);
+});
+
+test.run();

package/src/lib/changelog.ts

@@ -0,0 +1,69 @@
+import {readFile, writeFile} from 'node:fs/promises';
+import {z} from 'zod';
+import type {Logger} from '@ryanatkn/belt/log.js';
+import type {Fetch_Value_Cache} from '@ryanatkn/belt/fetch.js';
+
+import {github_fetch_commit_prs} from './github.js';
+
+/**
+ * Updates a changelog produced by `@changesets/changelog-git` with better links and formatting.
+ * It's similar to `@changesets/changelog-github` but doesn't require a token for light usage.
+ * This may be better implemented as a standalone dependency
+ * as an alternative to `@changesets/changelog-git`.
+ * @returns boolean indicating if the changelog changed
+ */
+export const update_changelog = async (
+	owner: string,
+	repo: string,
+	path = 'CHANGELOG.md',
+	token?: string,
+	log?: Logger,
+	cache: Fetch_Value_Cache = new Map(), // include a default cache to efficiently handle multiple changesets per commit
+): Promise<boolean> => {
+	const contents = await readFile(path, 'utf8');
+	const parsed = parse_changelog(contents);
+	const mapped = await map_changelog(parsed, owner, repo, token, log, cache);
+	const updated = serialize_changelog(mapped);
+	if (contents === updated) {
+		return false;
+	}
+	await writeFile(path, updated, 'utf8');
+	return true;
+};
+
+// keeping this really simple for now, no need to parse further for our current usecases
+const Parsed_Changelog = z.array(z.string());
+type Parsed_Changelog = z.infer<typeof Parsed_Changelog>;
+const parse_changelog = (contents: string): Parsed_Changelog => contents.split('\n');
+const serialize_changelog = (parsed: Parsed_Changelog): string => parsed.join('\n');
+
+const LINE_WITH_SHA_MATCHER = /^- ([a-z0-9]{7,8}): /u;
+
+const map_changelog = async (
+	parsed: Parsed_Changelog,
+	owner: string,
+	repo: string,
+	token?: string,
+	log?: Logger,
+	cache?: Fetch_Value_Cache,
+): Promise<Parsed_Changelog> => {
+	const mapped: Parsed_Changelog = [];
+	for (const line of parsed) {
+		const matches = LINE_WITH_SHA_MATCHER.exec(line);
+		if (matches) {
+			const commit_sha = matches[1];
+			const l = '- ' + line.substring(commit_sha.length + 4);
+			const prs = await github_fetch_commit_prs(owner, repo, commit_sha, token, log, cache); // eslint-disable-line no-await-in-loop
+			if (prs?.length) {
+				mapped.push(`${l} (${prs.map((p) => `[#${p.number}](${p.html_url})`).join(', ')})`);
+			} else {
+				mapped.push(
+					`${l} ([${commit_sha}](https://github.com/${owner}/${repo}/commit/${commit_sha}))`,
+				);
+			}
+		} else {
+			mapped.push(line);
+		}
+	}
+	return mapped;
+};