stylelint-plugin-rhythmguard 2.2.0 → 3.0.0

package/src/cli/quickstart.js

@@ -14,6 +14,7 @@ const path = require('node:path');
 
 const { createAuditReport } = require('../audit/report');
 const { detect } = require('./init');
+const { discoverTokenPackages } = require('../utils/scale-inference');
 
 const TOKEN_FILE_PATTERN = /(^|[.-])tokens?\.json$/i;
 const TOKEN_DIRS = ['tokens', 'design-tokens', path.join('src', 'tokens'), path.join('dist', 'tokens')];
@@ -76,13 +77,14 @@ function topEntries(counts, limit = MAX_LISTED) {
     .slice(0, limit);
 }
 
-function suggestedStylelintConfig({ profile, tokenFiles }) {
+function suggestedStylelintConfig({ nextjs = false, profile, tokenFiles }) {
   const ruleOptions = { scale: 'auto' };
   if (tokenFiles.length > 0) {
     ruleOptions.scaleSources = tokenFiles.map(toPosix);
   }
   return {
     extends: [`stylelint-plugin-rhythmguard/configs/${profile}`],
+    ...(nextjs ? { ignoreFiles: ['.next/**', 'out/**', 'node_modules/**'] } : {}),
     rules: {
       'rhythmguard/use-scale': [true, ruleOptions],
     },
@@ -127,6 +129,8 @@ async function run() {
   out.push(`    Next.js         ${stack.nextjs ? 'yes' : 'no'}`);
   out.push(`    Stylelint config ${stack.hasExistingConfig ? 'present' : 'none'}`);
   out.push(`    Token files     ${tokenFiles.length > 0 ? tokenFiles.join(', ') : 'none found'}`);
+  const tokenPackages = [...new Set(discoverTokenPackages(cwd).map((source) => source.package))];
+  out.push(`    Token packages  ${tokenPackages.length > 0 ? tokenPackages.join(', ') : 'none installed'}`);
   out.push(`    .rhythmguardrc  ${rcPresent ? 'present (its token sources are used)' : 'none'}`);
   out.push('');
 
@@ -179,9 +183,9 @@ async function run() {
   }
   out.push('');
 
-  const profile = stack.tailwind ? (stack.nextjs ? 'react-tailwind' : 'tailwind') : 'recommended';
+  const profile = stack.tailwind ? 'tailwind' : 'recommended';
   out.push(`  Paste this into .stylelintrc.json${stack.hasExistingConfig ? ' (merge with your existing config)' : ''}:`, '');
-  out.push(JSON.stringify(suggestedStylelintConfig({ profile, tokenFiles }), null, 2).replace(/^/gm, '    '));
+  out.push(JSON.stringify(suggestedStylelintConfig({ nextjs: stack.nextjs, profile, tokenFiles }), null, 2).replace(/^/gm, '    '));
   out.push('');
 
   if (stack.tailwind) {

package/src/index.js

@@ -19,11 +19,7 @@ module.exports.configs = {
   recommended: require('./configs/recommended'),
   strict: require('./configs/strict'),
   tailwind: require('./configs/tailwind'),
-  expanded: require('./configs/expanded'),
-  logical: require('./configs/logical'),
-  migration: require('./configs/migration'),
   motion: require('./configs/motion'),
-  'react-tailwind': require('./configs/react-tailwind'),
 };
 module.exports.eslint = require('./eslint');
 module.exports.presets = require('./presets');

package/src/utils/scale-inference.js

@@ -5,7 +5,7 @@ const path = require('node:path');
 
 const { parseLengthToken, toPx } = require('./length');
 const { buildEffectiveTokenMap } = require('./token-map');
-const { parseTokenSources } = require('./token-sources');
+const { collectScssTokens, createTokenKindMatcher, parseTokenSources } = require('./token-sources');
 const { getScalePreset } = require('../presets/scales');
 
 // Matches the audit default so lint and audit agree on what a spacing token is.
@@ -21,6 +21,80 @@ const MIN_INFERRED_SCALE_LENGTH = 4;
 const RC_FILE = '.rhythmguardrc.json';
 
 const sourceCache = new Map();
+const TOKEN_PACKAGES = require('./token-packages.json').packages;
+
+/**
+ * Installed design-token packages that ship a spacing scale (allowlist in
+ * token-packages.json). Resolved from the project, so only what the project
+ * actually depends on is read. Returns token-source entries.
+ */
+function readDirectDependencies(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+    return new Set([
+      ...Object.keys(pkg.dependencies || {}),
+      ...Object.keys(pkg.devDependencies || {}),
+      ...Object.keys(pkg.peerDependencies || {}),
+    ]);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Project roots from cwd up to the repository boundary (first directory holding
+ * .git), each with the dependencies it declares directly. Hoisted monorepo
+ * installs are found by walking up; a stray global node_modules is never
+ * consulted because the walk stops at the repository.
+ */
+function projectRoots(cwd) {
+  const roots = [];
+  let current = path.resolve(cwd);
+  for (;;) {
+    const direct = readDirectDependencies(current);
+    if (direct) {
+      roots.push({ dir: current, direct });
+    }
+    const parent = path.dirname(current);
+    if (fs.existsSync(path.join(current, '.git')) || parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return roots;
+}
+
+function discoverTokenPackages(cwd = process.cwd()) {
+  const sources = [];
+  const roots = projectRoots(cwd);
+  for (const entry of TOKEN_PACKAGES) {
+    // Only packages the project depends on directly count. A transitive
+    // tailwindcss (for example via stylelint-config-tailwindcss) must not hand
+    // a non-Tailwind project the Tailwind scale.
+    const owner = roots.find((root) => root.direct.has(entry.name));
+    if (!owner) {
+      continue;
+    }
+    const root = roots
+      .map((candidate) => path.join(candidate.dir, 'node_modules', entry.name))
+      .find((dir) => fs.existsSync(path.join(dir, 'package.json')));
+    if (!root) {
+      continue;
+    }
+    for (const file of entry.files) {
+      const resolved = path.join(root, file);
+      if (fs.existsSync(resolved)) {
+        sources.push({
+          format: 'auto',
+          package: entry.name,
+          path: resolved,
+          ...(entry.tokenPattern ? { tokenPattern: entry.tokenPattern } : {}),
+        });
+      }
+    }
+  }
+  return sources;
+}
 
 function pxValuesFromKeys(keys, baseFontSize) {
   const values = new Set([0]);
@@ -54,6 +128,7 @@ function normalizeSource(source, baseDir) {
     return {
       format: typeof source.format === 'string' ? source.format : 'auto',
       path: path.resolve(source.baseDir || baseDir, rawPath),
+      ...(source.tokenPattern ? { tokenPattern: source.tokenPattern } : {}),
     };
   }
 
@@ -69,7 +144,7 @@ function cacheKey(sources) {
       } catch {
         // missing file: key still changes when it appears
       }
-      return `${source.path}|${source.format}|${mtime}`;
+      return `${source.path}|${source.format}|${source.tokenPattern || ''}|${mtime}`;
     })
     .join('\n');
 }
@@ -86,13 +161,9 @@ function scaleFromSources(sources, baseFontSize) {
   }
 
   const parsed = parseTokenSources({ baseFontSize, sources: normalized, tokenKind: 'spacing' });
-  const keys = [];
-  for (const definition of parsed.definitions.values()) {
-    keys.push(...definition.normalizedValues);
-  }
-
-  const scale = pxValuesFromKeys(keys, baseFontSize);
-  const outcome = scale.length >= MIN_INFERRED_SCALE_LENGTH
+  // scaleFromDefinitions also expands a bare Tailwind --spacing base into its multiples.
+  const scale = scaleFromDefinitions(parsed.definitions, baseFontSize);
+  const outcome = scale
     ? {
       files: parsed.sources.map((source) => source.file),
       scale,
@@ -157,8 +228,27 @@ function rcTokenSources(cwd) {
     .filter(Boolean);
 }
 
-function scaleFromTokenMap(map, baseFontSize) {
-  const keys = [];
+/**
+ * Sass variables and maps declared in the linted stylesheet itself (postcss-scss
+ * exposes them as declarations whose prop starts with `$`). Evaluated with the
+ * same collector the audit uses; component variables such as $dropdown-spacer
+ * are excluded by the anchored name rule.
+ */
+function sassValuesFromRoot(root) {
+  const lines = [];
+  root.walkDecls((decl) => {
+    if (typeof decl.prop === 'string' && decl.prop.startsWith('$')) {
+      lines.push(`${decl.prop}: ${decl.value};`);
+    }
+  });
+  if (lines.length === 0) {
+    return [];
+  }
+  return collectScssTokens(lines.join('\n'), createTokenKindMatcher('spacing')).map((token) => token.value);
+}
+
+function scaleFromTokenMap(map, baseFontSize, extraKeys = []) {
+  const keys = [...extraKeys];
   const baseKeys = [];
   for (const [key, reference] of Object.entries(map)) {
     const name = String(reference).match(/^var\((--[\w-]+)\)$/);
@@ -206,7 +296,7 @@ function resolveAutoScale({
       root,
       tokenRegex,
     });
-    const scale = scaleFromTokenMap(stylesheetMap, baseFontSize);
+    const scale = scaleFromTokenMap(stylesheetMap, baseFontSize, sassValuesFromRoot(root));
     if (scale) {
       return { files: [], scale, source: 'stylesheet', tokenCount: scale.length - 1, warnings: [] };
     }
@@ -229,6 +319,11 @@ function resolveAutoScale({
     }
   }
 
+  const fromPackages = scaleFromSources(discoverTokenPackages(process.cwd()), baseFontSize);
+  if (fromPackages) {
+    return { source: 'token-package', ...fromPackages };
+  }
+
   return {
     files: [],
     preset: FALLBACK_PRESET,
@@ -250,6 +345,7 @@ function autoScaleFallbackNote(inference) {
 module.exports = {
   DEFAULT_AUTO_TOKEN_PATTERN,
   autoScaleFallbackNote,
+  discoverTokenPackages,
   resolveAutoScale,
   scaleFromDefinitions,
 };

package/src/utils/token-packages.json

@@ -0,0 +1,48 @@
+{
+  "$comment": "Design-token packages whose installed files declare a spacing scale. Used by scale: \"auto\" after the project's own stylesheets are checked. Each entry lists the files to read (relative to the package root) and, when the package does not use space/spacing names, the token pattern to match. Additions welcome; keep them to files that ship in the published package.",
+  "packages": [
+    {
+      "name": "tailwindcss",
+      "files": [
+        "theme.css"
+      ],
+      "note": "Tailwind v4 base multiplier --spacing"
+    },
+    {
+      "name": "@radix-ui/themes",
+      "files": [
+        "tokens.css"
+      ],
+      "note": "--space-1..9 as calc(<px> * var(--scaling))"
+    },
+    {
+      "name": "@mantine/core",
+      "files": [
+        "styles.css"
+      ],
+      "note": "--mantine-spacing-* as calc(<rem> * var(--mantine-scale))"
+    },
+    {
+      "name": "@primer/primitives",
+      "files": [
+        "dist/css/base/size/size.css"
+      ],
+      "tokenPattern": "^--base-size-\\d+$",
+      "note": "Primer names its spacing ladder size"
+    },
+    {
+      "name": "@shopify/polaris-tokens",
+      "files": [
+        "dist/css/styles.css"
+      ],
+      "note": "--p-space-* in rem"
+    },
+    {
+      "name": "@spectrum-css/tokens",
+      "files": [
+        "dist/css/global-vars.css"
+      ],
+      "note": "--spectrum-spacing-* in px"
+    }
+  ]
+}

package/src/utils/token-sources.js

@@ -32,7 +32,13 @@ const TOKEN_KIND_PATTERNS = Object.freeze({
   motion: /^--(?:motion|duration|delay|ease|easing)-/,
   size: /^--(?:size|width|height|container)-/,
   // Anchored or prefixed (--spacing-4, --lb-spacing-md, bare Tailwind v4 --spacing), never letter-/word-spacing.
-  spacing: /(?:^--|-)(?<!letter-)(?<!word-)(?:space|spacing)(?:-|$)/,
+  // CSS custom properties (--spacing-4, --lb-spacing-md, bare --spacing) and Sass
+  // variables or map entries ($spacer, $spacers.3, $system-spacing.small.2).
+  // Custom properties may carry a namespace (--lb-spacing-md, --mantine-spacing-xs, bare
+  // --spacing) but never letter-/word-spacing. Sass names must start with the scale word
+  // (an optional `system-` prefix allowed): $spacer, $spacers.3, $spacing-01, $system-spacing.
+  // Component variables such as $dropdown-spacer or $card-spacer-y are not scale tokens.
+  spacing: /^(?:\$(?:system-)?(?:space|spacing|spacer)s?(?:-|$|\.)|--(?:[\w-]*-)?(?<!letter-)(?<!word-)(?:space|spacing)(?:-|$))/,
   typography: /^--(?:font|font-size|line-height|leading|tracking|typography)-/,
 });
 
@@ -62,6 +68,15 @@ function normalizeTokenKind(kind) {
   return normalized;
 }
 
+function createPatternMatcher(pattern, fallback) {
+  try {
+    const regex = new RegExp(pattern);
+    return (token) => regex.test(token);
+  } catch {
+    return fallback;
+  }
+}
+
 function createTokenKindMatcher(kind) {
   const normalizedKind = normalizeTokenKind(kind);
   const pattern = TOKEN_KIND_PATTERNS[normalizedKind] || TOKEN_KIND_PATTERNS.spacing;
@@ -109,16 +124,19 @@ function parseTokenSources({
     }
 
     let tokens = [];
+    const matchesSource = normalizedSource.tokenPattern
+      ? createPatternMatcher(normalizedSource.tokenPattern, matchesKind)
+      : matchesKind;
     try {
       if (normalizedSource.format === 'css') {
-        tokens = collectCssTokens(text, matchesKind);
+        tokens = collectCssTokens(text, matchesSource);
       } else {
         const parsed = JSON.parse(text);
         const detectedFormat = normalizedSource.requestedFormat === 'auto'
           ? detectJsonTokenFormat(parsed)
           : normalizedSource.format;
         sourceReport.format = detectedFormat;
-        tokens = collectJsonTokens(parsed, matchesKind);
+        tokens = collectJsonTokens(parsed, matchesSource);
       }
     } catch (err) {
       const warning = `Unable to parse token source ${normalizedSource.displayPath}: ${err.message}`;
@@ -168,6 +186,9 @@ function normalizeTokenSource(source) {
     format: requestedFormat === 'auto' ? detectSourceFormat(resolvedPath) : requestedFormat,
     requestedFormat,
     resolvedPath,
+    // Optional per-source override for packages that name spacing tokens differently
+    // (Primer's --base-size-*). Falls back to the kind matcher when absent.
+    tokenPattern: typeof source.tokenPattern === 'string' && source.tokenPattern ? source.tokenPattern : null,
   };
 }
 
@@ -231,9 +252,266 @@ function collectCssTokens(source, matchesKind) {
     });
   }
 
+  tokens.push(...collectScssTokens(source, matchesKind));
   return tokens;
 }
 
+/**
+ * Sass variables and maps as token sources. Handles `$spacer: 1rem`, maps such
+ * as `$spacers: (1: $spacer * .25, ...)` including nested maps, variable
+ * references, `* / + -` arithmetic and `math.div()`. Anything it cannot
+ * evaluate (function calls, strings, keywords, interpolated keys, cycles) is
+ * skipped rather than guessed. Token names are `$name` or `$name.key.path`.
+ */
+function collectScssTokens(source, matchesKind) {
+  const declarations = parseScssDeclarations(source);
+  const cache = new Map();
+
+  const resolveVariable = (name, stack) => {
+    if (cache.has(name)) {
+      return cache.get(name);
+    }
+    if (stack.has(name) || !declarations.has(name)) {
+      return null;
+    }
+    stack.add(name);
+    const raw = declarations.get(name);
+    const value = isScssMap(raw) ? null : evaluateScssExpression(raw, resolveVariable, stack);
+    stack.delete(name);
+    cache.set(name, value);
+    return value;
+  };
+
+  const tokens = [];
+  const push = (tokenName, value) => {
+    if (!value || !matchesKind(tokenName)) {
+      return;
+    }
+    tokens.push({ token: tokenName, value: formatScssValue(value) });
+  };
+
+  for (const [name, raw] of declarations) {
+    const tokenName = `$${name}`;
+    if (isScssMap(raw)) {
+      walkScssMap(raw, [tokenName], (pathName, expression) => {
+        push(pathName, evaluateScssExpression(expression, resolveVariable, new Set()));
+      });
+      continue;
+    }
+    push(tokenName, resolveVariable(name, new Set()));
+  }
+
+  return tokens;
+}
+
+function stripScssComments(source) {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/(^|[^:])\/\/[^\n]*/g, '$1');
+}
+
+function parseScssDeclarations(source) {
+  const text = stripScssComments(source);
+  const declarations = new Map();
+  const startPattern = /(?:^|\n)[ \t]*\$([\w-]+)[ \t]*:/g;
+  let match;
+
+  while ((match = startPattern.exec(text)) !== null) {
+    const name = match[1];
+    let index = match.index + match[0].length;
+    let depth = 0;
+    let quote = null;
+    let value = '';
+
+    for (; index < text.length; index += 1) {
+      const char = text[index];
+      if (quote) {
+        value += char;
+        if (char === quote) quote = null;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+      } else if (char === '(') {
+        depth += 1;
+      } else if (char === ')') {
+        depth -= 1;
+      } else if (char === ';' && depth === 0) {
+        break;
+      }
+      value += char;
+    }
+
+    startPattern.lastIndex = index;
+    const cleaned = value.replace(/!(default|global)\b/g, '').trim();
+    if (cleaned && !declarations.has(name)) {
+      declarations.set(name, cleaned);
+    }
+  }
+
+  return declarations;
+}
+
+function isScssMap(raw) {
+  return raw.startsWith('(') && raw.endsWith(')') && /:/.test(raw);
+}
+
+function splitTopLevel(text, separator) {
+  const parts = [];
+  let depth = 0;
+  let quote = null;
+  let current = '';
+  for (const char of text) {
+    if (quote) {
+      current += char;
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") quote = char;
+    else if (char === '(') depth += 1;
+    else if (char === ')') depth -= 1;
+    if (char === separator && depth === 0) {
+      parts.push(current);
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+
+function walkScssMap(raw, pathSegments, visit) {
+  const inner = raw.slice(1, -1);
+  for (const entry of splitTopLevel(inner, ',')) {
+    const pair = splitTopLevel(entry, ':');
+    if (pair.length < 2) continue;
+    const key = pair[0].trim().replace(/^["']|["']$/g, '');
+    const expression = pair.slice(1).join(':').trim();
+    if (!key || key.includes('#{')) continue;
+    const nextPath = [...pathSegments, key];
+    if (isScssMap(expression)) {
+      walkScssMap(expression, nextPath, visit);
+    } else {
+      visit(nextPath.join('.'), expression);
+    }
+  }
+}
+
+const SCSS_TOKEN_PATTERN = /\s*(?:(-?(?:\d+\.?\d*|\.\d+)[a-zA-Z%]*)|(\$[\w-]+)|([a-zA-Z_][\w.-]*)\s*\(|([()*/+,-]))/y;
+
+function tokenizeScssExpression(expression) {
+  const tokens = [];
+  let index = 0;
+  while (index < expression.length) {
+    SCSS_TOKEN_PATTERN.lastIndex = index;
+    const match = SCSS_TOKEN_PATTERN.exec(expression);
+    if (!match) {
+      if (/\s/.test(expression[index])) {
+        index += 1;
+        continue;
+      }
+      return null;
+    }
+    index = SCSS_TOKEN_PATTERN.lastIndex;
+    if (match[1] !== undefined) tokens.push({ type: 'number', raw: match[1] });
+    else if (match[2] !== undefined) tokens.push({ type: 'var', name: match[2].slice(1) });
+    else if (match[3] !== undefined) tokens.push({ type: 'call', name: match[3] });
+    else tokens.push({ type: 'op', value: match[4] });
+  }
+  return tokens;
+}
+
+function evaluateScssExpression(expression, resolveVariable, stack) {
+  const tokens = tokenizeScssExpression(expression.trim());
+  if (!tokens || tokens.length === 0) {
+    return null;
+  }
+  let position = 0;
+  const peek = () => tokens[position];
+  const next = () => tokens[position++];
+
+  const parseNumber = (raw) => {
+    const parsed = parseLengthToken(raw);
+    if (parsed) return { number: parsed.number, unit: parsed.unit };
+    const numeric = Number(raw);
+    return Number.isFinite(numeric) ? { number: numeric, unit: '' } : null;
+  };
+
+  const combine = (left, op, right) => {
+    if (!left || !right) return null;
+    if (op === '*') {
+      if (left.unit && right.unit) return null;
+      return { number: left.number * right.number, unit: left.unit || right.unit };
+    }
+    if (op === '/') {
+      if (right.number === 0) return null;
+      if (right.unit && right.unit !== left.unit) return null;
+      return { number: left.number / right.number, unit: right.unit ? '' : left.unit };
+    }
+    const compatible = left.unit === right.unit || left.number === 0 || right.number === 0;
+    if (!compatible) return null;
+    return { number: op === '+' ? left.number + right.number : left.number - right.number, unit: left.unit || right.unit };
+  };
+
+  const parsePrimary = () => {
+    const token = next();
+    if (!token) return null;
+    if (token.type === 'number') return parseNumber(token.raw);
+    if (token.type === 'var') return resolveVariable(token.name, stack);
+    if (token.type === 'op' && token.value === '-') {
+      const value = parsePrimary();
+      return value ? { number: -value.number, unit: value.unit } : null;
+    }
+    if (token.type === 'op' && token.value === '(') {
+      const value = parseExpression();
+      const closing = next();
+      return closing && closing.type === 'op' && closing.value === ')' ? value : null;
+    }
+    if (token.type === 'call') {
+      const args = [];
+      let current = parseExpression();
+      args.push(current);
+      while (peek() && peek().type === 'op' && peek().value === ',') {
+        next();
+        args.push(parseExpression());
+      }
+      const closing = next();
+      if (!closing || closing.type !== 'op' || closing.value !== ')') return null;
+      if (token.name === 'math.div' && args.length === 2) return combine(args[0], '/', args[1]);
+      return null;
+    }
+    return null;
+  };
+
+  const parseTerm = () => {
+    let value = parsePrimary();
+    while (peek() && peek().type === 'op' && (peek().value === '*' || peek().value === '/')) {
+      const op = next().value;
+      value = combine(value, op, parsePrimary());
+    }
+    return value;
+  };
+
+  const parseExpression = () => {
+    let value = parseTerm();
+    while (peek() && peek().type === 'op' && (peek().value === '+' || peek().value === '-')) {
+      const op = next().value;
+      value = combine(value, op, parseTerm());
+    }
+    return value;
+  };
+
+  const result = parseExpression();
+  return position === tokens.length ? result : null;
+}
+
+function formatScssValue(value) {
+  const rounded = Math.round(value.number * 1000) / 1000;
+  if (rounded === 0) return '0';
+  return `${rounded}${value.unit}`;
+}
+
 function collectJsonTokens(parsed, matchesKind) {
   if (!isPlainObject(parsed)) {
     return [];
@@ -441,6 +719,7 @@ module.exports = {
   VALID_TOKEN_KINDS,
   VALID_TOKEN_SOURCE_FORMATS,
   addDefinition,
+  collectScssTokens,
   createTokenKindMatcher,
   getNormalizedValueKeys,
   normalizeTokenKind,

package/types/__checks__/consumer.ts

@@ -15,23 +15,17 @@ import eslintPlugin from 'stylelint-plugin-rhythmguard/eslint';
 import { getScalePreset, listScalePresetNames } from 'stylelint-plugin-rhythmguard/presets';
 import recommended from 'stylelint-plugin-rhythmguard/configs/recommended';
 import embed from 'stylelint-plugin-rhythmguard/configs/embed';
-import reactTailwind from 'stylelint-plugin-rhythmguard/configs/react-tailwind';
 import useScale, { ruleName as useScaleName } from 'stylelint-plugin-rhythmguard/rules/use-scale';
 
 const pluginConfigs: readonly RhythmguardStylelintConfig[] = [
   plugin.configs.recommended,
   plugin.configs.strict,
   plugin.configs.tailwind,
-  plugin.configs.expanded,
-  plugin.configs.logical,
-  plugin.configs.migration,
   plugin.configs.motion,
-  plugin.configs['react-tailwind'],
   configs.recommended,
   plugin.configs.embed,
   embed,
   recommended,
-  reactTailwind,
 ];
 
 const ruleOptions: RhythmguardRuleOptions = {

package/types/audit.d.ts

@@ -60,7 +60,12 @@ export interface AuditSummary {
 }
 
 export interface AuditScanned {
+  /** Authored stylesheets scanned: .css plus .scss when postcss-scss is available. */
   cssFiles: number;
+  /** .scss files found. Audited through postcss-scss when it resolves. */
+  scssFiles?: number;
+  /** .scss files found but not audited because postcss-scss is not installed. */
+  scssSkipped?: number;
   templateFiles: number;
   totalFiles?: number;
   [key: string]: unknown;
@@ -88,7 +93,7 @@ export interface AuditBaselineComparison {
   [key: string]: unknown;
 }
 
-export type AuditScaleSource = "default" | "explicit" | "fallback" | "scanned-css" | "token-sources";
+export type AuditScaleSource = "default" | "explicit" | "fallback" | "scanned-css" | "token-package" | "token-sources";
 
 export interface AuditScale {
   /** Files the scale was derived from (token sources or scanned stylesheets). Empty for explicit, default and fallback. */

package/types/index.d.ts

@@ -39,11 +39,7 @@ export interface RhythmguardPlugin extends Array<StylelintRuleModule> {
   audit: typeof auditApi;
   configs: {
     embed: RhythmguardStylelintConfig;
-    expanded: RhythmguardStylelintConfig;
-    logical: RhythmguardStylelintConfig;
-    migration: RhythmguardStylelintConfig;
     motion: RhythmguardStylelintConfig;
-    "react-tailwind": RhythmguardStylelintConfig;
     recommended: RhythmguardStylelintConfig;
     strict: RhythmguardStylelintConfig;
     tailwind: RhythmguardStylelintConfig;

package/types/shared.d.ts

@@ -10,6 +10,8 @@ export interface ScaleSource {
   /** `auto` (default), `css`, `flat-json`, `style-dictionary`, or `dtcg`. */
   format?: string;
   path?: string;
+  /** Regex for token names in this file, overriding the spacing kind matcher (for packages that name spacing differently). */
+  tokenPattern?: string;
 }
 
 export interface RhythmguardRuleOptions {