tailwind-lint 0.12.1 → 0.13.1

package/README.md

@@ -60,7 +60,15 @@ tailwind-lint --verbose
 **Tailwind CSS v3:**
 
 - Finds JavaScript config files: `tailwind.config.js`, `tailwind.config.cjs`, `tailwind.config.mjs`, `tailwind.config.ts`
-- Uses file patterns from the `content` array in your config
+- Uses file patterns from the `content` array in your config, resolved from the package root (or from the config file with `content.relative: true`)
+
+**Monorepos:**
+
+- Workspace packages from `package.json` `workspaces` or `pnpm-workspace.yaml` are detected; without a workspace definition every directory with a `package.json` is treated as a package
+- Each package gets its own config detected; packages without one fall back to the closest parent config
+- Each file is linted with the config of the closest package that contains it, so apps with different themes or Tailwind versions (v3 and v4 side by side) are linted correctly
+- `tailwindcss` is resolved from the config's package first, falling back to the working directory
+- Use `--verbose` to see which config each package uses
 
 ### Options
 

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_linter = require("./linter-BP0uKBfa.cjs");
+const require_linter = require("./linter-B-Bi_uRJ.cjs");
 let node_path = require("node:path");
 node_path = require_linter.__toESM(node_path, 1);
 let ansis = require("ansis");
@@ -101,15 +101,13 @@ function createJsonErrorOutput({ error, cwd, configPath, autoDiscover, fix, patt
 //#region src/cli.ts
 const MAX_FILENAME_DISPLAY_LENGTH = 50;
 function resolveOptions(files, options) {
-	const hasConfigFlag = !!options.config;
 	const hasAutoFlag = !!options.auto;
 	const hasFiles = files.length > 0;
 	let cwd = process.cwd();
-	let configPath = options.config;
+	const configPath = options.config && node_path.resolve(options.config);
 	let patterns = files;
 	let autoDiscover = hasAutoFlag;
-	if (hasConfigFlag && options.config) configPath = node_path.isAbsolute(options.config) ? options.config : node_path.resolve(process.cwd(), options.config);
-	if (hasConfigFlag && options.config && !hasFiles) {
+	if (configPath && !hasFiles) {
 		const configDir = node_path.dirname(configPath);
 		cwd = require_linter.isCssConfigFile(configPath) ? require_linter.findProjectRoot(configDir) : configDir;
 		patterns = [];
@@ -158,11 +156,12 @@ async function displayResults(files, fixMode) {
 		}
 	}
 	console.log();
-	if (totalErrors === 0 && totalWarnings === 0) if (totalFixed > 0) {
-		const issueText = `${totalFixed} issue${totalFixed !== 1 ? "s" : ""}`;
-		console.log(ansis.default.green.bold(`✔ Fixed ${issueText}`));
-	} else console.log(ansis.default.green.bold("✔ No issues found"));
-	else {
+	if (totalErrors === 0 && totalWarnings === 0) {
+		if (totalFixed > 0) {
+			const issueText = `${totalFixed} issue${totalFixed !== 1 ? "s" : ""}`;
+			console.log(ansis.default.green.bold(`✔ Fixed ${issueText}`));
+		} else console.log(ansis.default.green.bold("✔ No issues found"));
+	} else {
 		const parts = [];
 		if (totalErrors > 0) parts.push(`${totalErrors} error${totalErrors !== 1 ? "s" : ""}`);
 		if (totalWarnings > 0) parts.push(`${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}`);

package/dist/cli.d.cts

@@ -1 +1 @@
-export { };
+export {}

package/dist/{linter-BP0uKBfa.cjs → linter-B-Bi_uRJ.cjs}

@@ -15,7 +15,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -30,8 +30,10 @@ let vscode_languageserver_textdocument = require("vscode-languageserver-textdocu
 let node_module = require("node:module");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs, 1);
+let node_url = require("node:url");
 let postcss = require("postcss");
 postcss = __toESM(postcss, 1);
+let node_fs_promises = require("node:fs/promises");
 //#region src/constants.ts
 const DEFAULT_IGNORE_PATTERNS = [
 	"**/node_modules/**",
@@ -90,7 +92,6 @@ const VITE_CONFIG_PATHS = [
 	"vite.config.mts",
 	"vite.config.cts"
 ];
-const SYNTHETIC_VITE_CSS_CONFIG_NAME = ".tailwind-lint.vite.css";
 const SYNTHETIC_VITE_CSS_CONFIG_CONTENT = "@import \"tailwindcss\";";
 const LANGUAGE_MAP = {
 	".astro": "astro",
@@ -134,7 +135,7 @@ async function getQuickfixes(state, document, uri, diagnostics) {
 		code: diag.code,
 		source: diag.source || "tailwindcss"
 	}));
-	return (await (0, _tailwindcss_language_service.doCodeActions)(state, {
+	const params = {
 		textDocument: { uri },
 		range: {
 			start: {
@@ -147,7 +148,8 @@ async function getQuickfixes(state, document, uri, diagnostics) {
 			}
 		},
 		context: { diagnostics: lspDiagnostics }
-	}, document)).filter((action) => action.kind === "quickfix" || action.kind?.startsWith(`quickfix.`));
+	};
+	return (await (0, _tailwindcss_language_service.doCodeActions)(state, params, document)).filter((action) => action.kind === "quickfix" || action.kind?.startsWith(`quickfix.`));
 }
 function applyFirstQuickfix(action, uri, document, content) {
 	if (!action.edit?.changes?.[uri]) return null;
@@ -257,7 +259,7 @@ function readVsCodeTailwindSettings(cwd) {
 	const files = readNestedObject(raw, "tailwindCSS.files");
 	const lint = readNestedObject(raw, "tailwindCSS.lint");
 	return {
-		includeLanguages: asRecord(raw["tailwindCSS.includeLanguages"]),
+		includeLanguages: asStringRecord(raw["tailwindCSS.includeLanguages"]),
 		classAttributes: asStringArray(raw["tailwindCSS.classAttributes"]),
 		classFunctions: asStringArray(raw["tailwindCSS.classFunctions"]),
 		experimental: {
@@ -275,7 +277,7 @@ function readZedTailwindSettings(cwd) {
 	const normalized = asRecord(serverSettings?.tailwindCSS) ?? serverSettings;
 	if (!normalized) return {};
 	return {
-		includeLanguages: asRecord(normalized.includeLanguages),
+		includeLanguages: asStringRecord(normalized.includeLanguages),
 		classAttributes: asStringArray(normalized.classAttributes),
 		classFunctions: asStringArray(normalized.classFunctions),
 		experimental: {
@@ -303,6 +305,11 @@ function readNestedObject(input, key) {
 function asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function asStringRecord(value) {
+	const record = asRecord(value);
+	if (!record) return;
+	return Object.fromEntries(Object.entries(record).filter((entry) => typeof entry[1] === "string"));
+}
 function asStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
@@ -440,6 +447,7 @@ function createEditorState(cwd) {
 				invalidApply: "error",
 				invalidScreen: "error",
 				invalidVariant: "error",
+				deprecatedAtRule: "warning",
 				invalidConfigPath: "error",
 				invalidTailwindDirective: "error",
 				invalidSourceDirective: "error",
@@ -456,6 +464,7 @@ function createEditorState(cwd) {
 		capabilities: {
 			configuration: true,
 			diagnosticRelatedInformation: true,
+			diagnosticTagSupport: false,
 			itemDefaults: []
 		},
 		getConfiguration: async () => settings,
@@ -487,50 +496,40 @@ var AdapterLoadError = class extends Error {
 //#endregion
 //#region src/adapters/v3-adapter.ts
 const require$4 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
-async function loadV3ClassMetadata(state, cwd, verbose = false) {
+function interopDefault(module) {
+	return module && typeof module === "object" && "default" in module ? module.default : module;
+}
+async function loadV3ClassMetadata(state, resolvePaths, verbose = false) {
 	try {
-		const tailwindPath = require$4.resolve("tailwindcss", { paths: [cwd] });
-		const tailwindcss = require$4(tailwindPath);
-		try {
-			const tailwindDir = node_path.dirname(require$4.resolve("tailwindcss/package.json", { paths: [cwd] }));
-			const contextUtils = require$4(node_path.join(tailwindDir, "lib", "lib", "setupContextUtils"));
-			const generateRulesModule = require$4(node_path.join(tailwindDir, "lib", "lib", "generateRules"));
-			state.modules = {
-				tailwindcss: {
-					version: state.version || "unknown",
-					module: tailwindcss
-				},
-				jit: {
-					generateRules: { module: generateRulesModule.generateRules || ((_set, _context) => []) },
-					createContext: { module: contextUtils.createContext },
-					expandApplyAtRules: { module: generateRulesModule.expandApplyAtRules }
-				}
-			};
-			if (verbose) console.log(ansis.default.dim("  ✓ Loaded v3 JIT modules"));
-		} catch (jitError) {
-			if (verbose) {
-				const message = jitError instanceof Error ? jitError.message : String(jitError);
-				console.log(ansis.default.yellow(`  ⚠ Warning: Could not load v3 JIT modules: ${message}`));
-			}
-			state.modules = { tailwindcss: {
+		const tailwindDir = node_path.dirname(require$4.resolve("tailwindcss/package.json", { paths: resolvePaths }));
+		const load = (id) => require$4(require$4.resolve(id, { paths: [tailwindDir] }));
+		const loadLib = (name) => require$4(node_path.join(tailwindDir, "lib", "lib", name));
+		const { createContext } = loadLib("setupContextUtils");
+		const { generateRules } = loadLib("generateRules");
+		state.jit = true;
+		state.modules = {
+			tailwindcss: {
 				version: state.version || "unknown",
-				module: tailwindcss
-			} };
-		}
-		extractConfigMetadata(state);
-		if (!state.classNames) state.classNames = {
-			context: {},
-			classNames: {}
-		};
-		if (state.modules?.jit?.createContext && state.config) try {
-			state.jitContext = state.modules.jit.createContext.module(state.config);
-			if (verbose) console.log(ansis.default.dim("  ✓ Created JIT context"));
-		} catch (contextError) {
-			if (verbose) {
-				const message = contextError instanceof Error ? contextError.message : String(contextError);
-				console.log(ansis.default.yellow(`  ⚠ Warning: Could not create JIT context: ${message}`));
+				module: load("tailwindcss")
+			},
+			postcss: {
+				version: load("postcss/package.json").version,
+				module: load("postcss")
+			},
+			postcssSelectorParser: { module: load("postcss-selector-parser") },
+			jit: {
+				generateRules: { module: generateRules },
+				createContext: { module: createContext },
+				expandApplyAtRules: { module: interopDefault(loadLib("expandApplyAtRules")) },
+				evaluateTailwindFunctions: { module: interopDefault(loadLib("evaluateTailwindFunctions")) }
 			}
-		}
+		};
+		extractConfigMetadata(state);
+		const jitContext = createContext(state.config);
+		state.jitContext = jitContext;
+		state.classList = jitContext.getClassList?.({ includeMetadata: true });
+		state.variants = jitContext.getVariants?.() ?? [];
+		if (verbose) console.log(ansis.default.dim("  ✓ Created v3 JIT context"));
 	} catch (error) {
 		if (error instanceof Error) throw new AdapterLoadError("v3", error);
 		throw new Error(`Failed to load v3 class metadata: ${String(error)}`);
@@ -542,37 +541,72 @@ function extractConfigMetadata(state) {
 	const theme = config.theme;
 	state.screens = Object.keys(theme?.screens ?? {});
 	state.blocklist = config.blocklist ?? [];
-	if (config.variants && typeof config.variants === "object") state.variants = Object.keys(config.variants).map((name) => ({
-		name,
-		values: [],
-		isArbitrary: false,
-		hasDash: true,
-		selectors: () => []
-	}));
 	if (config.corePlugins) state.corePlugins = Array.isArray(config.corePlugins) ? config.corePlugins : Object.keys(config.corePlugins);
 }
 //#endregion
 //#region src/adapters/v4-adapter.ts
 const require$3 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
-async function loadV4DesignSystem(state, cwd, configPath, verbose = false) {
+function resolveModule(id, paths) {
+	let firstError;
+	for (const dir of paths) try {
+		return (0, node_module.createRequire)(node_path.join(dir, "noop.js")).resolve(id);
+	} catch (error) {
+		firstError ??= error;
+	}
+	throw firstError ?? /* @__PURE__ */ new Error(`Cannot find module "${id}"`);
+}
+async function importModule(modulePath) {
+	let mod;
 	try {
-		const tailwindPath = require$3.resolve("tailwindcss", { paths: [cwd] });
+		mod = await import((0, node_url.pathToFileURL)(modulePath).href);
+	} catch {
+		mod = require$3(modulePath);
+	}
+	if (mod !== null && typeof mod === "object" && "default" in mod) return mod.default;
+	return mod;
+}
+function fromPostcss(nodes) {
+	return nodes.map((node) => {
+		switch (node.type) {
+			case "rule": return {
+				kind: "rule",
+				selector: node.selector,
+				nodes: fromPostcss(node.nodes)
+			};
+			case "atrule": return {
+				kind: "at-rule",
+				name: node.name,
+				params: node.params,
+				nodes: node.nodes ? fromPostcss(node.nodes) : null
+			};
+			case "decl": return {
+				kind: "declaration",
+				property: node.prop,
+				value: node.value,
+				important: node.important
+			};
+			default: return {
+				kind: "comment",
+				value: node.text
+			};
+		}
+	});
+}
+async function loadV4DesignSystem(state, resolvePaths, target, verbose = false) {
+	try {
+		const tailwindPath = require$3.resolve("tailwindcss", { paths: resolvePaths });
 		const tailwindcss = require$3(tailwindPath);
 		if (tailwindcss !== null && tailwindcss !== void 0 && (typeof tailwindcss === "object" || typeof tailwindcss === "function") && "__unstable__loadDesignSystem" in tailwindcss && typeof tailwindcss.__unstable__loadDesignSystem === "function") {
-			let cssContent;
-			const basePath = node_path.dirname(configPath);
-			if (fileExists(configPath)) cssContent = readFileSync(configPath);
-			else cssContent = SYNTHETIC_VITE_CSS_CONFIG_CONTENT;
+			const cssContent = target.kind === "vite" ? SYNTHETIC_VITE_CSS_CONFIG_CONTENT : readFileSync(target.path);
 			const loadDesignSystem = tailwindcss.__unstable__loadDesignSystem;
 			const designSystem = await loadDesignSystem(cssContent, {
-				base: basePath,
+				base: node_path.dirname(target.path),
 				async loadModule(id, base, _type) {
 					try {
-						const modulePath = require$3.resolve(id, { paths: [base, cwd] });
-						const module = require$3(modulePath);
+						const modulePath = resolveModule(id, [base, ...resolvePaths]);
 						return {
 							base: node_path.dirname(modulePath),
-							module
+							module: await importModule(modulePath)
 						};
 					} catch (error) {
 						throw new Error(`Failed to load module "${id}": ${error instanceof Error ? error.message : String(error)}`);
@@ -584,7 +618,7 @@ async function loadV4DesignSystem(state, cwd, configPath, verbose = false) {
 						content
 					};
 					if (!_id.startsWith(".") && !_id.startsWith("/")) try {
-						const pkgJsonPath = require$3.resolve(`${_id}/package.json`, { paths: [base, cwd] });
+						const pkgJsonPath = require$3.resolve(`${_id}/package.json`, { paths: [base, ...resolvePaths] });
 						const pkgDir = node_path.dirname(pkgJsonPath);
 						const cssPath = node_path.join(pkgDir, "index.css");
 						if (fileExists(cssPath)) return {
@@ -606,15 +640,16 @@ async function loadV4DesignSystem(state, cwd, configPath, verbose = false) {
 			Object.assign(designSystem, {
 				dependencies: () => /* @__PURE__ */ new Set(),
 				compile(classes) {
-					if (designSystem.candidatesToCss) return designSystem.candidatesToCss(classes).map((result) => {
-						if (typeof result === "string" && result.length > 0) try {
-							return postcss.default.parse(result);
+					if (designSystem.candidatesToAst) return designSystem.candidatesToAst(classes);
+					if (designSystem.candidatesToCss) return designSystem.candidatesToCss(classes).map((css) => {
+						if (!css) return [];
+						try {
+							return fromPostcss(postcss.default.parse(css).nodes);
 						} catch {
-							return postcss.default.root();
+							return [];
 						}
-						return postcss.default.root();
 					});
-					return classes.map(() => postcss.default.root());
+					return classes.map(() => []);
 				}
 			});
 			state.designSystem = designSystem;
@@ -632,6 +667,7 @@ async function loadV4DesignSystem(state, cwd, configPath, verbose = false) {
 const require$2 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
 const CONFIG_DISCOVERY_MAX_DEPTH = 8;
 const PROJECT_ROOT_MARKERS = ["package.json", ".git"];
+const VITE_CONFIG_NAME_REGEX = /^vite\.config\.[cm]?[jt]s$/;
 const isCssConfigFile = (filePath) => filePath.endsWith(".css");
 function findProjectRoot(startDir) {
 	let current = node_path.resolve(startDir);
@@ -642,9 +678,6 @@ function findProjectRoot(startDir) {
 		current = parent;
 	}
 }
-function syntheticViteCssConfigPath(viteConfigPath) {
-	return node_path.join(node_path.dirname(viteConfigPath), SYNTHETIC_VITE_CSS_CONFIG_NAME);
-}
 async function loadTailwindConfig(configPath) {
 	if (isCssConfigFile(configPath)) return {};
 	if (!node_path.isAbsolute(configPath)) throw new Error(`Config path must be absolute for security reasons: ${configPath}`);
@@ -661,66 +694,116 @@ async function loadTailwindConfig(configPath) {
 		throw new Error(`Failed to load config from ${configPath}: ${errorMessage}`);
 	}
 }
-async function findTailwindConfigPath(cwd, configPath) {
-	if (configPath) {
-		const resolved = node_path.isAbsolute(configPath) ? configPath : node_path.resolve(cwd, configPath);
-		return fileExists(resolved) ? resolved : null;
-	}
-	const v4Paths = V4_CSS_FOLDERS.flatMap((folder) => V4_CSS_NAMES.map((name) => node_path.join(folder, name)));
-	for (const p of v4Paths) {
-		const fullPath = node_path.join(cwd, p);
-		if (fileExists(fullPath)) try {
-			const content = readFileSync(fullPath);
-			if (TAILWIND_V4_IMPORT_REGEX.test(content)) return fullPath;
-		} catch {}
-	}
-	for (const p of V3_CONFIG_PATHS) {
-		const fullPath = node_path.join(cwd, p);
-		if (fileExists(fullPath)) return fullPath;
-	}
-	const cssCandidates = await (0, tinyglobby.glob)("**/*.css", {
-		cwd,
+function toConfigTarget(configPath) {
+	return {
+		kind: configKind(configPath),
+		path: configPath,
+		root: findProjectRoot(node_path.dirname(configPath))
+	};
+}
+function configKind(configPath) {
+	if (isCssConfigFile(configPath)) return "css";
+	return VITE_CONFIG_NAME_REGEX.test(node_path.basename(configPath)) ? "vite" : "js";
+}
+async function findTailwindConfigs(cwd) {
+	const root = node_path.resolve(cwd);
+	const files = await (0, tinyglobby.glob)([
+		"**/package.json",
+		"**/*.css",
+		...[...V3_CONFIG_PATHS, ...VITE_CONFIG_PATHS].map((p) => `**/${p}`)
+	], {
+		cwd: root,
 		absolute: true,
 		ignore: DEFAULT_IGNORE_PATTERNS,
 		deep: CONFIG_DISCOVERY_MAX_DEPTH
 	});
-	const v4Matches = [];
-	for (const candidate of cssCandidates) try {
-		const content = readFileSync(candidate);
-		if (TAILWIND_V4_IMPORT_REGEX.test(content)) v4Matches.push(candidate);
-	} catch {}
-	if (v4Matches.length > 0) return sortCssCandidates(cwd, v4Matches)[0];
-	const v3Recursive = await (0, tinyglobby.glob)(V3_CONFIG_PATHS.map((p) => `**/${p}`), {
-		cwd,
+	const isPackageJson = (file) => node_path.basename(file) === "package.json";
+	const packageRoots = await findPackageRoots(root, files.filter(isPackageJson).map(node_path.dirname));
+	const deepestFirst = [...packageRoots].sort((a, b) => b.length - a.length);
+	const candidatesByRoot = new Map(packageRoots.map((packageRoot) => [packageRoot, []]));
+	for (const file of files) {
+		if (isPackageJson(file)) continue;
+		const owner = deepestFirst.find((packageRoot) => isInsideDir(packageRoot, file));
+		if (owner) candidatesByRoot.get(owner)?.push(file);
+	}
+	return {
+		targets: (await Promise.all([...candidatesByRoot].map(([packageRoot, candidates]) => pickConfig(packageRoot, candidates)))).filter((target) => target !== void 0),
+		packageRoots
+	};
+}
+async function findPackageRoots(root, packageDirs) {
+	const workspaces = await readWorkspacePatterns(root);
+	if (!workspaces) return [.../* @__PURE__ */ new Set([root, ...packageDirs])];
+	const toPackageJson = (pattern) => `${pattern.replace(/\/+$/, "")}/package.json`;
+	const workspacePackageJsons = await (0, tinyglobby.glob)(workspaces.filter((p) => !p.startsWith("!")).map(toPackageJson), {
+		cwd: root,
 		absolute: true,
-		ignore: DEFAULT_IGNORE_PATTERNS,
-		deep: CONFIG_DISCOVERY_MAX_DEPTH
+		ignore: [...DEFAULT_IGNORE_PATTERNS, ...workspaces.filter((p) => p.startsWith("!")).map((p) => toPackageJson(p.slice(1)))]
 	});
-	if (v3Recursive.length > 0) return sortByPathDepth(v3Recursive)[0];
-	const viteConfigPath = await findTailwindViteConfigPath(cwd);
-	if (viteConfigPath) return syntheticViteCssConfigPath(viteConfigPath);
-	return null;
-}
-async function findTailwindViteConfigPath(cwd) {
-	for (const p of VITE_CONFIG_PATHS) {
-		const fullPath = node_path.join(cwd, p);
-		if (isTailwindViteConfig(fullPath)) return fullPath;
+	return [.../* @__PURE__ */ new Set([root, ...workspacePackageJsons.map(node_path.dirname)])];
+}
+async function readWorkspacePatterns(root) {
+	const [packageJson, pnpmWorkspace] = await Promise.all([readText(node_path.join(root, "package.json")), readText(node_path.join(root, "pnpm-workspace.yaml"))]);
+	const patterns = [...parsePackageJsonWorkspaces(packageJson), ...parsePnpmWorkspacePackages(pnpmWorkspace)];
+	return patterns.length > 0 ? patterns : void 0;
+}
+function parsePackageJsonWorkspaces(content) {
+	try {
+		const { workspaces } = JSON.parse(content);
+		return ((Array.isArray(workspaces) ? workspaces : workspaces?.packages) ?? []).filter((p) => typeof p === "string");
+	} catch {
+		return [];
 	}
-	const matches = (await (0, tinyglobby.glob)(VITE_CONFIG_PATHS.map((p) => `**/${p}`), {
-		cwd,
-		absolute: true,
-		ignore: DEFAULT_IGNORE_PATTERNS,
-		deep: CONFIG_DISCOVERY_MAX_DEPTH
-	})).filter(isTailwindViteConfig);
-	if (matches.length === 0) return null;
-	return sortByPathDepth(matches)[0];
 }
-function isTailwindViteConfig(filePath) {
-	if (!fileExists(filePath)) return false;
+function parsePnpmWorkspacePackages(content) {
+	const patterns = [];
+	let inPackages = false;
+	for (const line of content.split(/\r?\n/)) if (/^packages\s*:/.test(line)) inPackages = true;
+	else if (/^[^\s#]/.test(line)) inPackages = false;
+	else if (inPackages) {
+		const item = line.match(/^\s*-\s*["']?([^"'#\s]+)["']?/);
+		if (item) patterns.push(item[1]);
+	}
+	return patterns;
+}
+function nestedRootIgnores(root, roots) {
+	return roots.filter((other) => other !== root && isInsideDir(root, other)).map((other) => `${node_path.relative(root, other)}/**`);
+}
+function isInsideDir(dir, filePath) {
+	const relative = node_path.relative(dir, filePath);
+	return !relative.startsWith("..") && !node_path.isAbsolute(relative);
+}
+async function pickConfig(root, candidates) {
+	const target = (kind, configPath) => ({
+		kind,
+		path: configPath,
+		root
+	});
+	const candidateSet = new Set(candidates);
+	const existing = (paths) => paths.map((p) => node_path.join(root, p)).filter((p) => candidateSet.has(p));
+	const byName = (names) => candidates.filter((c) => names.includes(node_path.basename(c)));
+	const preferredCss = existing(V4_CSS_FOLDERS.flatMap((folder) => V4_CSS_NAMES.map((name) => node_path.join(folder, name))));
+	const preferredCssMatch = await findFirstMatch(preferredCss, TAILWIND_V4_IMPORT_REGEX);
+	if (preferredCssMatch) return target("css", preferredCssMatch);
+	const rootV3 = existing(V3_CONFIG_PATHS)[0];
+	if (rootV3) return target("js", rootV3);
+	const cssMatch = await findFirstMatch(sortCssCandidates(root, candidates.filter((c) => isCssConfigFile(c) && !preferredCss.includes(c))), TAILWIND_V4_IMPORT_REGEX);
+	if (cssMatch) return target("css", cssMatch);
+	const nestedV3 = sortByPathDepth(byName(V3_CONFIG_PATHS))[0];
+	if (nestedV3) return target("js", nestedV3);
+	const viteConfigs = [...existing(VITE_CONFIG_PATHS), ...sortByPathDepth(byName(VITE_CONFIG_PATHS))];
+	const viteMatch = await findFirstMatch([...new Set(viteConfigs)], TAILWIND_VITE_PLUGIN_REGEX);
+	if (viteMatch) return target("vite", viteMatch);
+}
+async function findFirstMatch(paths, regex) {
+	const contents = await Promise.all(paths.map(readText));
+	return paths.find((_, index) => regex.test(contents[index]));
+}
+async function readText(filePath) {
 	try {
-		return TAILWIND_VITE_PLUGIN_REGEX.test(readFileSync(filePath));
+		return await (0, node_fs_promises.readFile)(filePath, "utf-8");
 	} catch {
-		return false;
+		return "";
 	}
 }
 function sortByPathDepth(paths) {
@@ -758,9 +841,9 @@ function splitDepth(value) {
 //#endregion
 //#region src/state.ts
 const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
-function getTailwindVersion(cwd) {
+function getTailwindVersion(paths) {
 	try {
-		const tailwindPackageJson = require$1.resolve("tailwindcss/package.json", { paths: [cwd] });
+		const tailwindPackageJson = require$1.resolve("tailwindcss/package.json", { paths });
 		const { readFileSync } = require$1("node:fs");
 		return JSON.parse(readFileSync(tailwindPackageJson, "utf-8")).version;
 	} catch {
@@ -770,41 +853,52 @@ function getTailwindVersion(cwd) {
 function isV4Config(version) {
 	return version?.startsWith("4.") ?? false;
 }
-function resolveTailwindPath(cwd, configDir) {
-	const paths = configDir ? [configDir, cwd] : [cwd];
+function resolveTailwindPath(paths) {
 	try {
 		return require$1.resolve("tailwindcss", { paths });
 	} catch {
 		throw new Error(`Could not find tailwindcss module in ${paths.join(" or ")}.\nInstall it with: npm install -D tailwindcss`);
 	}
 }
-async function createState(cwd, configPath, verbose = false) {
-	const resolvedConfigPath = await findTailwindConfigPath(cwd, configPath);
-	if (!resolvedConfigPath) throw new Error("Could not find Tailwind config file. Expected one of:\n  • Tailwind v4 (CSS): app.css, index.css, tailwind.css in project root or src/\n  • Tailwind v4 (Vite): vite.config.* with @tailwindcss/vite\n  • Tailwind v3 (JS): tailwind.config.js, tailwind.config.ts\nRun 'npx tailwindcss init' to create a config file.");
-	const isCssConfig = isCssConfigFile(resolvedConfigPath);
-	const tailwindPath = resolveTailwindPath(cwd, node_path.dirname(resolvedConfigPath));
-	const tailwindcss = require$1(tailwindPath);
-	const version = getTailwindVersion(cwd);
+function loadResolveConfig(paths) {
+	try {
+		const module = require$1(require$1.resolve("tailwindcss/resolveConfig", { paths }));
+		return typeof module === "function" ? module : module.default;
+	} catch {
+		return;
+	}
+}
+const CONFIG_TYPE_LABELS = {
+	css: "CSS (v4)",
+	vite: "Vite (v4)",
+	js: "JavaScript"
+};
+async function createState(cwd, target, verbose = false) {
+	const isCssConfig = target.kind !== "js";
+	const resolvePaths = [node_path.dirname(target.path), cwd];
+	resolveTailwindPath(resolvePaths);
+	const version = getTailwindVersion(resolvePaths);
 	const isV4 = isV4Config(version);
 	if (verbose) {
 		console.log(ansis.default.cyan.bold("→ Tailwind Configuration"));
 		console.log(ansis.default.dim(`  Version: ${version || "unknown"}`));
-		console.log(ansis.default.dim(`  Config type: ${isCssConfig ? "CSS (v4)" : "JavaScript"}`));
-		console.log(ansis.default.dim(`  Config path: ${resolvedConfigPath}`));
+		console.log(ansis.default.dim(`  Config type: ${CONFIG_TYPE_LABELS[target.kind]}`));
+		console.log(ansis.default.dim(`  Config path: ${target.path}`));
 	}
 	let config = {};
 	let resolvedConfig = { separator: ":" };
 	if (!isCssConfig) {
-		config = await loadTailwindConfig(resolvedConfigPath);
+		config = await loadTailwindConfig(target.path);
 		resolvedConfig = {
 			...config,
 			separator: config.separator ?? ":"
 		};
-		if (tailwindcss.resolveConfig) resolvedConfig = tailwindcss.resolveConfig(config);
+		const resolveConfig = loadResolveConfig(resolvePaths);
+		if (resolveConfig) resolvedConfig = resolveConfig(config);
 	}
 	const state = {
 		enabled: true,
-		configPath: resolvedConfigPath,
+		configPath: target.path,
 		config: resolvedConfig,
 		version,
 		v4: isV4 || void 0,
@@ -818,14 +912,15 @@ async function createState(cwd, configPath, verbose = false) {
 		editor: createEditorState(cwd),
 		features: ["diagnostics"]
 	};
-	if (isV4 || isCssConfig) await loadV4DesignSystem(state, cwd, resolvedConfigPath, verbose);
-	else await loadV3ClassMetadata(state, cwd, verbose);
+	if (isV4 || isCssConfig) await loadV4DesignSystem(state, resolvePaths, target, verbose);
+	else await loadV3ClassMetadata(state, resolvePaths, verbose);
 	return state;
 }
 //#endregion
 //#region src/linter.ts
 const SOURCE_FILE_PATTERN = "**/*.{js,jsx,ts,tsx,html,vue,svelte,astro,mdx}";
 const GLOB_PATTERN_REGEX = /[*?[\]{}]/;
+const MAX_LISTED_PACKAGES = 10;
 async function validateDocument(state, filePath, content) {
 	try {
 		if (!state) throw new Error("State is not initialized");
@@ -833,7 +928,8 @@ async function validateDocument(state, filePath, content) {
 		if (!state.v4 && !state.modules?.tailwindcss) throw new Error("Tailwind modules not initialized for Tailwind v3. This might indicate a configuration issue.");
 		const languageId = getLanguageId(filePath);
 		const uri = `file://${filePath}`;
-		return await (0, _tailwindcss_language_service.doValidate)(state, vscode_languageserver_textdocument.TextDocument.create(uri, languageId, 1, content));
+		const document = vscode_languageserver_textdocument.TextDocument.create(uri, languageId, 1, content);
+		return await (0, _tailwindcss_language_service.doValidate)(state, document);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		if (message.includes("Cannot read") || message.includes("undefined")) {
@@ -844,52 +940,43 @@ async function validateDocument(state, filePath, content) {
 		throw new Error(`Failed to validate document ${filePath}: ${message}`);
 	}
 }
-async function discoverFiles(cwd, patterns, configPath, autoDiscover) {
-	if (autoDiscover) return discoverFilesFromConfig(cwd, configPath);
-	return expandPatterns(cwd, patterns);
-}
 async function expandPatterns(cwd, patterns, extraIgnore = []) {
-	const files = await (0, tinyglobby.glob)(patterns, {
+	return (0, tinyglobby.glob)(patterns, {
 		cwd,
-		absolute: false,
+		absolute: true,
 		ignore: [...DEFAULT_IGNORE_PATTERNS, ...extraIgnore]
 	});
-	return [...new Set(files)].sort((a, b) => a.localeCompare(b));
-}
-async function discoverFilesFromConfig(cwd, configPath) {
-	const configFilePath = await findTailwindConfigPath(cwd, configPath);
-	if (!configFilePath) throw new Error("Could not find Tailwind config for auto-discovery.\nUse --config to specify the path, or provide file patterns directly.");
-	const discoveryCwd = isCssConfigFile(configFilePath) ? findProjectRoot(node_path.dirname(configFilePath)) : cwd;
-	if (!isCssConfigFile(configFilePath)) {
-		const config = await loadTailwindConfig(configFilePath);
+}
+async function discoverFilesFromConfig(target, configRoots) {
+	if (target.kind === "js") {
+		const config = await loadTailwindConfig(target.path);
 		if (!config || !config.content) throw new Error("Tailwind config is missing the 'content' property.\nAdd a content array to specify which files to scan:\n  content: ['./src/**/*.{js,jsx,ts,tsx}']");
 		const patterns = extractContentPatterns(config);
 		if (patterns.length === 0) throw new Error("No content patterns found in Tailwind config.\nEnsure your config has a content array with file patterns.");
-		return expandPatterns(discoveryCwd, patterns);
+		return expandPatterns(!Array.isArray(config.content) && config.content.relative === true ? node_path.dirname(target.path) : target.root, patterns);
 	}
-	const configDir = node_path.dirname(configFilePath);
-	const cssContent = fileExists(configFilePath) ? readFileSync(configFilePath) : SYNTHETIC_VITE_CSS_CONFIG_CONTENT;
-	const includeConfigFile = (files) => {
-		if (!fileExists(configFilePath)) return files;
-		const relativeConfigPath = node_path.relative(discoveryCwd, configFilePath);
-		return [.../* @__PURE__ */ new Set([relativeConfigPath, ...files])].sort((a, b) => a.localeCompare(b));
-	};
-	const resolveDiscoveredFiles = (files) => discoveryCwd === cwd ? files : files.map((file) => node_path.resolve(discoveryCwd, file)).sort((a, b) => a.localeCompare(b));
+	const { root } = target;
+	const configDir = node_path.dirname(target.path);
+	const cssContent = target.kind === "vite" ? SYNTHETIC_VITE_CSS_CONFIG_CONTENT : readFileSync(target.path);
 	const { include, exclude } = extractSourcePatterns(cssContent);
 	const importSource = extractImportSourceDirectives(cssContent);
-	const resolveFromConfig = (pattern) => {
-		const absolutePattern = node_path.resolve(configDir, pattern);
-		return node_path.relative(discoveryCwd, absolutePattern);
-	};
+	const resolveFromConfig = (pattern) => node_path.relative(root, node_path.resolve(configDir, pattern));
 	const resolvedExclude = exclude.map(resolveFromConfig);
-	const gitignorePatterns = readGitignorePatterns(discoveryCwd);
-	const extraIgnore = [...resolvedExclude, ...gitignorePatterns];
+	const extraIgnore = [
+		...resolvedExclude,
+		...readGitignorePatterns(root),
+		...nestedRootIgnores(root, configRoots)
+	];
 	const explicitSourcePatterns = include.map((source) => resolveFromConfig(normalizeSourcePattern(source)));
 	let autoPatterns = [];
-	if (!importSource.disableAutoSource) autoPatterns = importSource.roots.length > 0 ? importSource.roots.map((root) => resolveFromConfig(normalizeSourcePattern(root))) : [DEFAULT_FILE_PATTERN];
-	const autoFiles = autoPatterns.length > 0 ? await expandPatterns(discoveryCwd, autoPatterns, extraIgnore) : [];
-	const explicitFiles = explicitSourcePatterns.length > 0 ? await expandPatterns(discoveryCwd, explicitSourcePatterns, resolvedExclude) : [];
-	return resolveDiscoveredFiles(includeConfigFile([.../* @__PURE__ */ new Set([...autoFiles, ...explicitFiles])].sort((a, b) => a.localeCompare(b))));
+	if (!importSource.disableAutoSource) autoPatterns = importSource.roots.length > 0 ? importSource.roots.map((sourceRoot) => resolveFromConfig(normalizeSourcePattern(sourceRoot))) : [DEFAULT_FILE_PATTERN];
+	const [autoFiles, explicitFiles] = await Promise.all([autoPatterns.length > 0 ? expandPatterns(root, autoPatterns, extraIgnore) : [], explicitSourcePatterns.length > 0 ? expandPatterns(root, explicitSourcePatterns, resolvedExclude) : []]);
+	const configFile = target.kind === "css" ? [target.path] : [];
+	return [.../* @__PURE__ */ new Set([
+		...configFile,
+		...autoFiles,
+		...explicitFiles
+	])];
 }
 function normalizeSourcePattern(pattern) {
 	if (GLOB_PATTERN_REGEX.test(pattern) || node_path.extname(pattern)) return pattern;
@@ -965,9 +1052,9 @@ async function processFile(state, cwd, filePath, fix) {
 		fixedCount
 	};
 }
-async function initializeState(cwd, configPath, verbose = false) {
+async function initializeState(cwd, target, verbose = false) {
 	try {
-		const state = await createState(cwd, configPath, verbose);
+		const state = await createState(cwd, target, verbose);
 		if (verbose) console.log();
 		return state;
 	} catch (error) {
@@ -976,42 +1063,80 @@ async function initializeState(cwd, configPath, verbose = false) {
 	}
 }
 async function lint({ cwd, patterns, configPath, autoDiscover, fix = false, verbose = false, onProgress }) {
-	const state = await initializeState(cwd, configPath, verbose);
-	const discoveredFiles = await discoverFiles(cwd, patterns, configPath, autoDiscover);
-	const files = uniqueFilesByResolvedPath(cwd, state.configPath && isCssConfigFile(state.configPath) && fileExists(state.configPath) ? [node_path.relative(cwd, state.configPath), ...discoveredFiles] : discoveredFiles);
+	const targets = await resolveConfigTargets(cwd, configPath);
+	if (verbose) logTargets(cwd, targets);
+	const configRoots = targets.map((target) => target.root);
+	const patternFiles = autoDiscover ? [] : await expandPatterns(cwd, patterns);
+	const discoveredFilesByTarget = await Promise.all(targets.map((target) => autoDiscover ? discoverFilesFromConfig(target, configRoots) : patternFiles));
+	const owners = /* @__PURE__ */ new Map();
+	for (const [index, target] of targets.entries()) {
+		const files = target.kind === "css" && !autoDiscover ? [target.path, ...discoveredFilesByTarget[index]] : discoveredFilesByTarget[index];
+		for (const file of files) {
+			const current = owners.get(file);
+			if (!current || ownershipScore(target, file) > ownershipScore(current, file)) owners.set(file, target);
+		}
+	}
 	const skippedFiles = [];
-	const lintableFiles = files.filter((file) => {
-		if (getFileSize(node_path.isAbsolute(file) ? file : node_path.resolve(cwd, file)) > 524288) {
+	const filesByTarget = /* @__PURE__ */ new Map();
+	for (const [absolutePath, target] of owners) {
+		const file = node_path.relative(cwd, absolutePath);
+		if (getFileSize(absolutePath) > 524288) {
 			skippedFiles.push(file);
-			return false;
+			continue;
 		}
-		return true;
-	});
+		const files = filesByTarget.get(target) ?? [];
+		files.push(file);
+		filesByTarget.set(target, files);
+	}
+	const totalFiles = owners.size - skippedFiles.length;
 	if (verbose) {
-		console.log(ansis.default.cyan.bold(`→ Discovered ${lintableFiles.length} file${lintableFiles.length !== 1 ? "s" : ""} to lint`));
+		console.log(ansis.default.cyan.bold(`→ Discovered ${totalFiles} file${totalFiles !== 1 ? "s" : ""} to lint`));
 		console.log();
 	}
-	if (lintableFiles.length === 0) return {
-		files: [],
-		totalFilesProcessed: 0,
-		skippedFiles
-	};
+	const results = [];
+	let processedCount = 0;
+	for (const target of targets) {
+		const files = filesByTarget.get(target);
+		if (!files) continue;
+		const offset = processedCount;
+		processedCount += files.length;
+		const processed = await processFiles(await initializeState(cwd, target, verbose), cwd, files.sort((a, b) => a.localeCompare(b)), fix, onProgress && ((current, _total, file) => onProgress(offset + current, totalFiles, file)));
+		results.push(...processed);
+	}
 	return {
-		files: (await processFiles(state, cwd, lintableFiles, fix, onProgress)).filter((result) => result.diagnostics.length > 0 || result.fixed),
-		totalFilesProcessed: lintableFiles.length,
-		skippedFiles
+		files: results.filter((result) => result.diagnostics.length > 0 || result.fixed).sort((a, b) => a.path.localeCompare(b.path)),
+		totalFilesProcessed: totalFiles,
+		skippedFiles: skippedFiles.sort((a, b) => a.localeCompare(b))
 	};
 }
-function uniqueFilesByResolvedPath(cwd, files) {
-	const seen = /* @__PURE__ */ new Set();
-	const unique = [];
-	for (const file of files) {
-		const absolutePath = node_path.isAbsolute(file) ? file : node_path.resolve(cwd, file);
-		if (seen.has(absolutePath)) continue;
-		seen.add(absolutePath);
-		unique.push(file);
+async function resolveConfigTargets(cwd, configPath) {
+	if (configPath) {
+		const absolutePath = node_path.resolve(cwd, configPath);
+		if (!fileExists(absolutePath)) throw new Error(`Tailwind config file not found: ${absolutePath}`);
+		return [toConfigTarget(absolutePath)];
 	}
-	return unique.sort((a, b) => a.localeCompare(b));
+	const { targets, packageRoots } = await findTailwindConfigs(cwd);
+	if (targets.length === 0) throw new Error(noConfigMessage(cwd, packageRoots));
+	return targets;
+}
+function noConfigMessage(cwd, packageRoots) {
+	const packages = packageRoots.map((root) => node_path.relative(cwd, root)).filter(Boolean).sort((a, b) => a.localeCompare(b));
+	const shown = packages.slice(0, MAX_LISTED_PACKAGES);
+	const more = packages.length - shown.length;
+	return `Could not find a Tailwind config in ${cwd}${packages.length > 0 ? ` or its packages:\n${shown.map((p) => `  • ${p}`).join("\n")}${more > 0 ? `\n  …and ${more} more` : ""}` : ""}\nExpected one of:
+  • Tailwind v4 (CSS): a CSS file with @import "tailwindcss", e.g. app.css or src/index.css
+  • Tailwind v4 (Vite): vite.config.* with @tailwindcss/vite
+  • Tailwind v3 (JS): tailwind.config.js, tailwind.config.ts
+Use --config to specify the path.`;
+}
+function logTargets(cwd, targets) {
+	const display = (p) => node_path.relative(cwd, p) || ".";
+	console.log(ansis.default.cyan.bold("→ Tailwind configs"));
+	for (const target of targets) console.log(ansis.default.dim(`  ${display(target.root)} → ${display(target.path)}`));
+	console.log();
+}
+function ownershipScore(target, absolutePath) {
+	return isInsideDir(target.root, absolutePath) ? target.root.length : -1;
 }
 //#endregion
 Object.defineProperty(exports, "DEFAULT_FILE_PATTERN", {

package/dist/linter.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_linter = require("./linter-BP0uKBfa.cjs");
+const require_linter = require("./linter-B-Bi_uRJ.cjs");
 exports.extractImportSourceDirectives = require_linter.extractImportSourceDirectives;
 exports.extractSourcePatterns = require_linter.extractSourcePatterns;
 exports.lint = require_linter.lint;

package/dist/linter.d.cts

@@ -383,6 +383,6 @@ declare function extractImportSourceDirectives(cssContent: string): {
   roots: string[];
   disableAutoSource: boolean;
 };
-declare function lint({ cwd, patterns, configPath, autoDiscover, fix, verbose, onProgress }: LintOptions): Promise<LintResult>;
+export declare function lint({ cwd, patterns, configPath, autoDiscover, fix, verbose, onProgress }: LintOptions): Promise<LintResult>;
 //#endregion
-export { type LintFileResult, type LintOptions, type LintResult, extractImportSourceDirectives, extractSourcePatterns, lint };
+export { type LintFileResult, type LintOptions, type LintResult, extractImportSourceDirectives, extractSourcePatterns };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "tailwind-lint",
-	"version": "0.12.1",
+	"version": "0.13.1",
 	"description": "A command-line tool that uses the Tailwind CSS IntelliSense plugin to show linting suggestions for your Tailwind CSS classes",
 	"keywords": [
 		"cli",
@@ -58,24 +58,25 @@
 		"test:watch": "vitest"
 	},
 	"dependencies": {
-		"@tailwindcss/language-service": "^0.14.29",
-		"ansis": "^4.3.1",
+		"@tailwindcss/language-service": "^0.16.0",
+		"ansis": "^4.4.0",
 		"commander": "^15.0.0",
-		"postcss": "^8.5.19",
+		"postcss": "^8.5.28",
 		"tinyglobby": "^0.2.17",
-		"vscode-languageserver-textdocument": "^1.0.12"
+		"vscode-languageserver-textdocument": "^1.0.15"
 	},
 	"devDependencies": {
-		"@types/node": "^26.1.1",
-		"oxfmt": "^0.58.0",
-		"oxlint": "^1.73.0",
-		"tsdown": "^0.22.7",
+		"@types/node": "^26.6.4",
+		"oxfmt": "^0.71.0",
+		"oxlint": "^1.86.0",
+		"tsdown": "^0.23.0",
 		"typescript": "^7.0.2",
-		"vitest": "^4.1.10"
+		"vitest": "^5.0.3",
+		"vscode-languageserver": "8.1.0"
 	},
 	"engines": {
 		"node": ">=22.0.0",
 		"pnpm": ">=10.0.0"
 	},
-	"packageManager": "pnpm@11.13.0"
+	"packageManager": "pnpm@12.8.1"
 }