tailwind-canonical 0.7.0 → 0.7.1

package/dist/core/scanner.js

@@ -17,6 +17,15 @@ export const DEFAULT_IGNORE = [
 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);
@@ -24,10 +33,14 @@ export function globToRegex(pattern) {
     while (i < pattern.length) {
         const c = pattern[i];
         if (c === '*' && pattern[i + 1] === '*') {
-            re += '.*';
             i += 2;
-            if (pattern[i] === '/')
+            if (pattern[i] === '/') {
+                re += '(?:[^/]+/)*';
                 i++;
+            }
+            else {
+                re += '.*';
+            }
         }
         else if (c === '*') {
             re += '[^/]*';
@@ -37,27 +50,17 @@ export function globToRegex(pattern) {
             re += '[^/]';
             i++;
         }
-        else if (c === '{') {
+        else if (c === '{' && pattern.indexOf('}', i) !== -1) {
             const close = pattern.indexOf('}', i);
-            if (close === -1) {
-                re += '\\{';
-                i++;
-            }
-            else {
-                const alts = pattern
-                    .slice(i + 1, close)
-                    .split(',')
-                    .map((a) => a.replace(/[.+^${}()|[\]\\]/g, '\\$&'));
-                re += `(?:${alts.join('|')})`;
-                i = close + 1;
-            }
-        }
-        else if (/[.+^${}()|[\]\\]/.test(c)) {
-            re += `\\${c}`;
-            i++;
+            const alts = pattern
+                .slice(i + 1, close)
+                .split(',')
+                .map(wildcardToRegex);
+            re += `(?:${alts.join('|')})`;
+            i = close + 1;
         }
         else {
-            re += c;
+            re += escapeRegex(c);
             i++;
         }
     }

package/dist/core/sorter.js

@@ -135,11 +135,61 @@ function getVariantOrder(cls) {
         return 2;
     return 3;
 }
-export function sortClasses(classStr, sortOrder) {
-    const classes = classStr.split(/\s+/).filter(Boolean);
-    if (classes.length <= 1)
-        return classStr;
-    const rank = buildRank(sortOrder?.length ? sortOrder : DEFAULT_SORT_ORDER);
+const RE_ARBITRARY = /\[[^\]]*\]/g;
+const RE_IMPLAUSIBLE_CLASS = /^:|:$|["'`{}?]|^[&|]+$/;
+function isPlausibleClass(token) {
+    return !RE_IMPLAUSIBLE_CLASS.test(token.replace(RE_ARBITRARY, '[]'));
+}
+function interpolationEnd(str, from) {
+    let depth = 0;
+    let quote = null;
+    for (let j = from + 1; j < str.length; j++) {
+        const ch = str[j];
+        if (quote) {
+            if (ch === '\\')
+                j++;
+            else if (ch === quote)
+                quote = null;
+        }
+        else if (ch === '"' || ch === "'" || ch === '`')
+            quote = ch;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}' && --depth === 0)
+            return j + 1;
+    }
+    return str.length;
+}
+function splitAtoms(str) {
+    const atoms = [];
+    let i = 0;
+    while (i < str.length) {
+        if (/\s/.test(str[i])) {
+            i++;
+            continue;
+        }
+        let j = i;
+        let interpolated = false;
+        while (j < str.length && !/\s/.test(str[j])) {
+            if (str.startsWith('${', j)) {
+                interpolated = true;
+                j = interpolationEnd(str, j);
+            }
+            else
+                j++;
+        }
+        const text = str.slice(i, j);
+        atoms.push({
+            text,
+            start: i,
+            end: j,
+            fixed: interpolated || !isPlausibleClass(text),
+        });
+        i = j;
+    }
+    return atoms;
+}
+function sortSegment(classes, rank) {
     return classes
         .map((cls, i) => ({
         cls,
@@ -156,8 +206,31 @@ export function sortClasses(classStr, sortOrder) {
             return cd;
         return a.i - b.i;
     })
-        .map((x) => x.cls)
-        .join(' ');
+        .map((x) => x.cls);
+}
+export function sortClasses(classStr, sortOrder) {
+    const atoms = splitAtoms(classStr);
+    if (atoms.length <= 1)
+        return classStr;
+    const rank = buildRank(sortOrder?.length ? sortOrder : DEFAULT_SORT_ORDER);
+    if (!atoms.some((a) => a.fixed))
+        return sortSegment(atoms.map((a) => a.text), rank).join(' ');
+    const texts = atoms.map((a) => a.text);
+    let start = 0;
+    for (let k = 0; k <= atoms.length; k++) {
+        if (k < atoms.length && !atoms[k].fixed)
+            continue;
+        const sorted = sortSegment(texts.slice(start, k), rank);
+        texts.splice(start, sorted.length, ...sorted);
+        start = k + 1;
+    }
+    let out = '';
+    let cursor = 0;
+    atoms.forEach((atom, k) => {
+        out += classStr.slice(cursor, atom.start) + texts[k];
+        cursor = atom.end;
+    });
+    return out + classStr.slice(cursor);
 }
 export function sortContent(content, opts = {}, sortOrder) {
     return replaceClassStrings(content, (s) => sortClasses(s, sortOrder), {

package/dist/core/suppressions.d.ts

@@ -1,7 +1,6 @@
 export declare function getSuppressedLines(content: string): Set<number>;
 export declare function makeLineSuppressor(content: string): (line: number) => boolean;
-export declare function indexToLineCol(content: string, index: number): {
+export declare function createPositionLookup(content: string): (index: number) => {
     line: number;
     col: number;
 };
-export declare function lineAt(content: string, offset: number): number;

package/dist/core/suppressions.js

@@ -26,18 +26,22 @@ export function makeLineSuppressor(content) {
     const suppressed = getSuppressedLines(content);
     return (line) => suppressed.has(line);
 }
-export function indexToLineCol(content, index) {
-    let line = 1;
-    let lastNewline = -1;
-    const end = Math.min(index, content.length);
-    for (let i = 0; i < end; i++) {
-        if (content[i] === '\n') {
-            line++;
-            lastNewline = i;
-        }
+export function createPositionLookup(content) {
+    const lineStarts = [0];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === '\n')
+            lineStarts.push(i + 1);
     }
-    return { line, col: index - lastNewline };
-}
-export function lineAt(content, offset) {
-    return indexToLineCol(content, offset).line;
+    return (index) => {
+        let low = 0;
+        let high = lineStarts.length;
+        while (low + 1 < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (lineStarts[mid] <= index)
+                low = mid;
+            else
+                high = mid;
+        }
+        return { line: low + 1, col: index - lineStarts[low] + 1 };
+    };
 }

package/dist/core/typos.js

@@ -1,6 +1,6 @@
 import { extractClassStrings, SINGLE_CLASS_REGEX, toClassStringOpts, } from './class-strings.js';
 import { parseColorClass, TAILWIND_COLORS } from './lexicon.js';
-import { getSuppressedLines, indexToLineCol } from './suppressions.js';
+import { createPositionLookup, getSuppressedLines } from './suppressions.js';
 const MIN_COLOR_LEN = 3;
 function levenshtein(a, b) {
     const m = a.length;
@@ -45,6 +45,7 @@ export function detectTypo(cls, extraColors = new Set()) {
 export function analyzeTyposContent(filePath, content, config = {}) {
     const findings = [];
     const suppressed = getSuppressedLines(content);
+    const positionAt = createPositionLookup(content);
     const opts = toClassStringOpts(config);
     const extraColors = new Set(config.extraColors ?? []);
     for (const { value, start } of extractClassStrings(content, opts)) {
@@ -53,7 +54,7 @@ export function analyzeTyposContent(filePath, content, config = {}) {
             if (!typo)
                 continue;
             const index = start + (clsMatch.index ?? 0);
-            const { line, col } = indexToLineCol(content, index);
+            const { line, col } = positionAt(index);
             if (suppressed.has(line))
                 continue;
             findings.push({

package/dist/eslint/plugin.js

@@ -1,5 +1,5 @@
 import { createRequire } from 'node:module';
-import { suggestCanonical } from '../core/rules.js';
+import { suggestCanonical, } from '../core/rules.js';
 const _require = createRequire(import.meta.url);
 /**
  * Inner-text range of a `TemplateElement`. In espree, `quasi.range` spans the
@@ -24,14 +24,20 @@ function makeStringRuleVisitor(checkLiteral) {
     return {
         Literal: (node) => 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);
                 checkLiteral({
                     type: 'Literal',
-                    value: quasi.value.cooked ?? quasi.value.raw,
+                    value,
                     raw: quasi.value.raw,
                     range: quasi.range,
                     loc: quasi.loc,
                     quasiRange: quasiTextRange(quasi),
+                    valueIsRaw: isTagged || quasi.value.cooked === null,
                 });
             }
         },
@@ -39,7 +45,40 @@ function makeStringRuleVisitor(checkLiteral) {
 }
 function quoteReplacement(node, value) {
     const quote = node.raw?.startsWith('"') ? '"' : "'";
-    return `${quote}${value}${quote}`;
+    if (node.parent?.type === 'JSXAttribute') {
+        return `${quote}${escapeJsxAttribute(value, quote)}${quote}`;
+    }
+    return `${quote}${escapeString(value, quote)}${quote}`;
+}
+function escapeString(value, quote) {
+    const escaped = JSON.stringify(value).slice(1, -1);
+    return quote === '"'
+        ? escaped
+        : escaped.replace(/\\"/g, '"').replace(/'/g, "\\'");
+}
+function escapeJsxAttribute(value, quote) {
+    return value
+        .replace(/&/g, '&')
+        .replace(quote === '"' ? /"/g : /'/g, quote === '"' ? '"' : ''');
+}
+function escapeTemplateText(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${')
+        .replace(/\r/g, '\\r');
+}
+function replacementText(node, value) {
+    if (node.quasiRange) {
+        return node.valueIsRaw ? value : escapeTemplateText(value);
+    }
+    return quoteReplacement(node, value);
+}
+function replaceString(fixer, node, value) {
+    const text = replacementText(node, value);
+    return node.quasiRange
+        ? fixer.replaceTextRange(node.quasiRange, text)
+        : fixer.replaceText(node, text);
 }
 const noArbitraryCanonical = {
     meta: {
@@ -75,29 +114,36 @@ const noArbitraryCanonical = {
         function checkLiteral(node) {
             if (typeof node.value !== 'string')
                 return;
-            const value = node.value;
-            const suggestions = [...value.matchAll(/\S+/g)]
-                .map((match) => suggestCanonical(match[0], config))
-                .filter((suggestion) => suggestion !== null);
+            const suggestions = [];
+            const corrected = node.value.replace(/\S+/g, (token) => {
+                const suggestion = suggestCanonical(token, config);
+                if (!suggestion)
+                    return token;
+                suggestions.push(suggestion);
+                return suggestion.canonical;
+            });
             if (suggestions.length === 0)
                 return;
-            const corrected = value.replace(/\S+/g, (token) => suggestCanonical(token, config)?.canonical ?? token);
             const message = suggestions.length === 1
                 ? `Use canonical class '${suggestions[0].canonical}' instead of '${suggestions[0].original}'`
                 : `Use canonical classes '${suggestions.map((s) => s.canonical).join(' ')}' instead of '${suggestions.map((s) => s.original).join(' ')}'`;
             context.report({
                 node,
                 message,
-                fix(fixer) {
-                    if (node.quasiRange)
-                        return fixer.replaceTextRange(node.quasiRange, corrected);
-                    return fixer.replaceText(node, quoteReplacement(node, corrected));
-                },
+                fix: (fixer) => replaceString(fixer, node, corrected),
             });
         }
         return makeStringRuleVisitor(checkLiteral);
     },
 };
+function loadTwMerge() {
+    try {
+        return _require('tailwind-merge').twMerge;
+    }
+    catch {
+        return null;
+    }
+}
 const noConflictingClasses = {
     meta: {
         type: 'suggestion',
@@ -108,17 +154,9 @@ const noConflictingClasses = {
         },
     },
     create(context) {
-        let twMerge = null;
-        let peerMissing = false;
-        try {
-            const mod = _require('tailwind-merge');
-            twMerge = mod.twMerge;
-        }
-        catch {
-            peerMissing = true;
-        }
+        const twMerge = loadTwMerge();
         function checkLiteral(node) {
-            if (peerMissing || !twMerge)
+            if (!twMerge)
                 return;
             if (typeof node.value !== 'string')
                 return;
@@ -128,11 +166,7 @@ const noConflictingClasses = {
             context.report({
                 node,
                 message: `Conflicting Tailwind classes detected. Use '${merged}' instead.`,
-                fix(fixer) {
-                    if (node.quasiRange)
-                        return fixer.replaceTextRange(node.quasiRange, merged);
-                    return fixer.replaceText(node, quoteReplacement(node, merged));
-                },
+                fix: (fixer) => replaceString(fixer, node, merged),
             });
         }
         return makeStringRuleVisitor(checkLiteral);

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export type { Finding } from './core/analyzer.js';
 export { analyzeFile } from './core/analyzer.js';
 export { loadConfig } from './core/config.js';
-export type { ClassCombination, ColorVariant, ColorVariantGroup, ConsistencyOptions, ConsistencyReport, FileClasses, ScaleInconsistency, ScaleValue, } from './core/consistency.js';
+export type { ClassCombination, ColorVariant, ColorVariantGroup, ConsistencyOptions, ConsistencyReport, FileClasses, RareScaleValue, ScaleInconsistency, ScaleValue, } from './core/consistency.js';
 export { analyzeConsistency } from './core/consistency.js';
 export { dedupeFile, deduplicateClasses } from './core/deduplicator.js';
 export { fixFile } from './core/fixer.js';

package/dist/index.js

@@ -3,7 +3,7 @@
 // This barrel is the package's stable surface. Internal plumbing
 // (class-string extraction, suppression predicates, config validation,
 // file-class collection, consistency file readers) is intentionally NOT
-// re-exported here — import it by direct module path if you need it.
+// exposed through package exports.
 export { analyzeFile } from './core/analyzer.js';
 // Config loading
 export { loadConfig } from './core/config.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwind-canonical",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Lint and auto-fix Tailwind CSS arbitrary values that have canonical equivalents",
   "type": "module",
   "main": "./dist/index.js",
@@ -61,7 +61,7 @@
     "lefthook": "^2.1.12",
     "tailwind-merge": "^3.6.0",
     "tsx": "^4.23.13",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
     "eslint": ">=8.0.0",