@ryanatkn/gro 0.129.4 → 0.129.6

package/src/lib/loader.test.ts

@@ -0,0 +1,49 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {resolve} from 'node:path';
+
+test('import js', async () => {
+	const imported = await import(resolve('src/fixtures/modules/some_test_ts.js'));
+	assert.ok(imported);
+	assert.is(imported.a, 'ok');
+});
+
+test('import ts', async () => {
+	const imported = await import(resolve('src/fixtures/modules/some_test_ts.ts'));
+	assert.ok(imported);
+	assert.is(imported.a, 'ok');
+});
+
+test('import json', async () => {
+	const imported = await import(resolve('src/fixtures/modules/some_test_json.json'));
+	assert.ok(imported);
+	assert.is(imported.default.a, 'ok');
+});
+
+test('import css as a no-op', async () => {
+	const imported = await import(resolve('src/fixtures/modules/some_test_css.css'));
+	assert.is(typeof imported.default, 'string');
+	assert.ok(imported);
+});
+
+test('import svelte', async () => {
+	const imported = await import(resolve('src/fixtures/modules/Some_Test_Svelte.svelte'));
+	assert.ok(imported);
+	assert.is(imported.a, 'ok');
+});
+
+test('import svelte.js', async () => {
+	const imported = await import(resolve('src/fixtures/modules/some_test_svelte_js.svelte.js'));
+	assert.ok(imported.Some_Test_Svelte_Js);
+	const instance = new imported.Some_Test_Svelte_Js();
+	assert.is(instance.a, 'ok');
+});
+
+test('import svelte.ts', async () => {
+	const imported = await import(resolve('src/fixtures/modules/some_test_svelte_ts.svelte.ts'));
+	assert.ok(imported.Some_Test_Svelte_Ts);
+	const instance = new imported.Some_Test_Svelte_Ts();
+	assert.is(instance.a, 'ok');
+});
+
+test.run();

package/src/lib/loader.ts

@@ -0,0 +1,226 @@
+import * as esbuild from 'esbuild';
+import {compile, compileModule, preprocess} from 'svelte/compiler';
+import {fileURLToPath, pathToFileURL} from 'node:url';
+import {dirname, join} from 'node:path';
+import type {LoadHook, ResolveHook} from 'node:module';
+import {escape_regexp} from '@ryanatkn/belt/regexp.js';
+
+import {render_env_shim_module} from './sveltekit_shim_env.js';
+import {
+	render_sveltekit_shim_app_environment,
+	render_sveltekit_shim_app_paths,
+	SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER,
+	SVELTEKIT_SHIM_APP_PATHS_MATCHER,
+	sveltekit_shim_app_specifiers,
+} from './sveltekit_shim_app.js';
+import {sveltekit_config_global} from './sveltekit_config_global.js';
+import {SVELTE_MATCHER, SVELTE_RUNES_MATCHER} from './svelte_helpers.js';
+import {paths} from './paths.js';
+import {NODE_MODULES_DIRNAME} from './path_constants.js';
+import {to_define_import_meta_env, ts_transform_options} from './esbuild_helpers.js';
+import {resolve_specifier} from './resolve_specifier.js';
+import {resolve_node_specifier} from './resolve_node_specifier.js';
+import type {Package_Json} from './package_json.js';
+
+/*
+
+Usage via `$lib/register.ts`:
+
+```bash
+node --import @ryanatkn/gro/register.js foo.ts
+```
+
+Usage via `$lib/run.task.ts`:
+
+```bash
+gro run foo.ts
+```
+
+Direct usage without register (see also `$lib/gro.ts`):
+
+```bash
+node --import 'data:text/javascript,import {register} from "node:module"; import {pathToFileURL} from "node:url"; register("@ryanatkn/gro/loader.js", pathToFileURL("./"));' --enable-source-maps' foo.ts
+```
+
+TODO how to improve that gnarly import line? was originally designed for the now-deprecated `--loader`
+
+*/
+
+// TODO support `?raw` import variants
+// TODO sourcemaps for svelte and the svelte preprocessors
+// TODO `import.meta.resolve` wasn't available in loaders when this was first implemented, but might be now
+
+// dev is always true in the loader
+const dev = true;
+
+const dir = paths.root;
+
+const {
+	alias,
+	base_url,
+	assets_url,
+	env_dir,
+	private_prefix,
+	public_prefix,
+	svelte_compile_options,
+	svelte_compile_module_options,
+	svelte_preprocessors,
+} = sveltekit_config_global;
+
+const final_ts_transform_options: esbuild.TransformOptions = {
+	...ts_transform_options,
+	define: to_define_import_meta_env(dev, base_url),
+	sourcemap: 'inline',
+};
+
+const aliases = Object.entries({$lib: 'src/lib', ...alias});
+
+const TS_MATCHER = /\.(ts|tsx|mts|cts)$/u;
+const JSON_MATCHER = /\.(json)$/u;
+const NOOP_MATCHER = /\.(css|svg)$/u; // TODO others? configurable?
+const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/u;
+const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
+
+const package_json_cache: Record<string, Package_Json> = {};
+
+export const load: LoadHook = async (url, context, nextLoad) => {
+	if (SVELTEKIT_SHIM_APP_PATHS_MATCHER.test(url)) {
+		// SvelteKit `$app/paths` shim
+		return {
+			format: 'module',
+			shortCircuit: true,
+			source: render_sveltekit_shim_app_paths(base_url, assets_url),
+		};
+	} else if (SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER.test(url)) {
+		// SvelteKit `$app/environment` shim
+		return {
+			format: 'module',
+			shortCircuit: true,
+			source: render_sveltekit_shim_app_environment(dev),
+		};
+	} else if (SVELTE_RUNES_MATCHER.test(url)) {
+		// Svelte runes in js/ts
+		// TODO support sourcemaps
+		const loaded = await nextLoad(
+			url,
+			context.format === 'module' ? context : {...context, format: 'module'}, // TODO dunno why this is needed, specifically with tests
+		);
+		const filename = fileURLToPath(url);
+		const source = loaded.source!.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+		const transformed = compileModule(source, {...svelte_compile_module_options, filename});
+		return {format: 'module', shortCircuit: true, source: transformed.js.code};
+	} else if (TS_MATCHER.test(url)) {
+		// ts
+		const loaded = await nextLoad(
+			url,
+			context.format === 'module' ? context : {...context, format: 'module'}, // TODO dunno why this is needed, specifically with tests
+		);
+		const transformed = await esbuild.transform(
+			loaded.source!.toString(), // eslint-disable-line @typescript-eslint/no-base-to-string
+			{...final_ts_transform_options, sourcefile: url},
+		);
+		return {format: 'module', shortCircuit: true, source: transformed.code};
+	} else if (SVELTE_MATCHER.test(url)) {
+		// Svelte
+		// TODO support sourcemaps
+		const loaded = await nextLoad(
+			url,
+			context.format === 'module' ? context : {...context, format: 'module'}, // TODO dunno why this is needed, specifically with tests
+		);
+		const filename = fileURLToPath(url);
+		const raw_source = loaded.source!.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+		const preprocessed = svelte_preprocessors
+			? await preprocess(raw_source, svelte_preprocessors, {filename})
+			: null;
+		const source = preprocessed?.code ?? raw_source;
+		const transformed = compile(source, {...svelte_compile_options, filename});
+		return {format: 'module', shortCircuit: true, source: transformed.js.code};
+	} else if (JSON_MATCHER.test(url)) {
+		// json
+		// TODO probably follow esbuild and also export every top-level property for objects from the module - https://esbuild.github.io/content-types/#json (type generation?)
+		const loaded = await nextLoad(url);
+		const raw_source = loaded.source!.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+		const source = `export default ` + raw_source;
+		return {format: 'module', shortCircuit: true, source};
+	} else if (NOOP_MATCHER.test(url)) {
+		// no-ops like `.css` and `.svg`
+		const source = `export default 'no-op import from ${url}'`;
+		return {format: 'module', shortCircuit: true, source};
+	} else {
+		const matched_env = ENV_MATCHER.exec(url);
+		if (matched_env) {
+			// SvelteKit `$env`
+			const mode: 'static' | 'dynamic' = matched_env[1] as any;
+			const visibility: 'public' | 'private' = matched_env[2] as any;
+			return {
+				format: 'module',
+				shortCircuit: true,
+				source: render_env_shim_module(
+					dev,
+					mode,
+					visibility,
+					public_prefix,
+					private_prefix,
+					env_dir,
+				),
+			};
+		}
+	}
+
+	// fallback to default behavior
+	return nextLoad(url, context);
+};
+
+export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
+	if (
+		specifier === '$env/static/public' ||
+		specifier === '$env/static/private' ||
+		specifier === '$env/dynamic/public' ||
+		specifier === '$env/dynamic/private'
+	) {
+		// The returned `url` is validated before `load` is called,
+		// so we need a slightly roundabout strategy to pass through the specifier for virtual files.
+		return {
+			url: pathToFileURL(join(dir, 'src/lib', specifier)).href,
+			format: 'module',
+			shortCircuit: true,
+		};
+	}
+
+	const parent_url = context.parentURL;
+	if (!parent_url || NODE_MODULES_MATCHER.test(parent_url)) {
+		return nextResolve(specifier, context);
+	}
+
+	const shimmed = sveltekit_shim_app_specifiers.get(specifier);
+	if (shimmed !== undefined) {
+		return nextResolve(shimmed, context);
+	}
+
+	let path = specifier;
+
+	// Map the path with the SvelteKit aliases.
+	for (const [from, to] of aliases) {
+		if (path.startsWith(from)) {
+			path = join(dir, to, path.substring(from.length));
+			break;
+		}
+	}
+
+	// The specifier `path` has now been mapped to its final form, so we can inspect it.
+	if (path[0] !== '.' && path[0] !== '/') {
+		// Resolve to `node_modules`.
+		if (SVELTE_MATCHER.test(path) || JSON_MATCHER.test(path)) {
+			// Match the behavior of Vite and esbuild for Svelte and JSON imports.
+			// TODO maybe `.ts` too
+			const path_id = resolve_node_specifier(path, dir, parent_url, package_json_cache);
+			return {url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true};
+		} else {
+			return nextResolve(path, context);
+		}
+	}
+
+	const {path_id} = resolve_specifier(path, dirname(fileURLToPath(parent_url)));
+
+	return {url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true};
+};

package/src/lib/module.test.ts

@@ -0,0 +1,46 @@
+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/module.ts

@@ -0,0 +1,13 @@
+import {LIB_DIRNAME} from './paths.js';
+import {SOURCE_DIR, SOURCE_DIRNAME} from './path_constants.js';
+
+export const MODULE_PATH_SRC_PREFIX = SOURCE_DIR;
+export const MODULE_PATH_LIB_PREFIX = `$${LIB_DIRNAME}/`;
+
+const INTERNAL_MODULE_MATCHER = new RegExp(
+	`^(\\.?\\.?|${SOURCE_DIRNAME}|\\$${LIB_DIRNAME})\\/`,
+	'u',
+);
+
+export const is_external_module = (module_name: string): boolean =>
+	!INTERNAL_MODULE_MATCHER.test(module_name);

package/src/lib/modules.test.ts

@@ -0,0 +1,63 @@
+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/modules.ts

@@ -0,0 +1,112 @@
+import type {Timings} from '@ryanatkn/belt/timings.js';
+import {Unreachable_Error} from '@ryanatkn/belt/error.js';
+import type {Result} from '@ryanatkn/belt/result.js';
+import {print_error} from '@ryanatkn/belt/print.js';
+
+import type {Resolved_Input_File} from './input_path.js';
+import {print_path} from './paths.js';
+import type {Path_Id} from './path.js';
+
+export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
+	id: Path_Id;
+	mod: T_Module;
+}
+
+export type Load_Module_Result<T_Module> = Result<
+	{id: Path_Id; mod: T_Module},
+	Load_Module_Failure
+>;
+export type Load_Module_Failure =
+	| {ok: false; type: 'failed_import'; id: Path_Id; error: Error}
+	| {
+			ok: false;
+			type: 'failed_validation';
+			id: Path_Id;
+			mod: Record<string, any>;
+			validation: string;
+	  };
+
+export const load_module = async <T_Module extends Record<string, any>>(
+	id: Path_Id,
+	validate?: (mod: Record<string, any>) => mod is T_Module,
+): Promise<Load_Module_Result<T_Module>> => {
+	let mod;
+	try {
+		mod = await import(id);
+	} catch (err) {
+		return {ok: false, type: 'failed_import', id, error: err};
+	}
+	if (validate && !validate(mod)) {
+		return {ok: false, type: 'failed_validation', id, mod, validation: validate.name};
+	}
+	return {ok: true, id, mod};
+};
+
+export interface Load_Modules_Failure<T_Module_Meta extends Module_Meta> {
+	type: 'load_module_failures';
+	load_module_failures: Load_Module_Failure[];
+	reasons: string[];
+	// still return the modules and timings, deferring to the caller
+	modules: T_Module_Meta[];
+}
+
+export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<
+	{
+		modules: T_Module_Meta[];
+	},
+	Load_Modules_Failure<T_Module_Meta>
+>;
+
+// TODO parallelize and sort afterwards
+export const load_modules = async <
+	T_Module extends Record<string, any>,
+	T_Module_Meta extends Module_Meta<T_Module>,
+>(
+	resolved_input_files: Resolved_Input_File[],
+	validate: (mod: any) => mod is T_Module,
+	map_module_meta: (resolved_input_file: Resolved_Input_File, mod: T_Module) => T_Module_Meta,
+	timings?: Timings,
+): Promise<Load_Modules_Result<T_Module_Meta>> => {
+	const timing_to_load_modules = timings?.start('load modules');
+	const modules: T_Module_Meta[] = [];
+	const load_module_failures: Load_Module_Failure[] = [];
+	const reasons: string[] = [];
+	for (const resolved_input_file of resolved_input_files.values()) {
+		const {id, input_path} = resolved_input_file;
+		const result = await load_module(id, validate); // eslint-disable-line no-await-in-loop
+		if (result.ok) {
+			modules.push(map_module_meta(resolved_input_file, result.mod));
+		} else {
+			load_module_failures.push(result);
+			switch (result.type) {
+				case 'failed_import': {
+					reasons.push(
+						`Module import ${print_path(id)} failed from input ${print_path(
+							input_path,
+						)}: ${print_error(result.error)}`,
+					);
+					break;
+				}
+				case 'failed_validation': {
+					reasons.push(`Module ${print_path(id)} failed validation '${result.validation}'.`);
+					break;
+				}
+				default:
+					throw new Unreachable_Error(result);
+			}
+		}
+	}
+	timing_to_load_modules?.();
+
+	if (load_module_failures.length) {
+		return {
+			ok: false,
+			type: 'load_module_failures',
+			load_module_failures,
+			reasons,
+			modules,
+		};
+	}
+
+	return {ok: true, modules};
+};

package/src/lib/package.gen.ts

@@ -0,0 +1,33 @@
+import type {Gen} from './gen.js';
+import {load_package_json} from './package_json.js';
+import {IS_THIS_GRO, to_root_path} from './paths.js';
+import {create_src_json} from './src_json.js';
+
+// TODO rename? `Package_Json + Src_Json = package.ts` currently, idk
+
+// TODO consider an api that uses magic imports like SvelteKit's `$app`, like `$repo/package.json`
+
+/**
+ * A convenience `gen` file that outputs `$lib/package.ts`,
+ * which mirrors `package.json` but in TypeScript,
+ * allowing apps to import typesafe data from their own `package.json`.
+ */
+export const gen: Gen = ({origin_id}) => {
+	const package_json = load_package_json();
+	const src_json = create_src_json(package_json);
+
+	return `
+// generated by ${to_root_path(origin_id)}
+
+import type {Package_Json} from '${
+		IS_THIS_GRO ? './package_json.js' : '@ryanatkn/gro/package_json.js'
+	}';
+import type {Src_Json} from '${IS_THIS_GRO ? './src_json.js' : '@ryanatkn/gro/src_json.js'}';
+
+export const package_json = ${JSON.stringify(package_json)} satisfies Package_Json;
+
+export const src_json = ${JSON.stringify(src_json)} satisfies Src_Json;
+
+// generated by ${to_root_path(origin_id)}
+	`;
+};