@ryanatkn/gro 0.129.4 → 0.129.5

package/src/lib/sveltekit_shim_env.ts

@@ -0,0 +1,45 @@
+import {load_env} from './env.js';
+
+// TODO might want to do more escaping and validation
+
+/**
+ * Generates a module shim for SvelteKit's `$env` imports.
+ */
+export const render_env_shim_module = (
+	dev: boolean,
+	mode: 'static' | 'dynamic',
+	visibility: 'public' | 'private',
+	public_prefix = 'PUBLIC_',
+	private_prefix = '',
+	env_dir?: string,
+	env_files?: string[],
+	ambient_env?: Record<string, string | undefined>,
+): string => {
+	const env = load_env(
+		dev,
+		visibility,
+		public_prefix,
+		private_prefix,
+		env_dir,
+		env_files,
+		ambient_env,
+	);
+	if (mode === 'static') {
+		return `// shim for $env/static/${visibility}
+// @see https://github.com/sveltejs/kit/issues/1485
+${Object.entries(env)
+	.map(([k, v]) => `export let ${k} = ${JSON.stringify(v)};`)
+	.join('\n')}
+		`;
+	} else {
+		return `// shim for $env/dynamic/${visibility}
+// @see https://github.com/sveltejs/kit/issues/1485
+import {load_env} from '@ryanatkn/gro/env.js';
+export const env = load_env(${dev}, ${JSON.stringify(visibility)}, ${JSON.stringify(
+			public_prefix,
+		)}, ${JSON.stringify(private_prefix)}, ${JSON.stringify(env_dir)}, ${JSON.stringify(
+			env_files,
+		)}, ${JSON.stringify(ambient_env)});
+		`;
+	}
+};

package/src/lib/sync.task.ts

@@ -0,0 +1,47 @@
+import {z} from 'zod';
+import {spawn} from '@ryanatkn/belt/process.js';
+
+import {Task_Error, type Task} from './task.js';
+import {sync_package_json} from './package_json.js';
+import {sveltekit_sync} from './sveltekit_helpers.js';
+
+export const Args = z
+	.object({
+		sveltekit: z.boolean({description: 'dual of no-sveltekit'}).default(true),
+		'no-sveltekit': z.boolean({description: 'opt out of svelte-kit sync'}).default(false),
+		package_json: z.boolean({description: 'dual of no-package_json'}).default(true),
+		'no-package_json': z.boolean({description: 'opt out of package.json sync'}).default(false),
+		gen: z.boolean({description: 'dual of no-gen'}).default(true),
+		'no-gen': z.boolean({description: 'opt out of gen sync'}).default(false),
+		install: z.boolean({description: 'run npm install'}).default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'run `gro gen`, update `package.json`, and optionally `npm i` to sync up',
+	Args,
+	run: async ({args, invoke_task, config, log}): Promise<void> => {
+		const {sveltekit, package_json, gen, install} = args;
+
+		if (install) {
+			const result = await spawn('npm', ['i']);
+			if (!result.ok) {
+				throw new Task_Error('Failed npm install');
+			}
+		}
+
+		if (sveltekit) {
+			await sveltekit_sync();
+			log.info('synced SvelteKit');
+		}
+
+		if (package_json && config.map_package_json) {
+			await sync_package_json(config.map_package_json, log);
+		}
+
+		if (gen) {
+			await invoke_task('gen');
+		}
+	},
+};

package/src/lib/task.test.ts

@@ -0,0 +1,84 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {resolve} from 'node:path';
+
+import {is_task_path, to_task_name, validate_task_module, find_tasks, load_tasks} from './task.js';
+import * as actual_test_task_module from './test.task.js';
+import {create_empty_config} from './config.js';
+
+test('is_task_path basic behavior', () => {
+	assert.ok(is_task_path('foo.task.ts'));
+	assert.ok(is_task_path('foo.task.js'));
+	assert.ok(!is_task_path('foo.ts'));
+	assert.ok(is_task_path('bar/baz/foo.task.ts'));
+	assert.ok(!is_task_path('bar/baz/foo.ts'));
+});
+
+test('to_task_name basic behavior', () => {
+	assert.is(to_task_name('foo.task.ts', process.cwd(), '', ''), 'foo');
+	assert.is(to_task_name('bar/baz/foo.task.ts', process.cwd(), '', ''), 'bar/baz/foo');
+	assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b/c', '', ''), 'foo');
+	assert.is(to_task_name('a/b/c/foo.task.ts', 'a', '', ''), 'b/c/foo');
+	assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b', '', ''), 'c/foo');
+	assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/d'), '../c/foo');
+	assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b'), 'c/foo');
+	assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/c'), 'foo');
+	assert.is(to_task_name('/a/b/d/foo.task.js', '/a/b/d', '/a/b/d/foo', '/a/c'), '../b/d/foo');
+	assert.is(
+		to_task_name(
+			'/a/node_modules/b/c/foo.task.js',
+			'/a/node_modules/b/c',
+			'/a/node_modules/b/c/foo',
+			'/a',
+		),
+		'foo',
+	);
+	assert.is(
+		to_task_name(
+			'/a/node_modules/b/c/foo.task.js',
+			'/a/node_modules/b/c/', // compared to the above, adds a trailing slash here
+			'/a/node_modules/b/c/foo',
+			'/a',
+		),
+		'foo',
+	);
+	assert.is(
+		to_task_name(
+			'/a/node_modules/b/c/foo.task.js',
+			'/a/node_modules/b/c',
+			'/a/node_modules/b/c/foo',
+			'/a/', // compared to the above, adds a trailing slash here
+		),
+		'foo',
+	);
+	assert.is(
+		to_task_name(resolve('a/b'), resolve('b'), '', ''),
+		resolve('a/b'),
+		'falls back to the id when unresolved',
+	);
+});
+
+// TODO if we import directly, svelte-package generates types in `src/fixtures`
+const test_task_module = await import('../fixtures/' + 'test_task_module.task_fixture'); // eslint-disable-line no-useless-concat
+const test_invalid_task_module = await import('../fixtures/' + 'test_invalid_task_module.js'); // eslint-disable-line no-useless-concat
+
+test('validate_task_module basic behavior', () => {
+	assert.ok(validate_task_module(test_task_module));
+	assert.ok(!validate_task_module(test_invalid_task_module));
+	assert.ok(!validate_task_module({task: {run: {}}}));
+});
+
+test('load_tasks basic behavior', async () => {
+	const found = find_tasks(
+		[resolve('src/lib/test'), resolve('src/lib/test.task.ts')],
+		[resolve('src/lib')],
+		create_empty_config(),
+	);
+	assert.ok(found.ok);
+	const result = await load_tasks(found.value);
+	assert.ok(result.ok);
+	assert.is(result.value.modules.length, 1);
+	assert.is(result.value.modules[0].mod, actual_test_task_module);
+});
+
+test.run();

package/src/lib/task.ts

@@ -0,0 +1,235 @@
+import type {Logger} from '@ryanatkn/belt/log.js';
+import {strip_end, strip_start} from '@ryanatkn/belt/string.js';
+import type {z} from 'zod';
+import type {Timings} from '@ryanatkn/belt/timings.js';
+import {red} from '@ryanatkn/belt/styletext.js';
+import type {Result} from '@ryanatkn/belt/result.js';
+import {isAbsolute, join, relative} from 'node:path';
+
+import type {Args} from './args.js';
+import type {Path_Id} from './path.js';
+import type {Gro_Config} from './config.js';
+import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
+import {
+	resolve_input_files,
+	resolve_input_paths,
+	type Input_Path,
+	type Resolved_Input_File,
+	type Resolved_Input_Path,
+} from './input_path.js';
+import {print_path} from './paths.js';
+import {search_fs} from './search_fs.js';
+import {load_modules, type Load_Modules_Failure, type Module_Meta} from './modules.js';
+
+export interface Task<
+	T_Args = Args, // same as `z.infer<typeof Args>`
+	T_Args_Schema extends z.ZodType = z.ZodType,
+	T_Return = unknown,
+> {
+	run: (ctx: Task_Context<T_Args>) => T_Return | Promise<T_Return>; // TODO unused return value
+	summary?: string;
+	Args?: T_Args_Schema;
+}
+
+export interface Task_Context<T_Args = object> {
+	args: T_Args;
+	config: Gro_Config;
+	sveltekit_config: Parsed_Sveltekit_Config;
+	// TODO should this go here or on `config` for convenience?
+	// sveltekit_config: Parsed_Sveltekit_Config;
+	log: Logger;
+	timings: Timings;
+	invoke_task: (task_name: string, args?: Args, config?: Gro_Config) => 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 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,
+): string => {
+	let task_name = id.startsWith(task_root_dir)
+		? strip_start(strip_start(id, task_root_dir), '/')
+		: id;
+	for (const suffix of TASK_FILE_SUFFIXES) {
+		task_name = strip_end(task_name, suffix);
+	}
+	if (isAbsolute(input_path)) {
+		// is a bit hacky, but does what we want
+		const relative_to_root = relative(root_path, join(task_root_dir, task_name));
+		if (relative_to_root.startsWith('node_modules/')) {
+			return task_name;
+		}
+		return relative_to_root;
+	}
+	return task_name;
+};
+
+/**
+ * This is used by tasks to signal a known failure.
+ * It's useful for cleaning up logging because
+ * we usually don't need their stack trace.
+ */
+export class Task_Error extends Error {}
+
+export interface Found_Task {
+	input_path: Input_Path;
+	id: Path_Id;
+	task_root_dir: Path_Id;
+}
+
+export interface Found_Tasks {
+	resolved_input_files: Resolved_Input_File[];
+	resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+	resolved_input_paths: Resolved_Input_Path[];
+	input_paths: Input_Path[];
+	task_root_dirs: Path_Id[];
+}
+
+export type Find_Tasks_Result = Result<{value: Found_Tasks}, Find_Modules_Failure>;
+export type Find_Modules_Failure =
+	| {
+			type: 'unmapped_input_paths';
+			unmapped_input_paths: Input_Path[];
+			resolved_input_paths: Resolved_Input_Path[];
+			input_paths: Input_Path[];
+			task_root_dirs: Path_Id[];
+			reasons: string[];
+	  }
+	| {
+			type: 'input_directories_with_no_files';
+			input_directories_with_no_files: Input_Path[];
+			resolved_input_files: Resolved_Input_File[];
+			resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+			resolved_input_paths: Resolved_Input_Path[];
+			input_paths: Input_Path[];
+			task_root_dirs: Path_Id[];
+			reasons: string[];
+	  };
+
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_tasks = (
+	input_paths: Input_Path[],
+	task_root_dirs: Path_Id[],
+	config: Gro_Config,
+	timings?: Timings,
+): Find_Tasks_Result => {
+	// 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(
+		input_paths,
+		task_root_dirs,
+		TASK_FILE_SUFFIXES,
+	);
+	timing_to_resolve_input_paths?.();
+
+	// Error if any input path could not be mapped.
+	if (unmapped_input_paths.length) {
+		return {
+			ok: false,
+			type: 'unmapped_input_paths',
+			unmapped_input_paths,
+			resolved_input_paths,
+			input_paths,
+			task_root_dirs,
+			reasons: unmapped_input_paths.map((input_path) =>
+				red(`Input path ${print_path(input_path)} cannot be mapped to a file or directory.`),
+			),
+		};
+	}
+
+	// Find all of the files for any directories.
+	const timing_to_resolve_input_files = timings?.start('resolve input files');
+	const {resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files} =
+		resolve_input_files(resolved_input_paths, (id) =>
+			search_fs(id, {
+				filter: config.search_filters,
+				file_filter: (p) => TASK_FILE_SUFFIXES.some((s) => p.endsWith(s)),
+			}),
+		);
+	timing_to_resolve_input_files?.();
+
+	// Error if any input path has no files. (means we have an empty directory)
+	if (input_directories_with_no_files.length) {
+		return {
+			ok: false,
+			type: 'input_directories_with_no_files',
+			input_directories_with_no_files,
+			resolved_input_files,
+			resolved_input_files_by_root_dir,
+			resolved_input_paths,
+			input_paths,
+			task_root_dirs,
+			reasons: input_directories_with_no_files.map((input_path) =>
+				red(`Input directory contains no matching files: ${print_path(input_path)}`),
+			),
+		};
+	}
+
+	return {
+		ok: true,
+		value: {
+			resolved_input_files,
+			resolved_input_files_by_root_dir,
+			resolved_input_paths,
+			input_paths,
+			task_root_dirs,
+		},
+	};
+};
+
+export interface Loaded_Tasks {
+	modules: Task_Module_Meta[];
+	found_tasks: Found_Tasks;
+}
+
+export interface Task_Module {
+	task: Task;
+}
+
+export interface Task_Module_Meta extends Module_Meta<Task_Module> {
+	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 const load_tasks = async (
+	found_tasks: Found_Tasks,
+	root_path: Path_Id = process.cwd(), // TODO @multiple isn't passed in anywhere, maybe hoist to `invoke_task` and others
+): Promise<Load_Tasks_Result> => {
+	const loaded_modules = await load_modules(
+		found_tasks.resolved_input_files,
+		validate_task_module,
+		(resolved_input_file, mod): Task_Module_Meta => ({
+			id: resolved_input_file.id,
+			mod,
+			name: to_task_name(
+				resolved_input_file.id,
+				resolved_input_file.resolved_input_path.root_dir,
+				resolved_input_file.resolved_input_path.input_path,
+				root_path,
+			),
+		}),
+	);
+	if (!loaded_modules.ok) {
+		return loaded_modules;
+	}
+
+	return {
+		ok: true,
+		value: {modules: loaded_modules.modules, found_tasks},
+	};
+};
+
+export const validate_task_module = (mod: Record<string, any>): mod is Task_Module =>
+	!!mod.task && typeof mod.task.run === 'function';

package/src/lib/task_logging.ts

@@ -0,0 +1,180 @@
+import {cyan, gray, green, red} from '@ryanatkn/belt/styletext.js';
+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 type {Arg_Schema} from './args.js';
+import type {Loaded_Tasks, Task_Module_Meta} from './task.js';
+import {print_path} from './paths.js';
+
+export const log_tasks = (log: Logger, loaded_tasks: Loaded_Tasks, log_intro = true): void => {
+	const {modules, found_tasks} = loaded_tasks;
+	const {resolved_input_files_by_root_dir} = found_tasks;
+
+	const logged: string[] = [];
+	if (log_intro) {
+		logged.unshift(
+			`\n\n${gray('Run a task:')} gro [name]`,
+			`\n${gray('View help:')}  gro [name] --help`,
+		);
+	}
+
+	for (const [root_dir, resolved_input_files] of resolved_input_files_by_root_dir) {
+		const dir_label = print_path(root_dir);
+		if (!resolved_input_files.length) {
+			log.info(`No tasks found in ${dir_label}.`);
+			continue;
+		}
+		logged.push(
+			`${log_intro ? '\n\n' : ''}${resolved_input_files.length} task${plural(
+				resolved_input_files.length,
+			)} in ${dir_label}:\n`,
+		);
+		const longest_task_name = to_max_length(modules, (m) => m.name);
+		for (const resolved_input_file of resolved_input_files) {
+			const meta = modules.find((m) => m.id === resolved_input_file.id)!;
+			logged.push(
+				'\n' + cyan(pad(meta.name, longest_task_name)),
+				'  ',
+				meta.mod.task.summary ?? '',
+			);
+		}
+	}
+	log[log_intro ? 'info' : 'plain'](logged.join('') + '\n');
+};
+
+export const log_error_reasons = (log: Logger, reasons: string[]): void => {
+	for (const reason of reasons) {
+		log.error(red(reason));
+	}
+};
+
+const ARGS_PROPERTY_NAME = '[...args]';
+
+export const log_task_help = (log: Logger, meta: Task_Module_Meta): void => {
+	const {
+		name,
+		mod: {task},
+	} = meta;
+	const logged: string[] = [];
+	logged.push(
+		cyan(name),
+		'help',
+		cyan(`\n\ngro ${name}`) + `: ${task.summary ?? '(no summary available)'}\n`,
+	);
+	if (task.Args) {
+		const properties = to_arg_properties(task.Args._def, meta);
+		// TODO hacky padding for some quick and dirty tables
+		const longest_task_name = Math.max(
+			ARGS_PROPERTY_NAME.length,
+			to_max_length(properties, (p) => p.name),
+		);
+		const longest_type = to_max_length(properties, (p) => p.schema.type);
+		const longest_default = to_max_length(properties, (p) => print_value(p.schema.default));
+		for (const property of properties) {
+			const name = property.name === '_' ? ARGS_PROPERTY_NAME : property.name;
+			logged.push(
+				`\n${green(pad(name, longest_task_name))} `,
+				gray(pad(property.schema.type, longest_type)) + ' ',
+				pad(print_value(property.schema.default), longest_default) + ' ',
+				property.schema.description || '(no description available)',
+			);
+		}
+		if (!properties.length) {
+			logged.push('\n' + gray('this task has no args'));
+		}
+	}
+	log.info(...logged, '\n');
+};
+
+interface Arg_Schema_Property {
+	name: string;
+	schema: Arg_Schema;
+}
+
+const to_arg_properties = (def: ZodTypeDef, meta: Task_Module_Meta): 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}`,
+		);
+	}
+	const shape = (def as ZodObjectDef).shape();
+	const properties: Arg_Schema_Property[] = [];
+	for (const name in shape) {
+		if ('no-' + name in shape) continue;
+		const s = shape[name];
+		const schema: Arg_Schema = {
+			type: to_args_schema_type(s),
+			description: to_args_schema_description(s),
+			default: to_args_schema_default(s),
+		};
+		properties.push({name, schema});
+	}
+	return properties;
+};
+
+// quick n dirty padding logic
+const pad = (s: string, n: number): string => s + ' '.repeat(n - s.length);
+const to_max_length = <T>(items: 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:
+			return 'string';
+		case ZodFirstPartyTypeKind.ZodNumber:
+			return 'number';
+		case ZodFirstPartyTypeKind.ZodArray:
+			return '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 | string[]'; // TODO support unions of arbitrary types, or more hardcoded ones as needed
+		default: {
+			const subschema = to_subschema(_def);
+			if (subschema) {
+				return to_args_schema_type(subschema);
+			} else {
+				throw Error('Unknown zod type ' + t);
+			}
+		}
+	}
+};
+const to_args_schema_description = ({_def}: ZodTypeAny): string => {
+	if (_def.description) {
+		return _def.description;
+	}
+	const subschema = to_subschema(_def);
+	if (subschema) {
+		return to_args_schema_description(subschema);
+	}
+	return '';
+};
+const to_args_schema_default = ({_def}: ZodTypeAny): any => {
+	if (_def.defaultValue) {
+		return _def.defaultValue();
+	}
+	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;
+	}
+	return undefined;
+};

package/src/lib/test.task.ts

@@ -0,0 +1,50 @@
+import {yellow} from '@ryanatkn/belt/styletext.js';
+import {z} from 'zod';
+
+import {Task_Error, type Task} from './task.js';
+import {paths} from './paths.js';
+import {find_cli} from './cli.js';
+
+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 type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'run tests with uvu',
+	Args,
+	run: async ({args, log}): Promise<void> => {
+		const {_: patterns, bail, cwd, ignore} = args;
+
+		if (!find_cli('uvu')) {
+			log.warn(yellow('uvu is not installed, skipping tests'));
+			return;
+		}
+
+		const [{run}, {parse}] = await Promise.all([import('uvu/run'), import('uvu/parse')]);
+
+		// uvu doesn't work with esm loaders and TypeScript files,
+		// so we use its `parse` and `run` APIs directly instead of its CLI.
+		// To avoid surprises, we allow any number of patterns in the rest args,
+		// so we call `parse` multiple times because it supports only one.
+		const suites = [];
+		for (const pattern of patterns) {
+			const parsed = await parse(paths.source, pattern, {cwd, ignore}); // eslint-disable-line no-await-in-loop
+			suites.push(...parsed.suites);
+		}
+		await run(suites, {bail});
+
+		if (process.exitCode) {
+			throw new Task_Error('Tests failed.');
+		}
+	},
+};

package/src/lib/throttle.test.ts

@@ -0,0 +1,52 @@
+import {wait} from '@ryanatkn/belt/async.js';
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {throttle} from './throttle.js';
+
+test('throttles calls to a function', async () => {
+	const results: string[] = [];
+	const fn = throttle(async (name: string) => {
+		results.push(name + '_run');
+		await wait();
+		results.push(name + '_done');
+	});
+	const promise_a = fn('a');
+	const promise_b = fn('b'); // discarded
+	const promise_c = fn('c'); // discarded
+	const promise_d = fn('d');
+	assert.ok(promise_a !== promise_b);
+	assert.is(promise_b, promise_c);
+	assert.is(promise_b, promise_d);
+	assert.equal(results, ['a_run']);
+	await promise_a;
+	assert.equal(results, ['a_run', 'a_done']);
+	await promise_b;
+	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']);
+	const promise_e = fn('e'); // discarded
+	const promise_f = fn('f');
+	assert.ok(promise_d !== promise_e);
+	assert.is(promise_e, promise_f);
+	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']); // delayed
+	await wait();
+	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run']);
+	await promise_e;
+	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']);
+	const promise_g = fn('g');
+	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']); // delayed
+	await wait();
+	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done', 'g_run']);
+	await promise_g;
+	assert.equal(results, [
+		'a_run',
+		'a_done',
+		'd_run',
+		'd_done',
+		'f_run',
+		'f_done',
+		'g_run',
+		'g_done',
+	]);
+});
+
+test.run();