@infernodesign/eslint-config 2.4.1 → 2.5.0

package/README.md

@@ -611,8 +611,11 @@ export default config( {
   tailwindcss: {
     // Enable component class detection
     detectComponentClasses: true,
+    // Resolve Tailwind CSS files from a nested app when linting from a monorepo root
+    cwd: 'apps/web',
     // Specify the entry point for Tailwind CSS
-    // If not provided, the config will try to find the `global.css` or `globals.css` file in the project.
+    // If not provided, the config will try to find a common Tailwind CSS entry point in the project
+    // like `global.css`, `globals.css`, `app.css`, `index.css`, or `style.css`.
     entryPoint: 'src/styles/globals.css',
   },
 } )

package/dist/cli.js

@@ -8,7 +8,7 @@ import { cac } from "cac";
 import parse from "parse-gitignore";
 import { execSync } from "node:child_process";
 //#region package.json
-var version = "2.4.1";
+var version = "2.5.0";
 //#endregion
 //#region src/cli/constants.ts
 const vscodeSettingsString = `

package/dist/index.d.ts

@@ -19395,10 +19395,28 @@ interface OptionsTailwindcss {
    * @default false
    */
   detectComponentClasses?: boolean;
+  /**
+   * Working directory for resolving Tailwind CSS entry points.
+   *
+   * Use this when linting from a monorepo root while the Tailwind CSS setup lives in a nested app.
+   *
+   * @example
+   * ```ts
+   * tailwindcss: {
+   *   cwd: 'apps/web',
+   * },
+   * ```
+   *
+   * @see https://github.com/schoero/eslint-plugin-better-tailwindcss/blob/main/docs/settings/settings.md
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
   /**
    * Entry point for Tailwind CSS.
    *
-   * If not provided, the config will try to find the `global.css` or `globals.css` file in the project.
+   * If not provided, the config will try to find a common Tailwind CSS entry point in the project
+   * like `global.css`, `globals.css`, `app.css`, `index.css`, or `style.css`.
    *
    * @example
    * ```ts

package/dist/index.js

@@ -3,7 +3,7 @@ import { FlatConfigComposer } from "eslint-flat-config-utils";
 import process$1 from "node:process";
 import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import fs$1, { existsSync, readdirSync, statSync } from "node:fs";
+import fs$1, { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { isPackageExists } from "local-pkg";
 import createCommand from "eslint-plugin-command/config";
@@ -105,6 +105,9 @@ const GLOB_EXCLUDE = [
 	"**/.agents",
 	"**/.antigravity",
 	"**/.bmad",
+	"**/.bmad-*",
+	"**/_bmad",
+	"**/_bmad-*",
 	"**/.context",
 	"**/.codex",
 	"**/.claude",
@@ -112,10 +115,12 @@ const GLOB_EXCLUDE = [
 	"**/.windsurf",
 	"**/.*/skills",
 	"**/AGENTS.md",
+	"**/CLAUDE.md",
 	"**/.idea",
 	"**/.vscode",
 	"**/.zed",
 	"**/__snapshots__",
+	"**/badges",
 	"**/coverage",
 	"**/.cache",
 	"**/.eslintcache",
@@ -157,10 +162,14 @@ const GLOB_EXCLUDE = [
 ];
 const GLOB_SEARCH_EXCLUDE = new Set([
 	"__snapshots__",
+	"_bmad",
+	"_bmad-*",
 	".bmad",
+	".bmad-*",
 	".cache",
 	".changeset",
 	".claude",
+	".codex",
 	".cursor",
 	".eslintcache",
 	".git",
@@ -2287,25 +2296,60 @@ async function svelte(options = {}) {
 const defaultEntryPointCandidates = [
 	"src/styles/global.css",
 	"src/styles/globals.css",
+	"src/styles/app.css",
+	"src/styles/index.css",
+	"src/styles/style.css",
+	"src/app/styles/global.css",
+	"src/app/styles/globals.css",
+	"src/app/styles/app.css",
+	"src/app/styles/index.css",
+	"src/app/styles/style.css",
 	"src/app/global.css",
 	"src/app/globals.css",
-	"src/global.css",
-	"src/globals.css",
+	"src/app/app.css",
+	"app/styles/global.css",
+	"app/styles/globals.css",
+	"app/styles/app.css",
+	"app/styles/index.css",
+	"app/styles/style.css",
 	"app/global.css",
 	"app/globals.css",
+	"app/app.css",
+	"src/global.css",
+	"src/globals.css",
+	"src/app.css",
+	"src/index.css",
+	"src/style.css",
 	"styles/global.css",
 	"styles/globals.css",
+	"styles/app.css",
+	"styles/index.css",
+	"styles/style.css",
 	"global.css",
-	"globals.css"
+	"globals.css",
+	"app.css",
+	"index.css",
+	"style.css"
 ];
+const entryPointCandidateFileNames = new Set([
+	"app.css",
+	"global.css",
+	"globals.css",
+	"index.css",
+	"style.css"
+]);
+const tailwindEntryPointPattern = /@import\s+["']tailwindcss(?:\/[^"']+)?["']|@tailwind\s+(?:base|components|utilities|variants)|@theme\b|@utility\b|@custom-variant\b/;
+const tailwindEntryPointCache = /* @__PURE__ */ new Map();
+const warnings = /* @__PURE__ */ new Set();
 async function tailwindcss(options = {}) {
 	const { files = [GLOB_SRC], overrides = {} } = options;
 	if (!isPackageExists("tailwindcss")) return [];
 	await ensurePackages(["eslint-plugin-better-tailwindcss"]);
 	const tsconfigPath = options?.tsconfigPath !== void 0 ? toArray(options.tsconfigPath) : void 0;
-	const resolvedTsconfigPath = tsconfigPath?.[0] ? path.resolve(process.cwd(), tsconfigPath[0]) : void 0;
+	const cwd = resolveCwd(options.cwd);
+	const resolvedTsconfigPath = tsconfigPath?.[0] ? path.resolve(cwd, tsconfigPath[0]) : void 0;
 	const isTypeAware = !!resolvedTsconfigPath;
-	const resolvedEntryPointPath = resolveTailwindEntryPoint(options.entryPoint);
+	const resolvedEntryPointPath = resolveTailwindEntryPoint(options.entryPoint, cwd);
 	const isUsingEntryPoint = !!resolvedEntryPointPath;
 	const [pluginTailwindCSS, parserTs] = await Promise.all([interopDefault(import("eslint-plugin-better-tailwindcss")), interopDefault(import("@typescript-eslint/parser"))]);
 	return [{
@@ -2316,7 +2360,7 @@ async function tailwindcss(options = {}) {
 				...isTypeAware ? {
 					jsxPragma: null,
 					project: tsconfigPath,
-					tsconfigRootDir: process.cwd()
+					tsconfigRootDir: cwd
 				} : {}
 			}
 		},
@@ -2324,6 +2368,7 @@ async function tailwindcss(options = {}) {
 		plugins: { "tailwindcss": pluginTailwindCSS },
 		settings: { tailwindcss: {
 			...isUsingEntryPoint ? { entryPoint: resolvedEntryPointPath } : {},
+			...options.cwd ? { cwd } : {},
 			detectComponentClasses: options.detectComponentClasses ?? false,
 			...isTypeAware ? { tsconfig: resolvedTsconfigPath } : {}
 		} }
@@ -2368,15 +2413,15 @@ function findExistingFile(filePath) {
 * @param {string} relativePath - The relative path to the file to find.
 * @returns {string | undefined} The path to the existing file, or undefined if the file does not exist.
 */
-function findFileRecursiveFromCwd(relativePath) {
-	let resolvedPath = path.resolve(process.cwd(), relativePath);
+function findFileRecursiveFromCwd(relativePath, cwd) {
+	let resolvedPath = path.resolve(cwd, relativePath);
 	while (true) {
 		const foundFile = findExistingFile(resolvedPath);
 		if (foundFile) return foundFile;
 		const fileName = path.basename(resolvedPath);
 		const directory = path.dirname(resolvedPath);
 		const parentDirectory = path.resolve(directory, "..");
-		if (parentDirectory === directory || directory === process.cwd()) return;
+		if (parentDirectory === directory || directory === cwd) return;
 		resolvedPath = path.resolve(parentDirectory, fileName);
 	}
 }
@@ -2385,12 +2430,17 @@ function findFileRecursiveFromCwd(relativePath) {
 *
 * @returns {string | undefined} The path to the global CSS entry point, or undefined if no entry point is found.
 */
-function findGlobalCssEntryPoint() {
+function findGlobalCssEntryPoint(cwd) {
+	const explicitCandidates = [];
 	for (const candidate of defaultEntryPointCandidates) {
-		const found = findExistingFile(path.resolve(process.cwd(), candidate));
-		if (found) return found;
+		const found = findExistingFile(path.resolve(cwd, candidate));
+		if (found) explicitCandidates.push(found);
+	}
+	if (explicitCandidates.length) {
+		const resolvedEntryPoint = resolveBestEntryPointCandidate(explicitCandidates);
+		if (resolvedEntryPoint) return resolvedEntryPoint;
 	}
-	const queue = [process.cwd()];
+	const queue = [cwd];
 	const candidates = [];
 	while (queue.length) {
 		const currentPath = queue.shift();
@@ -2408,18 +2458,57 @@ function findGlobalCssEntryPoint() {
 				queue.push(nextPath);
 				continue;
 			}
-			if (entry.isFile() && (entry.name === "global.css" || entry.name === "globals.css")) candidates.push(nextPath);
+			if (entry.isFile() && entryPointCandidateFileNames.has(entry.name)) candidates.push(nextPath);
 		}
 	}
 	if (!candidates.length) {
-		console.warn(`[${PACKAGE_NAME}] No global CSS entry point found in "${process.cwd()}".`);
+		warnOnce(`[${PACKAGE_NAME}] No global CSS entry point found in "${cwd}".`);
 		return;
 	}
-	const resolvedEntryPoint = candidates.sort((a, b) => rankEntryPointPath(a) - rankEntryPointPath(b) || a.length - b.length || a.localeCompare(b))[0];
+	const resolvedEntryPoint = resolveBestEntryPointCandidate(candidates);
+	if (!resolvedEntryPoint) return;
 	console.log(`[${PACKAGE_NAME}] Resolved global CSS entryPoint: "${resolvedEntryPoint}".`);
 	return resolvedEntryPoint;
 }
 /**
+* Resolve the best entry point candidate from a list of file paths.
+*
+* @param {string[]} candidates - The entry point candidate paths.
+* @returns {string | undefined} The best entry point candidate, or undefined if no candidate exists.
+*/
+function resolveBestEntryPointCandidate(candidates) {
+	return candidates.sort(compareEntryPointPaths)[0];
+}
+/**
+* Compare two entry point paths.
+*
+* @param {string} a - The first entry point path.
+* @param {string} b - The second entry point path.
+* @returns {number} The comparison result.
+*/
+function compareEntryPointPaths(a, b) {
+	return Number(hasTailwindEntryPointDirective(b)) - Number(hasTailwindEntryPointDirective(a)) || rankEntryPointPath(a) - rankEntryPointPath(b) || a.length - b.length || a.localeCompare(b);
+}
+/**
+* Check whether a CSS file appears to be a Tailwind entry point.
+*
+* @param {string} filePath - The path to the CSS file.
+* @returns {boolean} Whether the CSS file contains Tailwind entry point directives.
+*/
+function hasTailwindEntryPointDirective(filePath) {
+	const cachedResult = tailwindEntryPointCache.get(filePath);
+	if (cachedResult !== void 0) return cachedResult;
+	try {
+		const fileContents = readFileSync(filePath, "utf8");
+		const hasTailwindDirective = tailwindEntryPointPattern.test(fileContents);
+		tailwindEntryPointCache.set(filePath, hasTailwindDirective);
+		return hasTailwindDirective;
+	} catch {
+		tailwindEntryPointCache.set(filePath, false);
+		return false;
+	}
+}
+/**
 * Rank the entry point path.
 *
 * @param {string} filePath - The path to the entry point.
@@ -2427,11 +2516,37 @@ function findGlobalCssEntryPoint() {
 */
 function rankEntryPointPath(filePath) {
 	const normalizedPath = filePath.split(path.sep).join("/");
-	if (normalizedPath.includes("/src/styles/")) return 0;
-	if (normalizedPath.includes("/src/")) return 1;
-	if (normalizedPath.includes("/app/")) return 2;
-	if (normalizedPath.endsWith("/global.css")) return 3;
-	if (normalizedPath.endsWith("/globals.css")) return 4;
+	if (normalizedPath.includes("/src/styles/")) return getEntryPointRank(0, normalizedPath);
+	if (normalizedPath.includes("/src/app/styles/")) return getEntryPointRank(1, normalizedPath);
+	if (normalizedPath.includes("/src/app/")) return getEntryPointRank(2, normalizedPath);
+	if (normalizedPath.includes("/app/styles/")) return getEntryPointRank(3, normalizedPath);
+	if (normalizedPath.includes("/app/")) return getEntryPointRank(4, normalizedPath);
+	if (normalizedPath.includes("/src/")) return getEntryPointRank(5, normalizedPath);
+	if (normalizedPath.includes("/styles/")) return getEntryPointRank(6, normalizedPath);
+	return getEntryPointRank(7, normalizedPath);
+}
+/**
+* Get the entry point rank from its directory and file name.
+*
+* @param {number} directoryRank - The rank of the entry point directory.
+* @param {string} normalizedPath - The normalized entry point path.
+* @returns {number} The entry point rank.
+*/
+function getEntryPointRank(directoryRank, normalizedPath) {
+	return directoryRank * 10 + getEntryPointFileNameRank(normalizedPath);
+}
+/**
+* Get the entry point file name rank.
+*
+* @param {string} normalizedPath - The normalized entry point path.
+* @returns {number} The entry point file name rank.
+*/
+function getEntryPointFileNameRank(normalizedPath) {
+	if (normalizedPath.endsWith("/global.css")) return 0;
+	if (normalizedPath.endsWith("/globals.css")) return 1;
+	if (normalizedPath.endsWith("/app.css")) return 2;
+	if (normalizedPath.endsWith("/index.css")) return 3;
+	if (normalizedPath.endsWith("/style.css")) return 4;
 	return 5;
 }
 /**
@@ -2440,16 +2555,35 @@ function rankEntryPointPath(filePath) {
 * @param {string} entryPoint - The entry point to resolve.
 * @returns {string | undefined} The path to the resolved entry point, or undefined if no entry point is found.
 */
-function resolveTailwindEntryPoint(entryPoint) {
+function resolveTailwindEntryPoint(entryPoint, cwd) {
 	if (entryPoint) {
-		const resolvedEntryPoint = findFileRecursiveFromCwd(entryPoint);
+		const resolvedEntryPoint = findFileRecursiveFromCwd(entryPoint, cwd);
 		if (resolvedEntryPoint) {
 			console.log(`[${PACKAGE_NAME}] Resolved Tailwind CSS entryPoint: "${resolvedEntryPoint}".`);
 			return resolvedEntryPoint;
 		}
-		console.warn(`[${PACKAGE_NAME}] Tailwind CSS entryPoint "${entryPoint}" was not found from "${process.cwd()}".`);
+		warnOnce(`[${PACKAGE_NAME}] Tailwind CSS entryPoint "${entryPoint}" was not found from "${cwd}".`);
 	}
-	return findGlobalCssEntryPoint();
+	return findGlobalCssEntryPoint(cwd);
+}
+/**
+* Resolve the Tailwind CSS working directory.
+*
+* @param {string} cwd - The configured working directory.
+* @returns {string} The resolved working directory.
+*/
+function resolveCwd(cwd) {
+	return cwd ? path.resolve(process.cwd(), cwd) : process.cwd();
+}
+/**
+* Warn only once per process for repeated Tailwind CSS resolution failures.
+*
+* @param {string} message - The warning message.
+*/
+function warnOnce(message) {
+	if (warnings.has(message)) return;
+	warnings.add(message);
+	console.warn(message);
 }
 //#endregion
 //#region src/configs/test.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infernodesign/eslint-config",
   "description": "ESLint config for Inferno Design.",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "type": "module",
   "author": "Inferno Design <support@infernodesign.com>",
   "license": "MIT",