slot-variants 1.3.0 → 1.4.0

package/README.md

@@ -668,7 +668,7 @@ The `postProcess` function is applied to each slot's final class string independ
 
 ### Caching
 
-Results are cached automatically for performance. The default cache size is **256** entries. Calls with `class` or `className` props bypass the cache.
+Results are cached automatically for performance. The default cache size is **256** entries.
 
 ```typescript
 const button = sv('btn', {
@@ -896,20 +896,30 @@ Class values inside the config (`base`, `variants`, `slots`, and `compound*` `cl
 
 ### Rules
 
-- **`slot-variants/no-duplicate-classes`** — flags class name tokens that will appear more than once in the output of an `sv()` or `cn()` call. For `sv()`, detects duplicates within `base`, across different variant keys, inside compound variants and compound slots, between `base` and a variant value, and within a single literal. For `cn()` (and the cn-style calling convention of `sv()` without a config), flags any token that appears in more than one always-present source — across args, inside arrays, template literals, or within a single literal.
+- **`slot-variants/no-conflicting-classes`** — flags class tokens that collide within the output of an `sv()` or `cn()` call: both exact-duplicate tokens that will appear more than once and distinct tokens that target the same Tailwind-style utility namespace (e.g. `w-100` and `w-200`). For `sv()`, detects collisions within `base`, across different variant keys, inside compound variants and compound slots, between `base` and a variant value, and within a single literal. For `cn()` (and the cn-style calling convention of `sv()` without a config), flags collisions across args, inside arrays, template literals, or within a single literal. Tokens with different variant prefixes (`w-100` vs `hover:w-200`) don't conflict, the trailing `!` important marker is ignored when computing the namespace, and tokens that only co-occur across mutually-exclusive variant values are skipped.
 
 - **`slot-variants/no-dynamic-classes`** — flags class-bearing positions in `sv()` and `cn()` calls that aren't statically inferrable. Only string literals, template literals without expressions, flat arrays of those in config, and explicit `undefined` config class values are accepted, and config objects must use static keys (no spreads, no computed keys). Identifiers, member access, calls, spreads, non-string literals, templates with expressions, nested config arrays, and runtime conditional records are reported. Non-class-bearing config keys (`defaultVariants`, `presets`, `requiredVariants`, `cacheSize`, `postProcess`, `introspection`) are not validated, and runtime variant matchers inside compound entries are left alone — only the `class`/`className` value (and the `slots` array of `compoundSlots`) is checked.
 
 - **`slot-variants/no-empty-classes`** — flags empty class values — empty strings, empty arrays, and empty objects — at any class-bearing position reachable from an `sv()` or `cn()` call, plus zero-argument `sv()` / `cn()` calls themselves (which always produce an empty class string). Reports empties in positional arguments (and inside arrays nested in those), in `base`, in variants including slot-keyed variant branches, in the `class`/`className` of `compoundVariants` and `compoundSlots` entries, and in the top-level `slots`, `variants`, `compoundVariants`, and `compoundSlots` containers themselves. Inside an `sv()` config, an empty string is still allowed as a direct `slots[key]` value — declaring a slot with no default classes is a valid use case.
 
-- **`slot-variants/no-redundant-spaces`** — flags class strings whose whitespace isn't canonical. Inside a class string, whitespace is canonical only as a single ASCII space between two non-whitespace tokens, so leading or trailing whitespace, repeated spaces, and non-space whitespace (tabs, newlines, etc.) are reported. The rule walks every string and expressionless template literal reachable from a call's arguments — including values nested inside arrays and objects — and bails silently on dynamic expressions.
+- **`slot-variants/no-redundant-spaces`** — flags class strings whose whitespace isn't canonical. Inside a class string, whitespace is canonical only as a single ASCII space between two non-whitespace tokens, so leading or trailing whitespace, repeated spaces, and non-space whitespace (tabs, newlines, etc.) are reported. The rule walks every string and expressionless template literal reachable from a call's arguments — including values nested inside arrays and objects — and bails silently on dynamic expressions. **Auto-fixable**: `eslint --fix` rewrites each offending literal in place, preserving its original quote style.
 
 - **`slot-variants/no-shared-tokens`** — flags class tokens that appear in every value of an exhaustively-covered variant, where “exhaustive” means the variant has a statically defined default value or is listed in `requiredVariants`. Those tokens are constant in the rendered output, so they belong in `base` or the corresponding `slots[slot]` entry rather than being repeated in every variant value. The rule only analyzes `sv()` calls with a config, compares tokens per-slot, skips non-exhaustive variants, single-value variants, boolean shorthand, undefined or dynamic defaults, and dynamic or partially-analyzable variant value records, and reports every repeated occurrence that should be lifted out.
 
-Only calls where `sv` or `cn` is a named import from `'slot-variants'` are analyzed. `no-duplicate-classes` skips dynamic inputs silently to avoid false positives; `no-dynamic-classes` is the opposite — it flags exactly those positions so the static analyzer can fully reason about every call. `no-shared-tokens` sits between them: it needs a fully statically analyzable, exhaustive variant before it can prove a token is constant across every value. `no-empty-classes` and `no-redundant-spaces` are independent and complement the structural rules: they cover empty and badly-shaped literals reachable from a call's arguments, regardless of whether the surrounding call is fully static.
+Only calls where `sv` or `cn` is a named import from `'slot-variants'` are analyzed. `no-conflicting-classes` skips dynamic inputs silently to avoid false positives; `no-dynamic-classes` is the opposite — it flags exactly those positions so the static analyzer can fully reason about every call. `no-shared-tokens` sits between them: it needs a fully statically analyzable, exhaustive variant before it can prove a token is constant across every value. `no-empty-classes` and `no-redundant-spaces` are independent and complement the structural rules: they cover empty and badly-shaped literals reachable from a call's arguments, regardless of whether the surrounding call is fully static.
 
 ### ESLint (flat config)
 
+Use the `recommended` preset to enable every rule at `error` in one line:
+
+```js
+import svPlugin from 'slot-variants/eslint-plugin';
+
+export default [svPlugin.configs.recommended];
+```
+
+Or wire each rule by hand if you want per-rule control:
+
 ```js
 import svPlugin from 'slot-variants/eslint-plugin';
 
@@ -917,7 +927,7 @@ export default [
   {
     plugins: { 'slot-variants': svPlugin },
     rules: {
-      'slot-variants/no-duplicate-classes': 'error',
+      'slot-variants/no-conflicting-classes': 'error',
       'slot-variants/no-dynamic-classes': 'error',
       'slot-variants/no-empty-classes': 'error',
       'slot-variants/no-redundant-spaces': 'error',
@@ -933,7 +943,7 @@ export default [
 {
   "jsPlugins": ["slot-variants/eslint-plugin"],
   "rules": {
-    "slot-variants/no-duplicate-classes": "error",
+    "slot-variants/no-conflicting-classes": "error",
     "slot-variants/no-dynamic-classes": "error",
     "slot-variants/no-empty-classes": "error",
     "slot-variants/no-redundant-spaces": "error",
@@ -960,7 +970,7 @@ const button = sv({
 cn('flex items-center', 'flex'); // 'flex' duplicated across args
 ```
 
-`no-duplicate-classes` reports `flex` on the `base` literal and on both variant values; for the `cn()` call, both occurrences of `'flex'` are flagged. Move the shared class into `base` — or use compound variants — so each class has a single source.
+`no-conflicting-classes` reports `flex` on the `base` literal and on both variant values; for the `cn()` call, both occurrences of `'flex'` are flagged. Move the shared class into `base` — or use compound variants — so each class has a single source.
 
 ```typescript
 import { sv, cn } from 'slot-variants';
@@ -1000,7 +1010,7 @@ sv({ slots: { body: 'p-4 ' } });               // trailing space
 cn(`flex\titems-center`);                      // tab between tokens
 ```
 
-`no-redundant-spaces` reports each literal whose whitespace deviates from the canonical "tokens separated by exactly one space" form. Trim and collapse the strings — or split them into array entries — so the stored class output is byte-stable and easy to scan in diffs.
+`no-redundant-spaces` reports each literal whose whitespace deviates from the canonical "tokens separated by exactly one space" form. Trim and collapse the strings — or split them into array entries — so the stored class output is byte-stable and easy to scan in diffs. Run `eslint --fix` to apply the canonical form automatically; the fixer rewrites the literal in place using the original quote style.
 
 ```typescript
 import { sv } from 'slot-variants';
@@ -1070,7 +1080,7 @@ module.exports = {
       size: { sm: 'text-sm', lg: 'text-lg' },
       intent: { primary: 'bg-blue-500', danger: 'bg-red-500' }
     },
-    defaultVariants: { size: 'md' },
+    defaultVariants: { size: 'sm' },
     compoundVariants: [
       { size: 'lg', intent: 'primary', class: 'uppercase' }
     ]
@@ -1093,7 +1103,7 @@ Everything else works identically — the config shape, `class`/`className` over
     variants: {
       size: { sm: 'text-sm', lg: 'text-lg' }
     },
-    defaultVariants: { size: 'md' }
+    defaultVariants: { size: 'sm' }
   });
 ```
 

package/{AGENTS.md → SKILL.md}

@@ -215,8 +215,6 @@ const button = sv('btn', {
 
 Cache inspection methods (`getCacheSize`, `clearCache`) are only exposed when `introspection: true` is set — see rule 11.
 
-Note: Using `class` or `className` prop bypasses caching.
-
 ### 10. Use Presets for Reusable Variant Combinations
 
 Define presets for frequently used combinations of variants (rarely needed):
@@ -449,7 +447,7 @@ import svPlugin from 'slot-variants/eslint-plugin';
 export default [{
   plugins: { 'slot-variants': svPlugin },
   rules: {
-    'slot-variants/no-duplicate-classes': 'error',
+    'slot-variants/no-conflicting-classes': 'error',
     'slot-variants/no-dynamic-classes': 'error',
     'slot-variants/no-empty-classes': 'error',
     'slot-variants/no-redundant-spaces': 'error',
@@ -463,7 +461,7 @@ export default [{
 {
   "jsPlugins": ["slot-variants/eslint-plugin"],
   "rules": {
-    "slot-variants/no-duplicate-classes": "error",
+    "slot-variants/no-conflicting-classes": "error",
     "slot-variants/no-dynamic-classes": "error",
     "slot-variants/no-empty-classes": "error",
     "slot-variants/no-redundant-spaces": "error",
@@ -474,18 +472,19 @@ export default [{
 
 All rules only analyze calls where `sv` or `cn` is a **named import** from `'slot-variants'`. Default, namespace, and aliased-to-other-identifier imports are ignored.
 
-### `slot-variants/no-duplicate-classes`
+### `slot-variants/no-conflicting-classes`
 
-Reports class tokens that will appear more than once in the output of an `sv()` or `cn()` call.
+Reports class tokens that collide within the output of an `sv()` or `cn()` call: exact-duplicate tokens that will appear more than once, and distinct tokens that target the same Tailwind-style utility namespace (e.g. `w-100` and `w-200`).
 
-- For `sv()` with a config, flags a token as duplicated when two of its sources can both be active at runtime: base + any variant, base + compound, two variants with different keys, two compound entries, or the same literal token repeated inside a single source.
-- Does **not** flag the same token appearing in different values of the **same** variant key (those are mutually exclusive).
-- For `cn()` (and `sv()` called without a config — the cn-style calling convention), flags any token that appears in more than one always-present source: across args, inside arrays, template literals without expressions, or within a single literal.
+- For `sv()` with a config, flags a collision when two of its sources can both be active at runtime: base + any variant, base + compound, two variants with different keys, two compound entries, or the same literal token repeated inside a single source.
+- Does **not** flag tokens that only co-occur across different values of the **same** variant key (those are mutually exclusive at runtime).
+- For `cn()` (and `sv()` called without a config — the cn-style calling convention), flags collisions across args, inside arrays, template literals without expressions, or within a single literal.
+- Tokens with different variant prefixes (`w-100` vs `hover:w-200`) don't conflict; the trailing `!` important marker is ignored when computing the namespace; single-word utilities (no `-`) participate only in exact-duplicate detection.
 - Bails out silently on dynamic inputs (identifiers, spreads, computed keys, template literals with expressions, cn-style `{ cls: condition }` records) — no false positives for code it can't statically resolve.
 
 ### `slot-variants/no-dynamic-classes`
 
-Reports class-bearing positions in `sv()` and `cn()` calls that aren't statically inferrable. Pair this rule with `no-duplicate-classes` to guarantee every call is fully analyzable.
+Reports class-bearing positions in `sv()` and `cn()` calls that aren't statically inferrable. Pair this rule with `no-conflicting-classes` to guarantee every call is fully analyzable.
 
 - Accepts only string literals, template literals without expressions, and arrays of those as class values. Identifiers, member access, calls, spreads, non-string literals, templates with expressions, and object records are reported.
 - For `sv()` config, validates `base`, `slots` values, `variants` values (both record form and boolean shorthand), and the `class` / `className` of `compoundVariants` / `compoundSlots` entries. The `slots` array of `compoundSlots` must be a static array of string literals.
@@ -525,6 +524,5 @@ Reports class tokens that appear in every value of an exhaustively-covered varia
 ## Performance Notes
 
 1. **Caching is automatic** - Results are cached by default
-2. **Class prop bypasses cache** - Dynamic classes at runtime should use `class` prop
-3. **Complex components benefit from larger cache** - Increase `cacheSize` for components with many variant combinations
-4. **Prefer static defaults** - Function-based defaults are called on every invocation
+2. **Complex components benefit from larger cache** - Increase `cacheSize` for components with many variant combinations
+3. **Prefer static defaults** - Function-based defaults are called on every invocation

package/dist/eslint-plugin.cjs

@@ -105,14 +105,15 @@ var getStrictProperties = (obj) => {
   if (!obj || obj.type !== "ObjectExpression") {
     return null;
   }
-  if (strictPropertiesCache.has(obj)) {
-    return strictPropertiesCache.get(obj) ?? null;
+  const cached = strictPropertiesCache.get(obj);
+  if (cached !== void 0) {
+    return cached;
   }
   const map = buildStrictPropertiesMap(obj);
   strictPropertiesCache.set(obj, map);
   return map;
 };
-var isSlotKeyedPropertyKey = (key, slotNames) => key === "base" || key !== null && slotNames.has(key);
+var isSlotKeyedPropertyKey = (key, slotNames) => key !== null && (key === "base" || slotNames.has(key));
 var buildSlotKeyedMap = (obj, slotNames) => {
   const result = /* @__PURE__ */ new Map();
   for (const prop of obj.properties) {
@@ -133,7 +134,12 @@ var collectSlotKeyedProperties = (node, slotNames) => {
   }
   return buildSlotKeyedMap(node, slotNames);
 };
-var getIdentifierCalleeName = (node) => node.callee.type === "Identifier" ? node.callee.name : null;
+var getIdentifierCalleeName = (node) => {
+  if (node.callee.type === "Identifier") {
+    return node.callee.name;
+  }
+  return null;
+};
 var matchSvCall = (node) => {
   const args = node.arguments;
   const last = args[args.length - 1];
@@ -172,7 +178,12 @@ var isConfigLike = (node) => {
 };
 var baseSource = { kind: "base" };
 var compoundSource = { kind: "compound" };
-var getVariantSource = (entry) => entry.source.kind === "variant" ? entry.source : null;
+var getVariantSource = (entry) => {
+  if (entry.source.kind === "variant") {
+    return entry.source;
+  }
+  return null;
+};
 var sharesVariantKey = (sharedKey, source) => sharedKey === null || sharedKey === source.key;
 var isExclusiveVariantSource = (source, sharedKey, seenValues) => source !== null && sharesVariantKey(sharedKey, source) && !seenValues.has(source.value);
 var isMutuallyExclusiveVariants = (list) => {
@@ -365,45 +376,6 @@ var collectConfigEntries = (config, slotNames, baseArgs, sourceCode) => {
   );
   return entries;
 };
-var reportDuplicatesBySlot = (context, bySlot) => {
-  for (const [slotKey, tokenMap] of bySlot.entries()) {
-    reportDuplicateTokens(context, tokenMap, "duplicate", {
-      slot: slotKey
-    });
-  }
-};
-var analyzeConfig = (context, configNode, baseArgs) => {
-  const config = getProperties(configNode);
-  const slotNames = getConfigSlotNames(config);
-  reportDuplicatesBySlot(
-    context,
-    indexEntriesBySlotAndToken(
-      collectConfigEntries(
-        config,
-        slotNames,
-        baseArgs,
-        context.sourceCode
-      )
-    )
-  );
-};
-var analyzeCnCall = (context, args) => {
-  const entries = [];
-  for (const arg of args) {
-    extractTokens(
-      arg,
-      "base",
-      baseSource,
-      EMPTY_SLOT_NAMES,
-      entries,
-      context.sourceCode
-    );
-  }
-  const tokenMap = indexEntriesBySlotAndToken(entries).get("base");
-  if (tokenMap) {
-    reportDuplicateTokens(context, tokenMap, "duplicateCn", {});
-  }
-};
 var reportDynamic = (context, node) => {
   context.report({ node, messageId: "dynamic" });
 };
@@ -540,7 +512,10 @@ var getCompoundEntryValueChecker = (key, hasSlotsKey) => {
     return checkConfigClassValueIsStatic;
   }
   if (key === "slots") {
-    return hasSlotsKey ? checkCompoundSlotsArray : null;
+    if (hasSlotsKey) {
+      return checkCompoundSlotsArray;
+    }
+    return null;
   }
   return null;
 };
@@ -652,15 +627,38 @@ var noDynamicClasses = {
     });
   }
 };
-var hasRedundantSpaces = (value) => !/^(?:[^\s]+(?: [^\s]+)*)?$/.test(value);
+var hasRedundantSpaces = (value) => !/^(?:\S+(?: \S+)*)?$/.test(value);
+var canonicalizeWhitespace = (value) => value.split(/\s+/).filter(Boolean).join(" ");
+var canHoistAsLiteral = (canonical, quote) => {
+  if (canonical.includes("\\") || canonical.includes(quote)) {
+    return false;
+  }
+  return quote !== "`" || !canonical.includes("${");
+};
 var reportRedundantSpaces = (context, node, value) => {
-  if (hasRedundantSpaces(value)) {
-    context.report({ node, messageId: "redundant" });
+  if (!hasRedundantSpaces(value)) {
+    return;
   }
+  const raw = context.sourceCode.getText(node);
+  const quote = raw[0] ?? "";
+  const canonical = canonicalizeWhitespace(value);
+  context.report({
+    node,
+    messageId: "redundant",
+    fix: (fixer) => {
+      if (!canHoistAsLiteral(canonical, quote)) {
+        return null;
+      }
+      return fixer.replaceText(node, `${quote}${canonical}${quote}`);
+    }
+  });
 };
 var getStaticStringText = (node) => {
   if (node.type === "Literal") {
-    return typeof node.value === "string" ? node.value : null;
+    if (typeof node.value === "string") {
+      return node.value;
+    }
+    return null;
   }
   if (node.type !== "TemplateLiteral" || node.expressions.length > 0) {
     return null;
@@ -721,6 +719,7 @@ var noRedundantSpaces = {
     docs: {
       description: "Disallow redundant whitespace inside class strings passed to sv() and cn() calls"
     },
+    fixable: "code",
     schema: [],
     messages: {
       redundant: "Redundant whitespace in class string."
@@ -741,24 +740,102 @@ var noRedundantSpaces = {
     });
   }
 };
-var noDuplicateClasses = {
+var getConflictKey = (token) => {
+  let stripped = token;
+  if (token.endsWith("!")) {
+    stripped = token.slice(0, -1);
+  }
+  const lastColon = stripped.lastIndexOf(":");
+  let variantPrefix = "";
+  let utility = stripped;
+  if (lastColon !== -1) {
+    variantPrefix = stripped.slice(0, lastColon);
+    utility = stripped.slice(lastColon + 1);
+  }
+  let utilStart = 0;
+  if (utility.startsWith("-")) {
+    utilStart = 1;
+  }
+  const firstDash = utility.indexOf("-", utilStart + 1);
+  if (firstDash === -1) {
+    return null;
+  }
+  return `${variantPrefix}|${utility.slice(utilStart, firstDash)}`;
+};
+var groupEntriesByConflictKey = (tokenMap) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [token, list] of tokenMap) {
+    const key = getConflictKey(token);
+    if (key === null) {
+      continue;
+    }
+    const group = getOrCreate(groups, key, () => ({
+      tokens: /* @__PURE__ */ new Set(),
+      entries: []
+    }));
+    group.tokens.add(token);
+    group.entries.push(...list);
+  }
+  return groups;
+};
+var reportConflicts = (context, tokenMap, messageId, data) => {
+  for (const group of groupEntriesByConflictKey(tokenMap).values()) {
+    if (group.tokens.size < 2 || isMutuallyExclusiveVariants(group.entries)) {
+      continue;
+    }
+    const tokens = [...group.tokens].sort().join(", ");
+    reportEntryList(context, group.entries, messageId, { tokens, ...data });
+  }
+};
+var analyzeConfigForRule = (context, configNode, baseArgs) => {
+  const config = getProperties(configNode);
+  const slotNames = getConfigSlotNames(config);
+  const bySlot = indexEntriesBySlotAndToken(
+    collectConfigEntries(config, slotNames, baseArgs, context.sourceCode)
+  );
+  for (const [slot, tokenMap] of bySlot) {
+    reportDuplicateTokens(context, tokenMap, "duplicate", { slot });
+    reportConflicts(context, tokenMap, "conflict", { slot });
+  }
+};
+var analyzeCnForRule = (context, args) => {
+  const entries = [];
+  for (const arg of args) {
+    extractTokens(
+      arg,
+      "base",
+      baseSource,
+      EMPTY_SLOT_NAMES,
+      entries,
+      context.sourceCode
+    );
+  }
+  const tokenMap = indexEntriesBySlotAndToken(entries).get("base");
+  if (tokenMap) {
+    reportDuplicateTokens(context, tokenMap, "duplicateCn", {});
+    reportConflicts(context, tokenMap, "conflictCn", {});
+  }
+};
+var noConflictingClasses = {
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow duplicate class names in sv() and cn() outputs across slots, variants, and compounds"
+      description: "Disallow duplicate class tokens and tokens targeting the same utility namespace within an sv() or cn() output"
     },
     schema: [],
     messages: {
       duplicate: 'Class "{{token}}" will appear more than once in the "{{slot}}" slot output.',
-      duplicateCn: 'Class "{{token}}" will appear more than once in the call output.'
+      duplicateCn: 'Class "{{token}}" will appear more than once in the call output.',
+      conflict: 'Conflicting classes "{{tokens}}" target the same utility namespace in the "{{slot}}" slot output.',
+      conflictCn: 'Conflicting classes "{{tokens}}" target the same utility namespace in the call output.'
     }
   },
   create(context) {
     return createTrackedCallListeners((_node, call) => {
       if (call.config) {
-        analyzeConfig(context, call.config, call.args);
+        analyzeConfigForRule(context, call.config, call.args);
       } else {
-        analyzeCnCall(context, call.args);
+        analyzeCnForRule(context, call.args);
       }
     });
   }
@@ -945,23 +1022,48 @@ var noSharedTokens = {
 var isEmptyStringNode = (node) => getStaticStringText(node) === "";
 var shouldReportEmptyString = (node, allowEmptyString) => !allowEmptyString && isEmptyStringNode(node);
 var isEmptyObjectExpression = (node) => node.type === "ObjectExpression" && node.properties.length === 0;
-var visitForEmptyClasses = (context, node, allowEmptyString) => {
+var removeFromList = (fixer, sourceCode, node, list) => {
+  let nonNullCount = 0;
+  for (const item of list) {
+    if (item) {
+      nonNullCount += 1;
+    }
+  }
+  if (nonNullCount <= 1) {
+    return null;
+  }
+  const [start, end] = sourceCode.getRange(node);
+  const after = sourceCode.getTokenAfter(node);
+  if (after && after.value === ",") {
+    return fixer.removeRange([start, after.range[1]]);
+  }
+  const before = sourceCode.getTokenBefore(node);
+  if (!before || before.value !== ",") {
+    return null;
+  }
+  return fixer.removeRange([before.range[0], end]);
+};
+var visitForEmptyClasses = (context, node, allowEmptyString, list) => {
+  let fix;
+  if (list) {
+    fix = (fixer) => removeFromList(fixer, context.sourceCode, node, list);
+  }
   if (shouldReportEmptyString(node, allowEmptyString)) {
-    context.report({ node, messageId: "emptyString" });
+    context.report({ node, messageId: "emptyString", fix });
     return;
   }
   if (node.type === "ArrayExpression") {
     if (node.elements.length === 0) {
-      context.report({ node, messageId: "emptyArray" });
+      context.report({ node, messageId: "emptyArray", fix });
       return;
     }
     forEachStaticItem(node.elements, (element) => {
-      visitForEmptyClasses(context, element, false);
+      visitForEmptyClasses(context, element, false, node.elements);
     });
     return;
   }
   if (isEmptyObjectExpression(node)) {
-    context.report({ node, messageId: "emptyObject" });
+    context.report({ node, messageId: "emptyObject", fix });
   }
 };
 var visitVariantRecordForEmpty = (context, node) => {
@@ -1025,6 +1127,7 @@ var noEmptyClasses = {
     docs: {
       description: "Disallow empty class values (empty strings, arrays, or objects) and zero-argument calls in sv() and cn()"
     },
+    fixable: "code",
     schema: [],
     messages: {
       emptyString: "Empty class string is not allowed.",
@@ -1040,7 +1143,7 @@ var noEmptyClasses = {
         return;
       }
       forEachStaticItem(call.args, (arg) => {
-        visitForEmptyClasses(context, arg, false);
+        visitForEmptyClasses(context, arg, false, node.arguments);
       });
       if (call.config) {
         dispatchSvConfigCheckers(
@@ -1053,14 +1156,30 @@ var noEmptyClasses = {
   }
 };
 var rules = {
-  "no-duplicate-classes": noDuplicateClasses,
+  "no-conflicting-classes": noConflictingClasses,
   "no-dynamic-classes": noDynamicClasses,
   "no-empty-classes": noEmptyClasses,
   "no-redundant-spaces": noRedundantSpaces,
   "no-shared-tokens": noSharedTokens
 };
 var meta = { name: "slot-variants" };
-var eslint_plugin_default = { meta, rules };
+var recommendedRules = {
+  "slot-variants/no-conflicting-classes": "error",
+  "slot-variants/no-dynamic-classes": "error",
+  "slot-variants/no-empty-classes": "error",
+  "slot-variants/no-redundant-spaces": "error",
+  "slot-variants/no-shared-tokens": "error"
+};
+var plugin = {
+  meta,
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: { "slot-variants": plugin },
+  rules: recommendedRules
+};
+var eslint_plugin_default = plugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   rules

package/dist/eslint-plugin.d.ts

@@ -1,26 +1,27 @@
-import { Rule } from 'eslint';
+import { Rule, Linter } from 'eslint';
 
 /**
  * Rules exported by the plugin.
  */
 declare const rules: {
-    'no-duplicate-classes': Rule.RuleModule;
+    'no-conflicting-classes': Rule.RuleModule;
     'no-dynamic-classes': Rule.RuleModule;
     'no-empty-classes': Rule.RuleModule;
     'no-redundant-spaces': Rule.RuleModule;
     'no-shared-tokens': Rule.RuleModule;
 };
-declare const _default: {
+declare const plugin: {
     meta: {
         name: string;
     };
     rules: {
-        'no-duplicate-classes': Rule.RuleModule;
+        'no-conflicting-classes': Rule.RuleModule;
         'no-dynamic-classes': Rule.RuleModule;
         'no-empty-classes': Rule.RuleModule;
         'no-redundant-spaces': Rule.RuleModule;
         'no-shared-tokens': Rule.RuleModule;
     };
+    configs: Record<string, Linter.Config>;
 };
 
-export { _default as default, rules };
+export { plugin as default, rules };