@fuzdev/gro 0.192.0

package/src/lib/parse_exports_context.ts

@@ -0,0 +1,395 @@
+import ts from 'typescript';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {DeclarationKind} from '@fuzdev/fuz_util/source_json.js';
+
+import type {ExportDeclaration} from './parse_exports.ts';
+
+/**
+ * A class to track export context and determine export kinds.
+ */
+export class ParseExportsContext {
+	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, DeclarationKind> = 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<ExportDeclaration> = [],
+	): Array<ExportDeclaration> {
+		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): DeclarationKind {
+		// 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): DeclarationKind {
+		// 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): DeclarationKind | 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

@@ -0,0 +1,180 @@
+import {parseSync, type ImportDeclaration} from 'oxc-parser';
+import type {Flavored} from '@fuzdev/fuz_util/types.js';
+import {UnreachableError} from '@fuzdev/fuz_util/error.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+
+import {JS_MATCHER, TS_MATCHER, SVELTE_MATCHER, SVELTE_SCRIPT_MATCHER} from './constants.ts';
+
+export type ImportSpecifier = Flavored<string, 'ImportSpecifier'>;
+
+// TODO this is probably way more complicated that it should be, maybe report the issues upstream unless I made a mistake here
+
+/**
+ * Extracts the string value from a module request, handling different quote styles.
+ * Returns null if the value is not a valid string literal.
+ */
+const extract_string_literal = (content: string, start: number, end: number): string | null => {
+	const value = content.substring(start, end);
+
+	// Check if it's a string literal (starts and ends with quotes)
+	if (
+		(value.startsWith("'") && value.endsWith("'")) ||
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith('`') && value.endsWith('`'))
+	) {
+		// Remove the quotes
+		return value.slice(1, -1);
+	}
+
+	// Not a valid string literal
+	return null;
+};
+
+export const parse_imports = (
+	id: PathId,
+	contents: string,
+	ignore_types = true,
+): Array<ImportSpecifier> => {
+	const specifiers: Array<string> = [];
+	const is_svelte = SVELTE_MATCHER.test(id);
+
+	const parse_from = (s: string): void => {
+		const parsed = parseSync(is_svelte ? id + '.ts' : id, s, {});
+
+		// Process static imports
+		for (const static_import of parsed.module.staticImports) {
+			// Get the module source node
+			const import_decl = parsed.program.body.find(
+				(node) => node.type === 'ImportDeclaration' && node.start === static_import.start,
+			) as ImportDeclaration | undefined;
+
+			if (!import_decl?.source) continue;
+
+			// Extract the module request string value
+			const value = extract_string_literal(s, import_decl.source.start, import_decl.source.end);
+
+			if (!value) continue;
+
+			// Skip type-only imports if ignore_types is true
+			if (ignore_types) {
+				// Handle import type {...} (type-only imports)
+				if (import_decl.importKind === 'type') {
+					continue;
+				}
+
+				// Handle inline type imports ({type foo})
+				if (static_import.entries.length > 0) {
+					// If all imports are type imports, skip this import
+					const has_non_type_specifier = static_import.entries.some((entry) => !entry.isType);
+					if (!has_non_type_specifier) {
+						continue;
+					}
+				}
+			}
+
+			specifiers.push(value);
+		}
+
+		// Process dynamic imports
+		for (const dynamic_import of parsed.module.dynamicImports) {
+			// Find the corresponding AST node
+			let found = false;
+			for (const node of parsed.program.body) {
+				if (
+					node.type === 'ExpressionStatement' &&
+					node.expression.type === 'AwaitExpression' &&
+					node.expression.argument.type === 'ImportExpression'
+				) {
+					const import_expr = node.expression.argument;
+					if (import_expr.start === dynamic_import.start) {
+						// Only process string literals (not expressions or variables)
+						if (import_expr.source.type === 'Literal') {
+							const value = String(import_expr.source.value);
+							if (value) {
+								specifiers.push(value);
+							}
+						}
+						found = true;
+						break;
+					}
+				}
+			}
+
+			// If we didn't find a match through AST, fall back to the original approach
+			// but only for simple string literals
+			if (!found) {
+				const value = extract_string_literal(
+					s,
+					dynamic_import.moduleRequest.start,
+					dynamic_import.moduleRequest.end,
+				);
+				if (value) {
+					specifiers.push(value);
+				}
+			}
+		}
+
+		// Process re-exports
+		for (const node of parsed.program.body) {
+			if (node.type === 'ExportNamedDeclaration' && node.source) {
+				// Skip type-only exports if ignore_types is true
+				if (ignore_types && node.exportKind === 'type') {
+					continue;
+				}
+
+				// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+				if (node.source.type === 'Literal') {
+					const value = node.source.value;
+					if (value) {
+						specifiers.push(value);
+					}
+				} else {
+					throw new UnreachableError(node.source.type);
+				}
+			}
+		}
+	};
+
+	if (is_svelte) {
+		// Reset the regexp state between calls
+		SVELTE_SCRIPT_MATCHER.lastIndex = 0;
+
+		// Capture script tags at the top level (not nested in HTML)
+		let last_index = 0;
+		const script_blocks: Array<{content: string; start: number; end: number}> = [];
+
+		// First collect all script blocks
+		let match;
+		while ((match = SVELTE_SCRIPT_MATCHER.exec(contents)) !== null) {
+			// Save position of the script tag
+			const start = match.index;
+			const end = SVELTE_SCRIPT_MATCHER.lastIndex;
+
+			// Only process top-level script tags (skip nested ones)
+			// A nested script would be inside another HTML tag between lastIndex and start
+			const text_between = contents.substring(last_index, start);
+			const contains_opening_tag = /<[a-z][^>]*>/i.test(text_between);
+			const contains_closing_tag = /<\/[a-z][^>]*>/i.test(text_between);
+
+			// If we're not nested (no HTML tag nesting), process this script
+			if (!(contains_opening_tag && !contains_closing_tag)) {
+				script_blocks.push({
+					content: match[1]!,
+					start,
+					end,
+				});
+			}
+
+			last_index = end;
+		}
+
+		// Process all the collected script blocks
+		for (const script_block of script_blocks) {
+			parse_from(script_block.content);
+		}
+	} else if (TS_MATCHER.test(id) || JS_MATCHER.test(id)) {
+		parse_from(contents);
+	}
+
+	return specifiers;
+};

package/src/lib/paths.ts

@@ -0,0 +1,111 @@
+import {join, extname, relative, basename} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {ensure_end, strip_end} from '@fuzdev/fuz_util/string.js';
+import {styleText as st} from 'node:util';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+
+import {
+	GRO_CONFIG_FILENAME,
+	GRO_DEV_DIR,
+	GRO_DIR,
+	SOURCE_DIR,
+	SVELTEKIT_DIST_DIRNAME,
+} from './constants.ts';
+import {default_svelte_config} from './svelte_config.ts';
+
+/*
+
+A path `id` is an absolute path to the source/.gro/dist directory.
+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 = ensure_end(root_dir, '/');
+	return {
+		root,
+		source: root + SOURCE_DIR,
+		lib: root + LIB_DIR,
+		build: root + GRO_DIR,
+		build_dev: root + GRO_DEV_DIR,
+		config: root + GRO_CONFIG_FILENAME,
+	};
+};
+
+export const infer_paths = (id: PathId): Paths => (is_gro_id(id) ? gro_paths : paths);
+
+export const is_gro_id = (id: PathId): 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: PathId, p = infer_paths(id)): string =>
+	relative(p.root, id) || './';
+
+// '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
+export const path_id_to_base_path = (path_id: PathId, p = infer_paths(path_id)): string =>
+	relative(p.source, path_id);
+
+// TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
+// 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
+export const base_path_to_path_id = (base_path: string, p = infer_paths(base_path)): PathId =>
+	join(p.source, base_path);
+
+export const print_path = (path: string, p = infer_paths(path)): string => {
+	let final_path =
+		strip_end(path, '/') === strip_end(GRO_DIST_DIR, '/') ? 'gro' : to_root_path(path, p);
+	final_path =
+		final_path === 'gro' ? final_path : final_path[0] === '.' ? final_path : './' + final_path;
+	return st('gray', final_path);
+};
+
+export const replace_extension = (path: string, new_extension: string): string => {
+	const {length} = extname(path);
+	return (length === 0 ? path : path.substring(0, path.length - length)) + new_extension;
+};
+
+/**
+ * Paths for the user repo.
+ */
+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
+const filename = fileURLToPath(import.meta.url);
+const gro_package_dir_path = join(
+	filename,
+	filename.includes('/gro/src/lib/')
+		? '../../../'
+		: filename.includes('/gro/dist/')
+			? '../../'
+			: '../',
+);
+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 + '/';