foresthouse 1.0.0-dev.16 → 1.0.0-dev.17

package/dist/{react-GNHqx2A-.mjs → react-Ba7anDr7.mjs}

@@ -1,10 +1,260 @@
 import { builtinModules } from "node:module";
+import fs from "node:fs";
 import path from "node:path";
 import ts from "typescript";
-import fs from "node:fs";
 import { ResolverFactory } from "oxc-resolver";
 import { parseSync, visitorKeys } from "oxc-parser";
 import process$1 from "node:process";
+//#region src/utils/to-display-path.ts
+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;
+}
+//#endregion
+//#region src/analyzers/base.ts
+var BaseAnalyzer = class {
+	constructor(entryFile, options) {
+		this.entryFile = entryFile;
+		this.options = options;
+	}
+	analyze() {
+		return this.doAnalyze();
+	}
+};
+//#endregion
+//#region src/analyzers/deps/index.ts
+const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+function analyzePackageDependencies(directory) {
+	return new PackageDependencyAnalyzer(directory).analyze();
+}
+var PackageDependencyAnalyzer = class extends BaseAnalyzer {
+	inputPath;
+	constructor(directory) {
+		super(directory, {});
+		this.inputPath = path.resolve(process.cwd(), directory);
+	}
+	doAnalyze() {
+		const rootPackageDir = findNearestPackageDirectory(resolveInputDirectory(this.inputPath));
+		const workspaceRootDir = findWorkspaceRoot(rootPackageDir) ?? rootPackageDir;
+		const workspacePackages = discoverWorkspacePackages(workspaceRootDir);
+		const nodes = /* @__PURE__ */ new Map();
+		visitPackage(rootPackageDir, workspaceRootDir, workspacePackages, nodes);
+		return {
+			repositoryRoot: workspaceRootDir,
+			rootId: rootPackageDir,
+			nodes
+		};
+	}
+};
+function visitPackage(packageDir, repositoryRoot, workspacePackages, nodes) {
+	if (nodes.has(packageDir)) return;
+	const manifest = readPackageManifest(packageDir);
+	const packageName = resolvePackageName(manifest, packageDir);
+	const dependencies = packageDir === repositoryRoot && workspacePackages.size > 0 ? collectRepositoryRootDependencies(manifest, workspacePackages, repositoryRoot) : collectManifestDependencies(manifest, workspacePackages, repositoryRoot);
+	nodes.set(packageDir, {
+		packageDir,
+		packageName,
+		dependencies
+	});
+	dependencies.forEach((dependency) => {
+		if (dependency.kind === "workspace") visitPackage(dependency.target, repositoryRoot, workspacePackages, nodes);
+	});
+}
+function resolveInputDirectory(resolvedPath) {
+	const stats = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath) : null;
+	if (stats === null) throw new Error(`Directory does not exist: ${resolvedPath}`);
+	if (stats.isDirectory()) return resolvedPath;
+	if (stats.isFile() && path.basename(resolvedPath) === "package.json") return path.dirname(resolvedPath);
+	throw new Error(`Expected a package directory: ${resolvedPath}`);
+}
+function findNearestPackageDirectory(startDirectory) {
+	let currentDirectory = startDirectory;
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) return currentDirectory;
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+	throw new Error(`No package.json found from ${startDirectory}`);
+}
+function findWorkspaceRoot(packageDir) {
+	let currentDirectory = packageDir;
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) {
+			const manifest = readPackageManifest(currentDirectory);
+			const workspacePatterns = resolveWorkspacePatterns(currentDirectory, manifest);
+			if (workspacePatterns.length > 0 && currentDirectory === packageDir) return currentDirectory;
+			if (workspacePatterns.length > 0 && isWorkspaceMatch(currentDirectory, workspacePatterns, packageDir)) return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return;
+		currentDirectory = parentDirectory;
+	}
+}
+function discoverWorkspacePackages(repositoryRoot) {
+	const workspacePatterns = resolveWorkspacePatterns(repositoryRoot, readPackageManifest(repositoryRoot));
+	if (workspacePatterns.length === 0) return /* @__PURE__ */ new Map();
+	const workspacePackageDirs = /* @__PURE__ */ new Set();
+	workspacePatterns.forEach((pattern) => {
+		expandWorkspacePattern(repositoryRoot, pattern).forEach((packageDir) => {
+			workspacePackageDirs.add(packageDir);
+		});
+	});
+	const workspacePackages = /* @__PURE__ */ new Map();
+	Array.from(workspacePackageDirs).sort((left, right) => left.localeCompare(right)).forEach((packageDir) => {
+		const workspaceName = resolvePackageName(readPackageManifest(packageDir), packageDir);
+		if (workspacePackages.has(workspaceName)) throw new Error(`Duplicate workspace package name: ${workspaceName}`);
+		workspacePackages.set(workspaceName, {
+			name: workspaceName,
+			packageDir,
+			label: toDisplayPath(packageDir, repositoryRoot)
+		});
+	});
+	return workspacePackages;
+}
+function collectManifestDependencies(manifest, workspacePackages, repositoryRoot) {
+	const dependencyEntries = Object.entries(manifest.dependencies ?? {});
+	const workspaceDependencies = [];
+	const externalDependencies = [];
+	dependencyEntries.forEach(([dependencyName, specifier]) => {
+		const workspacePackage = workspacePackages.get(dependencyName);
+		if (workspacePackage !== void 0) {
+			workspaceDependencies.push({
+				kind: "workspace",
+				name: dependencyName,
+				specifier,
+				target: workspacePackage.packageDir
+			});
+			return;
+		}
+		externalDependencies.push({
+			kind: "external",
+			name: dependencyName,
+			specifier
+		});
+	});
+	workspaceDependencies.sort((left, right) => {
+		const leftLabel = toDisplayPath(left.target, repositoryRoot);
+		const rightLabel = toDisplayPath(right.target, repositoryRoot);
+		return leftLabel.localeCompare(rightLabel);
+	});
+	externalDependencies.sort((left, right) => left.name.localeCompare(right.name));
+	return [...workspaceDependencies, ...externalDependencies];
+}
+function collectRepositoryRootDependencies(manifest, workspacePackages, _repositoryRoot) {
+	const topLevelWorkspaceDependencies = Array.from(workspacePackages.values()).sort((left, right) => left.label.localeCompare(right.label)).map((workspacePackage) => ({
+		kind: "workspace",
+		name: workspacePackage.name,
+		target: workspacePackage.packageDir
+	}));
+	const externalDependencies = Object.entries(manifest.dependencies ?? {}).filter(([dependencyName]) => !workspacePackages.has(dependencyName)).map(([dependencyName, specifier]) => ({
+		kind: "external",
+		name: dependencyName,
+		specifier
+	})).sort((left, right) => left.name.localeCompare(right.name));
+	return [...topLevelWorkspaceDependencies, ...externalDependencies];
+}
+function readPackageManifest(packageDir) {
+	const packageJsonPath = path.join(packageDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) throw new Error(`Missing package.json in ${packageDir}`);
+	const manifestText = fs.readFileSync(packageJsonPath, "utf8");
+	try {
+		const parsed = JSON.parse(manifestText);
+		if (!isRecord(parsed)) throw new Error("package.json must contain an object");
+		return parsed;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+		throw new Error(`Failed to read ${packageJsonPath}: ${message}`);
+	}
+}
+function resolvePackageName(manifest, packageDir) {
+	if (typeof manifest.name === "string" && manifest.name.trim().length > 0) return manifest.name;
+	throw new Error(`Package at ${packageDir} is missing a valid name`);
+}
+function getWorkspacePatterns(manifest) {
+	if (Array.isArray(manifest.workspaces)) return manifest.workspaces.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+	if (isRecord(manifest.workspaces) && Array.isArray(manifest.workspaces.packages)) return manifest.workspaces.packages.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+	return [];
+}
+function resolveWorkspacePatterns(repositoryRoot, manifest) {
+	const manifestPatterns = getWorkspacePatterns(manifest);
+	if (manifestPatterns.length > 0) return manifestPatterns;
+	return readPnpmWorkspacePatterns(repositoryRoot);
+}
+function readPnpmWorkspacePatterns(repositoryRoot) {
+	const pnpmWorkspacePath = path.join(repositoryRoot, PNPM_WORKSPACE_FILE);
+	if (!fs.existsSync(pnpmWorkspacePath)) return [];
+	const lines = fs.readFileSync(pnpmWorkspacePath, "utf8").split(/\r?\n/);
+	const patterns = [];
+	let inPackagesBlock = false;
+	for (const line of lines) {
+		const trimmedLine = line.trim();
+		if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) continue;
+		if (!inPackagesBlock) {
+			if (trimmedLine === "packages:") inPackagesBlock = true;
+			continue;
+		}
+		if (!line.startsWith(" ") && !line.startsWith("	")) break;
+		if (!trimmedLine.startsWith("- ")) continue;
+		const pattern = unquoteWorkspacePattern(trimmedLine.slice(2).trim());
+		if (pattern.length > 0) patterns.push(pattern);
+	}
+	return patterns;
+}
+function unquoteWorkspacePattern(pattern) {
+	if (pattern.startsWith("\"") && pattern.endsWith("\"") || pattern.startsWith("'") && pattern.endsWith("'")) return pattern.slice(1, -1);
+	return pattern;
+}
+function isWorkspaceMatch(repositoryRoot, patterns, packageDir) {
+	return patterns.some((pattern) => expandWorkspacePattern(repositoryRoot, pattern).includes(packageDir));
+}
+function expandWorkspacePattern(repositoryRoot, pattern) {
+	return matchWorkspaceSegments(repositoryRoot, normalizeWorkspacePattern(pattern), 0).filter((packageDir) => fs.existsSync(path.join(packageDir, "package.json")));
+}
+function normalizeWorkspacePattern(pattern) {
+	return pattern.split(/[\\/]+/).filter((segment) => segment.length > 0 && segment !== ".");
+}
+function matchWorkspaceSegments(currentDirectory, segments, index) {
+	if (index >= segments.length) return [currentDirectory];
+	const segment = segments[index];
+	if (segment === void 0) return [currentDirectory];
+	if (segment === "**") {
+		const results = new Set(matchWorkspaceSegments(currentDirectory, segments, index + 1));
+		listSubdirectories(currentDirectory).forEach((subdirectory) => {
+			matchWorkspaceSegments(subdirectory, segments, index).forEach((match) => {
+				results.add(match);
+			});
+		});
+		return [...results];
+	}
+	const matcher = createWorkspaceSegmentMatcher(segment);
+	const results = [];
+	listSubdirectories(currentDirectory).forEach((subdirectory) => {
+		if (!matcher(path.basename(subdirectory))) return;
+		results.push(...matchWorkspaceSegments(subdirectory, segments, index + 1));
+	});
+	return results;
+}
+function listSubdirectories(directory) {
+	return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git").map((entry) => path.join(directory, entry.name));
+}
+function createWorkspaceSegmentMatcher(segment) {
+	if (!segment.includes("*")) return (name) => name === segment;
+	const escapedSegment = escapeRegExp(segment).replaceAll("*", "[^/]*");
+	const pattern = new RegExp(`^${escapedSegment}$`);
+	return (name) => pattern.test(name);
+}
+function escapeRegExp(value) {
+	return value.replaceAll(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
 //#region src/typescript/config.ts
 function loadCompilerOptions(searchFrom, explicitConfigPath) {
 	const configPath = explicitConfigPath === void 0 ? findNearestConfig(searchFrom) : path.resolve(searchFrom, explicitConfigPath);
@@ -54,17 +304,6 @@ function isInsideNodeModules$1(filePath) {
 	return filePath.includes(`${path.sep}node_modules${path.sep}`);
 }
 //#endregion
-//#region src/analyzers/base.ts
-var BaseAnalyzer = class {
-	constructor(entryFile, options) {
-		this.entryFile = entryFile;
-		this.options = options;
-	}
-	analyze() {
-		return this.doAnalyze();
-	}
-};
-//#endregion
 //#region src/utils/is-source-code-file.ts
 const SOURCE_EXTENSIONS = new Set([
 	".js",
@@ -1251,6 +1490,40 @@ function matchesReactFilter(node, filter) {
 	return filter === "all" || node.kind === filter;
 }
 //#endregion
+//#region src/output/ascii/deps.ts
+function printPackageDependencyTree(graph, _options = {}) {
+	const rootNode = graph.nodes.get(graph.rootId);
+	if (rootNode === void 0) return toDisplayPath(graph.rootId, graph.repositoryRoot);
+	const lines = [rootNode.packageName];
+	const visited = new Set([graph.rootId]);
+	rootNode.dependencies.forEach((dependency, index) => {
+		lines.push(...renderDependency$1(dependency, graph, visited, "", index === rootNode.dependencies.length - 1));
+	});
+	return lines.join("\n");
+}
+function renderDependency$1(dependency, graph, visited, prefix, isLast) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const label = formatDependencyLabel$1(dependency, graph.repositoryRoot);
+	if (dependency.kind === "external") 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 childLines = [`${branch}${label}`];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const nextVisited = new Set(visited);
+	nextVisited.add(dependency.target);
+	childNode.dependencies.forEach((childDependency, index) => {
+		childLines.push(...renderDependency$1(childDependency, graph, nextVisited, nextPrefix, index === childNode.dependencies.length - 1));
+	});
+	return childLines;
+}
+function formatDependencyLabel$1(dependency, repositoryRoot) {
+	if (dependency.kind === "external") return `${dependency.name}@${dependency.specifier}`;
+	const workspaceLabel = toDisplayPath(dependency.target, repositoryRoot);
+	if (dependency.specifier === void 0) return workspaceLabel;
+	return `${workspaceLabel} (${dependency.specifier})`;
+}
+//#endregion
 //#region src/color.ts
 const ANSI_RESET = "\x1B[0m";
 const ANSI_COMPONENT = "\x1B[36m";
@@ -1294,14 +1567,6 @@ function getReactSymbolColor(kind) {
 	return ANSI_BUILTIN;
 }
 //#endregion
-//#region src/utils/to-display-path.ts
-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;
-}
-//#endregion
 //#region src/output/ascii/import.ts
 function printDependencyTree(graph, options = {}) {
 	const cwd = options.cwd ?? graph.cwd;
@@ -1422,6 +1687,51 @@ function formatReactNodeFilePath$1(node, cwd) {
 	return node.kind === "builtin" ? "html" : toDisplayPath(node.filePath, cwd);
 }
 //#endregion
+//#region src/output/json/deps.ts
+function graphToSerializablePackageTree(graph) {
+	return serializePackageNode(graph.rootId, graph, /* @__PURE__ */ new Set());
+}
+function serializePackageNode(packageDir, graph, visited) {
+	const packageNode = graph.nodes.get(packageDir);
+	const packagePath = toDisplayPath(packageDir, graph.repositoryRoot);
+	if (packageNode === void 0) return {
+		kind: "missing",
+		label: packagePath,
+		path: packagePath,
+		dependencies: []
+	};
+	if (visited.has(packageDir)) return {
+		kind: "circular",
+		label: packageNode.packageName,
+		packageName: packageNode.packageName,
+		path: packagePath,
+		dependencies: []
+	};
+	visited.add(packageDir);
+	return {
+		kind: packageDir === graph.rootId ? "root" : "workspace",
+		label: packageDir === graph.rootId ? packageNode.packageName : packagePath,
+		packageName: packageNode.packageName,
+		path: packagePath,
+		dependencies: packageNode.dependencies.map((dependency) => serializeDependency(dependency, graph, new Set(visited)))
+	};
+}
+function serializeDependency(dependency, graph, visited) {
+	if (dependency.kind === "external") return {
+		kind: "external",
+		name: dependency.name,
+		specifier: dependency.specifier,
+		target: `${dependency.name}@${dependency.specifier}`
+	};
+	return {
+		kind: "workspace",
+		name: dependency.name,
+		...dependency.specifier === void 0 ? {} : { specifier: dependency.specifier },
+		target: toDisplayPath(dependency.target, graph.repositoryRoot),
+		node: serializePackageNode(dependency.target, graph, visited)
+	};
+}
+//#endregion
 //#region src/output/json/import.ts
 function graphToSerializableTree(graph, options = {}) {
 	const visited = /* @__PURE__ */ new Set();
@@ -1532,6 +1842,6 @@ function formatReactNodeFilePath(filePath, kind, cwd) {
 	return kind === "builtin" ? "html" : toDisplayPath(filePath, cwd);
 }
 //#endregion
-export { getFilteredUsages as a, analyzeReactUsage as c, printDependencyTree as i, analyzeDependencies as l, graphToSerializableTree as n, getReactUsageEntries as o, printReactUsageTree as r, getReactUsageRoots as s, graphToSerializableReactTree as t, isSourceCodeFile as u };
+export { printDependencyTree as a, getReactUsageEntries as c, analyzeDependencies as d, isSourceCodeFile as f, printReactUsageTree as i, getReactUsageRoots as l, graphToSerializableTree as n, printPackageDependencyTree as o, analyzePackageDependencies as p, graphToSerializablePackageTree as r, getFilteredUsages as s, graphToSerializableReactTree as t, analyzeReactUsage as u };
 
-//# sourceMappingURL=react-GNHqx2A-.mjs.map
+//# sourceMappingURL=react-Ba7anDr7.mjs.map