tailwind-canonical 0.8.0 → 0.9.0

package/dist/core/config.js

@@ -7,6 +7,7 @@ export const CONFIG_FILENAMES = [
     'tailwind-canonical.config.mjs',
 ];
 const KNOWN_KEYS = [
+    'useDefaultTheme',
     'customTextTokens',
     'customSpacingTokens',
     'ignorePatterns',
@@ -141,6 +142,8 @@ export function validateConfig(input, filename = CONFIG_FILENAME) {
     }
     const cfg = input;
     assertKnownKeys(cfg, KNOWN_KEYS, 'unknown key', filename);
+    if ('useDefaultTheme' in cfg && typeof cfg.useDefaultTheme !== 'boolean')
+        fail(filename, 'useDefaultTheme must be a boolean');
     if ('customTextTokens' in cfg)
         assertPxTokenMap(cfg.customTextTokens, 'customTextTokens', filename);
     if ('customSpacingTokens' in cfg)
@@ -176,4 +179,4 @@ export function validateConfig(input, filename = CONFIG_FILENAME) {
     }
     return cfg;
 }
-export { loadConfig, resolveInitFilename } from '../io/config.js';
+export { findConfigPath, loadConfig, resolveInitFilename, } from '../io/config.js';

package/dist/core/consistency.d.ts

@@ -2,7 +2,12 @@ import { type ClassStringOpts } from './class-strings.js';
 import type { Config } from './rules.js';
 export type FileClasses = {
     file: string;
+    /** All class occurrences, used for color and scale statistics. */
     classes: string[];
+    /** Individual class strings, used for repeated-pattern detection.
+     * When omitted, `classes` is treated as one class string for compatibility.
+     */
+    classLists?: string[][];
 };
 export type ColorVariant = {
     token: string;

package/dist/core/consistency.js

@@ -9,7 +9,11 @@ function parseColor(cls, families, knownColors) {
         return null;
     // A known color without an explicit family forms its own family, so colors
     // newly added to the palette are grouped rather than silently dropped.
-    const family = families[color] ?? (knownColors.has(color) ? color : null);
+    const family = Object.hasOwn(families, color)
+        ? families[color]
+        : knownColors.has(color)
+            ? color
+            : null;
     if (!family)
         return null;
     return { property, family, token: `${color}-${shade}` };
@@ -22,7 +26,8 @@ function parseScale(cls, scaleProperties) {
     const base = stripVariants(cls);
     const negative = base.startsWith('-');
     const body = negative ? base.slice(1) : base;
-    const dash = body.lastIndexOf('-');
+    const bracket = body.indexOf('[');
+    const dash = body.lastIndexOf('-', bracket === -1 ? body.length : bracket);
     if (dash === -1)
         return null;
     const property = body.slice(0, dash);
@@ -149,20 +154,22 @@ function detectRareScaleValues(inconsistencies, minPropertyOccurrences, maxFiles
 // frequent sub-patterns (no k-subset itemset mining).
 function detectCombinations(input, minSize, minFiles, max) {
     const combos = new Map();
-    for (const { file, classes } of input) {
-        if (classes.length < minSize)
-            continue;
-        const unique = [...new Set(classes)].sort();
-        if (unique.length < minSize)
-            continue;
-        const key = unique.join(' ');
-        let entry = combos.get(key);
-        if (!entry) {
-            entry = { classes: unique, count: 0, files: new Set() };
-            combos.set(key, entry);
+    for (const { file, classes: allClasses, classLists } of input) {
+        for (const classes of classLists ?? [allClasses]) {
+            if (classes.length < minSize)
+                continue;
+            const unique = [...new Set(classes)].sort();
+            if (unique.length < minSize)
+                continue;
+            const key = unique.join(' ');
+            let entry = combos.get(key);
+            if (!entry) {
+                entry = { classes: unique, count: 0, files: new Set() };
+                combos.set(key, entry);
+            }
+            entry.count++;
+            entry.files.add(file);
         }
-        entry.count++;
-        entry.files.add(file);
     }
     return [...combos.values()]
         .filter((c) => c.files.size >= minFiles)

package/dist/core/deduplicator.js

@@ -186,6 +186,8 @@ const CORNER_MAP = {
     br: ['br'],
 };
 function parseRoundedCorner(cls) {
+    if (/^rounded-(?:s|e|ss|se|es|ee)(?:-|$)/.test(cls))
+        return null;
     const m = cls.match(/^rounded-(tl|tr|bl|br|t|b|l|r)(?:-(.+))?$/) ??
         cls.match(/^rounded()(?:-(.+))?$/);
     if (!m)
@@ -321,6 +323,8 @@ function keepLastOf(slots, indices) {
         slots[i] = [];
 }
 export function deduplicateClasses(classStr) {
+    if (classStr.includes('${'))
+        return classStr;
     const original = classStr.split(/\s+/).filter(Boolean);
     if (original.length <= 1)
         return classStr;

package/dist/core/merger.d.ts

@@ -1,4 +1,5 @@
 import { type ClassStringOpts } from './class-strings.js';
+export declare function mergeClasses(classes: string, twMerge: (classes: string) => string, opts?: Pick<ClassStringOpts, 'customTextTokens'>): string;
 export declare function mergeContent(content: string, twMerge: (classes: string) => string, opts?: ClassStringOpts): {
     result: string;
     count: number;

package/dist/core/merger.js

@@ -84,9 +84,12 @@ function restoreLeadingForUnsafeTextSizes(original, merged, customTextClasses) {
     }
     return restored.join(' ');
 }
-export function mergeContent(content, twMerge, opts = {}) {
+export function mergeClasses(classes, twMerge, opts = {}) {
     const customTextClasses = new Set(Object.values(opts.customTextTokens ?? {}).map((token) => `text-${token}`));
-    return replaceClassStrings(content, (classes) => restoreLeadingForUnsafeTextSizes(classes, twMerge(classes), customTextClasses), {
+    return restoreLeadingForUnsafeTextSizes(classes, twMerge(classes), customTextClasses);
+}
+export function mergeContent(content, twMerge, opts = {}) {
+    return replaceClassStrings(content, (classes) => mergeClasses(classes, twMerge, opts), {
         ...opts,
         isSuppressed: makeLineSuppressor(content),
     });

package/dist/core/rules.d.ts

@@ -26,6 +26,8 @@ type DefaultCommandConfig = {
     targets?: string[];
 };
 export type Config = {
+    /** Set false for custom themes: only explicitly configured px mappings apply. */
+    useDefaultTheme?: boolean;
     customTextTokens?: Record<number, string>;
     customSpacingTokens?: Record<number, string>;
     ignorePatterns?: RegExp[];

package/dist/core/rules.js

@@ -13,7 +13,6 @@ const TEXT_SIZE_MAP = {
     96: '8xl',
     128: '9xl',
 };
-const BUILT_IN_TEXT_PX = new Set(Object.keys(TEXT_SIZE_MAP).map(Number));
 /**
  * Radius px → token suffix. v4 renamed the small end (`rounded-sm` → `-xs`,
  * bare `rounded` → `-sm`) and added `4xl`; `''` is the bare v3 `rounded`.
@@ -343,7 +342,7 @@ function textSuggestion(cls, px, textTokens) {
     return {
         original: cls,
         canonical: `text-${token}`,
-        isCustomToken: !BUILT_IN_TEXT_PX.has(px),
+        isCustomToken: textTokens[px] !== TEXT_SIZE_MAP[px],
     };
 }
 function spacingSuggestion(cls, prefix, px, spacingTokens, v3) {
@@ -466,6 +465,29 @@ export function suggestCanonical(cls, config = {}) {
     };
 }
 function suggestUtility(cls, config) {
+    if (config.useDefaultTheme === false) {
+        const text = cls.match(/^text-\[(\d+)px\]$/);
+        if (text) {
+            const token = config.customTextTokens?.[Number(text[1])];
+            return token
+                ? { original: cls, canonical: `text-${token}`, isCustomToken: true }
+                : null;
+        }
+        const spacing = cls.match(SPACING_PX_RE);
+        if (spacing) {
+            const token = config.customSpacingTokens?.[Number(spacing[2])];
+            return token
+                ? {
+                    original: cls,
+                    canonical: `${spacing[1]}-${token}`,
+                    isCustomToken: true,
+                }
+                : null;
+        }
+        // Even rem-to-px equivalences depend on the consumer's root font size.
+        // A custom theme must opt in through explicit mappings, never inference.
+        return null;
+    }
     const textTokens = { ...TEXT_SIZE_MAP, ...config.customTextTokens };
     const spacingTokens = config.customSpacingTokens ?? {};
     const v3 = config.tailwindVersion === 3;

package/dist/core/scanner.d.ts

@@ -5,5 +5,4 @@ export type ScanOptions = {
     ignore?: string[];
 };
 export declare function isGlob(target: string): boolean;
-export declare function globToRegex(pattern: string): RegExp;
 export { resolveTargets, scanFiles } from '../io/scanner.js';

package/dist/core/scanner.js

@@ -15,55 +15,6 @@ export const DEFAULT_IGNORE = [
     'coverage',
 ];
 export function isGlob(target) {
-    return target.includes('*') || target.includes('?') || target.includes('{');
-}
-function escapeRegex(text) {
-    return text.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-}
-function wildcardToRegex(text) {
-    return text
-        .split('*')
-        .map((part) => part.split('?').map(escapeRegex).join('[^/]'))
-        .join('[^/]*');
-}
-export function globToRegex(pattern) {
-    let i = 0;
-    const anchored = pattern.startsWith('/') || /^[A-Za-z]:/.test(pattern);
-    let re = anchored ? '^' : '(?:^|/)';
-    while (i < pattern.length) {
-        const c = pattern[i];
-        if (c === '*' && pattern[i + 1] === '*') {
-            i += 2;
-            if (pattern[i] === '/') {
-                re += '(?:[^/]+/)*';
-                i++;
-            }
-            else {
-                re += '.*';
-            }
-        }
-        else if (c === '*') {
-            re += '[^/]*';
-            i++;
-        }
-        else if (c === '?') {
-            re += '[^/]';
-            i++;
-        }
-        else if (c === '{' && pattern.indexOf('}', i) !== -1) {
-            const close = pattern.indexOf('}', i);
-            const alts = pattern
-                .slice(i + 1, close)
-                .split(',')
-                .map(wildcardToRegex);
-            re += `(?:${alts.join('|')})`;
-            i = close + 1;
-        }
-        else {
-            re += escapeRegex(c);
-            i++;
-        }
-    }
-    return new RegExp(`${re}$`);
+    return /[*?{[(]/.test(target);
 }
 export { resolveTargets, scanFiles } from '../io/scanner.js';

package/dist/eslint/plugin.d.ts

@@ -9,7 +9,7 @@ interface TailwindCanonicalPlugin {
             plugins: {
                 'tailwind-canonical': TailwindCanonicalPlugin;
             };
-            rules: Record<string, string>;
+            rules: Record<string, 'warn'>;
         };
     };
 }

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)