foresthouse 1.1.0-dev.2 → 1.1.0

package/README.md

@@ -2,6 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/foresthouse.svg?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/foresthouse)
 [![codecov](https://img.shields.io/codecov/c/github/async3619/foresthouse?style=flat&colorA=000000&colorB=000000)](https://codecov.io/gh/async3619/foresthouse)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json&style=flat&colorA=000000&colorB=000000)](https://codspeed.io/async3619/foresthouse?utm_source=badge)
 [![license](https://img.shields.io/npm/l/foresthouse?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/foresthouse)
 
 `foresthouse` is a modern TypeScript-first Node.js CLI that can print source import trees, React usage trees, and package-manifest dependency trees.

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as printReactUsageTree, c as printPackageDependencyTree, f as analyzeReactUsage, g as analyzePackageDependencies, h as analyzePackageDependencyDiff, i as graphToSerializablePackageTree, m as isSourceCodeFile, n as graphToSerializableTree, o as printDependencyTree, p as analyzeDependencies, r as diffGraphToSerializablePackageTree, s as printPackageDependencyDiffTree, t as graphToSerializableReactTree } from "./react-GTkYqQLE.mjs";
+import { a as printReactUsageTree, c as printPackageDependencyTree, f as analyzeReactUsage, g as analyzePackageDependencies, h as analyzePackageDependencyDiff, i as graphToSerializablePackageTree, m as isSourceCodeFile, n as graphToSerializableTree, o as printDependencyTree, p as analyzeDependencies, r as diffGraphToSerializablePackageTree, s as printPackageDependencyDiffTree, t as graphToSerializableReactTree } from "./react-xFA5HmqF.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { a as printReactUsageTree, c as printPackageDependencyTree, d as getReactUsageRoots, f as analyzeReactUsage, g as analyzePackageDependencies, h as analyzePackageDependencyDiff, i as graphToSerializablePackageTree, l as getFilteredUsages, n as graphToSerializableTree, o as printDependencyTree, p as analyzeDependencies, r as diffGraphToSerializablePackageTree, s as printPackageDependencyDiffTree, t as graphToSerializableReactTree, u as getReactUsageEntries } from "./react-GTkYqQLE.mjs";
+import { a as printReactUsageTree, c as printPackageDependencyTree, d as getReactUsageRoots, f as analyzeReactUsage, g as analyzePackageDependencies, h as analyzePackageDependencyDiff, i as graphToSerializablePackageTree, l as getFilteredUsages, n as graphToSerializableTree, o as printDependencyTree, p as analyzeDependencies, r as diffGraphToSerializablePackageTree, s as printPackageDependencyDiffTree, t as graphToSerializableReactTree, u as getReactUsageEntries } from "./react-xFA5HmqF.mjs";
 export { analyzeDependencies, analyzePackageDependencies, analyzePackageDependencyDiff, analyzeReactUsage, diffGraphToSerializablePackageTree, getFilteredUsages, getReactUsageEntries, getReactUsageRoots, graphToSerializablePackageTree, graphToSerializableReactTree, graphToSerializableTree, printDependencyTree, printPackageDependencyDiffTree, printPackageDependencyTree, printReactUsageTree };

package/dist/{react-GTkYqQLE.mjs → react-xFA5HmqF.mjs}

@@ -246,11 +246,11 @@ function listSubdirectories$1(directory) {
 }
 function createWorkspaceSegmentMatcher$1(segment) {
 	if (!segment.includes("*")) return (name) => name === segment;
-	const escapedSegment = escapeRegExp(segment).replaceAll("*", "[^/]*");
+	const escapedSegment = escapeRegExp$1(segment).replaceAll("*", "[^/]*");
 	const pattern = new RegExp(`^${escapedSegment}$`);
 	return (name) => pattern.test(name);
 }
-function escapeRegExp(value) {
+function escapeRegExp$1(value) {
 	return value.replaceAll(/[|\\{}()[\]^$+?.]/g, "\\$&");
 }
 function isRecord$1(value) {
@@ -760,20 +760,6 @@ function getCommandErrorMessage(error) {
 }
 //#endregion
 //#region src/typescript/program.ts
-function createProgram(entryFile, compilerOptions, currentDirectory) {
-	const host = ts.createCompilerHost(compilerOptions, true);
-	host.getCurrentDirectory = () => currentDirectory;
-	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 createModuleResolutionHost(currentDirectory) {
 	return {
 		fileExists: ts.sys.fileExists,
@@ -784,17 +770,6 @@ function createModuleResolutionHost(currentDirectory) {
 		...ts.sys.realpath === void 0 ? {} : { realpath: ts.sys.realpath }
 	};
 }
-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;
-	}
-}
 //#endregion
 //#region src/typescript/config.ts
 const nearestConfigCache = /* @__PURE__ */ new Map();
@@ -1142,79 +1117,11 @@ function resolveExistingPath(cwd, entryFile) {
 	return normalizedPath;
 }
 //#endregion
-//#region src/analyzers/import/unused.ts
-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;
-	}
-}
-//#endregion
 //#region src/analyzers/import/references.ts
-function collectModuleReferences(sourceFile, checker) {
+function collectModuleReferences(filePath, sourceText, trackUnusedImports) {
+	const parseResult = parseSync(filePath, sourceText);
+	const mod = parseResult.module;
 	const references = /* @__PURE__ */ new Map();
-	const unusedImports = checker === void 0 ? /* @__PURE__ */ new Map() : collectUnusedImports(sourceFile, checker);
 	function addReference(specifier, referenceKind, isTypeOnly, unused) {
 		const key = `${referenceKind}:${isTypeOnly ? "type" : "value"}:${specifier}`;
 		const existing = references.get(key);
@@ -1232,26 +1139,76 @@ function collectModuleReferences(sourceFile, checker) {
 			unused
 		});
 	}
+	for (const imp of mod.staticImports) {
+		const specifier = imp.moduleRequest.value;
+		const isTypeOnly = imp.entries.length > 0 && imp.entries.every((e) => e.isType);
+		let unused = false;
+		if (trackUnusedImports && imp.entries.length > 0) {
+			const localNames = imp.entries.map((e) => e.localName.value);
+			unused = !isAnyNameUsedAfter(imp.end, localNames, sourceText);
+		}
+		addReference(specifier, "import", isTypeOnly, unused);
+	}
+	for (const exp of mod.staticExports) {
+		const reExportEntry = exp.entries.find((e) => e.moduleRequest !== null);
+		if (reExportEntry?.moduleRequest != null) {
+			const specifier = reExportEntry.moduleRequest.value;
+			addReference(specifier, "export", exp.entries.every((e) => e.isType), false);
+		}
+	}
+	for (const di of mod.dynamicImports) {
+		const req = di.moduleRequest;
+		if (req.start != null && req.end != null) {
+			const specifier = extractStringLiteral(sourceText, req.start, req.end);
+			if (specifier !== void 0) addReference(specifier, "dynamic-import", false, false);
+		}
+	}
+	if (sourceText.includes("require(")) collectRequireReferences(parseResult.program.body, addReference);
+	return [...references.values()];
+}
+function isAnyNameUsedAfter(afterPosition, names, sourceText) {
+	const restOfFile = sourceText.slice(afterPosition);
+	return names.some((name) => {
+		return new RegExp(`\\b${escapeRegExp(name)}\\b`).test(restOfFile);
+	});
+}
+function escapeRegExp(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractStringLiteral(sourceText, start, end) {
+	const raw = sourceText.slice(start, end);
+	if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith("\"") && raw.endsWith("\"") || raw.startsWith("`") && raw.endsWith("`") && !raw.includes("${")) return raw.slice(1, -1);
+}
+function collectRequireReferences(body, addReference) {
 	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 (node === null || node === void 0 || typeof node !== "object") return;
+		const n = node;
+		if (n.type === "TSImportEqualsDeclaration") {
+			const moduleRef = n.moduleReference;
+			if (moduleRef?.type === "TSExternalModuleReference") {
+				const expr = moduleRef.expression;
+				if (expr?.type === "Literal" && typeof expr.value === "string") {
+					addReference(expr.value, "import-equals", false, false);
+					return;
+				}
 			}
-			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);
+		}
+		if (n.type === "CallExpression") {
+			const callee = n.callee;
+			const args = n.arguments;
+			if (callee?.type === "Identifier" && callee.name === "require" && Array.isArray(args) && args.length === 1) {
+				const arg = args[0];
+				if (arg?.type === "Literal" && typeof arg.value === "string") {
+					addReference(arg.value, "require", false, false);
+					return;
+				}
 			}
 		}
-		ts.forEachChild(node, visit);
+		for (const value of Object.values(n)) if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item === "object" && "type" in item) visit(item);
+		} else if (value && typeof value === "object" && "type" in value) visit(value);
 	}
-	visit(sourceFile);
-	return [...references.values()];
+	for (const stmt of body) visit(stmt);
 }
 //#endregion
 //#region src/analyzers/import/resolver.ts
@@ -1351,8 +1308,6 @@ function buildDependencyGraph(entryConfigs, options) {
 var DependencyGraphBuilder = class {
 	nodes = /* @__PURE__ */ new Map();
 	configCache = /* @__PURE__ */ new Map();
-	programCache = /* @__PURE__ */ new Map();
-	checkerCache = /* @__PURE__ */ new Map();
 	resolverCache = /* @__PURE__ */ new Map();
 	resolutionCache = /* @__PURE__ */ new Map();
 	packageRootCache = /* @__PURE__ */ new Map();
@@ -1376,18 +1331,13 @@ var DependencyGraphBuilder = class {
 		const normalizedPath = normalizeFilePath(filePath);
 		if (this.nodes.has(normalizedPath)) return;
 		const config = this.getConfigForFile(normalizedPath);
-		const checker = this.options.trackUnusedImports ? this.getCheckerForFile(normalizedPath, config) : void 0;
-		const dependencies = collectModuleReferences(this.getSourceFileForFile(normalizedPath, config), checker).map((reference) => this.resolveDependencyWithCache(reference, normalizedPath, config, entryConfigPath));
+		const dependencies = collectModuleReferences(normalizedPath, fs.readFileSync(normalizedPath, "utf8"), this.options.trackUnusedImports).map((reference) => this.resolveDependencyWithCache(reference, normalizedPath, config, entryConfigPath));
 		this.nodes.set(normalizedPath, {
 			id: normalizedPath,
 			dependencies
 		});
 		for (const dependency of dependencies) if (dependency.kind === "source") this.visitFile(dependency.target, entryConfigPath);
 	}
-	getSourceFileForFile(filePath, config) {
-		if (!this.options.trackUnusedImports) return createSourceFile(filePath);
-		return this.getProgramForFile(filePath, config).getSourceFile(filePath) ?? createSourceFile(filePath);
-	}
 	getConfigForFile(filePath) {
 		const directory = path.dirname(filePath);
 		const cached = this.configCache.get(directory);
@@ -1396,29 +1346,12 @@ var DependencyGraphBuilder = class {
 		this.configCache.set(directory, loaded);
 		return loaded;
 	}
-	getProgramForFile(filePath, config) {
-		const cacheKey = this.getProgramCacheKey(filePath, config);
-		const cached = this.programCache.get(cacheKey);
-		if (cached !== void 0) return cached;
-		const currentDirectory = config.path === void 0 ? path.dirname(filePath) : path.dirname(config.path);
-		const program = createProgram(filePath, config.compilerOptions, currentDirectory);
-		this.programCache.set(cacheKey, program);
-		return program;
-	}
-	getCheckerForFile(filePath, config) {
-		const cacheKey = this.getProgramCacheKey(filePath, config);
-		const cached = this.checkerCache.get(cacheKey);
-		if (cached !== void 0) return cached;
-		const checker = this.getProgramForFile(filePath, config).getTypeChecker();
-		this.checkerCache.set(cacheKey, checker);
-		return checker;
-	}
-	getProgramCacheKey(filePath, config) {
+	getConfigCacheKey(filePath, config) {
 		return config.path ?? `default:${path.dirname(filePath)}`;
 	}
 	getResolverForFile(filePath) {
 		const config = this.getConfigForFile(filePath);
-		const cacheKey = this.getProgramCacheKey(filePath, config);
+		const cacheKey = this.getConfigCacheKey(filePath, config);
 		const cached = this.resolverCache.get(cacheKey);
 		if (cached !== void 0) return cached;
 		const resolver = new ResolverFactory({
@@ -1472,7 +1405,7 @@ var DependencyGraphBuilder = class {
 		const scopeKey = entryConfigPath ?? "";
 		if (isPackageLikeImport(specifier)) {
 			const packageRoot = this.getPackageRoot(containingFile) ?? path.dirname(containingFile);
-			return `package:${this.getProgramCacheKey(containingFile, config)}:${packageRoot}:${specifier}:${scopeKey}`;
+			return `package:${this.getConfigCacheKey(containingFile, config)}:${packageRoot}:${specifier}:${scopeKey}`;
 		}
 		return `path:${path.dirname(containingFile)}:${specifier}:${scopeKey}`;
 	}
@@ -2892,4 +2825,4 @@ function formatReactNodeFilePath(filePath, kind, cwd) {
 //#endregion
 export { printReactUsageTree as a, printPackageDependencyTree as c, getReactUsageRoots as d, analyzeReactUsage as f, analyzePackageDependencies as g, analyzePackageDependencyDiff as h, graphToSerializablePackageTree as i, getFilteredUsages as l, isSourceCodeFile as m, graphToSerializableTree as n, printDependencyTree as o, analyzeDependencies as p, diffGraphToSerializablePackageTree as r, printPackageDependencyDiffTree as s, graphToSerializableReactTree as t, getReactUsageEntries as u };
 
-//# sourceMappingURL=react-GTkYqQLE.mjs.map
+//# sourceMappingURL=react-xFA5HmqF.mjs.map