@ryanatkn/gro 0.129.4 → 0.129.6

package/src/lib/throttle.ts

@@ -0,0 +1,63 @@
+import {wait} from '@ryanatkn/belt/async.js';
+
+// TODO maybe support non-promise return values?
+
+/**
+ * Throttles calls to a callback that returns a void promise.
+ * Immediately invokes the callback on the first call.
+ * If the throttled function is called while the promise is already pending,
+ * the call is queued to run after the pending promise completes plus `delay`,
+ * and only the last call is invoked.
+ * In other words, all calls and their args are discarded
+ * during the pending window except for the most recent.
+ * Unlike debouncing, this calls the throttled callback
+ * both on the leading and trailing edges of the delay window.
+ * It also differs from a queue where every call to the throttled callback eventually runs.
+ * @param cb - any function that returns a void promise
+ * @param delay - delay this many milliseconds between the pending call finishing and the next starting
+ * @returns same as `cb`
+ */
+export const throttle = <T extends (...args: any[]) => Promise<void>>(cb: T, delay = 0): T => {
+	let pending_promise: Promise<void> | null = null;
+	let next_args: any[] | null = null;
+	let next_promise: Promise<void> | null = null;
+	let next_promise_resolve: ((value: any) => void) | null = null;
+
+	const defer = (args: any[]): Promise<void> => {
+		next_args = args;
+		if (!next_promise) {
+			next_promise = new Promise((resolve) => {
+				next_promise_resolve = resolve;
+			});
+		}
+		return next_promise;
+	};
+
+	const flush = async (): Promise<void> => {
+		if (!next_promise_resolve) return;
+		const result = await call(next_args!);
+		next_args = null;
+		next_promise = null;
+		const resolve = next_promise_resolve;
+		next_promise_resolve = null;
+		resolve(result); // resolve last to prevent synchronous call issues
+	};
+
+	const call = (args: any[]): Promise<any> => {
+		pending_promise = cb(...args);
+		void pending_promise.then(async () => {
+			await wait(delay);
+			pending_promise = null;
+			await flush();
+		});
+		return pending_promise;
+	};
+
+	return ((...args) => {
+		if (pending_promise) {
+			return defer(args);
+		} else {
+			return call(args);
+		}
+	}) as T;
+};

package/src/lib/typecheck.task.ts

@@ -0,0 +1,57 @@
+import {print_spawn_result} from '@ryanatkn/belt/process.js';
+import {z} from 'zod';
+
+import {Task_Error, type Task} from './task.js';
+import {serialize_args, to_forwarded_args} from './args.js';
+import {find_cli, spawn_cli} from './cli.js';
+import {SVELTE_CHECK_CLI, sveltekit_sync} from './sveltekit_helpers.js';
+
+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'),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'run tsc on the project without emitting any files',
+	Args,
+	run: async ({args, log}): Promise<void> => {
+		const {svelte_check_cli, typescript_cli} = args;
+
+		await sveltekit_sync();
+
+		// Prefer svelte-check if available.
+		const found_svelte_check_cli = find_cli(svelte_check_cli);
+		if (found_svelte_check_cli) {
+			const serialized = serialize_args(to_forwarded_args(svelte_check_cli));
+			const svelte_check_result = await spawn_cli(found_svelte_check_cli, serialized, log);
+			if (!svelte_check_result?.ok) {
+				throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result!)}`);
+			}
+			return;
+		}
+
+		// Fall back to tsc.
+		const found_typescript_cli = find_cli(typescript_cli);
+		if (found_typescript_cli) {
+			const forwarded = to_forwarded_args(typescript_cli);
+			if (!forwarded.noEmit) forwarded.noEmit = true;
+			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!)}`);
+			}
+			return;
+		}
+
+		throw new Task_Error(
+			`Failed to typecheck because neither \`${svelte_check_cli}\` nor \`${typescript_cli}\` was found`,
+		);
+	},
+};

package/src/lib/upgrade.task.ts

@@ -0,0 +1,108 @@
+import {spawn} from '@ryanatkn/belt/process.js';
+import {z} from 'zod';
+
+import {Task_Error, type Task} from './task.js';
+import {load_package_json, type Package_Json} from './package_json.js';
+import {Git_Origin, git_pull} from './git.js';
+import {spawn_cli} from './cli.js';
+
+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),
+		dry: z.boolean({description: 'if true, print out the planned upgrades'}).default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'upgrade deps',
+	Args,
+	run: async ({args, log}): Promise<void> => {
+		const {_, only, origin, force, pull, dry} = args;
+
+		if (_.length && only.length) {
+			throw new Task_Error('Cannot call `gro upgrade` with both rest args and --only.');
+		}
+
+		// TODO maybe a different task that pulls and does other things, like `gro ready`
+		if (pull) {
+			await git_pull(origin);
+		}
+
+		const package_json = load_package_json();
+
+		const all_deps = to_deps(package_json);
+
+		const deps = only.length
+			? all_deps.filter((d) => only.includes(d.key))
+			: all_deps.filter((d) => !_.includes(d.key));
+
+		if (only.length && only.length !== deps.length) {
+			throw new Task_Error(
+				`Some deps to upgrade were not found: ${only.filter((o) => !deps.find((d) => d.key === o)).join(', ')}`,
+			);
+		}
+
+		const upgrade_items = to_upgrade_items(deps);
+
+		log.info(`upgrading:`, upgrade_items.join(' '));
+
+		const install_args = ['install'].concat(upgrade_items);
+
+		if (dry) {
+			install_args.push('--dry-run');
+			log.info(`deps`, deps);
+		}
+
+		if (force) {
+			install_args.push('--force');
+		}
+
+		await spawn('npm', install_args);
+
+		// Sync in a new process to pick up any changes after installing, avoiding some errors.
+		await spawn_cli('gro', ['sync']);
+	},
+};
+
+interface Dep {
+	key: string;
+	value: string;
+}
+
+const to_deps = (package_json: Package_Json): Dep[] => {
+	const prod_deps: Dep[] = package_json.dependencies
+		? Object.entries(package_json.dependencies).map(([key, value]) => ({key, value}))
+		: [];
+	const dev_deps: Dep[] = package_json.devDependencies
+		? Object.entries(package_json.devDependencies).map(([key, value]) => ({key, value}))
+		: [];
+	return prod_deps.concat(dev_deps);
+};
+
+const EXACT_VERSION_MATCHER = /^..*@.+/u;
+const CUSTOM_TAG_MATCHER = /^[\^~><=]*.+-(.+)/u;
+
+// TODO hacky and limited
+// TODO probably want to pass through exact deps as well, e.g. @foo/bar@1
+const to_upgrade_items = (deps: Dep[]): string[] =>
+	deps.map((dep) => {
+		if (EXACT_VERSION_MATCHER.test(dep.key)) {
+			return dep.key;
+		}
+		const custom_tag_matches = CUSTOM_TAG_MATCHER.exec(dep.value);
+		if (custom_tag_matches) {
+			return dep.key + '@' + custom_tag_matches[1].split('.')[0]; // I tried adding `\.?` to the end but doesn't work and I'm being lazy so I'm just splitting
+		}
+		return dep.key + '@latest';
+	});

package/src/lib/watch_dir.ts

@@ -0,0 +1,88 @@
+import chokidar, {type WatchOptions} from 'chokidar';
+import {relative} from 'node:path';
+
+import type {Path_Filter} from './path.js';
+import {statSync} from 'node:fs';
+
+// TODO pretty hacky
+
+export interface Watch_Node_Fs {
+	init: () => Promise<void>;
+	close: () => Promise<void>;
+}
+
+export interface Watcher_Change {
+	type: Watcher_Change_Type;
+	path: string;
+	is_directory: boolean;
+}
+export type Watcher_Change_Type = 'create' | 'update' | 'delete';
+export type Watcher_Change_Callback = (change: Watcher_Change) => void;
+
+export interface Options {
+	dir: string;
+	on_change: Watcher_Change_Callback;
+	filter?: Path_Filter | null | undefined;
+	chokidar?: WatchOptions;
+	/**
+	 * When `false`, returns the `path` relative to `dir`.
+	 * @default true
+	 */
+	absolute?: boolean;
+}
+
+/**
+ * Watch for changes on the filesystem using chokidar.
+ */
+export const watch_dir = ({
+	dir,
+	on_change,
+	filter,
+	absolute = true,
+	chokidar: chokidar_options,
+}: Options): Watch_Node_Fs => {
+	let watcher: chokidar.FSWatcher | undefined;
+
+	return {
+		init: async () => {
+			watcher = chokidar.watch(dir, chokidar_options);
+			watcher.on('add', (path, s) => {
+				const stats = s ?? statSync(path);
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, stats.isDirectory())) return;
+				on_change({type: 'create', path: final_path, is_directory: stats.isDirectory()});
+			});
+			watcher.on('addDir', (path, s) => {
+				const stats = s ?? statSync(path);
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, stats.isDirectory())) return;
+				on_change({type: 'create', path: final_path, is_directory: stats.isDirectory()});
+			});
+			watcher.on('change', (path, s) => {
+				const stats = s ?? statSync(path);
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, stats.isDirectory())) return;
+				on_change({type: 'update', path: final_path, is_directory: stats.isDirectory()});
+			});
+			watcher.on('unlink', (path) => {
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, false)) return;
+				on_change({type: 'delete', path: final_path, is_directory: false});
+			});
+			watcher.on('unlinkDir', (path) => {
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, true)) return;
+				on_change({type: 'delete', path: final_path, is_directory: true});
+			});
+			// wait until ready
+			let resolve: any;
+			const promise = new Promise((r) => (resolve = r));
+			watcher.once('ready', () => resolve());
+			await promise;
+		},
+		close: async () => {
+			if (!watcher) return;
+			await watcher.close();
+		},
+	};
+};