@fuzdev/gro 0.192.0

package/src/lib/module.ts

@@ -0,0 +1,13 @@
+import {LIB_DIRNAME} from './paths.ts';
+import {SOURCE_DIR, SOURCE_DIRNAME} from './constants.ts';
+
+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.ts

@@ -0,0 +1,117 @@
+import type {Timings} from '@fuzdev/fuz_util/timings.js';
+import {UnreachableError} from '@fuzdev/fuz_util/error.js';
+import type {Result} from '@fuzdev/fuz_util/result.js';
+import {print_error} from '@fuzdev/fuz_util/print.js';
+import {pathToFileURL} from 'node:url';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+
+import type {ResolvedInputFile} from './input_path.ts';
+import {print_path} from './paths.ts';
+
+export interface ModuleMeta<TModule extends Record<string, any> = Record<string, any>> {
+	id: PathId;
+	mod: TModule;
+}
+
+export type LoadModuleResult<TModule> = Result<{id: PathId; mod: TModule}, LoadModuleFailure>;
+export type LoadModuleFailure =
+	| {ok: false; type: 'failed_import'; id: PathId; error: Error}
+	| {
+			ok: false;
+			type: 'failed_validation';
+			id: PathId;
+			mod: Record<string, any>;
+			validation: string;
+	  };
+
+export const load_module = async <TModule extends Record<string, any>>(
+	id: PathId,
+	validate?: (mod: Record<string, any>) => mod is TModule,
+	bust_cache?: boolean,
+): Promise<LoadModuleResult<TModule>> => {
+	let mod;
+	try {
+		let import_path = id;
+		if (bust_cache) {
+			const url = pathToFileURL(id);
+			url.searchParams.set('t', Date.now().toString());
+			import_path = url.href;
+		}
+		mod = await import(import_path);
+	} catch (error) {
+		return {ok: false, type: 'failed_import', id, error};
+	}
+	if (validate && !validate(mod)) {
+		return {ok: false, type: 'failed_validation', id, mod, validation: validate.name};
+	}
+	return {ok: true, id, mod};
+};
+
+export interface LoadModulesFailure<TModuleMeta extends ModuleMeta> {
+	type: 'load_module_failures';
+	load_module_failures: Array<LoadModuleFailure>;
+	reasons: Array<string>;
+	// still return the modules and timings, deferring to the caller
+	modules: Array<TModuleMeta>;
+}
+
+export type LoadModulesResult<TModuleMeta extends ModuleMeta> = Result<
+	{
+		modules: Array<TModuleMeta>;
+	},
+	LoadModulesFailure<TModuleMeta>
+>;
+
+// TODO parallelize and sort afterwards
+export const load_modules = async <
+	TModule extends Record<string, any>,
+	TModuleMeta extends ModuleMeta<TModule>,
+>(
+	resolved_input_files: Array<ResolvedInputFile>,
+	validate: (mod: any) => mod is TModule,
+	map_module_meta: (resolved_input_file: ResolvedInputFile, mod: TModule) => TModuleMeta,
+	timings?: Timings,
+): Promise<LoadModulesResult<TModuleMeta>> => {
+	const timing_to_load_modules = timings?.start('load modules');
+	const modules: Array<TModuleMeta> = [];
+	const load_module_failures: Array<LoadModuleFailure> = [];
+	const reasons: Array<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 UnreachableError(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_json.ts

@@ -0,0 +1,255 @@
+import {z} from 'zod';
+import {join} from 'node:path';
+import {readFile, writeFile} from 'node:fs/promises';
+import {plural, strip_end} from '@fuzdev/fuz_util/string.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {styleText as st} from 'node:util';
+import {PackageJson, PackageJsonExports} from '@fuzdev/fuz_util/package_json.js';
+import {fs_search} from '@fuzdev/fuz_util/fs.js';
+
+import {paths, gro_paths, IS_THIS_GRO} from './paths.ts';
+import {
+	PACKAGE_JSON_FILENAME,
+	SVELTEKIT_DIST_DIRNAME,
+	TS_MATCHER,
+	JS_MATCHER,
+	SVELTE_MATCHER,
+	JSON_MATCHER,
+	CSS_MATCHER,
+} from './constants.ts';
+import {has_sveltekit_library} from './sveltekit_helpers.ts';
+import {GITHUB_REPO_MATCHER} from './github.ts';
+
+export type PackageJsonMapper = (
+	package_json: PackageJson,
+) => PackageJson | null | Promise<PackageJson | null>;
+
+export const PACKAGE_JSON_EMPTY: PackageJson = {name: '', version: ''};
+
+export const package_json_load = async (
+	dir = IS_THIS_GRO ? gro_paths.root : paths.root,
+	cache?: Record<string, PackageJson>,
+	parse = true, // TODO pass `false` here in more places, especially anything perf-sensitive like work on startup
+	log?: Logger,
+): Promise<PackageJson> => {
+	let package_json: PackageJson;
+	if (cache && dir in cache) {
+		return cache[dir]!;
+	}
+	try {
+		package_json = JSON.parse(await package_json_load_contents(dir));
+	} catch (error) {
+		log?.error(st('yellow', `Failed to load package.json in ${dir}`), error);
+		return PACKAGE_JSON_EMPTY;
+	}
+	if (parse) {
+		package_json = parse_package_json(PackageJson, package_json);
+	}
+	if (cache) {
+		cache[dir] = package_json;
+	}
+	return package_json;
+};
+
+export const package_json_sync = async (
+	map_package_json: PackageJsonMapper,
+	log: Logger,
+	write = true,
+	dir = paths.root,
+	exports_dir = paths.lib,
+): Promise<{package_json: PackageJson | null; changed: boolean}> => {
+	const exported_files = await fs_search(exports_dir);
+	const exported_paths = exported_files.map((f) => f.path);
+	const updated = await package_json_update(
+		async (package_json) => {
+			if ((await has_sveltekit_library(package_json)).ok) {
+				package_json.exports = package_json_to_exports(exported_paths);
+			}
+			const mapped = await map_package_json(package_json);
+			return mapped ? parse_package_json(PackageJson, mapped) : mapped;
+		},
+		dir,
+		write,
+	);
+
+	const exports_count =
+		updated.changed && updated.package_json?.exports
+			? Object.keys(updated.package_json.exports).length
+			: 0;
+	log.info(
+		updated.changed
+			? `updated package.json exports with ${exports_count} total export${plural(exports_count)}`
+			: 'no changes to exports in package.json',
+	);
+
+	return updated;
+};
+
+export const package_json_load_for_gro = (): Promise<PackageJson> =>
+	package_json_load(gro_paths.root);
+
+// TODO probably make this nullable and make callers handle failures
+const package_json_load_contents = (dir: string): Promise<string> =>
+	readFile(join(dir, PACKAGE_JSON_FILENAME), 'utf8');
+
+export const package_json_write = (serialized_package_json: string): Promise<void> =>
+	writeFile(join(paths.root, PACKAGE_JSON_FILENAME), serialized_package_json);
+
+export const package_json_serialize = (package_json: PackageJson): string =>
+	JSON.stringify(parse_package_json(PackageJson, package_json), null, 2) + '\n';
+
+/**
+ * Updates package.json. Writes to the filesystem only when contents change.
+ */
+export const package_json_update = async (
+	update: (package_json: PackageJson) => PackageJson | null | Promise<PackageJson | null>,
+	dir = paths.root,
+	write = true,
+): Promise<{package_json: PackageJson | null; changed: boolean}> => {
+	const original_contents = await package_json_load_contents(dir);
+	const original = JSON.parse(original_contents);
+	const updated = await update(original);
+	if (updated === null) {
+		return {package_json: original, changed: false};
+	}
+	const updated_contents = package_json_serialize(updated);
+	if (updated_contents === original_contents) {
+		return {package_json: original, changed: false};
+	}
+	if (write) await package_json_write(updated_contents);
+	return {package_json: updated, changed: true};
+};
+
+const is_index = (path: string): boolean => path === 'index.ts' || path === 'index.js';
+
+export const package_json_to_exports = (paths: Array<string>): PackageJsonExports => {
+	const has_index = paths.some(is_index);
+	const has_js = paths.some((p) => TS_MATCHER.test(p) || JS_MATCHER.test(p));
+	const has_svelte = paths.some((p) => SVELTE_MATCHER.test(p));
+	const has_json = paths.some((p) => JSON_MATCHER.test(p));
+	const has_css = paths.some((p) => CSS_MATCHER.test(p));
+
+	const exports: PackageJsonExports = {
+		'./package.json': './package.json',
+	};
+
+	if (has_index) {
+		exports['.'] = {
+			types: IMPORT_PREFIX + 'index.d.ts',
+			default: IMPORT_PREFIX + 'index.js',
+		};
+	}
+
+	if (has_js) {
+		exports['./*.js'] = {
+			types: IMPORT_PREFIX + '*.d.ts',
+			default: IMPORT_PREFIX + '*.js',
+		};
+		exports['./*.ts'] = {
+			types: IMPORT_PREFIX + '*.d.ts',
+			default: IMPORT_PREFIX + '*.js',
+		};
+	}
+
+	if (has_svelte) {
+		exports['./*.svelte'] = {
+			types: IMPORT_PREFIX + '*.svelte.d.ts',
+			svelte: IMPORT_PREFIX + '*.svelte',
+			default: IMPORT_PREFIX + '*.svelte',
+		};
+	}
+
+	if (has_json) {
+		exports['./*.json'] = {
+			types: IMPORT_PREFIX + '*.json.d.ts',
+			default: IMPORT_PREFIX + '*.json',
+		};
+	}
+
+	if (has_css) {
+		exports['./*.css'] = {
+			default: IMPORT_PREFIX + '*.css',
+		};
+	}
+
+	return parse_or_throw_formatted_error('package.json#exports', PackageJsonExports, exports);
+};
+
+const IMPORT_PREFIX = './' + SVELTEKIT_DIST_DIRNAME + '/';
+
+export const package_json_parse_repo_url = (
+	package_json: PackageJson,
+): {owner: string; repo: string} | undefined => {
+	const {repository} = package_json;
+	const repo_url = repository
+		? typeof repository === 'string'
+			? repository
+			: repository.url
+		: undefined;
+	if (!repo_url) {
+		return;
+	}
+	const parsed_repo_url = GITHUB_REPO_MATCHER.exec(strip_end(strip_end(repo_url, '/'), '.git'));
+	if (!parsed_repo_url) {
+		return;
+	}
+	const [, owner, repo] = parsed_repo_url;
+	return {owner: owner!, repo: repo!};
+};
+
+/**
+ * Parses a `PackageJson` object but preserves the order of the original keys.
+ */
+const parse_package_json = (schema: typeof PackageJson, value: any): PackageJson => {
+	const parsed = parse_or_throw_formatted_error(PACKAGE_JSON_FILENAME, schema, value);
+	const keys = Object.keys(value);
+	return Object.fromEntries(
+		Object.entries(parsed).sort(([a], [b]) => keys.indexOf(a) - keys.indexOf(b)),
+	) as any;
+};
+
+// TODO maybe extract to zod helpers? see also everything in `task_logging.ts`
+const parse_or_throw_formatted_error = <T extends z.ZodType>(
+	name: string,
+	schema: T,
+	value: any,
+): z.infer<T> => {
+	const parsed = schema.safeParse(value);
+	if (!parsed.success) {
+		let msg = st('red', `Failed to parse ${name}:\n`);
+		for (const issue of parsed.error.issues) {
+			msg += st('red', `\n\t"${issue.path}" ${issue.message}\n`);
+		}
+		throw Error(msg);
+	}
+	return parsed.data;
+};
+
+export const package_json_has_dependency = (dep_name: string, package_json: PackageJson): boolean =>
+	!!package_json.devDependencies?.[dep_name] ||
+	!!package_json.dependencies?.[dep_name] ||
+	!!package_json.peerDependencies?.[dep_name];
+
+export interface PackageJsonDep {
+	name: string;
+	version: string;
+}
+
+export const package_json_extract_dependencies = (
+	package_json: PackageJson,
+): Array<PackageJsonDep> => {
+	const deps_by_name: Map<string, PackageJsonDep> = new Map();
+	// Earlier versions override later ones, so peer deps goes last.
+	const add_deps = (deps: Record<string, string> | undefined) => {
+		if (!deps) return;
+		for (const [name, version] of Object.entries(deps)) {
+			if (!deps_by_name.has(name)) {
+				deps_by_name.set(name, {name, version});
+			}
+		}
+	};
+	add_deps(package_json.dependencies);
+	add_deps(package_json.devDependencies);
+	add_deps(package_json.peerDependencies);
+	return Array.from(deps_by_name.values());
+};

package/src/lib/parse_exports.ts

@@ -0,0 +1,100 @@
+import ts from 'typescript';
+import {extname} from 'node:path';
+import type {Flavored} from '@fuzdev/fuz_util/types.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {DeclarationKind} from '@fuzdev/fuz_util/source_json.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+
+import {TS_MATCHER} from './constants.ts';
+import {ParseExportsContext} from './parse_exports_context.ts';
+
+export interface Declaration {
+	name: string;
+	kind: DeclarationKind | null;
+}
+
+export type ExportDeclaration = Flavored<Declaration, 'ExportDeclaration'>;
+
+/**
+ * Parse exports from a file based on its file type and content.
+ */
+export const parse_exports = (
+	id: PathId,
+	program?: ts.Program,
+	declarations: Array<ExportDeclaration> = [],
+	log?: Logger,
+): Array<ExportDeclaration> => {
+	// First, infer declarations based on file extension
+	infer_declarations_from_file_type(id, declarations);
+
+	// For TypeScript files with program, perform detailed export analysis
+	if (TS_MATCHER.test(id) && program) {
+		const source_file = program.getSourceFile(id);
+		if (!source_file) return declarations;
+
+		const checker = program.getTypeChecker();
+
+		// Get the exports of the source file (module)
+		const symbol = checker.getSymbolAtLocation(source_file);
+		if (!symbol) return declarations;
+
+		// Get the module exports
+		const exports = checker.getExportsOfModule(symbol);
+
+		// Process TypeScript declarations
+		const export_context = new ParseExportsContext(program, log);
+		export_context.analyze_source_file(source_file);
+		export_context.process_exports(source_file, exports, declarations);
+	}
+
+	return declarations;
+};
+
+// TODO temporary until proper type inference
+export const infer_declarations_from_file_type = (
+	file_path: PathId,
+	declarations: Array<ExportDeclaration> = [],
+): Array<ExportDeclaration> => {
+	const extension = extname(file_path).toLowerCase();
+
+	switch (extension) {
+		case '.svelte': {
+			declarations.push({
+				name: 'default',
+				kind: 'component',
+			});
+			break;
+		}
+		case '.css': {
+			declarations.push({
+				name: 'default',
+				kind: 'css',
+			});
+			break;
+		}
+		case '.json': {
+			declarations.push({
+				name: 'default',
+				kind: 'json',
+			});
+			break;
+		}
+	}
+
+	return declarations;
+};
+
+/**
+ * Process TypeScript exports, identifying their kinds.
+ */
+export const process_ts_exports = (
+	source_file: ts.SourceFile,
+	program: ts.Program,
+	exports: Array<ts.Symbol>,
+	declarations: Array<ExportDeclaration> = [],
+	log?: Logger,
+): Array<ExportDeclaration> => {
+	const export_context = new ParseExportsContext(program, log);
+	export_context.analyze_source_file(source_file);
+	return export_context.process_exports(source_file, exports, declarations);
+};