@ryanatkn/gro 0.129.8 → 0.129.9

package/src/lib/module.test.ts

@@ -1,46 +0,0 @@
-import {suite} from 'uvu';
-import * as assert from 'uvu/assert';
-
-import {is_external_module} from './module.js';
-
-/* test__is_external_module */
-const test__is_external_module = suite('is_external_module');
-
-test__is_external_module('internal browser module patterns', () => {
-	assert.is(is_external_module('./foo'), false);
-	assert.is(is_external_module('./foo.js'), false);
-	assert.is(is_external_module('../foo'), false);
-	assert.is(is_external_module('../foo.js'), false);
-	assert.is(is_external_module('../../../foo'), false);
-	assert.is(is_external_module('../../../foo.js'), false);
-	assert.is(is_external_module('/foo'), false);
-	assert.is(is_external_module('/foo.js'), false);
-	assert.is(is_external_module('src/foo'), false);
-	assert.is(is_external_module('src/foo.js'), false);
-	assert.is(is_external_module('$lib/foo'), false);
-	assert.is(is_external_module('$lib/foo.js'), false);
-	assert.is(is_external_module('./foo/bar/baz'), false);
-	assert.is(is_external_module('./foo/bar/baz.js'), false);
-	assert.is(is_external_module('../foo/bar/baz'), false);
-	assert.is(is_external_module('../foo/bar/baz.js'), false);
-	assert.is(is_external_module('../../../foo/bar/baz'), false);
-	assert.is(is_external_module('../../../foo/bar/baz.js'), false);
-	assert.is(is_external_module('/foo/bar/baz'), false);
-	assert.is(is_external_module('/foo/bar/baz.js'), false);
-	assert.is(is_external_module('src/foo/bar/baz'), false);
-	assert.is(is_external_module('src/foo/bar/baz.js'), false);
-	assert.is(is_external_module('$lib/foo/bar/baz'), false);
-	assert.is(is_external_module('$lib/foo/bar/baz.js'), false);
-});
-
-test__is_external_module('external browser module patterns', () => {
-	assert.is(is_external_module('foo'), true);
-	assert.is(is_external_module('foo.js'), true);
-	assert.is(is_external_module('foo/bar/baz'), true);
-	assert.is(is_external_module('foo/bar/baz.js'), true);
-	assert.is(is_external_module('@foo/bar/baz'), true);
-	assert.is(is_external_module('@foo/bar/baz.js'), true);
-});
-
-test__is_external_module.run();
-/* test__is_external_module */

package/src/lib/modules.test.ts

@@ -1,63 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-import {resolve} from 'node:path';
-
-import {load_module} from './modules.js';
-
-// TODO if we import directly, svelte-package generates types in `src/fixtures`
-/* eslint-disable no-useless-concat */
-const mod_test1 = await import('../fixtures/' + 'test1.foo.js');
-
-test('load_module basic behavior', async () => {
-	const id = resolve('src/fixtures/test1.foo.js');
-	let validated_mod;
-	const result = await load_module(id, (mod): mod is any => {
-		validated_mod = mod;
-		return true;
-	});
-	assert.ok(result.ok);
-	assert.is(result.id, id);
-	assert.is(result.mod, validated_mod);
-	assert.is(result.mod, mod_test1);
-});
-
-test('load_module without validation', async () => {
-	const id = resolve('src/fixtures/test1.foo.js');
-	const result = await load_module(id);
-	assert.ok(result.ok);
-	assert.is(result.id, id);
-	assert.is(result.mod, mod_test1);
-});
-
-test('load_module fails validation', async () => {
-	const id = resolve('src/fixtures/test1.foo.js');
-	let validated_mod;
-	const test_validation = (mod: Record<string, any>) => {
-		validated_mod = mod;
-		return false;
-	};
-	const result = await load_module(id, test_validation as any);
-	assert.ok(!result.ok);
-	if (result.type === 'failed_validation') {
-		assert.is(result.validation, test_validation.name);
-		assert.is(result.id, id);
-		assert.is(result.mod, validated_mod);
-		assert.is(result.mod, mod_test1);
-	} else {
-		throw Error('Should be invalid');
-	}
-});
-
-test('load_module fails to import', async () => {
-	const id = resolve('foo/test/failure');
-	const result = await load_module(id);
-	assert.ok(!result.ok);
-	if (result.type === 'failed_import') {
-		assert.is(result.id, id);
-		assert.ok(result.error instanceof Error);
-	} else {
-		throw Error('Should fail to import');
-	}
-});
-
-test.run();

package/src/lib/package_json.test.ts

@@ -1,101 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-
-import {
-	Package_Json,
-	load_package_json,
-	parse_repo_url,
-	serialize_package_json,
-	to_package_exports,
-} from './package_json.js';
-
-test('load_package_json', () => {
-	const package_json = load_package_json();
-	assert.ok(package_json);
-	const parsed = Package_Json.parse(package_json);
-	assert.ok(parsed);
-	serialize_package_json(package_json);
-});
-
-test('load_package_json with cache', () => {
-	const cache = {};
-	const package_json1 = load_package_json(undefined, cache);
-	assert.ok(package_json1);
-	assert.is(Object.keys(cache).length, 1);
-	const package_json2 = load_package_json(undefined, cache);
-	assert.is(Object.keys(cache).length, 1);
-	assert.is(package_json1, package_json2);
-});
-
-test('Package_Json.parse', () => {
-	Package_Json.parse({name: 'abc', version: '123'});
-});
-
-test('Package_Json.parse fails with bad data', () => {
-	let err;
-	try {
-		Package_Json.parse({version: '123'});
-	} catch (_err) {
-		err = _err;
-	}
-	assert.ok(err);
-});
-
-test('serialize_package_json', () => {
-	serialize_package_json({name: 'abc', version: '123'});
-});
-
-test('serialize_package_json fails with bad data', () => {
-	let err;
-	try {
-		serialize_package_json({version: '123'} as any);
-	} catch (_err) {
-		err = _err;
-	}
-	assert.ok(err);
-});
-
-test('to_package_exports', () => {
-	assert.equal(to_package_exports(['a/b.ts']), {
-		'./package.json': './package.json',
-		'./a/b.js': {
-			default: './dist/a/b.js',
-			types: './dist/a/b.d.ts',
-		},
-	});
-	assert.equal(
-		to_package_exports([
-			'a/b/Some_Test_Svelte.svelte',
-			'a/b/some_test_ts.ts',
-			'a/b/some_test_json.json',
-			'index.ts',
-		]),
-		{
-			'.': {
-				default: './dist/index.js',
-				types: './dist/index.d.ts',
-			},
-			'./package.json': './package.json',
-			'./a/b/some_test_json.json': {
-				default: './dist/a/b/some_test_json.json',
-			},
-			'./a/b/Some_Test_Svelte.svelte': {
-				svelte: './dist/a/b/Some_Test_Svelte.svelte',
-				default: './dist/a/b/Some_Test_Svelte.svelte',
-				types: './dist/a/b/Some_Test_Svelte.svelte.d.ts',
-			},
-			'./a/b/some_test_ts.js': {
-				default: './dist/a/b/some_test_ts.js',
-				types: './dist/a/b/some_test_ts.d.ts',
-			},
-		},
-	);
-});
-
-test('parse_repo_url', () => {
-	const parsed = parse_repo_url(load_package_json());
-	assert.is(parsed?.owner, 'ryanatkn');
-	assert.is(parsed?.repo, 'gro');
-});
-
-test.run();

package/src/lib/paths.test.ts

@@ -1,77 +0,0 @@
-import {suite} from 'uvu';
-import * as assert from 'uvu/assert';
-import {resolve, join} from 'node:path';
-
-import {
-	create_paths,
-	paths,
-	gro_paths,
-	is_gro_id,
-	to_root_path,
-	path_id_to_base_path,
-	base_path_to_path_id,
-} from './paths.js';
-
-/* test__create_paths */
-const test__create_paths = suite('create_paths');
-
-test__create_paths('basic behavior', () => {
-	const root = resolve('../fake');
-	const p = create_paths(root);
-	assert.is(p.root, join(root, '/'));
-	assert.is(p.source, join(root, 'src/'));
-});
-
-test__create_paths('paths object has the same identity as the gro_paths object', () => {
-	assert.is(paths, gro_paths); // because we're testing inside the Gro project
-});
-
-test__create_paths.run();
-/* test__create_paths */
-
-/* test__is_gro_id */
-const test__is_gro_id = suite('is_gro_id');
-
-test__is_gro_id('basic behavior', () => {
-	assert.ok(is_gro_id(resolve(paths.source)));
-	assert.ok(!is_gro_id(resolve('../fake/src')));
-});
-
-test__is_gro_id.run();
-/* test__is_gro_id */
-
-/* test__to_root_path */
-const test__to_root_path = suite('to_root_path');
-
-test__to_root_path('basic behavior', () => {
-	assert.is(to_root_path(resolve('foo/bar')), 'foo/bar');
-	assert.is(to_root_path(resolve('./')), './');
-	assert.is(to_root_path(resolve('./')), './');
-});
-
-test__to_root_path.run();
-/* test__to_root_path */
-
-/* test__path_id_to_base_path */
-const test__path_id_to_base_path = suite('path_id_to_base_path');
-
-test__path_id_to_base_path('basic behavior', () => {
-	assert.is(path_id_to_base_path(resolve('src/foo/bar/baz.ts')), 'foo/bar/baz.ts');
-});
-
-test__path_id_to_base_path.run();
-/* test__path_id_to_base_path */
-
-/* test__base_path_to_path_id */
-const test__base_path_to_path_id = suite('base_path_to_path_id');
-
-test__base_path_to_path_id('basic behavior', () => {
-	assert.is(base_path_to_path_id('foo/bar/baz.ts'), resolve('src/foo/bar/baz.ts'));
-});
-
-test__base_path_to_path_id('does not change extension', () => {
-	assert.is(base_path_to_path_id('foo/bar/baz.js'), resolve('src/foo/bar/baz.js'));
-});
-
-test__base_path_to_path_id.run();
-/* test__base_path_to_path_id */

package/src/lib/plugin.test.ts

@@ -1,57 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-
-import {replace_plugin} from './plugin.js';
-
-test('replace_plugin', () => {
-	const a = {name: 'a'};
-	const b = {name: 'b'};
-	const c = {name: 'c'};
-	const plugins = [a, b, c];
-	const a2 = {name: 'a'};
-	const b2 = {name: 'b'};
-	const c2 = {name: 'c'};
-	let p = plugins;
-	p = replace_plugin(p, a2);
-	assert.is(p[0], a2);
-	assert.is(p[1], b);
-	assert.is(p[2], c);
-	p = replace_plugin(p, b2);
-	assert.is(p[0], a2);
-	assert.is(p[1], b2);
-	assert.is(p[2], c);
-	// allows duplicate names in the array
-	p = replace_plugin(p, c2, 'a');
-	assert.is(p[0], c2);
-	assert.is(p[1], b2);
-	assert.is(p[2], c);
-	p = replace_plugin(p, a2, 'c');
-	assert.is(p[0], a2);
-	assert.is(p[1], b2);
-	assert.is(p[2], c);
-	p = replace_plugin(p, c2);
-	assert.is(p[0], a2);
-	assert.is(p[1], b2);
-	assert.is(p[2], c2);
-});
-
-test('replace_plugin without an array', () => {
-	const a = {name: 'a'};
-	const a2 = {name: 'a'};
-	const p = replace_plugin(a, a2);
-	assert.is(p[0], a2);
-});
-
-test('replace_plugin throws if it cannot find the given name', () => {
-	const a = {name: 'a'};
-	const plugins = [a];
-	let err;
-	try {
-		replace_plugin(plugins, {name: 'b'});
-	} catch (_err) {
-		err = _err;
-	}
-	if (!err) assert.unreachable('should have failed');
-});
-
-test.run();

package/src/lib/resolve_node_specifier.test.ts

@@ -1,31 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-
-import {resolve_node_specifier} from './resolve_node_specifier.js';
-import {paths} from './paths.js';
-
-test('resolves a JS specifier', () => {
-	assert.is(
-		resolve_node_specifier('@ryanatkn/fuz/tome.js'),
-		paths.root + 'node_modules/@ryanatkn/fuz/dist/tome.js',
-	);
-});
-
-test('resolves a Svelte specifier', () => {
-	assert.is(
-		resolve_node_specifier('@ryanatkn/fuz/Library.svelte'),
-		paths.root + 'node_modules/@ryanatkn/fuz/dist/Library.svelte',
-	);
-});
-
-test('throws for a specifier that does not exist', () => {
-	let err;
-	try {
-		resolve_node_specifier('@ryanatkn/fuz/this_does_not_exist');
-	} catch (_err) {
-		err = _err;
-	}
-	assert.ok(err);
-});
-
-test.run();

package/src/lib/resolve_specifier.test.ts

@@ -1,76 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-import {join} from 'node:path';
-
-import {resolve_specifier} from './resolve_specifier.js';
-import {paths} from './paths.js';
-
-const dir = paths.source + 'fixtures/';
-
-test('resolves a specifier to a file that exists with an unknown file extension', () => {
-	assert.equal(resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
-		specifier: './test_file.other.ext',
-		path_id: join(dir, 'test_file.other.ext'),
-		namespace: undefined,
-	});
-});
-
-test('resolves a ts specifier', () => {
-	assert.equal(resolve_specifier(join(dir, 'test_ts.ts'), dir), {
-		specifier: './test_ts.js',
-		path_id: join(dir, 'test_ts.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-});
-
-test('resolves relative ts specifiers', () => {
-	assert.equal(resolve_specifier('./test_ts.ts', dir), {
-		specifier: './test_ts.js',
-		path_id: join(dir, 'test_ts.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-	assert.equal(resolve_specifier('./a/b/test_ts.ts', dir), {
-		specifier: './a/b/test_ts.js',
-		path_id: join(dir, 'a/b/test_ts.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-	assert.equal(resolve_specifier('../../test_ts.ts', dir), {
-		specifier: '../../test_ts.js',
-		path_id: join(dir, '../../test_ts.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-});
-
-test('resolves an extensionless specifier', () => {
-	assert.equal(resolve_specifier(join(dir, 'test_ts'), dir), {
-		specifier: './test_ts.js',
-		path_id: join(dir, 'test_ts.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-});
-
-test('resolves a js specifier', () => {
-	assert.equal(resolve_specifier(join(dir, 'test_js.js'), dir), {
-		specifier: './test_js.js',
-		path_id: join(dir, 'test_js.js'),
-		namespace: 'sveltekit_local_imports_js',
-	});
-});
-
-test('resolves a js specifier as ts for a file that does not exist', () => {
-	assert.equal(resolve_specifier(join(dir, 'test_missing.js'), dir), {
-		specifier: './test_missing.js',
-		path_id: join(dir, 'test_missing.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-});
-
-test('resolves an extensionless specifier for a file that does not exist', () => {
-	assert.equal(resolve_specifier(join(dir, 'test_missing'), dir), {
-		specifier: './test_missing.js',
-		path_id: join(dir, 'test_missing.ts'),
-		namespace: 'sveltekit_local_imports_ts',
-	});
-});
-
-test.run();

package/src/lib/run_gen.test.ts

@@ -1,196 +0,0 @@
-import {suite} from 'uvu';
-import * as assert from 'uvu/assert';
-import {resolve, join} from 'node:path';
-import {Logger} from '@ryanatkn/belt/log.js';
-import {Timings} from '@ryanatkn/belt/timings.js';
-
-import type {Genfile_Module_Meta} from './gen.js';
-import {run_gen} from './run_gen.js';
-import {load_config} from './config.js';
-
-const log = new Logger('test__gen'); // TODO test logger?
-
-/* test__gen */
-const test__gen = suite('gen');
-
-test__gen('basic behavior', async () => {
-	const path_id_a = resolve('src/foo.gen.ts');
-	const path_id_bc = resolve('src/bar/bc');
-	let file_a: undefined | {filename: string; content: string};
-	let file_b: undefined | {filename: string; content: string};
-	let file_c1: undefined | {filename: string; content: string};
-	let file_c2: undefined | {filename: string; content: string};
-	const mod_a: Genfile_Module_Meta = {
-		id: path_id_a,
-		mod: {
-			gen: (ctx) => {
-				assert.is(ctx.origin_id, path_id_a);
-				if (file_a) throw Error('Already generated file_a');
-				file_a = {
-					filename: 'foo.ts',
-					content: 'file_a',
-				};
-				return file_a.content; // here we return the shorthand version
-			},
-		},
-	};
-	const mod_b: Genfile_Module_Meta = {
-		id: join(path_id_bc, 'mod_b.gen.ts'),
-		mod: {
-			gen: (ctx) => {
-				assert.is(ctx.origin_id, mod_b.id);
-				if (file_b) throw Error('Already generated file_b');
-				file_b = {
-					filename: 'output_b.ts',
-					content: 'file_b',
-				};
-				return file_b;
-			},
-		},
-	};
-	const mod_c: Genfile_Module_Meta = {
-		id: join(path_id_bc, 'mod_c.gen.ts'),
-		mod: {
-			gen: (ctx) => {
-				assert.is(ctx.origin_id, mod_c.id);
-				if (file_c1) throw Error('Already generated file_c1');
-				if (file_c2) throw Error('Already generated file_c2');
-				file_c1 = {
-					filename: 'output_c1.ts',
-					content: 'file_c1',
-				};
-				file_c2 = {
-					filename: 'output_c2.ts',
-					content: 'file_c2',
-				};
-				return [file_c1, file_c2];
-			},
-		},
-	};
-	const gen_modules_by_input_path = [mod_a, mod_b, mod_c];
-	const gen_results = await run_gen(
-		gen_modules_by_input_path,
-		await load_config(),
-		log,
-		new Timings(),
-		(content, opts) =>
-			Promise.resolve(opts.filepath!.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content),
-	);
-	assert.is(gen_results.input_count, 3);
-	assert.is(gen_results.output_count, 4);
-	assert.is(gen_results.successes.length, 3);
-	assert.is(gen_results.failures.length, 0);
-	assert.is(gen_results.results.length, 3);
-	assert.is(gen_results.results[0], gen_results.successes[0]);
-	assert.is(gen_results.results[1], gen_results.successes[1]);
-	assert.is(gen_results.results[2], gen_results.successes[2]);
-
-	const result_a = gen_results.results[0];
-	assert.ok(result_a.ok);
-	assert.ok(file_a);
-	assert.equal(result_a.files, [
-		{
-			content: file_a.content,
-			id: join(mod_a.id, '../', file_a.filename),
-			origin_id: mod_a.id,
-			format: true,
-		},
-	]);
-
-	const result_b = gen_results.results[1];
-	assert.ok(result_b.ok);
-	assert.ok(file_b);
-	assert.equal(result_b.files, [
-		{
-			content: `${file_b.content}/*FORMATTED*/`,
-			id: join(mod_b.id, '../', file_b.filename),
-			origin_id: mod_b.id,
-			format: true,
-		},
-	]);
-	const result_c = gen_results.results[2];
-	assert.ok(result_c.ok);
-	assert.ok(file_c1);
-	assert.ok(file_c2);
-	assert.equal(result_c.files, [
-		{
-			content: file_c1.content,
-			id: join(mod_c.id, '../', file_c1.filename),
-			origin_id: mod_c.id,
-			format: true,
-		},
-		{
-			content: file_c2.content,
-			id: join(mod_c.id, '../', file_c2.filename),
-			origin_id: mod_c.id,
-			format: true,
-		},
-	]);
-});
-
-test__gen('failing gen function', async () => {
-	const path_id_a = resolve('src/foo.gen.ts');
-	const path_idB = resolve('src/bar/baz');
-	let file_b: undefined | {filename: string; content: string}; // no file_a because it's never generated
-	let genError; // this error should be passed through to the result
-	// This is the failing gen module.
-	// It's ordered first to test that its failure doesn't cascade.
-	const mod_a: Genfile_Module_Meta = {
-		id: path_id_a,
-		mod: {
-			gen: () => {
-				genError = Error('This fails for testing');
-				throw genError;
-			},
-		},
-	};
-	const mod_b: Genfile_Module_Meta = {
-		id: join(path_idB, 'mod_b.gen.ts'),
-		mod: {
-			gen: (ctx) => {
-				assert.is(ctx.origin_id, mod_b.id);
-				if (file_b) throw Error('Already generated file_b');
-				file_b = {
-					filename: 'output_b.ts',
-					content: 'file_b',
-				};
-				return file_b;
-			},
-		},
-	};
-	const gen_modules_by_input_path: Genfile_Module_Meta[] = [mod_a, mod_b];
-	const gen_results = await run_gen(
-		gen_modules_by_input_path,
-		await load_config(),
-		log,
-		new Timings(),
-	);
-	assert.is(gen_results.input_count, 2);
-	assert.is(gen_results.output_count, 1);
-	assert.is(gen_results.successes.length, 1);
-	assert.is(gen_results.failures.length, 1);
-	assert.is(gen_results.results.length, 2);
-	assert.is(gen_results.results[0], gen_results.failures[0]);
-	assert.is(gen_results.results[1], gen_results.successes[0]);
-
-	const result_a = gen_results.results[0];
-	assert.ok(result_a);
-	assert.ok(!result_a.ok);
-	assert.ok(result_a.reason);
-	assert.ok(result_a.error);
-
-	const result_b = gen_results.results[1];
-	assert.ok(result_b.ok);
-	assert.ok(file_b);
-	assert.equal(result_b.files, [
-		{
-			content: file_b.content,
-			id: join(mod_b.id, '../', file_b.filename),
-			origin_id: mod_b.id,
-			format: true,
-		},
-	]);
-});
-
-test__gen.run();
-/* test__gen */