@ryanatkn/gro 0.156.0 → 0.157.1

package/src/lib/parse_exports_context.ts

@@ -0,0 +1,394 @@
+import ts from 'typescript';
+import type {Logger} from '@ryanatkn/belt/log.js';
+
+import type {Declaration_Kind, Export_Declaration} from './parse_exports.ts';
+
+/**
+ * A class to track export context and determine export kinds.
+ */
+export class Parse_Exports_Context {
+	readonly #checker: ts.TypeChecker;
+
+	// Map of source file paths to their symbols
+	readonly #file_symbols: Map<string, ts.Symbol> = new Map();
+	// Cache for resolved symbols to avoid repeated resolution
+	readonly #symbol_kind_cache: Map<ts.Symbol, Declaration_Kind> = new Map();
+
+	readonly log: Logger | undefined;
+	debug = process.env.DEBUG_EXPORTS === 'true';
+
+	constructor(program: ts.Program, log?: Logger) {
+		this.log = log;
+		this.#checker = program.getTypeChecker();
+	}
+
+	/**
+	 * Log a debug message if debug mode is enabled.
+	 */
+	#log(...args: Array<unknown>): void {
+		if (this.debug && this.log) {
+			this.log.info(...args);
+		}
+	}
+
+	/**
+	 * Analyze a source file to prepare for export processing.
+	 */
+	analyze_source_file(source_file: ts.SourceFile): void {
+		const file_path = source_file.fileName;
+
+		// Skip if we've already analyzed this file
+		if (this.#file_symbols.has(file_path)) {
+			return;
+		}
+
+		// Get the source file symbol and cache it
+		const symbol = this.#checker.getSymbolAtLocation(source_file);
+		if (symbol) {
+			this.#file_symbols.set(file_path, symbol);
+		}
+	}
+
+	/**
+	 * Process a list of exported symbols and identify their kinds.
+	 */
+	process_exports(
+		source_file: ts.SourceFile,
+		exports: Array<ts.Symbol>,
+		declarations: Array<Export_Declaration> = [],
+	): Array<Export_Declaration> {
+		for (const export_symbol of exports) {
+			const name = export_symbol.name;
+			this.#log(`Determining kind for export: ${name}`);
+
+			const kind = this.#determine_export_kind(source_file, export_symbol);
+			declarations.push({
+				name,
+				kind,
+			});
+		}
+
+		return declarations;
+	}
+
+	/**
+	 * Determine the kind of an export based on its symbol.
+	 */
+	#determine_export_kind(source_file: ts.SourceFile, symbol: ts.Symbol): Declaration_Kind {
+		// Check if this is a type-only export (no value export)
+		if (this.#is_type_only_export(source_file, symbol)) {
+			return 'type';
+		}
+
+		// Get the true symbol by resolving aliases
+		const resolved_symbol = this.#resolve_symbol(symbol);
+
+		// Check if we've already determined this symbol's kind
+		if (this.#symbol_kind_cache.has(resolved_symbol)) {
+			return this.#symbol_kind_cache.get(resolved_symbol)!;
+		}
+
+		// Determine the kind based on declaration and type information
+		const kind = this.#infer_declaration_kind(resolved_symbol);
+
+		// Cache the result for future lookups
+		this.#symbol_kind_cache.set(resolved_symbol, kind);
+
+		return kind;
+	}
+
+	/**
+	 * Resolve a symbol through aliases to its original declaration.
+	 */
+	#resolve_symbol(symbol: ts.Symbol): ts.Symbol {
+		try {
+			if (symbol.flags & ts.SymbolFlags.Alias) {
+				return this.#checker.getAliasedSymbol(symbol);
+			}
+		} catch {
+			// If resolution fails, return the original symbol
+		}
+		return symbol;
+	}
+
+	/**
+	 * Infer the declaration kind from a symbol's declaration and type information.
+	 */
+	#infer_declaration_kind(symbol: ts.Symbol): Declaration_Kind {
+		// Check symbol flags first for direct type matching
+		if (this.#is_class_symbol(symbol)) {
+			return 'class';
+		}
+
+		if (this.#is_function_symbol(symbol)) {
+			return 'function';
+		}
+
+		// If no direct match from flags, look at declarations
+		if (symbol.declarations && symbol.declarations.length > 0) {
+			const decl = symbol.declarations[0];
+			const kind_from_decl = this.#infer_kind_from_declaration(decl);
+			if (kind_from_decl) {
+				return kind_from_decl;
+			}
+		}
+
+		// Check for callable type as a fallback for functions
+		if (this.#is_callable(symbol)) {
+			return 'function';
+		}
+
+		// Default to variable if no other type can be determined
+		return 'variable';
+	}
+
+	/**
+	 * Check if a symbol represents a callable type (function-like).
+	 */
+	#is_callable(symbol: ts.Symbol): boolean {
+		try {
+			// Try to get valid declaration node
+			const declaration = this.#get_valid_declaration(symbol);
+			if (!declaration) {
+				return false;
+			}
+
+			// Get the type at the declaration location
+			const type = this.#checker.getTypeOfSymbolAtLocation(symbol, declaration);
+
+			// Check if the type has call signatures (making it function-like)
+			return type.getCallSignatures().length > 0;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Get a valid declaration for a symbol, preferring valueDeclaration.
+	 */
+	#get_valid_declaration(symbol: ts.Symbol): ts.Node | undefined {
+		if (symbol.valueDeclaration) {
+			return symbol.valueDeclaration;
+		}
+
+		if (symbol.declarations && symbol.declarations.length > 0) {
+			return symbol.declarations[0];
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Infer the declaration kind from a specific declaration node.
+	 */
+	#infer_kind_from_declaration(decl: ts.Declaration): Declaration_Kind | null {
+		if (ts.isFunctionDeclaration(decl)) {
+			return 'function';
+		}
+
+		if (ts.isClassDeclaration(decl)) {
+			return 'class';
+		}
+
+		if (ts.isInterfaceDeclaration(decl) || ts.isTypeAliasDeclaration(decl)) {
+			return 'type';
+		}
+
+		if (ts.isVariableDeclaration(decl)) {
+			// Handle initializers for variable declarations
+			if (decl.initializer) {
+				if (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer)) {
+					return 'function';
+				}
+
+				if (ts.isClassExpression(decl.initializer)) {
+					return 'class';
+				}
+
+				// Handle identifiers pointing to other declarations
+				if (ts.isIdentifier(decl.initializer)) {
+					try {
+						const referred_symbol = this.#checker.getSymbolAtLocation(decl.initializer);
+						if (referred_symbol) {
+							// Avoid infinite recursion by not resolving symbols here
+							if (this.#is_function_symbol(referred_symbol)) {
+								return 'function';
+							}
+							if (this.#is_class_symbol(referred_symbol)) {
+								return 'class';
+							}
+						}
+					} catch {
+						// Ignore failures to resolve identifiers
+					}
+				}
+			}
+
+			// As a fallback, check if the variable's type is callable
+			try {
+				const symbol = this.#checker.getSymbolAtLocation(decl.name);
+				if (symbol && this.#is_callable(symbol)) {
+					return 'function';
+				}
+			} catch {
+				// Ignore errors in type checking
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Check if a symbol is exported as a type-only export.
+	 * A type-only export means it's ONLY exported as a type with no value export.
+	 */
+	#is_type_only_export(source_file: ts.SourceFile, symbol: ts.Symbol): boolean {
+		// First, check if the symbol has an explicit type-only export
+		let has_type_only_export = false;
+
+		// Check if it has a corresponding value export
+		const has_value_export = this.#has_value_export(source_file, symbol);
+
+		// If it has both type and value exports (dual purpose), it's not type-only
+		if (has_value_export) {
+			return false;
+		}
+
+		// Check export declarations for explicit type-only exports
+		ts.forEachChild(source_file, (node) => {
+			if (
+				ts.isExportDeclaration(node) &&
+				node.exportClause &&
+				ts.isNamedExports(node.exportClause)
+			) {
+				// Check if it's a type-only export declaration (export type {...})
+				if (node.isTypeOnly) {
+					for (const specifier of node.exportClause.elements) {
+						if (specifier.name.text === symbol.name) {
+							has_type_only_export = true;
+						}
+					}
+				} else {
+					// Check if it's a specific type export (export {type X})
+					for (const specifier of node.exportClause.elements) {
+						if (specifier.name.text === symbol.name && specifier.isTypeOnly) {
+							has_type_only_export = true;
+						}
+					}
+				}
+			}
+		});
+
+		// If explicitly marked as a type-only export, use that
+		// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+		if (has_type_only_export) {
+			return true;
+		}
+
+		// If not explicitly marked as type-only, check if the symbol itself is a type
+		// AND there's no value export for it
+		const resolved_symbol = this.#resolve_symbol(symbol);
+		return this.#is_type_symbol(resolved_symbol) && !has_value_export;
+	}
+
+	/**
+	 * Check if a symbol has a value export in the source file.
+	 */
+	#has_value_export(source_file: ts.SourceFile, symbol: ts.Symbol): boolean {
+		let has_value_export = false;
+
+		// Check export declarations
+		ts.forEachChild(source_file, (node) => {
+			if (
+				ts.isExportDeclaration(node) &&
+				node.exportClause &&
+				ts.isNamedExports(node.exportClause)
+			) {
+				// Skip type-only exports
+				if (node.isTypeOnly) return;
+
+				// Check if it's a regular export (not type-only)
+				for (const specifier of node.exportClause.elements) {
+					if (specifier.name.text === symbol.name && !specifier.isTypeOnly) {
+						has_value_export = true;
+					}
+				}
+			}
+			// Check for default export
+			else if (ts.isExportAssignment(node) && symbol.name === 'default') {
+				has_value_export = true;
+			}
+			// Check for direct exports (export const x = ...)
+			else if (this.#is_direct_export(node) && this.#get_export_name(node) === symbol.name) {
+				has_value_export = true;
+			}
+		});
+
+		return has_value_export;
+	}
+
+	/**
+	 * Check if a node is a direct export (export const/function/class).
+	 */
+	#is_direct_export(node: ts.Node): boolean {
+		return (
+			(ts.isVariableStatement(node) ||
+				ts.isFunctionDeclaration(node) ||
+				ts.isClassDeclaration(node)) &&
+			this.#has_export_modifier(node)
+		);
+	}
+
+	/**
+	 * Get the export name from a direct export node.
+	 */
+	#get_export_name(node: ts.Node): string | undefined {
+		if (ts.isVariableStatement(node) && node.declarationList.declarations.length > 0) {
+			const decl = node.declarationList.declarations[0];
+			if (ts.isIdentifier(decl.name)) {
+				return decl.name.text;
+			}
+		} else if (ts.isFunctionDeclaration(node) && node.name) {
+			return node.name.text;
+		} else if (ts.isClassDeclaration(node) && node.name) {
+			return node.name.text;
+		}
+		return undefined;
+	}
+
+	/**
+	 * Check if a node has an export modifier.
+	 */
+	#has_export_modifier(node: ts.Node): boolean {
+		return (
+			(ts.canHaveModifiers(node) &&
+				ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) ||
+			false
+		);
+	}
+
+	/**
+	 * Check if a symbol is a function symbol.
+	 */
+	#is_function_symbol(symbol: ts.Symbol): boolean {
+		return !!(symbol.flags & ts.SymbolFlags.Function || symbol.flags & ts.SymbolFlags.Method);
+	}
+
+	/**
+	 * Check if a symbol is a class symbol.
+	 */
+	#is_class_symbol(symbol: ts.Symbol): boolean {
+		return !!(symbol.flags & ts.SymbolFlags.Class);
+	}
+
+	/**
+	 * Check if a symbol is a type-only symbol (interface, type alias, etc.).
+	 */
+	#is_type_symbol(symbol: ts.Symbol): boolean {
+		return !!(
+			symbol.flags & ts.SymbolFlags.Interface ||
+			symbol.flags & ts.SymbolFlags.TypeAlias ||
+			symbol.flags & ts.SymbolFlags.TypeParameter
+		);
+	}
+}

package/src/lib/parse_imports.ts

@@ -3,8 +3,7 @@ import type {Flavored} from '@ryanatkn/belt/types.js';
 import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 
 import type {Path_Id} from './path.ts';
-import {SVELTE_MATCHER} from './svelte_helpers.ts';
-import {JS_MATCHER, TS_MATCHER, SVELTE_SCRIPT_MATCHER} from './constants.ts';
+import {JS_MATCHER, TS_MATCHER, SVELTE_MATCHER, SVELTE_SCRIPT_MATCHER} from './constants.ts';
 
 export type Import_Specifier = Flavored<string, 'Import_Specifier'>;
 

package/src/lib/paths.ts

@@ -1,6 +1,6 @@
 import {join, extname, relative, basename} from 'node:path';
 import {fileURLToPath} from 'node:url';
-import {strip_end} from '@ryanatkn/belt/string.js';
+import {ensure_end, strip_end} from '@ryanatkn/belt/string.js';
 import {styleText as st} from 'node:util';
 
 import {
@@ -22,21 +22,27 @@ It's the same name that Rollup uses.
 
 export const LIB_DIRNAME = basename(default_svelte_config.lib_path);
 export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
+/** @trailing_slash */
 export const LIB_DIR = LIB_PATH + '/';
 export const ROUTES_DIRNAME = basename(default_svelte_config.routes_path);
 
 export interface Paths {
+	/** @trailing_slash */
 	root: string;
+	/** @trailing_slash */
 	source: string;
+	/** @trailing_slash */
 	lib: string;
+	/** @trailing_slash */
 	build: string;
+	/** @trailing_slash */
 	build_dev: string;
 	config: string;
 }
 
 export const create_paths = (root_dir: string): Paths => {
 	// TODO remove reliance on trailing slash towards windows support
-	const root = strip_end(root_dir, '/') + '/';
+	const root = ensure_end(root_dir, '/');
 	return {
 		root,
 		source: root + SOURCE_DIR,
@@ -48,7 +54,9 @@ export const create_paths = (root_dir: string): Paths => {
 };
 
 export const infer_paths = (id: Path_Id): Paths => (is_gro_id(id) ? gro_paths : paths);
-export const is_gro_id = (id: Path_Id): boolean => id.startsWith(strip_end(gro_paths.root, '/')); // strip `/` in case we're looking at the Gro root without a trailing slash
+
+export const is_gro_id = (id: Path_Id): boolean =>
+	id.startsWith(gro_paths.root) || gro_paths.root === ensure_end(id, '/');
 
 // '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
 export const to_root_path = (id: Path_Id, p = infer_paths(id)): string =>
@@ -81,6 +89,7 @@ export const replace_extension = (path: string, new_extension: string): string =
  */
 export const paths = create_paths(process.cwd());
 
+/** @trailing_slash */
 export const GRO_PACKAGE_DIR = 'gro/';
 // TODO document these conditions with comments
 // TODO there's probably a more robust way to do this
@@ -98,4 +107,5 @@ export const IS_THIS_GRO = gro_package_dir_path === paths.root;
  * Paths for the Gro package being used by the user repo.
  */
 export const gro_paths = IS_THIS_GRO ? paths : create_paths(gro_package_dir_path);
+/** @trailing_slash */
 export const GRO_DIST_DIR = gro_paths.root + SVELTEKIT_DIST_DIRNAME + '/';

package/src/lib/src_json.ts

@@ -1,8 +1,8 @@
 import {z} from 'zod';
-import {join} from 'node:path';
-import {strip_start} from '@ryanatkn/belt/string.js';
-import {Project} from 'ts-morph';
+import {join, extname} from 'node:path';
+import {ensure_end, strip_start} from '@ryanatkn/belt/string.js';
 import {existsSync} from 'node:fs';
+import ts from 'typescript';
 
 import {paths, replace_extension} from './paths.ts';
 import {
@@ -10,6 +10,18 @@ import {
 	type Package_Json,
 	type Package_Json_Exports,
 } from './package_json.ts';
+import {parse_exports} from './parse_exports.ts';
+
+export const Src_Module_Declaration_Kind = z.enum([
+	'type',
+	'function',
+	'variable',
+	'class',
+	'component',
+	'json',
+	'css',
+]);
+export type Src_Module_Declaration_Kind = z.infer<typeof Src_Module_Declaration_Kind>;
 
 // TODO @many rename to prefix with `Src_Json_`?
 export const Src_Module_Declaration = z
@@ -17,7 +29,7 @@ export const Src_Module_Declaration = z
 		name: z.string(), // the export identifier
 		// TODO these are poorly named, and they're somewhat redundant with `kind`,
 		// they were added to distinguish `VariableDeclaration` functions and non-functions
-		kind: z.enum(['type', 'function', 'variable', 'class']).nullable(),
+		kind: Src_Module_Declaration_Kind.nullable(),
 		// code: z.string(), // TODO experiment with `getType().getText()`, some of them return the same as `name`
 	})
 	.passthrough();
@@ -68,71 +80,71 @@ export const to_src_modules = (
 ): Src_Modules | undefined => {
 	if (!exports) return;
 
-	const project = new Project();
-	project.addSourceFilesAtPaths(join(lib_path, '**/*.ts'));
-
-	return Object.fromEntries(
-		Object.entries(exports).map(([k, _v]) => {
-			// TODO hacky - doesn't handle any but the typical mappings, also add a helper?
-			const source_file_path =
-				k === '.' || k === './'
-					? 'index.ts'
-					: strip_start(k.endsWith('.js') ? replace_extension(k, '.ts') : k, './');
-			if (!source_file_path.endsWith('.ts')) {
-				// TODO support more than just TypeScript - maybe use @sveltejs/language-tools,
-				// see how @sveltejs/package generates types, or maybe use its generated declaration files with ts-morph
-				const src_module: Src_Module = {path: source_file_path, declarations: []};
-				return [k, src_module];
-			}
-			const source_file_id = join(lib_path, source_file_path);
-			if (!existsSync(source_file_id)) {
-				throw Error(
-					`Failed to infer source file from package.json export path ${k} - the inferred file ${source_file_id} does not exist`,
-				);
-			}
+	// Prepare a list of files to analyze
+	const file_paths: Array<{export_key: string; file_path: string}> = [];
+	for (const [k, _v] of Object.entries(exports)) {
+		// Handle different file types
+		const source_file_path =
+			k === '.' || k === './'
+				? 'index.ts'
+				: strip_start(k.endsWith('.js') ? replace_extension(k, '.ts') : k, './');
 
-			const declarations: Array<Src_Module_Declaration> = [];
-
-			const source_file = project.getSourceFile(source_file_id);
-			if (source_file) {
-				for (const [name, decls] of source_file.getExportedDeclarations()) {
-					// TODO how to correctly handle multiples?
-					for (const decl of decls) {
-						// TODO helper
-						const decl_type = decl.getType();
-						const k = decl.getKindName();
-						const kind =
-							k === 'InterfaceDeclaration' || k === 'TypeAliasDeclaration'
-								? 'type'
-								: k === 'ClassDeclaration'
-									? 'class'
-									: k === 'VariableDeclaration'
-										? decl_type.getCallSignatures().length
-											? 'function'
-											: 'variable' // TODO name?
-										: null;
-						// TODO
-						// const code =
-						// 	k === 'InterfaceDeclaration' || k === 'TypeAliasDeclaration'
-						// 		? decl_type.getText(source_file) // TODO
-						// 		: decl_type.getText(source_file);
-						const found = declarations.find((d) => d.name === name);
-						if (found) {
-							// TODO hacky, this only was added to prevent `TypeAliasDeclaration` from overriding `VariableDeclaration`
-							if (found.kind === 'type') {
-								found.kind = kind;
-								// found.code = code;
-							}
-						} else {
-							// TODO more
-							declarations.push({name, kind}); // code
-						}
-					}
-				}
+		const source_file_id = join(lib_path, source_file_path);
+
+		// Check if file exists
+		if (!existsSync(source_file_id)) {
+			// Handle non-TypeScript files (Svelte, CSS, JSON)
+			const extension = extname(source_file_id);
+			if (extension === '.svelte' || extension === '.css' || extension === '.json') {
+				file_paths.push({export_key: k, file_path: source_file_id});
+				continue;
 			}
 
-			const src_module: Src_Module = {path: source_file_path, declarations};
-			return [k, src_module];
-		}),
-	);
+			throw Error(
+				`Failed to infer source file from package.json export path ${k} - the inferred file ${source_file_id} does not exist`,
+			);
+		}
+
+		file_paths.push({export_key: k, file_path: source_file_id});
+	}
+
+	// Create a TypeScript program for all TypeScript files
+	const ts_files = file_paths
+		.filter(({file_path}) => file_path.endsWith('.ts') || file_path.endsWith('.tsx'))
+		.map(({file_path}) => file_path);
+
+	let program: ts.Program | undefined;
+	if (ts_files.length > 0) {
+		program = ts.createProgram(
+			ts_files,
+			// TODO get from tsconfig?
+			{
+				target: ts.ScriptTarget.ESNext,
+				module: ts.ModuleKind.ESNext,
+				moduleResolution: ts.ModuleResolutionKind.NodeNext,
+				verbatimModuleSyntax: true,
+				isolatedModules: true,
+			},
+		);
+	}
+
+	const result: Src_Modules = {};
+
+	// Process each file
+	for (const {export_key, file_path} of file_paths) {
+		const relative_path = file_path.replace(ensure_end(lib_path, '/'), '');
+
+		// Use parse_exports for all file types
+		const declarations = parse_exports(file_path, program).map(({name, kind}) => ({
+			name,
+			kind: kind as Src_Module_Declaration_Kind | null,
+		}));
+
+		result[export_key] = {
+			path: relative_path,
+			declarations,
+		};
+	}
+
+	return result;
 };