foresthouse 1.0.0-dev.1 → 1.0.0-dev.3

package/dist/tree-DbnWcUnV.mjs

@@ -0,0 +1,851 @@
+import { builtinModules } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { parseSync, visitorKeys } from "oxc-parser";
+//#region src/config.ts
+function loadCompilerOptions(searchFrom, explicitConfigPath) {
+	const configPath = explicitConfigPath === void 0 ? findNearestConfig(searchFrom) : path.resolve(searchFrom, explicitConfigPath);
+	if (configPath === void 0) return { compilerOptions: defaultCompilerOptions() };
+	const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+	if (readResult.error !== void 0) throw new Error(`Failed to read TypeScript config at ${configPath}: ${formatDiagnostic(readResult.error)}`);
+	const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, path.dirname(configPath), defaultCompilerOptions(), configPath);
+	if (parsed.errors.length > 0) {
+		const [firstError] = parsed.errors;
+		if (firstError === void 0) throw new Error(`Failed to parse TypeScript config at ${configPath}.`);
+		throw new Error(`Failed to parse TypeScript config at ${configPath}: ${formatDiagnostic(firstError)}`);
+	}
+	return {
+		path: configPath,
+		compilerOptions: parsed.options
+	};
+}
+function findNearestConfig(searchFrom) {
+	let currentDirectory = path.resolve(searchFrom);
+	while (true) {
+		const tsconfigPath = path.join(currentDirectory, "tsconfig.json");
+		if (ts.sys.fileExists(tsconfigPath)) return tsconfigPath;
+		const jsconfigPath = path.join(currentDirectory, "jsconfig.json");
+		if (ts.sys.fileExists(jsconfigPath)) return jsconfigPath;
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return;
+		currentDirectory = parentDirectory;
+	}
+}
+function defaultCompilerOptions() {
+	return {
+		allowJs: true,
+		jsx: ts.JsxEmit.ReactJSX,
+		module: ts.ModuleKind.NodeNext,
+		moduleResolution: ts.ModuleResolutionKind.NodeNext,
+		target: ts.ScriptTarget.ESNext,
+		resolveJsonModule: true,
+		esModuleInterop: true
+	};
+}
+function formatDiagnostic(diagnostic) {
+	return ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+}
+//#endregion
+//#region src/path-utils.ts
+const SOURCE_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+]);
+function normalizeFilePath(filePath) {
+	return path.normalize(filePath);
+}
+function toDisplayPath(filePath, cwd) {
+	const relativePath = path.relative(cwd, filePath);
+	if (relativePath === "") return ".";
+	const normalizedPath = relativePath.split(path.sep).join("/");
+	return normalizedPath.startsWith("..") ? filePath : normalizedPath;
+}
+function isSourceCodeFile(filePath) {
+	return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+//#endregion
+//#region src/analyzer.ts
+const BUILTIN_MODULES = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
+function analyzeDependencies(entryFile, options = {}) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const resolvedEntryPath = resolveExistingPath(cwd, entryFile);
+	const { compilerOptions, path: configPath } = loadCompilerOptions(path.dirname(resolvedEntryPath), options.configPath);
+	const host = {
+		fileExists: ts.sys.fileExists,
+		readFile: ts.sys.readFile,
+		directoryExists: ts.sys.directoryExists,
+		getCurrentDirectory: () => cwd,
+		getDirectories: ts.sys.getDirectories,
+		...ts.sys.realpath === void 0 ? {} : { realpath: ts.sys.realpath }
+	};
+	const nodes = /* @__PURE__ */ new Map();
+	const program = createProgram(resolvedEntryPath, compilerOptions, cwd);
+	visitFile(resolvedEntryPath, compilerOptions, host, program.getTypeChecker(), program, nodes);
+	return {
+		cwd,
+		entryId: resolvedEntryPath,
+		nodes,
+		...configPath === void 0 ? {} : { configPath }
+	};
+}
+function graphToSerializableTree(graph, options = {}) {
+	const visited = /* @__PURE__ */ new Set();
+	return serializeNode(graph.entryId, graph, visited, options.omitUnused ?? false);
+}
+function serializeNode(filePath, graph, visited, omitUnused) {
+	const node = graph.nodes.get(filePath);
+	const displayPath = toDisplayPath(filePath, graph.cwd);
+	if (node === void 0) return {
+		path: displayPath,
+		kind: "missing",
+		dependencies: []
+	};
+	if (visited.has(filePath)) return {
+		path: displayPath,
+		kind: "circular",
+		dependencies: []
+	};
+	visited.add(filePath);
+	const dependencies = node.dependencies.filter((dependency) => !omitUnused || !dependency.unused).map((dependency) => {
+		if (dependency.kind !== "source") return {
+			specifier: dependency.specifier,
+			referenceKind: dependency.referenceKind,
+			isTypeOnly: dependency.isTypeOnly,
+			unused: dependency.unused,
+			kind: dependency.kind,
+			target: dependency.kind === "missing" ? dependency.target : toDisplayPath(dependency.target, graph.cwd)
+		};
+		return {
+			specifier: dependency.specifier,
+			referenceKind: dependency.referenceKind,
+			isTypeOnly: dependency.isTypeOnly,
+			unused: dependency.unused,
+			kind: dependency.kind,
+			target: toDisplayPath(dependency.target, graph.cwd),
+			node: serializeNode(dependency.target, graph, new Set(visited), omitUnused)
+		};
+	});
+	return {
+		path: displayPath,
+		kind: filePath === graph.entryId ? "entry" : "source",
+		dependencies
+	};
+}
+function visitFile(filePath, compilerOptions, host, checker, program, nodes) {
+	const normalizedPath = normalizeFilePath(filePath);
+	if (nodes.has(normalizedPath)) return;
+	const dependencies = collectModuleReferences(program.getSourceFile(normalizedPath) ?? createSourceFile(normalizedPath), checker).map((reference) => resolveDependency(reference, normalizedPath, compilerOptions, host));
+	nodes.set(normalizedPath, {
+		id: normalizedPath,
+		dependencies
+	});
+	for (const dependency of dependencies) if (dependency.kind === "source") visitFile(dependency.target, compilerOptions, host, checker, program, nodes);
+}
+function collectModuleReferences(sourceFile, checker) {
+	const references = /* @__PURE__ */ new Map();
+	const unusedImports = collectUnusedImports(sourceFile, checker);
+	function addReference(specifier, referenceKind, isTypeOnly, unused) {
+		const key = `${referenceKind}:${isTypeOnly ? "type" : "value"}:${specifier}`;
+		const existing = references.get(key);
+		if (existing !== void 0) {
+			if (existing.unused && !unused) references.set(key, {
+				...existing,
+				unused: false
+			});
+			return;
+		}
+		references.set(key, {
+			specifier,
+			referenceKind,
+			isTypeOnly,
+			unused
+		});
+	}
+	function visit(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) addReference(node.moduleSpecifier.text, "import", node.importClause?.isTypeOnly ?? false, unusedImports.get(node) ?? false);
+		else if (ts.isExportDeclaration(node) && node.moduleSpecifier !== void 0 && ts.isStringLiteralLike(node.moduleSpecifier)) addReference(node.moduleSpecifier.text, "export", node.isTypeOnly ?? false, false);
+		else if (ts.isImportEqualsDeclaration(node)) {
+			const moduleReference = node.moduleReference;
+			if (ts.isExternalModuleReference(moduleReference) && moduleReference.expression !== void 0 && ts.isStringLiteralLike(moduleReference.expression)) addReference(moduleReference.expression.text, "import-equals", false, false);
+		} else if (ts.isCallExpression(node)) {
+			if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length === 1) {
+				const [argument] = node.arguments;
+				if (argument !== void 0 && ts.isStringLiteralLike(argument)) addReference(argument.text, "dynamic-import", false, false);
+			}
+			if (ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1) {
+				const [argument] = node.arguments;
+				if (argument !== void 0 && ts.isStringLiteralLike(argument)) addReference(argument.text, "require", false, false);
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return [...references.values()];
+}
+function resolveDependency(reference, containingFile, compilerOptions, host) {
+	const specifier = reference.specifier;
+	if (BUILTIN_MODULES.has(specifier)) return createEdge(reference, "builtin", specifier);
+	const resolution = ts.resolveModuleName(specifier, containingFile, compilerOptions, host).resolvedModule;
+	if (resolution !== void 0) {
+		const resolvedPath = normalizeFilePath(resolution.resolvedFileName);
+		if (resolution.isExternalLibraryImport || resolvedPath.includes(`${path.sep}node_modules${path.sep}`)) return createEdge(reference, "external", specifier);
+		if (isSourceCodeFile(resolvedPath) && !resolvedPath.endsWith(".d.ts")) return createEdge(reference, "source", resolvedPath);
+	}
+	if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return createEdge(reference, "external", specifier);
+	return createEdge(reference, "missing", specifier);
+}
+function createEdge(reference, kind, target) {
+	return {
+		specifier: reference.specifier,
+		referenceKind: reference.referenceKind,
+		isTypeOnly: reference.isTypeOnly,
+		unused: reference.unused,
+		kind,
+		target
+	};
+}
+function createProgram(entryFile, compilerOptions, cwd) {
+	const host = ts.createCompilerHost(compilerOptions, true);
+	host.getCurrentDirectory = () => cwd;
+	if (ts.sys.realpath !== void 0) host.realpath = ts.sys.realpath;
+	return ts.createProgram({
+		rootNames: [entryFile],
+		options: compilerOptions,
+		host
+	});
+}
+function createSourceFile(filePath) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	return ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(filePath));
+}
+function collectUnusedImports(sourceFile, checker) {
+	const importUsage = /* @__PURE__ */ new Map();
+	const symbolToImportDeclaration = /* @__PURE__ */ new Map();
+	const importedLocalNames = /* @__PURE__ */ new Set();
+	sourceFile.statements.forEach((statement) => {
+		if (!ts.isImportDeclaration(statement) || statement.importClause === void 0) return;
+		const identifiers = getImportBindingIdentifiers(statement.importClause);
+		if (identifiers.length === 0) return;
+		importUsage.set(statement, {
+			canTrack: false,
+			used: false
+		});
+		identifiers.forEach((identifier) => {
+			importedLocalNames.add(identifier.text);
+			const symbol = tryGetSymbolAtLocation(checker, identifier);
+			if (symbol === void 0) return;
+			symbolToImportDeclaration.set(symbol, statement);
+			const state = importUsage.get(statement);
+			if (state !== void 0) state.canTrack = true;
+		});
+	});
+	function visit(node) {
+		if (ts.isImportDeclaration(node)) return;
+		if (ts.isIdentifier(node) && importedLocalNames.has(node.text) && isReferenceIdentifier(node)) {
+			const symbol = tryGetSymbolAtLocation(checker, node);
+			const declaration = symbol === void 0 ? void 0 : symbolToImportDeclaration.get(symbol);
+			if (declaration !== void 0) {
+				const state = importUsage.get(declaration);
+				if (state !== void 0) state.used = true;
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return new Map([...importUsage.entries()].map(([declaration, state]) => [declaration, state.canTrack && !state.used]));
+}
+function getImportBindingIdentifiers(importClause) {
+	const identifiers = [];
+	if (importClause.name !== void 0) identifiers.push(importClause.name);
+	const namedBindings = importClause.namedBindings;
+	if (namedBindings === void 0) return identifiers;
+	if (ts.isNamespaceImport(namedBindings)) {
+		identifiers.push(namedBindings.name);
+		return identifiers;
+	}
+	namedBindings.elements.forEach((element) => {
+		identifiers.push(element.name);
+	});
+	return identifiers;
+}
+function isReferenceIdentifier(node) {
+	const parent = node.parent;
+	if (ts.isPropertyAccessExpression(parent) && parent.name === node) return false;
+	if (ts.isQualifiedName(parent) && parent.right === node) return false;
+	if (ts.isPropertyAssignment(parent) && parent.name === node) return false;
+	if (ts.isBindingElement(parent) && parent.propertyName === node) return false;
+	if (ts.isJsxAttribute(parent) && parent.name === node) return false;
+	if (ts.isExportSpecifier(parent)) return parent.propertyName === node || parent.propertyName === void 0;
+	return true;
+}
+function tryGetSymbolAtLocation(checker, node) {
+	try {
+		return checker.getSymbolAtLocation(node);
+	} catch {
+		return;
+	}
+}
+function getScriptKind(filePath) {
+	switch (path.extname(filePath).toLowerCase()) {
+		case ".js":
+		case ".mjs":
+		case ".cjs": return ts.ScriptKind.JS;
+		case ".jsx": return ts.ScriptKind.JSX;
+		case ".tsx": return ts.ScriptKind.TSX;
+		case ".json": return ts.ScriptKind.JSON;
+		default: return ts.ScriptKind.TS;
+	}
+}
+function resolveExistingPath(cwd, entryFile) {
+	const normalizedPath = normalizeFilePath(path.resolve(cwd, entryFile));
+	if (!fs.existsSync(normalizedPath)) throw new Error(`Entry file not found: ${entryFile}`);
+	if (!isSourceCodeFile(normalizedPath)) throw new Error(`Entry file must be a JS/TS source file: ${entryFile}`);
+	return normalizedPath;
+}
+//#endregion
+//#region src/react-analyzer.ts
+const FUNCTION_NODE_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression"
+]);
+function analyzeReactUsage(entryFile, options = {}) {
+	const dependencyGraph = analyzeDependencies(entryFile, options);
+	const reachableFiles = new Set([dependencyGraph.entryId, ...dependencyGraph.nodes.keys()]);
+	const fileAnalyses = /* @__PURE__ */ new Map();
+	for (const filePath of [...reachableFiles].sort()) {
+		if (!isSourceCodeFile(filePath) || filePath.endsWith(".d.ts")) continue;
+		const parseResult = parseSync(filePath, fs.readFileSync(filePath, "utf8"), {
+			astType: "ts",
+			sourceType: "unambiguous"
+		});
+		const dependencyNode = dependencyGraph.nodes.get(filePath);
+		const sourceDependencies = /* @__PURE__ */ new Map();
+		dependencyNode?.dependencies.forEach((dependency) => {
+			if (dependency.kind === "source") sourceDependencies.set(dependency.specifier, dependency.target);
+		});
+		fileAnalyses.set(filePath, analyzeReactFile(parseResult.program, filePath, sourceDependencies));
+	}
+	const nodes = /* @__PURE__ */ new Map();
+	for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) nodes.set(symbol.id, {
+		id: symbol.id,
+		name: symbol.name,
+		kind: symbol.kind,
+		filePath: symbol.filePath,
+		exportNames: [...symbol.exportNames].sort(),
+		usages: []
+	});
+	for (const fileAnalysis of fileAnalyses.values()) fileAnalysis.importsByLocalName.forEach((binding, localName) => {
+		if (binding.sourcePath !== void 0) return;
+		if (!isHookName(localName) && !isHookName(binding.importedName)) return;
+		const externalNode = createExternalHookNode(binding, localName);
+		if (!nodes.has(externalNode.id)) nodes.set(externalNode.id, externalNode);
+	});
+	for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) {
+		const usages = /* @__PURE__ */ new Map();
+		symbol.componentReferences.forEach((referenceName) => {
+			const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "component");
+			if (targetId !== void 0 && targetId !== symbol.id) usages.set(`render:${targetId}`, {
+				kind: "render",
+				target: targetId
+			});
+		});
+		symbol.hookReferences.forEach((referenceName) => {
+			const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "hook");
+			if (targetId !== void 0 && targetId !== symbol.id) usages.set(`hook:${targetId}`, {
+				kind: "hook-call",
+				target: targetId
+			});
+		});
+		const node = nodes.get(symbol.id);
+		if (node === void 0) continue;
+		const sortedUsages = [...usages.values()].sort((left, right) => compareReactNodeIds(left.target, right.target, nodes));
+		nodes.set(symbol.id, {
+			...node,
+			usages: sortedUsages
+		});
+	}
+	return {
+		cwd: dependencyGraph.cwd,
+		entryId: dependencyGraph.entryId,
+		nodes
+	};
+}
+function graphToSerializableReactTree(graph, options = {}) {
+	return {
+		kind: "react-usage",
+		roots: getReactUsageRoots(graph, options.filter).map((rootId) => serializeReactUsageNode(rootId, graph, options.filter ?? "all", /* @__PURE__ */ new Set()))
+	};
+}
+function getReactUsageRoots(graph, filter = "all") {
+	const filteredNodes = getFilteredReactUsageNodes(graph, filter);
+	const inboundCounts = /* @__PURE__ */ new Map();
+	filteredNodes.forEach((node) => {
+		inboundCounts.set(node.id, 0);
+	});
+	filteredNodes.forEach((node) => {
+		getFilteredUsages(node, graph, filter).forEach((usage) => {
+			inboundCounts.set(usage.target, (inboundCounts.get(usage.target) ?? 0) + 1);
+		});
+	});
+	const roots = filteredNodes.filter((node) => (inboundCounts.get(node.id) ?? 0) === 0).map((node) => node.id);
+	if (roots.length > 0) return roots.sort((left, right) => compareReactNodeIds(left, right, graph.nodes));
+	return filteredNodes.map((node) => node.id).sort((left, right) => compareReactNodeIds(left, right, graph.nodes));
+}
+function getFilteredUsages(node, graph, filter = "all") {
+	return node.usages.filter((usage) => {
+		const targetNode = graph.nodes.get(usage.target);
+		return targetNode !== void 0 && matchesReactFilter(targetNode, filter);
+	});
+}
+function analyzeReactFile(program, filePath, sourceDependencies) {
+	const symbolsByName = /* @__PURE__ */ new Map();
+	program.body.forEach((statement) => {
+		collectTopLevelReactSymbols(statement, filePath, symbolsByName);
+	});
+	const importsByLocalName = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	program.body.forEach((statement) => {
+		collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName);
+	});
+	symbolsByName.forEach((symbol) => {
+		analyzeSymbolUsages(symbol);
+	});
+	return {
+		filePath,
+		importsByLocalName,
+		exportsByName,
+		symbolsById: new Map([...symbolsByName.values()].map((symbol) => [symbol.id, symbol])),
+		symbolsByName
+	};
+}
+function collectTopLevelReactSymbols(statement, filePath, symbolsByName) {
+	switch (statement.type) {
+		case "FunctionDeclaration":
+			addFunctionSymbol(statement, filePath, symbolsByName);
+			return;
+		case "VariableDeclaration":
+			statement.declarations.forEach((declarator) => {
+				addVariableSymbol(declarator, filePath, symbolsByName);
+			});
+			return;
+		case "ExportNamedDeclaration":
+			if (statement.declaration !== null) collectTopLevelReactSymbols(statement.declaration, filePath, symbolsByName);
+			return;
+		case "ExportDefaultDeclaration":
+			addDefaultExportSymbol(statement, filePath, symbolsByName);
+			return;
+		default: return;
+	}
+}
+function addFunctionSymbol(declaration, filePath, symbolsByName) {
+	const name = declaration.id?.name;
+	if (name === void 0) return;
+	const kind = classifyReactSymbol(name, declaration);
+	if (kind === void 0) return;
+	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration));
+}
+function addVariableSymbol(declarator, filePath, symbolsByName) {
+	if (declarator.id.type !== "Identifier" || declarator.init === null) return;
+	if (declarator.init.type !== "ArrowFunctionExpression" && declarator.init.type !== "FunctionExpression") return;
+	const name = declarator.id.name;
+	const kind = classifyReactSymbol(name, declarator.init);
+	if (kind === void 0) return;
+	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declarator.init));
+}
+function addDefaultExportSymbol(declaration, filePath, symbolsByName) {
+	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") addFunctionSymbol(declaration.declaration, filePath, symbolsByName);
+	else if (declaration.declaration.type === "ArrowFunctionExpression") {
+		const name = "default";
+		const kind = declaration.declaration.body ? classifyReactSymbol(name, declaration.declaration) : void 0;
+		if (kind !== void 0) symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration.declaration));
+	}
+}
+function createPendingSymbol(filePath, name, kind, declaration) {
+	return {
+		id: `${filePath}#${kind}:${name}`,
+		name,
+		kind,
+		filePath,
+		declaration,
+		exportNames: /* @__PURE__ */ new Set(),
+		componentReferences: /* @__PURE__ */ new Set(),
+		hookReferences: /* @__PURE__ */ new Set()
+	};
+}
+function collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName) {
+	switch (statement.type) {
+		case "ImportDeclaration":
+			collectImportBindings(statement, sourceDependencies, importsByLocalName);
+			return;
+		case "ExportNamedDeclaration":
+			collectNamedExports(statement, symbolsByName, exportsByName);
+			return;
+		case "ExportDefaultDeclaration":
+			collectDefaultExport(statement, symbolsByName, exportsByName);
+			return;
+		default: return;
+	}
+}
+function collectImportBindings(declaration, sourceDependencies, importsByLocalName) {
+	if (declaration.importKind === "type") return;
+	const sourceSpecifier = declaration.source.value;
+	const sourcePath = sourceDependencies.get(declaration.source.value);
+	declaration.specifiers.forEach((specifier) => {
+		const binding = getImportBinding(specifier, sourceSpecifier, sourcePath);
+		if (binding === void 0) return;
+		importsByLocalName.set(binding.localName, {
+			importedName: binding.importedName,
+			sourceSpecifier: binding.sourceSpecifier,
+			...binding.sourcePath === void 0 ? {} : { sourcePath: binding.sourcePath }
+		});
+	});
+}
+function getImportBinding(specifier, sourceSpecifier, sourcePath) {
+	if (specifier.type === "ImportSpecifier") {
+		if (specifier.importKind === "type") return;
+		return {
+			localName: specifier.local.name,
+			importedName: toModuleExportName(specifier.imported),
+			sourceSpecifier,
+			...sourcePath === void 0 ? {} : { sourcePath }
+		};
+	}
+	if (specifier.type === "ImportDefaultSpecifier") return {
+		localName: specifier.local.name,
+		importedName: "default",
+		sourceSpecifier,
+		...sourcePath === void 0 ? {} : { sourcePath }
+	};
+}
+function collectNamedExports(declaration, symbolsByName, exportsByName) {
+	if (declaration.exportKind === "type") return;
+	if (declaration.declaration !== null) {
+		if (declaration.declaration.type === "FunctionDeclaration") {
+			const name = declaration.declaration.id?.name;
+			if (name !== void 0) addExportBinding(name, name, symbolsByName, exportsByName);
+		} else if (declaration.declaration.type === "VariableDeclaration") declaration.declaration.declarations.forEach((declarator) => {
+			if (declarator.id.type === "Identifier") addExportBinding(declarator.id.name, declarator.id.name, symbolsByName, exportsByName);
+		});
+		return;
+	}
+	if (declaration.source !== null) return;
+	declaration.specifiers.forEach((specifier) => {
+		if (specifier.exportKind === "type") return;
+		addExportBinding(toModuleExportName(specifier.local), toModuleExportName(specifier.exported), symbolsByName, exportsByName);
+	});
+}
+function collectDefaultExport(declaration, symbolsByName, exportsByName) {
+	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") {
+		const localName = declaration.declaration.id?.name;
+		if (localName !== void 0) addExportBinding(localName, "default", symbolsByName, exportsByName);
+		return;
+	}
+	if (declaration.declaration.type === "Identifier") {
+		addExportBinding(declaration.declaration.name, "default", symbolsByName, exportsByName);
+		return;
+	}
+	if (declaration.declaration.type === "ArrowFunctionExpression") addExportBinding("default", "default", symbolsByName, exportsByName);
+}
+function addExportBinding(localName, exportedName, symbolsByName, exportsByName) {
+	const symbol = symbolsByName.get(localName);
+	if (symbol === void 0) return;
+	symbol.exportNames.add(exportedName);
+	exportsByName.set(exportedName, symbol.id);
+}
+function analyzeSymbolUsages(symbol) {
+	const root = symbol.declaration.type === "ArrowFunctionExpression" ? symbol.declaration.body : symbol.declaration.body;
+	if (root === null) return;
+	walkReactUsageTree(root, (node) => {
+		if (node.type === "JSXElement") {
+			const name = getComponentReferenceName(node);
+			if (name !== void 0) symbol.componentReferences.add(name);
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const hookReference = getHookReferenceName(node);
+			if (hookReference !== void 0) symbol.hookReferences.add(hookReference);
+			const componentReference = getCreateElementComponentReferenceName(node);
+			if (componentReference !== void 0) symbol.componentReferences.add(componentReference);
+		}
+	});
+}
+function classifyReactSymbol(name, declaration) {
+	if (isHookName(name)) return "hook";
+	if (isComponentName(name) && returnsReactElement(declaration)) return "component";
+}
+function returnsReactElement(declaration) {
+	if (declaration.type === "ArrowFunctionExpression" && declaration.expression) return containsReactElementLikeExpression(declaration.body);
+	const body = declaration.body;
+	if (body === null) return false;
+	let found = false;
+	walkReactUsageTree(body, (node) => {
+		if (node.type !== "ReturnStatement" || node.argument === null) return;
+		if (containsReactElementLikeExpression(node.argument)) found = true;
+	});
+	return found;
+}
+function containsReactElementLikeExpression(expression) {
+	let found = false;
+	walkNode(expression, (node) => {
+		if (node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "CallExpression" && isReactCreateElementCall(node)) found = true;
+	});
+	return found;
+}
+function getComponentReferenceName(node) {
+	const name = getJsxName(node.openingElement.name);
+	return name !== void 0 && isComponentName(name) ? name : void 0;
+}
+function getHookReferenceName(node) {
+	const calleeName = getIdentifierName(node.callee);
+	return calleeName !== void 0 && isHookName(calleeName) ? calleeName : void 0;
+}
+function getCreateElementComponentReferenceName(node) {
+	if (!isReactCreateElementCall(node)) return;
+	const [firstArgument] = node.arguments;
+	if (firstArgument === void 0 || firstArgument.type !== "Identifier") return;
+	return isComponentName(firstArgument.name) ? firstArgument.name : void 0;
+}
+function isReactCreateElementCall(node) {
+	const callee = unwrapExpression(node.callee);
+	if (callee.type !== "MemberExpression" || callee.computed) return false;
+	return callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.name === "createElement";
+}
+function getJsxName(name) {
+	if (name.type === "JSXIdentifier") return name.name;
+}
+function getIdentifierName(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "Identifier" ? unwrapped.name : void 0;
+}
+function unwrapExpression(expression) {
+	let current = expression;
+	while (true) {
+		if (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+}
+function walkReactUsageTree(root, visit) {
+	walkNode(root, visit, true);
+}
+function walkNode(node, visit, allowNestedFunctions = false) {
+	visit(node);
+	const keys = visitorKeys[node.type];
+	if (keys === void 0) return;
+	keys.forEach((key) => {
+		const value = node[key];
+		walkChild(value, visit, allowNestedFunctions);
+	});
+}
+function walkChild(value, visit, allowNestedFunctions) {
+	if (Array.isArray(value)) {
+		value.forEach((entry) => {
+			walkChild(entry, visit, allowNestedFunctions);
+		});
+		return;
+	}
+	if (!isNode(value)) return;
+	if (!allowNestedFunctions && FUNCTION_NODE_TYPES.has(value.type)) return;
+	walkNode(value, visit, false);
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
+	const localSymbol = fileAnalysis.symbolsByName.get(name);
+	if (localSymbol !== void 0 && localSymbol.kind === kind) return localSymbol.id;
+	const importBinding = fileAnalysis.importsByLocalName.get(name);
+	if (importBinding === void 0) return;
+	if (importBinding.sourcePath === void 0) return kind === "hook" ? getExternalHookNodeId(importBinding, name) : void 0;
+	const sourceFileAnalysis = fileAnalyses.get(importBinding.sourcePath);
+	if (sourceFileAnalysis === void 0) return;
+	const targetId = sourceFileAnalysis.exportsByName.get(importBinding.importedName);
+	if (targetId === void 0) return;
+	return sourceFileAnalysis.symbolsById.get(targetId)?.kind === kind ? targetId : void 0;
+}
+function createExternalHookNode(binding, localName) {
+	const name = getExternalHookName(binding, localName);
+	return {
+		id: getExternalHookNodeId(binding, localName),
+		name,
+		kind: "hook",
+		filePath: binding.sourceSpecifier,
+		exportNames: [binding.importedName],
+		usages: []
+	};
+}
+function getExternalHookNodeId(binding, localName) {
+	return `external:${binding.sourceSpecifier}#hook:${getExternalHookName(binding, localName)}`;
+}
+function getExternalHookName(binding, localName) {
+	return binding.importedName === "default" ? localName : binding.importedName;
+}
+function getFilteredReactUsageNodes(graph, filter) {
+	return [...graph.nodes.values()].filter((node) => matchesReactFilter(node, filter)).sort((left, right) => compareReactNodes(left, right));
+}
+function matchesReactFilter(node, filter) {
+	return filter === "all" || node.kind === filter;
+}
+function serializeReactUsageNode(nodeId, graph, filter, visited) {
+	const node = graph.nodes.get(nodeId);
+	if (node === void 0) return {
+		id: nodeId,
+		name: nodeId,
+		symbolKind: "circular",
+		filePath: "",
+		exportNames: [],
+		usages: []
+	};
+	if (visited.has(nodeId)) return {
+		id: node.id,
+		name: node.name,
+		symbolKind: "circular",
+		filePath: toDisplayPath(node.filePath, graph.cwd),
+		exportNames: node.exportNames,
+		usages: []
+	};
+	const nextVisited = new Set(visited);
+	nextVisited.add(nodeId);
+	return {
+		id: node.id,
+		name: node.name,
+		symbolKind: node.kind,
+		filePath: toDisplayPath(node.filePath, graph.cwd),
+		exportNames: node.exportNames,
+		usages: getFilteredUsages(node, graph, filter).map((usage) => ({
+			kind: usage.kind,
+			targetId: usage.target,
+			node: serializeReactUsageNode(usage.target, graph, filter, nextVisited)
+		}))
+	};
+}
+function compareReactNodeIds(leftId, rightId, nodes) {
+	const left = nodes.get(leftId);
+	const right = nodes.get(rightId);
+	if (left === void 0 || right === void 0) return leftId.localeCompare(rightId);
+	return compareReactNodes(left, right);
+}
+function compareReactNodes(left, right) {
+	return left.filePath.localeCompare(right.filePath) || left.name.localeCompare(right.name) || left.kind.localeCompare(right.kind);
+}
+function toModuleExportName(name) {
+	return name.type === "Literal" ? name.value : name.name;
+}
+function isHookName(name) {
+	return /^use[A-Z0-9]/.test(name);
+}
+function isComponentName(name) {
+	return /^[A-Z]/.test(name);
+}
+//#endregion
+//#region src/react-tree.ts
+function printReactUsageTree(graph, options = {}) {
+	const cwd = options.cwd ?? graph.cwd;
+	const filter = options.filter ?? "all";
+	const roots = getReactUsageRoots(graph, filter);
+	if (roots.length === 0) return "No React symbols found.";
+	const lines = [];
+	roots.forEach((rootId, index) => {
+		const root = graph.nodes.get(rootId);
+		if (root === void 0) return;
+		lines.push(formatReactNodeLabel(root, cwd));
+		const usages = getFilteredUsages(root, graph, filter);
+		usages.forEach((usage, usageIndex) => {
+			lines.push(...renderUsage(usage, graph, cwd, filter, new Set([root.id]), "", usageIndex === usages.length - 1));
+		});
+		if (index < roots.length - 1) lines.push("");
+	});
+	return lines.join("\n");
+}
+function renderUsage(usage, graph, cwd, filter, visited, prefix, isLast) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const target = graph.nodes.get(usage.target);
+	if (target === void 0) return [`${branch}${usage.target}`];
+	if (visited.has(target.id)) return [`${branch}${formatReactNodeLabel(target, cwd)} (circular)`];
+	const childLines = [`${branch}${formatReactNodeLabel(target, cwd)}`];
+	const nextVisited = new Set(visited);
+	nextVisited.add(target.id);
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const childUsages = getFilteredUsages(target, graph, filter);
+	childUsages.forEach((childUsage, index) => {
+		childLines.push(...renderUsage(childUsage, graph, cwd, filter, nextVisited, nextPrefix, index === childUsages.length - 1));
+	});
+	return childLines;
+}
+function formatReactNodeLabel(node, cwd) {
+	return `${node.name} [${node.kind}] (${toDisplayPath(node.filePath, cwd)})`;
+}
+//#endregion
+//#region src/tree.ts
+function printDependencyTree(graph, options = {}) {
+	const cwd = options.cwd ?? graph.cwd;
+	const includeExternals = options.includeExternals ?? false;
+	const omitUnused = options.omitUnused ?? false;
+	const rootLines = [toDisplayPath(graph.entryId, cwd)];
+	const visited = new Set([graph.entryId]);
+	const entryNode = graph.nodes.get(graph.entryId);
+	if (entryNode === void 0) return rootLines.join("\n");
+	const rootDependencies = filterDependencies(entryNode.dependencies, includeExternals, omitUnused);
+	rootDependencies.forEach((dependency, index) => {
+		const lines = renderDependency(dependency, graph, visited, "", index === rootDependencies.length - 1, includeExternals, omitUnused, cwd);
+		rootLines.push(...lines);
+	});
+	return rootLines.join("\n");
+}
+function renderDependency(dependency, graph, visited, prefix, isLast, includeExternals, omitUnused, cwd) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const label = formatDependencyLabel(dependency, graph, cwd);
+	if (dependency.kind !== "source") return [`${branch}${label}`];
+	if (visited.has(dependency.target)) return [`${branch}${label} (circular)`];
+	const childNode = graph.nodes.get(dependency.target);
+	if (childNode === void 0) return [`${branch}${label}`];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const nextVisited = new Set(visited);
+	nextVisited.add(dependency.target);
+	const childLines = [`${branch}${label}`];
+	const childDependencies = filterDependencies(childNode.dependencies, includeExternals, omitUnused);
+	childDependencies.forEach((childDependency, index) => {
+		const isChildLast = index === childDependencies.length - 1;
+		childLines.push(...renderDependency(childDependency, graph, nextVisited, nextPrefix, isChildLast, includeExternals, omitUnused, cwd));
+	});
+	return childLines;
+}
+function filterDependencies(dependencies, includeExternals, omitUnused) {
+	return dependencies.filter((dependency) => {
+		if (omitUnused && dependency.unused) return false;
+		if (dependency.kind === "source" || dependency.kind === "missing") return true;
+		return includeExternals;
+	});
+}
+function formatDependencyLabel(dependency, _graph, cwd) {
+	const prefixes = [];
+	if (dependency.isTypeOnly) prefixes.push("type");
+	if (dependency.referenceKind === "require") prefixes.push("require");
+	else if (dependency.referenceKind === "dynamic-import") prefixes.push("dynamic");
+	else if (dependency.referenceKind === "export") prefixes.push("re-export");
+	else if (dependency.referenceKind === "import-equals") prefixes.push("import=");
+	const annotation = prefixes.length > 0 ? `[${prefixes.join(", ")}] ` : "";
+	if (dependency.kind === "source") return withUnusedSuffix(`${annotation}${toDisplayPath(dependency.target, cwd)}`, dependency.unused);
+	if (dependency.kind === "missing") return withUnusedSuffix(`${annotation}${dependency.specifier} [missing]`, dependency.unused);
+	if (dependency.kind === "builtin") return withUnusedSuffix(`${annotation}${dependency.target} [builtin]`, dependency.unused);
+	return withUnusedSuffix(`${annotation}${dependency.target} [external]`, dependency.unused);
+}
+function withUnusedSuffix(label, unused) {
+	return unused ? `${label} (unused)` : label;
+}
+//#endregion
+export { graphToSerializableReactTree as a, getReactUsageRoots as i, printReactUsageTree as n, analyzeDependencies as o, analyzeReactUsage as r, graphToSerializableTree as s, printDependencyTree as t };
+
+//# sourceMappingURL=tree-DbnWcUnV.mjs.map