tailwind-canonical 0.7.1 → 0.9.0

package/dist/eslint/plugin.js

@@ -1,4 +1,6 @@
 import { createRequire } from 'node:module';
+import { validateConfig } from '../core/config.js';
+import { mergeClasses } from '../core/merger.js';
 import { suggestCanonical, } from '../core/rules.js';
 const _require = createRequire(import.meta.url);
 /**
@@ -13,31 +15,97 @@ function quasiTextRange(quasi) {
     const start = quasi.range[0] + 1;
     return [start, start + quasi.value.raw.length];
 }
-/**
- * Builds the shared ESLint visitor that runs `checkLiteral` on every string
- * `Literal` and on each quasi of a `TemplateLiteral`. Both rules walk class
- * strings identically, so the traversal lives here once. Quasi nodes carry the
- * real `range`/`loc` so `context.report` and the fixer operate on actual source
- * positions instead of a detached synthetic node.
- */
-function makeStringRuleVisitor(checkLiteral) {
+/** Only inspect strings whose syntax establishes that they contain classes. */
+function isClassContext(node, config) {
+    const attributes = config.attributeNames?.length
+        ? config.attributeNames
+        : ['className'];
+    const functions = config.functionNames ?? ['cn', 'clsx', 'cva'];
+    const properties = [];
+    let current = node;
+    while (current.parent) {
+        const parent = current.parent;
+        if (parent.type === 'JSXAttribute') {
+            const name = parent.name;
+            return (properties.length === 0 &&
+                typeof name === 'object' &&
+                attributes.includes(name.name ?? ''));
+        }
+        if (parent.type === 'CallExpression') {
+            if (parent.callee?.type !== 'Identifier')
+                return false;
+            const name = String(parent.callee.name);
+            if (!functions.includes(name))
+                return false;
+            if (properties.length === 0)
+                return true;
+            if (name === 'cva') {
+                if (properties.some((property) => property.isKey))
+                    return false;
+                return ((properties.length === 3 && properties[2].key === 'variants') ||
+                    (properties.length === 2 &&
+                        properties[1].key === 'compoundVariants' &&
+                        ['class', 'className'].includes(properties[0].key)));
+            }
+            // clsx-style object arguments emit their keys; values are predicates.
+            return properties.every((property) => property.isKey);
+        }
+        if (parent.type === 'Property') {
+            properties.push({
+                key: String(parent.key?.name ?? parent.key?.value ?? ''),
+                isKey: current === parent.key,
+            });
+        }
+        if (parent.type === 'LogicalExpression' &&
+            parent.operator === '&&' &&
+            current === parent.left)
+            return false;
+        if (parent.type === 'ConditionalExpression' &&
+            current !== parent.consequent &&
+            current !== parent.alternate)
+            return false;
+        if (![
+            'JSXExpressionContainer',
+            'ArrayExpression',
+            'ObjectExpression',
+            'Property',
+            'ConditionalExpression',
+            'LogicalExpression',
+        ].includes(parent.type))
+            return false;
+        current = parent;
+    }
+    return false;
+}
+function makeStringRuleVisitor(checkLiteral, config = {}) {
     return {
-        Literal: (node) => checkLiteral(node),
+        Literal: (node) => {
+            if (isClassContext(node, config)) {
+                checkLiteral(node);
+            }
+        },
         TemplateLiteral(node) {
-            const isTagged = node.parent
-                ?.type === 'TaggedTemplateExpression';
-            for (const quasi of node.quasis) {
-                const value = isTagged
-                    ? quasi.value.raw
-                    : (quasi.value.cooked ?? quasi.value.raw);
+            if (!isClassContext(node, config))
+                return;
+            for (const [index, quasi] of node.quasis.entries()) {
+                const value = quasi.value.cooked ?? quasi.value.raw;
+                // A token touching an interpolation is incomplete: e.g.
+                // `text-[12px]${suffix}` must not become `text-xs${suffix}`.
+                const start = value.match(index > 0 ? /^\S*\s*/ : /^\s*/)?.[0].length ?? 0;
+                const trailing = value.match(index < node.quasis.length - 1 ? /\s*\S*$/ : /\s*$/)?.[0]
+                    .length ?? 0;
+                const end = Math.max(start, value.length - trailing);
+                const inner = value.slice(start, end);
                 checkLiteral({
                     type: 'Literal',
-                    value,
+                    value: inner,
                     raw: quasi.value.raw,
                     range: quasi.range,
                     loc: quasi.loc,
                     quasiRange: quasiTextRange(quasi),
-                    valueIsRaw: isTagged || quasi.value.cooked === null,
+                    valueIsRaw: quasi.value.cooked === null,
+                    templatePrefix: value.slice(0, start),
+                    templateSuffix: value.slice(end),
                 });
             }
         },
@@ -70,7 +138,8 @@ function escapeTemplateText(value) {
 }
 function replacementText(node, value) {
     if (node.quasiRange) {
-        return node.valueIsRaw ? value : escapeTemplateText(value);
+        const full = (node.templatePrefix ?? '') + value + (node.templateSuffix ?? '');
+        return node.valueIsRaw ? full : escapeTemplateText(full);
     }
     return quoteReplacement(node, value);
 }
@@ -88,8 +157,8 @@ const noArbitraryCanonical = {
         // config object can be passed as rule options without schema errors (#42).
         // Honored by this rule (via suggestCanonical): customTextTokens,
         // customSpacingTokens, ignorePatterns, tailwindVersion.
-        // Accepted but ignored here (CLI-only): functionNames, attributeNames,
-        // sortOrder.
+        // functionNames and attributeNames restrict class string detection.
+        // Other CLI-only keys are accepted for shared config objects.
         schema: [
             {
                 type: 'object',
@@ -98,9 +167,18 @@ const noArbitraryCanonical = {
                     customSpacingTokens: { type: 'object' },
                     ignorePatterns: { type: 'array' },
                     tailwindVersion: { enum: [3, 4] },
+                    useDefaultTheme: { type: 'boolean' },
                     functionNames: { type: 'array', items: { type: 'string' } },
                     attributeNames: { type: 'array', items: { type: 'string' } },
                     sortOrder: { type: 'array', items: { type: 'string' } },
+                    extraColorFamilies: { type: 'object' },
+                    extraScaleProperties: { type: 'array', items: { type: 'string' } },
+                    extraColors: { type: 'array', items: { type: 'string' } },
+                    analyze: { type: 'object' },
+                    minRareScalePropertyOccurrences: { type: 'number' },
+                    rareScaleMaxFiles: { type: 'number' },
+                    rareScaleMaxCount: { type: 'number' },
+                    defaultCommand: { type: 'object' },
                 },
                 additionalProperties: false,
             },
@@ -110,7 +188,7 @@ const noArbitraryCanonical = {
         },
     },
     create(context) {
-        const config = context.options[0] ?? {};
+        const config = validateConfig(context.options[0], 'ESLint rule options');
         function checkLiteral(node) {
             if (typeof node.value !== 'string')
                 return;
@@ -133,7 +211,7 @@ const noArbitraryCanonical = {
                 fix: (fixer) => replaceString(fixer, node, corrected),
             });
         }
-        return makeStringRuleVisitor(checkLiteral);
+        return makeStringRuleVisitor(checkLiteral, config);
     },
 };
 function loadTwMerge() {
@@ -141,26 +219,25 @@ function loadTwMerge() {
         return _require('tailwind-merge').twMerge;
     }
     catch {
-        return null;
+        throw new Error('The no-conflicting-classes rule requires the optional peer dependency "tailwind-merge". Install it with: pnpm add -D tailwind-merge');
     }
 }
 const noConflictingClasses = {
     meta: {
         type: 'suggestion',
         fixable: 'code',
-        schema: [],
+        schema: noArbitraryCanonical.meta?.schema ?? [],
         messages: {
             conflicting: "Conflicting Tailwind classes detected. Use '{{merged}}' instead.",
         },
     },
     create(context) {
         const twMerge = loadTwMerge();
+        const config = validateConfig(context.options[0], 'ESLint rule options');
         function checkLiteral(node) {
-            if (!twMerge)
-                return;
             if (typeof node.value !== 'string')
                 return;
-            const merged = twMerge(node.value);
+            const merged = mergeClasses(node.value, twMerge, config);
             if (merged === node.value)
                 return;
             context.report({
@@ -169,7 +246,7 @@ const noConflictingClasses = {
                 fix: (fixer) => replaceString(fixer, node, merged),
             });
         }
-        return makeStringRuleVisitor(checkLiteral);
+        return makeStringRuleVisitor(checkLiteral, config);
     },
 };
 const plugin = {

package/dist/io/config.d.ts

@@ -8,4 +8,7 @@ import type { Config } from '../core/rules.js';
  * nothing.
  */
 export declare function resolveInitFilename(cwd: string): string;
-export declare function loadConfig(cwd: string): Promise<Config>;
+export declare function findConfigPath(cwd: string): string | undefined;
+export declare function loadConfig(cwd: string, options?: {
+    reload?: boolean;
+}): Promise<Config>;

package/dist/io/config.js

@@ -1,4 +1,6 @@
+import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { basename, dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { CONFIG_FILENAMES, validateConfig } from '../core/config.js';
@@ -51,7 +53,7 @@ export function resolveInitFilename(cwd) {
         ? 'tailwind-canonical.config.js'
         : 'tailwind-canonical.config.mjs';
 }
-function findConfigPath(cwd) {
+export function findConfigPath(cwd) {
     let dir = cwd;
     while (true) {
         const filename = CONFIG_FILENAMES.find((name) => existsSync(join(dir, name)));
@@ -65,14 +67,50 @@ function findConfigPath(cwd) {
         dir = parent;
     }
 }
-export async function loadConfig(cwd) {
+const reloadCache = new Map();
+export async function loadConfig(cwd, options = {}) {
     const path = findConfigPath(cwd);
     if (!path)
         return {};
     const filename = basename(path);
     let mod;
+    let hash;
     try {
-        mod = await import(pathToFileURL(path).href);
+        const url = pathToFileURL(path);
+        if (options.reload) {
+            hash = createHash('sha256').update(readFileSync(path)).digest('hex');
+            const cached = reloadCache.get(path);
+            if (cached?.hash === hash)
+                return cached.config;
+            // Content-based URLs avoid another ESM instance on unchanged source saves.
+            url.searchParams.set('version', hash);
+        }
+        if (options.reload &&
+            /\.(?:js|ts)$/.test(filename) &&
+            nearestPackageType(dirname(path)) === 'commonjs') {
+            // CJS has an additional require cache: query parameters only invalidate
+            // its ESM namespace wrapper. Read it via require after clearing that cache.
+            const require = createRequire(import.meta.url);
+            delete require.cache[require.resolve(path)];
+            try {
+                const loaded = require(path);
+                mod =
+                    typeof loaded === 'object' &&
+                        loaded !== null &&
+                        '__esModule' in loaded &&
+                        'default' in loaded
+                        ? loaded
+                        : { default: loaded };
+            }
+            catch (error) {
+                if (!['ERR_REQUIRE_ESM', 'ERR_REQUIRE_ASYNC_MODULE'].includes(error.code ?? ''))
+                    throw error;
+                mod = await import(url.href);
+            }
+        }
+        else {
+            mod = await import(url.href);
+        }
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -95,5 +133,8 @@ export async function loadConfig(cwd) {
         }
         throw err;
     }
-    return validateConfig(mod.default, filename);
+    const config = validateConfig(mod.default, filename);
+    if (hash)
+        reloadCache.set(path, { hash, config });
+    return config;
 }

package/dist/io/consistency.js

@@ -1,15 +1,13 @@
 import { readFileSync } from 'node:fs';
-import { toClassStringOpts } from '../core/class-strings.js';
-import { analyzeConsistency, collectClasses, } from '../core/consistency.js';
+import { extractClassStrings, SINGLE_CLASS_REGEX, toClassStringOpts, } from '../core/class-strings.js';
+import { analyzeConsistency, } from '../core/consistency.js';
 export function analyzeConsistencyFiles(filePaths, config = {}, options = {}, onError) {
     const opts = toClassStringOpts(config);
     const input = [];
     for (const file of filePaths) {
         try {
-            input.push({
-                file,
-                classes: collectClasses(readFileSync(file, 'utf8'), opts),
-            });
+            const classLists = extractClassStrings(readFileSync(file, 'utf8'), opts).map(({ value }) => [...value.matchAll(SINGLE_CLASS_REGEX)].map((match) => match[0]));
+            input.push({ file, classes: classLists.flat(), classLists });
         }
         catch (err) {
             if (onError)

package/dist/io/scanner.js

@@ -1,7 +1,7 @@
-import { readdirSync, statSync } from 'node:fs';
+import { existsSync, lstatSync, readdirSync, statSync, } from 'node:fs';
 import { glob } from 'node:fs/promises';
-import { join } from 'node:path';
-import { DEFAULT_EXTENSIONS, DEFAULT_IGNORE, globToRegex, isGlob, } from '../core/scanner.js';
+import { isAbsolute, join, matchesGlob, resolve } from 'node:path';
+import { DEFAULT_EXTENSIONS, DEFAULT_IGNORE, isGlob, } from '../core/scanner.js';
 export function scanFiles(target, options = {}) {
     const ignore = options.ignore ?? DEFAULT_IGNORE;
     const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
@@ -21,7 +21,8 @@ export function scanFiles(target, options = {}) {
             if (entry.isDirectory()) {
                 walk(full);
             }
-            else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+            else if (entry.isFile() &&
+                extensions.some((ext) => entry.name.endsWith(ext))) {
                 files.push(full);
             }
         }
@@ -42,10 +43,10 @@ export async function resolveTargets(patterns, options = {}) {
     const ignore = options.ignore ?? DEFAULT_IGNORE;
     const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
     const positive = [];
-    const negativeRegexes = [];
+    const negativePatterns = [];
     for (const p of patterns) {
         if (p.startsWith('!')) {
-            negativeRegexes.push(globToRegex(p.slice(1)));
+            negativePatterns.push(p.slice(1).replace(/\\/g, '/'));
         }
         else {
             positive.push(p);
@@ -53,14 +54,15 @@ export async function resolveTargets(patterns, options = {}) {
     }
     const files = new Set();
     for (const pattern of positive) {
-        if (isGlob(pattern)) {
+        if (isGlob(pattern) && !existsSync(pattern)) {
             for await (const f of glob(pattern, {
                 exclude: (entry) => entry
                     .replace(/\\/g, '/')
                     .split('/')
                     .some((s) => ignore.includes(s)),
             })) {
-                if (extensions.some((ext) => f.endsWith(ext))) {
+                if (extensions.some((ext) => f.endsWith(ext)) &&
+                    lstatSync(f).isFile()) {
                     files.add(f);
                 }
             }
@@ -71,10 +73,24 @@ export async function resolveTargets(patterns, options = {}) {
             }
         }
     }
-    if (negativeRegexes.length > 0) {
+    if (negativePatterns.length > 0) {
+        const exclusions = negativePatterns.map((pattern) => ({
+            pattern,
+            literal: existsSync(pattern)
+                ? resolve(pattern).replace(/\\/g, '/')
+                : undefined,
+        }));
         for (const f of [...files]) {
             const normalized = f.replace(/\\/g, '/');
-            if (negativeRegexes.some((re) => re.test(normalized))) {
+            if (exclusions.some(({ pattern, literal }) => {
+                if (literal) {
+                    const full = resolve(f).replace(/\\/g, '/');
+                    return (full === literal ||
+                        full.startsWith(literal.endsWith('/') ? literal : `${literal}/`));
+                }
+                return (matchesGlob(normalized, pattern) ||
+                    (!isAbsolute(pattern) && matchesGlob(normalized, `**/${pattern}`)));
+            })) {
                 files.delete(f);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwind-canonical",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Lint and auto-fix Tailwind CSS arbitrary values that have canonical equivalents",
   "type": "module",
   "main": "./dist/index.js",
@@ -64,8 +64,8 @@
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "eslint": ">=8.0.0",
-    "tailwind-merge": ">=2.0.0"
+    "eslint": ">=8.57.1 <11",
+    "tailwind-merge": ">=2.0.0 <4"
   },
   "peerDependenciesMeta": {
     "eslint": {
@@ -80,8 +80,10 @@
     "dev": "tsc --watch",
     "test": "node --import=tsx/esm --test \"src/**/*.test.ts\"",
     "typecheck": "tsc --noEmit",
-    "lint": "biome check src/",
-    "lint:fix": "biome check --write src/",
-    "knip": "knip"
+    "lint": "biome check src/ scripts/",
+    "lint:fix": "biome check --write src/ scripts/",
+    "knip": "knip",
+    "benchmark": "pnpm build && node scripts/benchmark.mjs",
+    "test:compat": "node scripts/compatibility.mjs"
   }
 }