oxlint-plugin-react-doctor 0.2.0-beta.2 → 0.2.0-beta.3

package/dist/index.js

@@ -1,3 +1,5 @@
+import path from "node:path";
+import fs from "node:fs";
 //#region src/plugin/constants/library.ts
 const HEAVY_LIBRARIES = new Set([
 	"@monaco-editor/react",
@@ -47,13 +49,6 @@ const MUTATING_HTTP_METHODS = new Set([
 ]);
 //#endregion
 //#region src/plugin/constants/dom.ts
-const BARREL_INDEX_SUFFIXES = [
-	"/index",
-	"/index.js",
-	"/index.ts",
-	"/index.tsx",
-	"/index.mjs"
-];
 const PASSIVE_EVENT_NAMES = new Set([
 	"scroll",
 	"wheel",
@@ -2276,7 +2271,345 @@ const noArrayIndexAsKey = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/create-relative-import-source.ts
+const createRelativeImportSource = (filename, targetFilePath) => {
+	const targetPathWithoutExtension = targetFilePath.slice(0, targetFilePath.length - path.extname(targetFilePath).length);
+	const targetModulePath = path.basename(targetPathWithoutExtension) === "index" ? path.dirname(targetPathWithoutExtension) : targetPathWithoutExtension;
+	const relativePath = path.relative(path.dirname(filename), targetModulePath).split(path.sep).join("/");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+};
+//#endregion
+//#region src/plugin/utils/parse-export-specifiers.ts
+const getSpecifierName = (rawName) => rawName.replace(/^type\s+/, "").trim();
+const parseExportSpecifiers = (specifiersText, declarationIsTypeOnly) => specifiersText.split(",").map((specifierText) => specifierText.trim()).filter(Boolean).map((specifierText) => {
+	const isTypeOnly = declarationIsTypeOnly || specifierText.startsWith("type ");
+	const [rawLocalName, rawExportedName] = specifierText.split(/\s+as\s+/);
+	const localName = getSpecifierName(rawLocalName ?? "");
+	return {
+		localName,
+		exportedName: getSpecifierName(rawExportedName ?? localName),
+		isTypeOnly
+	};
+});
+//#endregion
+//#region src/plugin/utils/strip-js-comments.ts
+const BLOCK_COMMENT_PATTERN = /\/\*[\s\S]*?\*\//g;
+const LINE_COMMENT_PATTERN = /^\s*\/\/.*$/gm;
+const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN, "").replace(LINE_COMMENT_PATTERN, "");
+//#endregion
+//#region src/plugin/utils/is-barrel-index-module.ts
+const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
+const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
+const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
+const createNonBarrelInfo = () => ({
+	isBarrel: false,
+	exportsByName: /* @__PURE__ */ new Map(),
+	starExportSources: []
+});
+const addImportedBinding = (importedBindings, binding) => {
+	importedBindings.set(binding.localName, {
+		...binding,
+		didExport: false
+	});
+};
+const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
+	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
+		localName: specifier.exportedName,
+		importedName: specifier.localName,
+		source,
+		isTypeOnly: specifier.isTypeOnly
+	});
+};
+const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
+	const trimmedImportClause = importClause.trim();
+	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
+	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
+		localName: namespaceMatch[1],
+		importedName: "*",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
+	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
+	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
+	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
+		localName: defaultImportName,
+		importedName: "default",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+};
+const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
+	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
+		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
+		const isTypeOnly = Boolean(typeKeyword);
+		if (namespaceExportName) {
+			exportsByName.set(namespaceExportName, {
+				exportedName: namespaceExportName,
+				importedName: "*",
+				source,
+				isTypeOnly
+			});
+			return "";
+		}
+		if (specifiersText) {
+			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: specifier.localName,
+				source,
+				isTypeOnly: specifier.isTypeOnly
+			});
+			return "";
+		}
+		starExportSources.push(source);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1, (_match, typeKeyword, specifiersText) => {
+		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
+			const importedBinding = importedBindings.get(specifier.localName);
+			if (!importedBinding) return _match;
+			importedBinding.didExport = true;
+			exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: importedBinding.importedName,
+				source: importedBinding.source,
+				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
+			});
+		}
+		return "";
+	});
+	return withoutKnownDeclarations;
+};
+const hasUnexportedRuntimeImport = (importedBindings) => {
+	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
+	return false;
+};
+const classifyBarrelModule = (sourceText) => {
+	const strippedSource = stripJsComments(sourceText).trim();
+	if (!strippedSource) return createNonBarrelInfo();
+	const importedBindings = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	const starExportSources = [];
+	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
+	return {
+		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
+		exportsByName,
+		starExportSources
+	};
+};
+const getBarrelIndexModuleInfo = (filePath) => {
+	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
+	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
+	if (cachedResult !== void 0) return cachedResult;
+	let moduleInfo = createNonBarrelInfo();
+	try {
+		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
+	} catch {
+		moduleInfo = createNonBarrelInfo();
+	}
+	barrelIndexModuleInfoCache.set(filePath, moduleInfo);
+	return moduleInfo;
+};
+const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
+//#endregion
+//#region src/plugin/utils/does-module-export-name.ts
+const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
+const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const doesSourceTextExportName = (sourceText, exportedName) => {
+	const strippedSource = stripJsComments(sourceText);
+	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
+	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
+	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
+	return false;
+};
+const doesModuleExportName = (filePath, exportedName) => {
+	try {
+		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/plugin/utils/resolve-relative-import-path.ts
+const MODULE_FILE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+];
+const PACKAGE_EXPORT_CONDITIONS = [
+	"import",
+	"default",
+	"module",
+	"browser",
+	"require"
+];
+const PACKAGE_ENTRY_FIELDS = [
+	"module",
+	"main",
+	"browser"
+];
+const getExistingFilePath = (filePath) => {
+	try {
+		return fs.statSync(filePath).isFile() ? filePath : null;
+	} catch {
+		return null;
+	}
+};
+const getExistingDirectoryPath = (directoryPath) => {
+	try {
+		return fs.statSync(directoryPath).isDirectory() ? directoryPath : null;
+	} catch {
+		return null;
+	}
+};
+const getModuleFilePathCandidates = (modulePath) => {
+	const extension = path.extname(modulePath);
+	if (!extension) return MODULE_FILE_EXTENSIONS.map((moduleExtension) => `${modulePath}${moduleExtension}`);
+	const modulePathWithoutExtension = modulePath.slice(0, -extension.length);
+	if (extension === ".js") return [
+		modulePath,
+		`${modulePathWithoutExtension}.ts`,
+		`${modulePathWithoutExtension}.tsx`,
+		`${modulePathWithoutExtension}.jsx`
+	];
+	if (extension === ".jsx") return [modulePath, `${modulePathWithoutExtension}.tsx`];
+	if (extension === ".mjs") return [modulePath, `${modulePathWithoutExtension}.mts`];
+	if (extension === ".cjs") return [modulePath, `${modulePathWithoutExtension}.cts`];
+	return [modulePath];
+};
+const isObjectRecord = (value) => typeof value === "object" && value !== null;
+const getConditionalExportEntry = (exportEntry) => {
+	if (typeof exportEntry === "string") return exportEntry;
+	if (Array.isArray(exportEntry)) {
+		for (const fallbackEntry of exportEntry) {
+			const resolvedFallbackEntry = getConditionalExportEntry(fallbackEntry);
+			if (resolvedFallbackEntry) return resolvedFallbackEntry;
+		}
+		return null;
+	}
+	if (!isObjectRecord(exportEntry)) return null;
+	for (const condition of PACKAGE_EXPORT_CONDITIONS) {
+		const nestedEntry = getConditionalExportEntry(exportEntry[condition]);
+		if (nestedEntry) return nestedEntry;
+	}
+	return null;
+};
+const getPackageExportEntry = (packageJson) => {
+	const exportsField = packageJson.exports;
+	if (!exportsField) return null;
+	const directExportEntry = getConditionalExportEntry(exportsField);
+	if (directExportEntry) return directExportEntry;
+	if (!isObjectRecord(exportsField)) return null;
+	return getConditionalExportEntry(exportsField["."]);
+};
+const resolveModulePathWithIndexFallback = (modulePath) => {
+	const filePath = resolveModuleFilePath(modulePath);
+	if (filePath) return filePath;
+	return resolveModuleFilePath(path.join(modulePath, "index"));
+};
+const resolvePackageDirectoryEntry = (directoryPath) => {
+	const existingDirectoryPath = getExistingDirectoryPath(directoryPath);
+	if (!existingDirectoryPath) return null;
+	const packageJsonPath = path.join(existingDirectoryPath, "package.json");
+	try {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+		const packageEntry = getPackageExportEntry(packageJson) ?? PACKAGE_ENTRY_FIELDS.map((fieldName) => packageJson[fieldName]).find((value) => typeof value === "string");
+		if (!packageEntry) return null;
+		return resolveModulePathWithIndexFallback(path.resolve(existingDirectoryPath, packageEntry));
+	} catch {
+		return null;
+	}
+};
+const resolveModuleFilePath = (modulePath) => {
+	const exactFilePath = getExistingFilePath(modulePath);
+	if (exactFilePath) return exactFilePath;
+	for (const candidateFilePath of getModuleFilePathCandidates(modulePath)) {
+		const filePath = getExistingFilePath(candidateFilePath);
+		if (filePath) return filePath;
+	}
+	return null;
+};
+const resolveRelativeImportPath = (filename, source) => {
+	const importPath = path.resolve(path.dirname(filename), source);
+	const directFilePath = resolveModuleFilePath(importPath);
+	if (directFilePath) return directFilePath;
+	const packageEntryFilePath = resolvePackageDirectoryEntry(importPath);
+	if (packageEntryFilePath) return packageEntryFilePath;
+	return resolveModuleFilePath(path.join(importPath, "index"));
+};
+//#endregion
+//#region src/plugin/utils/resolve-barrel-export-file-path.ts
+const getUniqueFilePath = (filePaths) => {
+	const uniqueFilePaths = new Set(filePaths);
+	if (uniqueFilePaths.size !== 1) return null;
+	const [filePath] = uniqueFilePaths;
+	return filePath ?? null;
+};
+const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
+	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
+	if (!resolvedTargetPath) return null;
+	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
+	if (nestedTargetPath) return nestedTargetPath;
+	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
+};
+const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
+	if (visitedFilePaths.has(barrelFilePath)) return null;
+	visitedFilePaths.add(barrelFilePath);
+	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
+	if (!moduleInfo.isBarrel) return null;
+	const target = moduleInfo.exportsByName.get(exportedName);
+	if (target) {
+		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
+		if (!resolvedTargetPath) return null;
+		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
+	}
+	if (exportedName === "default") return null;
+	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
+};
+//#endregion
 //#region src/plugin/rules/bundle-size/no-barrel-import.ts
+const getLiteralName = (node) => {
+	if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+};
+const getRuntimeImportRequests = (node) => {
+	if (node.importKind === "type") return [];
+	return node.specifiers.flatMap((specifier) => {
+		if (specifier.type === "ImportSpecifier") {
+			if (specifier.importKind === "type") return [];
+			return [{ importedName: getLiteralName(specifier.imported) }];
+		}
+		if (specifier.type === "ImportDefaultSpecifier") return [{ importedName: "default" }];
+		return [{ importedName: null }];
+	});
+};
+const buildReportMessage = (filename, barrelFilePath, importRequests) => {
+	const directImportSources = /* @__PURE__ */ new Set();
+	for (const request of importRequests) {
+		if (!request.importedName) continue;
+		const directFilePath = resolveBarrelExportFilePath(barrelFilePath, request.importedName);
+		if (directFilePath) directImportSources.add(createRelativeImportSource(filename, directFilePath));
+	}
+	if (directImportSources.size === 1) {
+		const [directImportSource] = directImportSources;
+		return `Import from barrel/index file — import directly from "${directImportSource}" for better tree-shaking`;
+	}
+	if (directImportSources.size > 1) return `Import from barrel/index file — import directly from source modules: ${[...directImportSources].map((source) => `"${source}"`).join(", ")}`;
+	return "Import from barrel/index file — import directly from the source module for better tree-shaking";
+};
 const noBarrelImport = defineRule({
 	id: "no-barrel-import",
 	severity: "warn",
@@ -2287,11 +2620,16 @@ const noBarrelImport = defineRule({
 			if (didReportForFile) return;
 			const source = node.source?.value;
 			if (typeof source !== "string" || !source.startsWith(".")) return;
-			if (BARREL_INDEX_SUFFIXES.some((suffix) => source.endsWith(suffix))) {
+			const filename = context.getFilename?.() ?? "";
+			if (!filename) return;
+			const importRequests = getRuntimeImportRequests(node);
+			if (importRequests.length === 0) return;
+			const resolvedImportPath = resolveRelativeImportPath(filename, source);
+			if (resolvedImportPath && isBarrelIndexModule(resolvedImportPath)) {
 				didReportForFile = true;
 				context.report({
 					node,
-					message: "Import from barrel/index file — import directly from the source module for better tree-shaking"
+					message: buildReportMessage(filename, resolvedImportPath, importRequests)
 				});
 			}
 		} };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.2.0-beta.2",
+  "version": "0.2.0-beta.3",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",