stylelint-plugin-rhythmguard 3.10.2 → 3.12.0

package/src/rules/prefer-token/index.js

@@ -7,6 +7,7 @@ const {
   isHairlineLength,
   numbersEqual,
   parseLengthToken,
+  pxOnScale,
   toPx,
 } = require('../../core/length');
 const {
@@ -15,14 +16,17 @@ const {
 } = require('../../core/options');
 const {
   collectMathBounds,
+  declarationValueSource,
   isBoundFunction,
   isKeyword,
   isMathFunction,
-  isTokenFunction,
   propertyMatches,
+  sassOperandNodes,
   shouldLintMathArgument,
+  skipTokenFunction,
   walkRootValueNodes,
   walkTransformTranslateNodes,
+  writeDeclarationValue,
 } = require('../../core/value-nodes');
 const { buildEffectiveTokenMap } = require('../../core/token-map');
 
@@ -36,9 +40,9 @@ const { validatePrimary, validatePreferTokenSecondaryOptions } = require('../val
 
 const {
   negateReplacement,
+  signedTokensForLength,
   tokenFitsProperty,
   tokenIndexFromDefinitions,
-  tokensForLength,
 } = require('../../core/token-index');
 
 const ruleName = 'rhythmguard/prefer-token';
@@ -61,30 +65,31 @@ function listTokens(tokens) {
     : references.join('');
 }
 
-function applyNegativeToken(replacement, parsedLength) {
-  return !replacement || parsedLength.number >= 0 ? replacement : negateReplacement(replacement);
-}
-
-/** The token for a raw length, and the text the fix writes (negated when the literal is). */
+/**
+ * The token for a raw length, and the text the fix writes. A key with the
+ * literal's sign holds exactly that value, so its token is written as is; a
+ * negative literal that only matches the positive key gets the token negated.
+ * Keys are signed, so a positive literal never finds a negative token (issue
+ * #221).
+ */
 function resolveTokenReplacement(tokenMap, raw, parsedLength, options) {
-  const found = (token) => ({ replacement: applyNegativeToken(token, parsedLength), token });
-
-  if (Object.prototype.hasOwnProperty.call(tokenMap, raw)) {
-    return found(tokenMap[raw]);
-  }
-
-  const absoluteRaw = formatLength(Math.abs(parsedLength.number), parsedLength.unit || 'px');
-  if (Object.prototype.hasOwnProperty.call(tokenMap, absoluteRaw)) {
-    return found(tokenMap[absoluteRaw]);
+  const unit = parsedLength.unit || 'px';
+  const negative = parsedLength.number < 0;
+  // [key, negate]: the literal as written, then normalized, then in px.
+  const lookups = [[raw, false], [formatLength(parsedLength.number, unit), false]];
+  if (negative) lookups.push([formatLength(Math.abs(parsedLength.number), unit), true]);
+  if (options.unitStrategy === 'convert') {
+    const px = toPx(parsedLength.number, parsedLength.unit, options.baseFontSize);
+    if (px !== null) {
+      lookups.push([`${px}px`, false]);
+      if (negative) lookups.push([`${Math.abs(px)}px`, true]);
+    }
   }
 
-  if (options.unitStrategy === 'convert') {
-    const absPx = toPx(Math.abs(parsedLength.number), parsedLength.unit, options.baseFontSize);
-    if (absPx !== null) {
-      const pxKey = `${absPx}px`;
-      if (Object.prototype.hasOwnProperty.call(tokenMap, pxKey)) {
-        return found(tokenMap[pxKey]);
-      }
+  for (const [key, negate] of lookups) {
+    if (Object.prototype.hasOwnProperty.call(tokenMap, key)) {
+      const token = tokenMap[key];
+      return { replacement: negate ? negateReplacement(token) : token, token };
     }
   }
 
@@ -98,15 +103,16 @@ function resolveTokenReplacement(tokenMap, raw, parsedLength, options) {
  * token in another unit, or several tokens, are named but never written.
  */
 function resolveFromIndex(tokenIndex, parsedLength, prop, options) {
-  const px = toPx(Math.abs(parsedLength.number), parsedLength.unit || 'px', options.baseFontSize);
+  const px = toPx(parsedLength.number, parsedLength.unit || 'px', options.baseFontSize);
   if (px === null || tokenIndex.length === 0) {
     return { candidates: [] };
   }
   const unit = parsedLength.unit || 'px';
-  const sameUnit = tokensForLength(tokenIndex, px, unit, { prop });
-  const candidates = sameUnit.length > 0 || options.unitStrategy !== 'convert'
+  const sameUnit = signedTokensForLength(tokenIndex, px, unit, { prop });
+  const found = sameUnit.tokens.length > 0 || options.unitStrategy !== 'convert'
     ? sameUnit
-    : tokensForLength(tokenIndex, px, unit, { anyUnit: true, prop });
+    : signedTokensForLength(tokenIndex, px, unit, { anyUnit: true, prop });
+  const candidates = found.tokens;
   if (candidates.length !== 1) {
     return { candidates };
   }
@@ -114,13 +120,19 @@ function resolveFromIndex(tokenIndex, parsedLength, prop, options) {
   const entry = tokenIndex.find((item) => item.token === candidates[0]);
   return {
     candidates,
-    fixable: sameUnit.length === 1,
+    fixable: sameUnit.tokens.length === 1,
     origin: entry ? entry.file : null,
-    replacement: applyNegativeToken(token, parsedLength),
+    replacement: found.negate ? negateReplacement(token) : token,
     token,
   };
 }
 
+/** The custom property a replacement such as `var(--space-2)` or `calc(-1 * var(--space-2))` writes. */
+function replacementToken(replacement) {
+  const match = typeof replacement === 'string' ? replacement.match(/var\(\s*(--[^\s,)]+)/) : null;
+  return match ? match[1] : null;
+}
+
 const ruleFunction = (primary, secondaryOptions) => {
   return (root, result) => {
     const valid = validatePrimary(result, ruleName, primary);
@@ -143,7 +155,7 @@ const ruleFunction = (primary, secondaryOptions) => {
 
     withResolvedScale(options, root);
 
-    const tokenRegex = createTokenRegex(options.tokenPattern, result, ruleName);
+    const tokenRegex = createTokenRegex(options.tokenPattern, { result, root, ruleName });
     const origins = {};
     const tokenMap = buildEffectiveTokenMap({
       options,
@@ -175,24 +187,36 @@ const ruleFunction = (primary, secondaryOptions) => {
         return;
       }
 
-      const parsed = valueParser(decl.value);
+      const source = declarationValueSource(decl);
+      const parsed = valueParser(source.parseText);
       const { scaleByUnit, scalePx } = getScaleStateForProperty(prop);
-      let changed = false;
-
-      const reportNode = (node, parsedLength, position = null) => {
+      // Operands of a Sass expression are reported, never rewritten (issue #234).
+      const sassOperands = sassOperandNodes(parsed, decl.value);
+
+      // `avoidTokens`: the var() names a fallback literal falls back from. A
+      // fallback held by one of them restates that token and passes; it is
+      // never replaced with the token it is the fallback of (issue #240).
+      const reportNode = (node, parsedLength, position = null, avoidTokens = []) => {
+        const fixable = !sassOperands.has(node);
         const mapped = resolveTokenReplacement(tokenMap, node.value, parsedLength, options);
         if (mapped && tokenFitsProperty(mapped.token, prop)) {
+          if (avoidTokens.includes(replacementToken(mapped.token))) {
+            return;
+          }
           const origin = origins[mapped.token] || null;
-          reportValueNode({ decl, message: messages.rejected(node.value, mapped.replacement, origin, options.note, [], position), node, replacement: mapped.replacement, result, ruleName });
+          reportValueNode({ decl, message: messages.rejected(node.value, mapped.replacement, origin, options.note, [], position), node, replacement: fixable ? mapped.replacement : null, result, ruleName });
           return;
         }
         const indexed = resolveFromIndex(tokenIndex, parsedLength, prop, options);
+        if (indexed.candidates.some((candidate) => avoidTokens.includes(candidate))) {
+          return;
+        }
         const named = indexed.replacement || null;
         reportValueNode({
           decl,
           message: messages.rejected(node.value, named, indexed.origin || null, options.note, indexed.candidates, position),
           node,
-          replacement: indexed.fixable ? named : null,
+          replacement: indexed.fixable && fixable ? named : null,
           result,
           ruleName,
         });
@@ -253,7 +277,7 @@ const ruleFunction = (primary, secondaryOptions) => {
           } else {
             const absPx = toPx(Math.abs(parsedLength.number), parsedLength.unit, options.baseFontSize);
             if (absPx !== null) {
-              const onScale = scalePx.some((entry) => numbersEqual(entry, absPx));
+              const onScale = pxOnScale(scalePx, absPx, parsedLength.unit, options.baseFontSize);
               if (onScale) {
                 return false;
               }
@@ -261,15 +285,16 @@ const ruleFunction = (primary, secondaryOptions) => {
           }
         }
 
-        reportNode(node, parsedLength, position);
+        reportNode(node, parsedLength, position, (context && context.tokenFallbackOf) || []);
         return true;
       };
 
       if (prop === 'transform') {
         walkTransformTranslateNodes(parsed, (node, context) => {
           if (node.type === 'function') {
-            if (isTokenFunction(node, options.tokenFunctions, tokenRegex)) {
-              return true;
+            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+            if (skipToken) {
+              return skipToken;
             }
 
             if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
@@ -283,22 +308,23 @@ const ruleFunction = (primary, secondaryOptions) => {
             return false;
           }
 
-          changed = checkWordNode(node, context) || changed;
+          checkWordNode(node, context);
           return false;
         });
       } else {
         const checkedBounds = new Set();
         walkRootValueNodes(parsed, (node, context) => {
           if (node.type === 'function') {
-            if (isTokenFunction(node, options.tokenFunctions, tokenRegex)) {
-              return true;
+            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+            if (skipToken) {
+              return skipToken;
             }
 
             if (options.checkMathBounds && isBoundFunction(node)) {
               for (const bound of collectMathBounds(node)) {
                 if (!checkedBounds.has(bound.node)) {
                   checkedBounds.add(bound.node);
-                  changed = checkWordNode(bound.node, null, bound.position) || changed;
+                  checkWordNode(bound.node, context, bound.position);
                 }
               }
             }
@@ -314,14 +340,12 @@ const ruleFunction = (primary, secondaryOptions) => {
             return false;
           }
 
-          changed = checkWordNode(node, context) || changed;
+          checkWordNode(node, context);
           return false;
         });
       }
 
-      if (changed) {
-        decl.value = parsed.toString();
-      }
+      writeDeclarationValue(decl, source, parsed);
     });
   };
 };

package/src/rules/report.js

@@ -13,12 +13,14 @@ const { declarationValueIndex } = require('../core/value-nodes');
  * against the root and replaced with the historical default so the file still
  * lints instead of throwing inside Stylelint.
  */
-function createTokenRegex(tokenPattern, result, ruleName) {
+function createTokenRegex(tokenPattern, { result, root, ruleName }) {
   try {
     return new RegExp(tokenPattern);
   } catch {
+    // Stylelint throws on a report without a node, so the root carries it (issue #222).
     stylelint.utils.report({
       message: `Invalid tokenPattern regex: ${tokenPattern}`,
+      node: root,
       result,
       ruleName,
     });

package/src/rules/use-motion-scale/index.js

@@ -8,7 +8,10 @@ const {
   numbersEqual,
 } = require('../../core/length');
 const {
+  declarationValueSource,
+  isMathFunction,
   walkRootValueNodes,
+  writeDeclarationValue,
 } = require('../../core/value-nodes');
 const {
   formatTime,
@@ -39,6 +42,7 @@ const EASING_PROPERTIES = new Set([
   'animation',
 ]);
 const EASING_FUNCTIONS = new Set(['cubic-bezier', 'linear', 'steps']);
+const SHORTHAND_PROPERTIES = new Set(['transition', 'animation']);
 
 const messages = stylelint.utils.ruleMessages(ruleName, {
   invalidDuration: (value, note = '') =>
@@ -96,13 +100,62 @@ function getFixedNodeValue(parsedTime, nearestMs, options) {
     return null;
   }
 
-  return formatTime(converted, parsedTime.unit);
+  return formatTime(parsedTime.number < 0 ? -converted : converted, parsedTime.unit);
 }
 
 function functionToString(node) {
   return valueParser.stringify(node);
 }
 
+/**
+ * The time nodes of a transition or animation shorthand that are its
+ * durations: the first time of each comma-separated layer (#236). The second
+ * is the delay, which may be negative. A function before the first time, such
+ * as var() or calc(), may itself be the duration, so that layer has no time
+ * known to be a duration and none is returned for it.
+ */
+function shorthandDurationNodes(parsed) {
+  const durations = new Set();
+  let settled = false;
+
+  for (const node of parsed.nodes) {
+    if (node.type === 'div' && node.value === ',') {
+      settled = false;
+      continue;
+    }
+
+    if (settled) {
+      continue;
+    }
+
+    if (node.type === 'function') {
+      settled = !EASING_FUNCTIONS.has(node.value.toLowerCase());
+      continue;
+    }
+
+    if (node.type === 'word' && parseTimeToken(node.value)) {
+      durations.add(node);
+      settled = true;
+    }
+  }
+
+  return durations;
+}
+
+/** Whether a negative time in this place is an error: true for durations, false for delays. */
+function createDurationRole(prop, parsed) {
+  if (prop.endsWith('-duration')) {
+    return () => true;
+  }
+
+  if (!SHORTHAND_PROPERTIES.has(prop)) {
+    return () => false;
+  }
+
+  const durations = shorthandDurationNodes(parsed);
+  return (node) => durations.has(node);
+}
+
 const ruleFunction = (primary, secondaryOptions) => {
   return (root, result) => {
     if (!validatePrimary(result, ruleName, primary) || !validateSecondaryOptions(result, secondaryOptions)) {
@@ -117,7 +170,9 @@ const ruleFunction = (primary, secondaryOptions) => {
         return;
       }
 
-      const parsed = valueParser(decl.value);
+      const source = declarationValueSource(decl);
+      const parsed = valueParser(source.parseText);
+      const isDuration = createDurationRole(prop, parsed);
       let changed = false;
 
       const reportDuration = (node, nearest, fixedValue = null) => {
@@ -161,6 +216,12 @@ const ruleFunction = (primary, secondaryOptions) => {
       walkRootValueNodes(parsed, (node) => {
         if (node.type === 'function') {
           const functionName = node.value.toLowerCase();
+          // A time inside calc(), clamp(), min() or max() is a term of the
+          // expression, not a duration on its own (#232).
+          if (isMathFunction(functionName)) {
+            return true;
+          }
+
           if (!EASING_PROPERTIES.has(prop) || !EASING_FUNCTIONS.has(functionName)) {
             return false;
           }
@@ -180,7 +241,9 @@ const ruleFunction = (primary, secondaryOptions) => {
           return false;
         }
 
-        if (parsedTime.number < 0) {
+        // A negative duration is invalid; a negative delay starts the motion
+        // partway through, so its size is checked like any other (#236).
+        if (parsedTime.number < 0 && isDuration(node)) {
           reportDuration(node, null);
           return false;
         }
@@ -189,7 +252,7 @@ const ruleFunction = (primary, secondaryOptions) => {
           return false;
         }
 
-        const msValue = toMs(parsedTime.number, parsedTime.unit);
+        const msValue = toMs(Math.abs(parsedTime.number), parsedTime.unit);
         if (msValue === null) {
           return false;
         }
@@ -214,7 +277,7 @@ const ruleFunction = (primary, secondaryOptions) => {
       });
 
       if (changed) {
-        decl.value = parsed.toString();
+        writeDeclarationValue(decl, source, parsed);
       }
     });
   };

package/src/rules/use-scale/index.js

@@ -9,6 +9,7 @@ const {
   nearestText,
   numbersEqual,
   parseLengthToken,
+  pxOnScale,
   toPx,
 } = require('../../core/length');
 const {
@@ -16,15 +17,20 @@ const {
   createPropertyScaleResolver,
 } = require('../../core/options');
 const {
+  blankBlockComments,
   collectMathBounds,
+  declarationValueSource,
   isBoundFunction,
   isKeyword,
   isMathFunction,
-  isTokenFunction,
   propertyMatches,
+  sassOperandNodes,
   shouldLintMathArgument,
+  skipTokenFunction,
   walkRootValueNodes,
   walkTransformTranslateNodes,
+  writeDeclarationValue,
+  writeValueEdits,
 } = require('../../core/value-nodes');
 
 const {
@@ -72,6 +78,7 @@ function readDecisions(options, { result, root }) {
 }
 
 function checkLengthValue({
+  avoidTokens = [],
   decl,
   evaluated = null,
   fixable = true,
@@ -149,7 +156,7 @@ function checkLengthValue({
     }
 
     const fixedValue = options.fixToScale && fixable
-      ? replacementFor(parsedLength, nearest.nearest, options, decl.prop)
+      ? replacementFor(parsedLength, nearest.nearest, options, decl.prop, avoidTokens)
       : null;
 
     report(node.value, decl, node, nearest, fixedValue, unit, evaluated ? evaluatedNote(evaluated, options) : '');
@@ -162,7 +169,7 @@ function checkLengthValue({
     return false;
   }
 
-  const isOnScale = scalePx.some((scaleValue) => numbersEqual(scaleValue, pxValue));
+  const isOnScale = pxOnScale(scalePx, pxValue, parsedLength.unit, options.baseFontSize);
   if (isOnScale) {
     return false;
   }
@@ -173,7 +180,7 @@ function checkLengthValue({
   }
 
   const fixedValue = options.fixToScale && fixable
-    ? replacementFor(parsedLength, nearest.nearest, options, decl.prop)
+    ? replacementFor(parsedLength, nearest.nearest, options, decl.prop, avoidTokens)
     : null;
 
   report(node.value, decl, node, nearest, fixedValue, 'px', evaluated ? evaluatedNote(evaluated, options) : '');
@@ -193,14 +200,17 @@ function evaluatedNote(evaluated, options) {
  * alone, as they always were.
  */
 function checkSassValue({ decl, options, report, resolveVariable, scaleByUnit, scalePx }) {
-  const terms = evaluateScssValueList(decl.value, resolveVariable, new Set());
+  // Offsets are offsets into the value as written, comments included (issue #233).
+  const source = declarationValueSource(decl);
+  const terms = evaluateScssValueList(blankBlockComments(source.parseText), resolveVariable, new Set());
   if (!terms) {
     // Not fully evaluable (an unknown variable, interpolation, a keyword): the
     // literal walk below still checks the plain lengths in the value.
     return false;
   }
-  // Right to left, so a fix spliced into an earlier term never shifts the spans
-  // of the terms still to be checked. Stylelint orders the warnings by position.
+  // Fixes are collected as spans of the written value and written once at the
+  // end. Stylelint orders the warnings by position.
+  const edits = [];
   for (const term of [...terms].reverse()) {
     if (!term.unit || term.number === 0) {
       continue;
@@ -208,9 +218,9 @@ function checkSassValue({ decl, options, report, resolveVariable, scaleByUnit, s
     const node = {
       sourceIndex: term.start,
       type: 'word',
-      get value() { return term.text; },
+      get value() { return source.text.slice(term.start, term.end); },
       // The fix writes into the declaration at the term's span.
-      set value(replacement) { decl.value = `${decl.value.slice(0, term.start)}${replacement}${decl.value.slice(term.end)}`; },
+      set value(replacement) { edits.push({ end: term.end, start: term.start, text: replacement }); },
     };
     checkLengthValue({
       decl,
@@ -224,6 +234,7 @@ function checkSassValue({ decl, options, report, resolveVariable, scaleByUnit, s
       scalePx,
     });
   }
+  writeValueEdits(decl, source, edits);
   return true;
 }
 
@@ -249,7 +260,7 @@ const ruleFunction = (primary, secondaryOptions) => {
     options.decisions = readDecisions(options, { result, root });
     withResolvedScale(options, root);
 
-    const tokenRegex = createTokenRegex(options.tokenPattern, result, ruleName);
+    const tokenRegex = createTokenRegex(options.tokenPattern, { result, root, ruleName });
     if (options.fixWith === 'token') {
       options.tokenIndex = tokenIndexFromDefinitions(
         collectTokenDefinitions({
@@ -269,7 +280,7 @@ const ruleFunction = (primary, secondaryOptions) => {
     const report = (value, decl, node, nearest, fixedValue = null, nearestUnit = 'px', extraNote = '', position = null) => {
       const lower = nearest ? formatLength(nearest.lower, nearestUnit) : 'n/a';
       const upper = nearest ? formatLength(nearest.upper, nearestUnit) : 'n/a';
-      const tokenNote = nearest ? tokenHoldsNote(fixedValue, formatLength(nearest.nearest, nearestUnit)) : '';
+      const tokenNote = nearest ? tokenHoldsNote(fixedValue, formatLength(nearest.nearest, nearestUnit), String(value).trim().startsWith('-')) : '';
       reportValueNode({
         decl,
         message: messages.rejected(value, lower, upper, [fallbackNote, tokenNote, extraNote, options.note].filter(Boolean).join(' '), position, position ? pxAside(value, options.baseFontSize) : '', getScaleStateForProperty(decl.prop.toLowerCase()).group),
@@ -312,15 +323,18 @@ const ruleFunction = (primary, secondaryOptions) => {
         return;
       }
 
-      const parsed = valueParser(decl.value);
-      let changed = false;
+      const source = declarationValueSource(decl);
+      const parsed = valueParser(source.parseText);
+      // Operands of a Sass expression that did not resolve are reported, never rewritten (issue #234).
+      const sassOperands = sassOperandNodes(parsed, decl.value);
 
       if (prop === 'transform') {
         walkTransformTranslateNodes(parsed, (node, context) => {
 
           if (node.type === 'function') {
-            if (isTokenFunction(node, options.tokenFunctions, tokenRegex)) {
-              return true;
+            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+            if (skipToken) {
+              return skipToken;
             }
 
             if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
@@ -342,15 +356,16 @@ const ruleFunction = (primary, secondaryOptions) => {
             return false;
           }
 
-          changed =
-            checkLengthValue({
-              decl,
-              node,
-              options,
-              report,
-              scaleByUnit,
-              scalePx,
-            }) || changed;
+          checkLengthValue({
+            avoidTokens: context.tokenFallbackOf,
+            decl,
+            fixable: !sassOperands.has(node),
+            node,
+            options,
+            report,
+            scaleByUnit,
+            scalePx,
+          });
 
           return false;
         });
@@ -359,8 +374,9 @@ const ruleFunction = (primary, secondaryOptions) => {
         walkRootValueNodes(parsed, (node, context) => {
 
           if (node.type === 'function') {
-            if (isTokenFunction(node, options.tokenFunctions, tokenRegex)) {
-              return true;
+            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+            if (skipToken) {
+              return skipToken;
             }
 
             if (options.checkMathBounds && isBoundFunction(node)) {
@@ -373,7 +389,7 @@ const ruleFunction = (primary, secondaryOptions) => {
                   continue;
                 }
                 const boundReport = (value, d, n, nearest, fixed, unit, extra) => report(value, d, n, nearest, fixed, unit, extra, bound.position);
-                changed = checkLengthValue({ decl, node: bound.node, options, report: boundReport, scaleByUnit, scalePx }) || changed;
+                checkLengthValue({ avoidTokens: context.tokenFallbackOf, decl, fixable: !sassOperands.has(bound.node), node: bound.node, options, report: boundReport, scaleByUnit, scalePx });
               }
             }
 
@@ -399,23 +415,22 @@ const ruleFunction = (primary, secondaryOptions) => {
             return false;
           }
 
-          changed =
-            checkLengthValue({
-              decl,
-              node,
-              options,
-              report,
-              scaleByUnit,
-              scalePx,
-            }) || changed;
+          checkLengthValue({
+            avoidTokens: context.tokenFallbackOf,
+            decl,
+            fixable: !sassOperands.has(node),
+            node,
+            options,
+            report,
+            scaleByUnit,
+            scalePx,
+          });
 
           return false;
         });
       }
 
-      if (changed) {
-        decl.value = parsed.toString();
-      }
+      writeDeclarationValue(decl, source, parsed);
     });
   };
 };

package/types/__checks__/eslint-config.ts

@@ -0,0 +1,37 @@
+/**
+ * Compile-time check that the ESLint plugin types fit ESLint's own config
+ * types (#242): a typed `eslint.config.ts` that registers the plugin with
+ * `defineConfig` must compile. Nothing here runs; it only has to type-check.
+ */
+import type { ESLint, Linter } from 'eslint';
+import { defineConfig } from 'eslint/config';
+import rhythmguard from 'eslint-plugin-rhythmguard';
+import companion from 'stylelint-plugin-rhythmguard/eslint';
+
+const config = defineConfig([
+  {
+    files: ['**/*.{js,jsx,mjs,cjs}'],
+    languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+    plugins: { 'rhythmguard-tailwind': rhythmguard },
+    rules: {
+      'rhythmguard-tailwind/tailwind-class-use-scale': ['error', { scale: [0, 4, 8, 12, 16, 24, 32] }],
+    },
+  },
+  {
+    files: ['**/*.jsx'],
+    plugins: { 'rhythmguard-tailwind': companion },
+    rules: companion.configs.recommended.rules,
+  },
+]);
+
+const asPlugin: ESLint.Plugin = rhythmguard;
+const companionAsPlugin: ESLint.Plugin = companion;
+const flatConfig: Linter.Config = {
+  plugins: { 'rhythmguard-tailwind': rhythmguard },
+  rules: rhythmguard.configs.recommended.rules,
+};
+
+void config;
+void asPlugin;
+void companionAsPlugin;
+void flatConfig;