@ryanatkn/gro 0.141.1 → 0.142.0

package/src/lib/resolve_node_specifier.ts

@@ -1,21 +1,32 @@
 import {join} from 'node:path';
+import {existsSync} from 'node:fs';
+import {DEV} from 'esm-env';
 
-import {Package_Json, load_package_json} from './package_json.js';
+import {Package_Json, Package_Json_Exports, load_package_json} from './package_json.js';
 import {paths} from './paths.js';
 import {NODE_MODULES_DIRNAME} from './path_constants.js';
 import type {Resolved_Specifier} from './resolve_specifier.js';
 
+/**
+ * Like `resolve_specifier` but for Node specifiers,
+ * typically those that aren't relative or absolute.
+ * Optionally return `null` instead of throwing by setting
+ * `throw_on_missing_package` to `false`.
+ */
 export const resolve_node_specifier = (
 	specifier: string,
 	dir = paths.root,
-	parent_url?: string,
+	parent_path?: string,
 	cache?: Record<string, Package_Json>,
-	exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default',
-): Resolved_Specifier => {
+	throw_on_missing_package = true,
+	// TODO this needs to use `--conditions`/`-C` to determine the correct key
+	exports_condition = DEV ? 'development' : 'default',
+): Resolved_Specifier | null => {
 	const raw = specifier.endsWith('?raw');
 	const mapped_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
 
-	let idx!: number;
+	// Parse the specifier
+	let idx: number = -1;
 	if (mapped_specifier[0] === '@') {
 		// get the index of the second `/`
 		let count = 0;
@@ -29,21 +40,47 @@ export const resolve_node_specifier = (
 	} else {
 		idx = mapped_specifier.indexOf('/');
 	}
-	const name = mapped_specifier.substring(0, idx);
-	const path = mapped_specifier.substring(idx + 1);
+	const pkg_name = idx === -1 ? mapped_specifier : mapped_specifier.substring(0, idx);
+	const module_path = idx === -1 ? '' : mapped_specifier.substring(idx + 1);
+	const subpath = module_path ? './' + module_path : '.';
+	const package_dir = join(dir, NODE_MODULES_DIRNAME, pkg_name);
 
-	const subpath = './' + path;
-	const package_dir = join(dir, NODE_MODULES_DIRNAME, name);
-	const package_json = load_package_json(package_dir, cache);
-	const exported = package_json.exports?.[subpath];
+	if (!existsSync(package_dir)) {
+		if (throw_on_missing_package) {
+			throw Error(
+				`Package not found at ${package_dir} for specifier ${specifier}, you may need to npm install or fix the path` +
+					(parent_path ? ` imported from ${parent_path}` : ''),
+			);
+		} else {
+			return null;
+		}
+	}
+
+	const package_json = load_package_json(package_dir, cache, false);
+	const {exported, exports_key} = resolve_subpath(package_json, specifier, subpath);
 	if (!exported) {
-		// same error message as Node
-		throw Error(
-			`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
-				(parent_url ? ` imported from ${parent_url}` : ''),
-		);
+		if (throw_on_missing_package) {
+			// same error message as Node
+			throw Error(
+				`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by 'exports' in ${package_dir}/package.json` +
+					(parent_path ? ` imported from ${parent_path}` : ''),
+			);
+		} else {
+			return null;
+		}
 	}
-	const path_id = join(package_dir, exported[exports_key]);
+	const exported_value = resolve_exported_value(exported, exports_key, exports_condition);
+	if (exported_value === undefined) {
+		if (throw_on_missing_package) {
+			throw Error(
+				`Package subpath '${subpath}' does not define the key '${exports_key}' in 'exports' in ${package_dir}/package.json` +
+					(parent_path ? ` imported from ${parent_path}` : ''),
+			);
+		} else {
+			return null;
+		}
+	}
+	const path_id = join(package_dir, exported_value);
 
 	return {
 		path_id,
@@ -54,3 +91,48 @@ export const resolve_node_specifier = (
 		namespace: undefined,
 	};
 };
+
+/**
+ * Resolves the subpath of a package.json `exports` field based on the `specifier`.
+ */
+const resolve_subpath = (
+	package_json: Package_Json,
+	specifier: string,
+	subpath: string,
+): {exported: Package_Json_Exports[string]; exports_key: string} => {
+	const exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default';
+
+	const exported =
+		subpath === '.' && !package_json.exports
+			? {[exports_key]: package_json.main}
+			: package_json.exports?.[subpath];
+
+	return {exported, exports_key};
+};
+
+/**
+ * Resolves the exported value based on the exports key and condition.
+ */
+const resolve_exported_value = (
+	exported: Exclude<Package_Json_Exports[string], undefined>,
+	exports_key: string,
+	exports_condition: string,
+): string | undefined => {
+	let exported_value = typeof exported === 'string' ? exported : exported[exports_key];
+
+	// TODO best effort fallback, support `default` but fall back to `import` or `node` as the exports key.
+	if (exported_value === undefined && typeof exported !== 'string' && exports_key === 'default') {
+		exported_value = exported.import ?? exported.node;
+	}
+
+	// Possibly resolve to conditional exports.
+	exported_value =
+		exported_value === undefined || typeof exported_value === 'string'
+			? exported_value
+			: (exported_value[exports_condition] ??
+				exported_value.default ??
+				exported_value.import ??
+				exported_value.node); // TODO this fallback has corner case bugs for off-spec exports
+
+	return exported_value;
+};

package/src/lib/resolve_specifier.ts

@@ -20,13 +20,9 @@ export interface Resolved_Specifier {
 }
 
 /**
- * Maps a `path` import specifier relative to the `importer`,
+ * Maps an import `specifier` relative to `dir`,
  * and infer the correct extension following Vite conventions.
- * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
- * @param specifier
- * @param dir - if defined, enables relative importers like from esbuild plugins
- * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
- * @returns
+ * If no `.js` file is found for the specifier on the filesystem, it assumes `.ts`.
  */
 export const resolve_specifier = (specifier: string, dir: string): Resolved_Specifier => {
 	const raw = specifier.endsWith('?raw');

package/src/lib/sveltekit_config.ts

@@ -57,7 +57,7 @@ export interface Parsed_Sveltekit_Config {
 	private_prefix: string | undefined;
 	public_prefix: string | undefined;
 	svelte_compile_options: CompileOptions;
-	svelte_compile_module_options: CompileOptions;
+	svelte_compile_module_options: ModuleCompileOptions;
 	svelte_preprocessors: PreprocessorGroup | PreprocessorGroup[] | undefined;
 }
 

package/src/lib/sync.task.ts

@@ -26,7 +26,7 @@ export const task: Task<Args> = {
 		const {sveltekit, package_json, gen, install} = args;
 
 		if (install) {
-			const result = await spawn('npm', ['i']);
+			const result = await spawn(config.pm_cli, ['i']);
 			if (!result.ok) {
 				throw new Task_Error('Failed npm install');
 			}

package/src/lib/upgrade.task.ts

@@ -5,6 +5,7 @@ import {Task_Error, type Task} from './task.js';
 import {extract_deps, load_package_json, type Package_Json_Dep} from './package_json.js';
 import {Git_Origin, git_pull} from './git.js';
 import {spawn_cli} from './cli.js';
+import {serialize_args, to_forwarded_args} from './args.js';
 
 export const Args = z
 	.object({
@@ -27,7 +28,7 @@ export type Args = z.infer<typeof Args>;
 export const task: Task<Args> = {
 	summary: 'upgrade deps',
 	Args,
-	run: async ({args, log}): Promise<void> => {
+	run: async ({args, log, config}): Promise<void> => {
 		const {_, only, origin, force, pull, dry} = args;
 
 		if (_.length && only.length) {
@@ -65,7 +66,8 @@ export const task: Task<Args> = {
 		if (force) {
 			install_args.push('--force');
 		}
-		await spawn('npm', install_args);
+		install_args.push(...serialize_args(to_forwarded_args(config.pm_cli)));
+		await spawn(config.pm_cli, install_args);
 
 		// Sync in a new process to pick up any changes after installing, avoiding some errors.
 		await spawn_cli('gro', ['sync', '--no-install']); // don't install because we do above

package/src/lib/watch_dir.ts

@@ -1,6 +1,7 @@
 import {watch, type ChokidarOptions, type FSWatcher} from 'chokidar';
 import {relative} from 'node:path';
 import {statSync} from 'node:fs';
+import {create_deferred, type Deferred} from '@ryanatkn/belt/async.js';
 
 import type {Path_Filter} from './path.js';
 
@@ -42,13 +43,12 @@ export const watch_dir = ({
 	chokidar,
 }: Options): Watch_Node_Fs => {
 	let watcher: FSWatcher | undefined;
-	let initing: Promise<void> | undefined;
+	let initing: Deferred<void> | undefined;
 
 	return {
 		init: async () => {
-			if (initing) return initing;
-			let resolve: any;
-			initing = new Promise((r) => (resolve = r)); // TODO `create_deferred`?// cwd: chokidar?.cwd ?? process.cwd()
+			if (initing) return initing.promise;
+			initing = create_deferred();
 			watcher = watch(dir, {...chokidar});
 			watcher.on('add', (path) => {
 				const final_path = absolute ? path : relative(dir, path);
@@ -77,8 +77,8 @@ export const watch_dir = ({
 				on_change({type: 'delete', path: final_path, is_directory: true});
 			});
 			// wait until ready
-			watcher.once('ready', () => resolve());
-			await initing;
+			watcher.once('ready', () => initing?.resolve());
+			await initing.promise;
 		},
 		close: async () => {
 			initing = undefined;