tailwind-canonical 0.7.0 → 0.8.0

package/dist/core/config.js

@@ -32,8 +32,7 @@ const ANALYZE_KEYS = [
     'maxRareValues',
     'maxPatterns',
 ];
-const ANALYZE_KEY_SET = new Set(ANALYZE_KEYS);
-const DEFAULT_COMMAND_KEYS = [
+const DEFAULT_COMMAND_BOOLEAN_KEYS = [
     'fix',
     'merge',
     'dedup',
@@ -42,21 +41,29 @@ const DEFAULT_COMMAND_KEYS = [
     'analyze',
     'typos',
     'watch',
+];
+const DEFAULT_COMMAND_KEYS = [
+    ...DEFAULT_COMMAND_BOOLEAN_KEYS,
     'reporter',
     'targets',
 ];
-const DEFAULT_COMMAND_KEY_SET = new Set(DEFAULT_COMMAND_KEYS);
 const REPORTERS = new Set(['text', 'json', 'sarif']);
-const KNOWN_KEY_SET = new Set(KNOWN_KEYS);
 const SORT_CATEGORIES = new Set(DEFAULT_SORT_ORDER);
-function invalidConfig(filename, message) {
-    return new Error(`Invalid ${filename}: ${message}`);
-}
 function fail(filename, message) {
-    throw invalidConfig(filename, message);
+    throw new Error(`Invalid ${filename}: ${message}`);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertKnownKeys(cfg, known, label, filename) {
+    for (const key of Object.keys(cfg)) {
+        if (!known.includes(key)) {
+            fail(filename, `${label} "${key}" (expected one of: ${known.join(', ')})`);
+        }
+    }
 }
 function assertPxTokenMap(value, key, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value)) {
         fail(filename, `${key} must be an object mapping px numbers to token names`);
     }
     for (const [k, v] of Object.entries(value)) {
@@ -77,7 +84,7 @@ function assertRegExpArray(value, key, filename) {
     }
 }
 function assertStringRecord(value, key, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value)) {
         fail(filename, `${key} must be an object mapping strings to strings`);
     }
     for (const [k, v] of Object.entries(value)) {
@@ -91,40 +98,20 @@ function assertPositiveInteger(value, key, filename) {
     }
 }
 function assertAnalyzeConfig(value, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value))
         fail(filename, 'analyze must be an object');
-    }
-    const cfg = value;
-    for (const key of Object.keys(cfg)) {
-        if (!ANALYZE_KEY_SET.has(key)) {
-            fail(filename, `analyze contains unknown key "${key}" (expected one of: ${ANALYZE_KEYS.join(', ')})`);
-        }
-    }
+    assertKnownKeys(value, ANALYZE_KEYS, 'analyze contains unknown key', filename);
     for (const key of ANALYZE_KEYS) {
-        if (key in cfg)
-            assertPositiveInteger(cfg[key], `analyze.${key}`, filename);
+        if (key in value)
+            assertPositiveInteger(value[key], `analyze.${key}`, filename);
     }
 }
 function assertDefaultCommandConfig(value, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value))
         fail(filename, 'defaultCommand must be an object');
-    }
     const cfg = value;
-    for (const key of Object.keys(cfg)) {
-        if (!DEFAULT_COMMAND_KEY_SET.has(key)) {
-            fail(filename, `defaultCommand contains unknown key "${key}" (expected one of: ${DEFAULT_COMMAND_KEYS.join(', ')})`);
-        }
-    }
-    for (const key of [
-        'fix',
-        'merge',
-        'dedup',
-        'sort',
-        'check',
-        'analyze',
-        'typos',
-        'watch',
-    ]) {
+    assertKnownKeys(cfg, DEFAULT_COMMAND_KEYS, 'defaultCommand contains unknown key', filename);
+    for (const key of DEFAULT_COMMAND_BOOLEAN_KEYS) {
         if (key in cfg && typeof cfg[key] !== 'boolean') {
             fail(filename, `defaultCommand.${key} must be a boolean`);
         }
@@ -153,11 +140,7 @@ export function validateConfig(input, filename = CONFIG_FILENAME) {
         fail(filename, 'default export must be an object');
     }
     const cfg = input;
-    for (const key of Object.keys(cfg)) {
-        if (!KNOWN_KEY_SET.has(key)) {
-            fail(filename, `unknown key "${key}" (expected one of: ${KNOWN_KEYS.join(', ')})`);
-        }
-    }
+    assertKnownKeys(cfg, KNOWN_KEYS, 'unknown key', filename);
     if ('customTextTokens' in cfg)
         assertPxTokenMap(cfg.customTextTokens, 'customTextTokens', filename);
     if ('customSpacingTokens' in cfg)

package/dist/core/consistency.d.ts

@@ -23,7 +23,7 @@ export type ScaleInconsistency = {
     property: string;
     values: ScaleValue[];
 };
-type RareScaleValue = {
+export type RareScaleValue = {
     property: string;
     value: string;
     className: string;

package/dist/core/deduplicator.js

@@ -30,53 +30,6 @@ const POSITION_GROUP = new Set([
     'relative',
     'sticky',
 ]);
-const SIDE_MAP = {
-    p: ['t', 'b', 'l', 'r'],
-    m: ['t', 'b', 'l', 'r'],
-    border: ['t', 'b', 'l', 'r'],
-    inset: ['t', 'b', 'l', 'r'],
-    gap: ['t', 'b', 'l', 'r'],
-    'scroll-p': ['t', 'b', 'l', 'r'],
-    'scroll-m': ['t', 'b', 'l', 'r'],
-    px: ['l', 'r'],
-    mx: ['l', 'r'],
-    'border-x': ['l', 'r'],
-    'inset-x': ['l', 'r'],
-    'gap-x': ['l', 'r'],
-    'scroll-px': ['l', 'r'],
-    'scroll-mx': ['l', 'r'],
-    py: ['t', 'b'],
-    my: ['t', 'b'],
-    'border-y': ['t', 'b'],
-    'inset-y': ['t', 'b'],
-    'gap-y': ['t', 'b'],
-    'scroll-py': ['t', 'b'],
-    'scroll-my': ['t', 'b'],
-    pt: ['t'],
-    mt: ['t'],
-    'border-t': ['t'],
-    top: ['t'],
-    'scroll-pt': ['t'],
-    'scroll-mt': ['t'],
-    pb: ['b'],
-    mb: ['b'],
-    'border-b': ['b'],
-    bottom: ['b'],
-    'scroll-pb': ['b'],
-    'scroll-mb': ['b'],
-    pl: ['l'],
-    ml: ['l'],
-    'border-l': ['l'],
-    left: ['l'],
-    'scroll-pl': ['l'],
-    'scroll-ml': ['l'],
-    pr: ['r'],
-    mr: ['r'],
-    'border-r': ['r'],
-    right: ['r'],
-    'scroll-pr': ['r'],
-    'scroll-mr': ['r'],
-};
 const FAMILIES = [
     {
         kind: 'p',
@@ -160,6 +113,20 @@ const FAMILIES = [
         regex: /^(scroll-m|scroll-mx|scroll-my|scroll-mt|scroll-mb|scroll-ml|scroll-mr)-(.+)$/,
     },
 ];
+const SIDE_MAP = {};
+for (const f of FAMILIES) {
+    const entries = [
+        [f.full, ['t', 'b', 'l', 'r']],
+        [f.x, ['l', 'r']],
+        [f.y, ['t', 'b']],
+        [f.t, ['t']],
+        [f.b, ['b']],
+        [f.l, ['l']],
+        [f.r, ['r']],
+    ];
+    for (const [prefix, sides] of entries)
+        SIDE_MAP[prefix] ??= sides;
+}
 function parseBoxClass(cls) {
     for (const family of FAMILIES) {
         const m = cls.match(family.regex);
@@ -207,39 +174,27 @@ function collapseBox(box, f) {
     }
     return parts.join(' ');
 }
+const CORNER_MAP = {
+    '': ['tl', 'tr', 'bl', 'br'],
+    t: ['tl', 'tr'],
+    b: ['bl', 'br'],
+    l: ['tl', 'bl'],
+    r: ['tr', 'br'],
+    tl: ['tl'],
+    tr: ['tr'],
+    bl: ['bl'],
+    br: ['br'],
+};
 function parseRoundedCorner(cls) {
-    const sideM = cls.match(/^rounded-(tl|tr|bl|br|t|b|l|r)(?:-(.+))?$/);
-    if (sideM) {
-        const side = sideM[1];
-        const val = sideM[2] ?? '';
-        const c = {};
-        if (side === 't') {
-            c.tl = val;
-            c.tr = val;
-        }
-        else if (side === 'b') {
-            c.bl = val;
-            c.br = val;
-        }
-        else if (side === 'l') {
-            c.tl = val;
-            c.bl = val;
-        }
-        else if (side === 'r') {
-            c.tr = val;
-            c.br = val;
-        }
-        else {
-            c[side] = val;
-        }
-        return { corners: c };
-    }
-    const allM = cls.match(/^rounded(?:-(.+))?$/);
-    if (allM) {
-        const val = allM[1] ?? '';
-        return { corners: { tl: val, tr: val, bl: val, br: val } };
-    }
-    return null;
+    const m = cls.match(/^rounded-(tl|tr|bl|br|t|b|l|r)(?:-(.+))?$/) ??
+        cls.match(/^rounded()(?:-(.+))?$/);
+    if (!m)
+        return null;
+    const value = m[2] ?? '';
+    const corners = {};
+    for (const corner of CORNER_MAP[m[1]])
+        corners[corner] = value;
+    return corners;
 }
 function collapseCorners(c) {
     const { tl, tr, bl, br } = c;
@@ -310,132 +265,117 @@ const BP_RANK = {
     '2xl': 5,
 };
 function collapseResponsiveCascade(classes) {
-    // Last-wins keyword utilities (display, position) share a single CSS property
-    // even though their class names differ, so they must group by property — not
-    // by class name — or an intermediate override (e.g. md:block between flex and
-    // lg:flex) is missed and the restoring class is wrongly dropped.
-    const propertyKey = (base) => {
-        if (DISPLAY_GROUP.has(base))
-            return 'display';
-        if (POSITION_GROUP.has(base))
-            return 'position';
-        const dash = base.lastIndexOf('-');
-        return dash === -1 ? base : base.slice(0, dash);
-    };
     const entries = classes.map((cls, idx) => {
         for (const bp of RESPONSIVE_BREAKPOINTS) {
             const prefix = `${bp}:`;
             if (cls.startsWith(prefix) && !cls.slice(prefix.length).includes(':')) {
                 const base = cls.slice(prefix.length);
-                return { bp, base, key: propertyKey(base), idx };
+                return { bp, base, idx };
             }
         }
-        return { bp: '', base: cls, key: propertyKey(cls), idx };
+        return { bp: '', base: cls, idx };
     });
-    const groups = new Map();
-    for (const e of entries) {
-        const arr = groups.get(e.key);
-        if (arr)
-            arr.push(e);
-        else
-            groups.set(e.key, [e]);
-    }
+    // Unknown variants cannot be ordered against the standard breakpoints safely.
+    if (entries.some((entry) => entry.base.includes(':')))
+        return classes;
+    if (!entries.some((entry) => entry.bp !== ''))
+        return classes;
+    const sorted = [...entries].sort((a, b) => BP_RANK[a.bp] - BP_RANK[b.bp] || a.idx - b.idx);
     const toRemove = new Set();
-    for (const group of groups.values()) {
-        if (group.length < 2 || !group.some((e) => e.bp !== ''))
-            continue;
-        const sorted = [...group].sort((a, b) => BP_RANK[a.bp] - BP_RANK[b.bp]);
-        let prev = null;
-        for (const entry of sorted) {
-            if (entry.base === prev) {
-                toRemove.add(entry.idx);
-            }
-            else {
-                prev = entry.base;
-            }
-        }
+    let prev = null;
+    for (const entry of sorted) {
+        if (entry.base === prev)
+            toRemove.add(entry.idx);
+        else
+            prev = entry.base;
     }
     return classes.filter((_, i) => !toRemove.has(i));
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
-function pushCollapsed(result, collapsed, classes) {
-    const original = [...new Set(classes)].join(' ');
-    result.push(...(collapsed === original ? original.split(' ') : collapsed.split(' ')));
+// Survivors keep their slot; new shorthands take the slot of the first token
+// they replace, so an unchanged group leaves the string byte-for-byte intact.
+function placeCollapsed(slots, classes, indices, collapsed) {
+    const firstIndex = new Map();
+    for (const i of indices) {
+        if (!firstIndex.has(classes[i]))
+            firstIndex.set(classes[i], i);
+    }
+    const kept = new Set();
+    const fresh = [];
+    for (const token of collapsed.split(' ')) {
+        const i = firstIndex.get(token);
+        if (i === undefined)
+            fresh.push(token);
+        else
+            kept.add(i);
+    }
+    for (const i of indices)
+        slots[i] = kept.has(i) ? [classes[i]] : [];
+    if (fresh.length === 0)
+        return;
+    const anchor = indices.find((i) => !kept.has(i)) ?? indices[0];
+    slots[anchor] = [...slots[anchor], ...fresh];
+}
+function keepLastOf(slots, indices) {
+    for (const i of indices.slice(0, -1))
+        slots[i] = [];
 }
 export function deduplicateClasses(classStr) {
-    let classes = classStr.split(/\s+/).filter(Boolean);
-    if (classes.length <= 1)
+    const original = classStr.split(/\s+/).filter(Boolean);
+    if (original.length <= 1)
         return classStr;
-    classes = collapseResponsiveCascade(classes);
-    let displayWinner = null;
-    let positionWinner = null;
+    const classes = collapseResponsiveCascade(original);
+    const slots = classes.map((cls) => [cls]);
+    const displayIndices = [];
+    const positionIndices = [];
     const seen = new Set();
-    const others = [];
     const boxGroups = new Map();
     const corners = { tl: null, tr: null, bl: null, br: null };
-    const cornersClasses = [];
-    for (const cls of classes) {
+    const cornerIndices = [];
+    classes.forEach((cls, idx) => {
         if (DISPLAY_GROUP.has(cls)) {
-            displayWinner = cls;
-            continue;
+            displayIndices.push(idx);
+            return;
         }
         if (POSITION_GROUP.has(cls)) {
-            positionWinner = cls;
-            continue;
+            positionIndices.push(idx);
+            return;
         }
         const parsed = parseBoxClass(cls);
         if (parsed) {
             const { family, sides } = parsed;
             let group = boxGroups.get(family.kind);
             if (!group) {
-                group = { family, box: { t: '', b: '', l: '', r: '' }, classes: [] };
+                group = { family, box: { t: '', b: '', l: '', r: '' }, indices: [] };
                 boxGroups.set(family.kind, group);
             }
-            group.classes.push(cls);
-            if (sides.t !== undefined)
-                group.box.t = sides.t;
-            if (sides.b !== undefined)
-                group.box.b = sides.b;
-            if (sides.l !== undefined)
-                group.box.l = sides.l;
-            if (sides.r !== undefined)
-                group.box.r = sides.r;
-            continue;
+            group.indices.push(idx);
+            Object.assign(group.box, sides);
+            return;
         }
-        const roundedParsed = parseRoundedCorner(cls);
-        if (roundedParsed) {
-            cornersClasses.push(cls);
-            const { corners: c } = roundedParsed;
-            if (c.tl !== undefined)
-                corners.tl = c.tl;
-            if (c.tr !== undefined)
-                corners.tr = c.tr;
-            if (c.bl !== undefined)
-                corners.bl = c.bl;
-            if (c.br !== undefined)
-                corners.br = c.br;
-            continue;
+        const roundedCorners = parseRoundedCorner(cls);
+        if (roundedCorners) {
+            cornerIndices.push(idx);
+            Object.assign(corners, roundedCorners);
+            return;
         }
-        if (!seen.has(cls)) {
+        if (seen.has(cls))
+            slots[idx] = [];
+        else
             seen.add(cls);
-            others.push(cls);
-        }
-    }
-    const result = [];
-    if (displayWinner)
-        result.push(displayWinner);
-    if (positionWinner)
-        result.push(positionWinner);
-    for (const { family, box, classes: groupClasses } of boxGroups.values()) {
-        if (groupClasses.length === 0)
-            continue;
-        pushCollapsed(result, collapseBox(box, family), groupClasses);
+    });
+    keepLastOf(slots, displayIndices);
+    keepLastOf(slots, positionIndices);
+    for (const { family, box, indices } of boxGroups.values()) {
+        placeCollapsed(slots, classes, indices, collapseBox(box, family));
     }
-    if (cornersClasses.length > 0) {
-        pushCollapsed(result, collapseCorners(corners), cornersClasses);
+    if (cornerIndices.length > 0) {
+        placeCollapsed(slots, classes, cornerIndices, collapseCorners(corners));
     }
-    result.push(...others);
-    return result.join(' ');
+    const result = slots.flat();
+    const unchanged = result.length === original.length &&
+        result.every((cls, i) => cls === original[i]);
+    return unchanged ? classStr : result.join(' ');
 }
 export function dedupeContent(content, opts = {}) {
     return replaceClassStrings(content, deduplicateClasses, {

package/dist/core/merger.js

@@ -38,9 +38,15 @@ function isUnsafeTextSize(base, customTextClasses) {
  * `cls`'s own position — a leading declared after it never applied to it.
  */
 function lastLeadingBefore(originalClasses, cls, mergedTokens) {
-    // twMerge only filters tokens, never synthesises one, so `cls` is always
-    // present in the original — `findIndex` cannot return -1 here.
-    const at = originalClasses.findIndex(({ token }) => token === cls.token);
+    // twMerge keeps the last occurrence of repeated class tokens. Use that
+    // occurrence when restoring its preceding leading utility.
+    let at = -1;
+    for (let i = originalClasses.length - 1; i >= 0; i -= 1) {
+        if (originalClasses[i].token === cls.token) {
+            at = i;
+            break;
+        }
+    }
     for (let i = at - 1; i >= 0; i -= 1) {
         const candidate = originalClasses[i];
         if (RE_LEADING.test(candidate.base) &&

package/dist/core/rules.d.ts

@@ -43,5 +43,10 @@ export type Config = {
     /** Target Tailwind major. v3 restricts suggestions to its discrete scale. */
     tailwindVersion?: 3 | 4;
 };
+/**
+ * Suggests the canonical form of a class, preserving its variants
+ * (`hover:`, `md:`, `[&:hover]:`), important modifier (`!p-4` / `p-4!`)
+ * and sign (`-mt-[8px]` / `mt-[-8px]` → `-mt-2`).
+ */
 export declare function suggestCanonical(cls: string, config?: Config): Suggestion | null;
 export {};