stylelint-plugin-rhythmguard 3.12.0 → 3.13.0

package/src/eslint/rules/tailwind-class-use-scale.js

@@ -34,6 +34,7 @@ function maybeCheckNodeText(node, sourceCode, context, analyzer, allowFix) {
 
 module.exports = {
   meta: {
+    type: 'suggestion',
     docs: {
       url: 'https://github.com/PetriLahdelma/stylelint-plugin-rhythmguard/blob/main/docs/rules/tailwind-class-use-scale.md',
       description: 'Enforce spacing scale for Tailwind arbitrary spacing utilities in class strings',

package/src/rules/no-offscale-transform/index.js

@@ -9,6 +9,7 @@ const {
   nearestText,
   numbersEqual,
   parseLengthToken,
+  pxAside,
   pxOnScale,
   toPx,
 } = require('../../core/length');
@@ -17,7 +18,9 @@ const {
   createPropertyScaleResolver,
 } = require('../../core/options');
 const {
+  collectMathBounds,
   declarationValueSource,
+  isBoundFunction,
   isMathFunction,
   shouldLintMathArgument,
   skipTokenFunction,
@@ -41,8 +44,13 @@ const ruleName = 'rhythmguard/no-offscale-transform';
 const messages = stylelint.utils.ruleMessages(ruleName, {
   invalidPreset: (presetName, presetNames) =>
     `Unknown scale preset "${presetName}". Available presets: ${presetNames.join(', ')}.`,
-  rejected: (value, lower, upper, note = '') =>
-    `Unexpected transform translation value "${value}". Use scale values (${nearestText(lower, upper)}).${note ? ` ${note}` : ''}`,
+  rejected: (value, lower, upper, note = '', position = null, aside = '') =>
+    `Unexpected transform translation ${position ? `${position} "${value}"${aside}` : `value "${value}"`}. Use scale values (${nearestText(lower, upper)}).${note ? ` ${note}` : ''}`,
+  // A value the options forbid outright has no nearest scale value to name (issue #274).
+  rejectedNegative: (value, note = '', position = null) =>
+    `Unexpected transform translation ${position || 'value'} "${value}". Negative values are disabled for this rule.${note ? ` ${note}` : ''}`,
+  rejectedPercentage: (value, note = '', position = null) =>
+    `Unexpected transform translation ${position || 'value'} "${value}". Percentages are disabled for this rule.${note ? ` ${note}` : ''}`,
 });
 
 const ruleFunction = (primary, secondaryOptions) => {
@@ -99,15 +107,17 @@ const ruleFunction = (primary, secondaryOptions) => {
       const { scaleByUnit, scalePx } = getScaleStateForProperty(prop);
       let changed = false;
 
-      // `nearest` is null for a value the options forbid outright, as in use-scale.
-      const report = (node, nearest, nearestUnit, fixedValue = null) => {
+      // `position` names a clamp(), min() or max() bound (issue #272).
+      const report = (node, nearest, nearestUnit, fixedValue = null, position = null) => {
         reportValueNode({
           decl,
           message: messages.rejected(
             node.value,
-            nearest ? formatLength(nearest.lower, nearestUnit) : 'n/a',
-            nearest ? formatLength(nearest.upper, nearestUnit) : 'n/a',
-            [nearest ? tokenHoldsNote(fixedValue, formatLength(nearest.nearest, nearestUnit), node.value.trim().startsWith('-')) : '', options.note].filter(Boolean).join(' '),
+            formatLength(nearest.lower, nearestUnit),
+            formatLength(nearest.upper, nearestUnit),
+            [tokenHoldsNote(fixedValue, formatLength(nearest.nearest, nearestUnit), node.value.trim().startsWith('-')), options.note].filter(Boolean).join(' '),
+            position,
+            position ? pxAside(node.value, options.baseFontSize) : '',
           ),
           node,
           replacement: fixedValue,
@@ -116,7 +126,12 @@ const ruleFunction = (primary, secondaryOptions) => {
         });
       };
 
-      const checkNode = (node, avoidTokens = []) => {
+      // A value the options forbid outright says so, with no fix (issue #274).
+      const reportForbidden = (node, message, position) => {
+        reportValueNode({ decl, message: message(node.value, options.note, position), node, result, ruleName });
+      };
+
+      const checkNode = (node, avoidTokens = [], position = null) => {
         const parsedLength = parseLengthToken(node.value);
         if (!parsedLength || parsedLength.number === 0) {
           return;
@@ -128,7 +143,7 @@ const ruleFunction = (primary, secondaryOptions) => {
 
         if (parsedLength.unit === '%') {
           if (!options.allowPercentages) {
-            report(node, null, '%');
+            reportForbidden(node, messages.rejectedPercentage, position);
           }
           return;
         }
@@ -138,7 +153,7 @@ const ruleFunction = (primary, secondaryOptions) => {
         }
 
         if (!options.allowNegative && parsedLength.number < 0) {
-          report(node, null, parsedLength.unit);
+          reportForbidden(node, messages.rejectedNegative, position);
           return;
         }
 
@@ -178,7 +193,7 @@ const ruleFunction = (primary, secondaryOptions) => {
             ? replacementFor(parsedLength, nearest.nearest, options, decl.prop, avoidTokens)
             : null;
 
-          report(node, nearest, unit, fixedValue);
+          report(node, nearest, unit, fixedValue, position);
           changed = true;
           return;
         }
@@ -202,62 +217,52 @@ const ruleFunction = (primary, secondaryOptions) => {
           ? replacementFor(parsedLength, nearest.nearest, options, decl.prop, avoidTokens)
           : null;
 
-        report(node, nearest, 'px', fixedValue);
+        report(node, nearest, 'px', fixedValue, position);
         changed = true;
       };
 
-      if (prop === 'transform') {
-        walkTransformTranslateNodes(parsed, (node, context) => {
-          if (node.type === 'function') {
-            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
-            if (skipToken) {
-              return skipToken;
-            }
-
-            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
-              return true;
-            }
-
-            return false;
+      // The bounds of clamp(), min() and max() are checked as in use-scale
+      // (issue #272).
+      const checkedBounds = new Set();
+      const visit = (node, context) => {
+        if (node.type === 'function') {
+          const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+          if (skipToken) {
+            return skipToken;
           }
 
-          if (node.type !== 'word') {
-            return false;
+          if (options.checkMathBounds && isBoundFunction(node)) {
+            for (const bound of collectMathBounds(node)) {
+              if (!checkedBounds.has(bound.node)) {
+                checkedBounds.add(bound.node);
+                checkNode(bound.node, context.tokenFallbackOf, bound.position);
+              }
+            }
           }
 
-          if (!shouldLintMathArgument(context, options)) {
-            return false;
+          if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
+            return true;
           }
 
-          checkNode(node, context.tokenFallbackOf);
           return false;
-        });
-      } else {
-        walkRootValueNodes(parsed, (node, context) => {
-          if (node.type === 'function') {
-            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
-            if (skipToken) {
-              return skipToken;
-            }
-
-            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
-              return true;
-            }
+        }
 
-            return false;
-          }
+        if (node.type !== 'word' || checkedBounds.has(node)) {
+          return false;
+        }
 
-          if (node.type !== 'word') {
-            return false;
-          }
+        if (!shouldLintMathArgument(context, options)) {
+          return false;
+        }
 
-          if (!shouldLintMathArgument(context, options)) {
-            return false;
-          }
+        checkNode(node, context.tokenFallbackOf);
+        return false;
+      };
 
-          checkNode(node, context.tokenFallbackOf);
-          return false;
-        });
+      if (prop === 'transform') {
+        walkTransformTranslateNodes(parsed, visit);
+      } else {
+        walkRootValueNodes(parsed, visit);
       }
 
       if (changed) {

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

@@ -81,8 +81,9 @@ function resolveTokenReplacement(tokenMap, raw, parsedLength, options) {
   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]);
+      // Formatted, so 1.1rem at a 14px base is "15.4px", not "15.400000000000002px" (issue #275).
+      lookups.push([formatLength(px, 'px'), false]);
+      if (negative) lookups.push([formatLength(Math.abs(px), 'px'), true]);
     }
   }
 
@@ -289,60 +290,44 @@ const ruleFunction = (primary, secondaryOptions) => {
         return true;
       };
 
-      if (prop === 'transform') {
-        walkTransformTranslateNodes(parsed, (node, context) => {
-          if (node.type === 'function') {
-            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
-            if (skipToken) {
-              return skipToken;
-            }
+      // The bounds of clamp(), min() and max() are checked in translate
+      // functions as anywhere else (issue #272).
+      const checkedBounds = new Set();
+      const visit = (node, context) => {
+        if (node.type === 'function') {
+          const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+          if (skipToken) {
+            return skipToken;
+          }
 
-            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
-              return true;
+          if (options.checkMathBounds && isBoundFunction(node)) {
+            for (const bound of collectMathBounds(node)) {
+              if (!checkedBounds.has(bound.node)) {
+                checkedBounds.add(bound.node);
+                checkWordNode(bound.node, context, bound.position);
+              }
             }
-
-            return false;
           }
 
-          if (node.type !== 'word') {
-            return false;
+          if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
+            return true;
           }
 
-          checkWordNode(node, context);
           return false;
-        });
-      } else {
-        const checkedBounds = new Set();
-        walkRootValueNodes(parsed, (node, context) => {
-          if (node.type === 'function') {
-            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);
-                  checkWordNode(bound.node, context, bound.position);
-                }
-              }
-            }
-
-            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
-              return true;
-            }
+        }
 
-            return false;
-          }
+        if (node.type !== 'word' || checkedBounds.has(node)) {
+          return false;
+        }
 
-          if (node.type !== 'word' || checkedBounds.has(node)) {
-            return false;
-          }
+        checkWordNode(node, context);
+        return false;
+      };
 
-          checkWordNode(node, context);
-          return false;
-        });
+      if (prop === 'transform') {
+        walkTransformTranslateNodes(parsed, visit);
+      } else {
+        walkRootValueNodes(parsed, visit);
       }
 
       writeDeclarationValue(decl, source, parsed);

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

@@ -23,7 +23,7 @@ const {
 } = require('../../core/time');
 
 const { reportValueNode } = require('../report');
-const { validatePrimary } = require('../validate');
+const { validatePrimary, validateSecondaryOptionShapes } = require('../validate');
 const { isNote, normalizeNote, withNote } = require('../../core/options');
 
 const ruleName = 'rhythmguard/use-motion-scale';
@@ -69,7 +69,20 @@ function buildOptions(rawOptions) {
   };
 }
 
+// Stylelint checks list options per element, so a scalar or an empty list
+// passed and the defaults were used without a word (issue #273).
+const MOTION_SHAPES = Object.freeze({
+  durationScale: Object.freeze({ expectsArray: true, nonEmpty: true }),
+  durationUnits: Object.freeze({ expectsArray: true, nonEmpty: true }),
+});
+
 function validateSecondaryOptions(result, secondaryOptions) {
+  const validEntries = validateEntries(result, secondaryOptions);
+  const validShapes = validateSecondaryOptionShapes(result, ruleName, secondaryOptions, MOTION_SHAPES);
+  return validEntries && validShapes;
+}
+
+function validateEntries(result, secondaryOptions) {
   return stylelint.utils.validateOptions(result, ruleName, {
     actual: secondaryOptions,
     optional: true,

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

@@ -9,6 +9,7 @@ const {
   nearestText,
   numbersEqual,
   parseLengthToken,
+  pxAside,
   pxOnScale,
   toPx,
 } = require('../../core/length');
@@ -52,17 +53,18 @@ const messages = stylelint.utils.ruleMessages(ruleName, {
     `Unknown scale preset "${presetName}". Available presets: ${presetNames.join(', ')}.`,
   rejected: (value, lower, upper, note = '', position = null, aside = '', group = null) =>
     `Unexpected off-scale ${position ? `${position} "${value}"${aside}` : `value "${value}"`}. Use ${group ? `${group} ` : ''}scale values (${nearestText(lower, upper)}).${note ? ` ${note}` : ''}`,
+  // A value the options forbid outright has no nearest scale value to name (issue #274).
+  rejectedNegative: (value, note = '', position = null) =>
+    `Unexpected ${position || 'value'} "${value}". Negative values are disabled for this rule.${note ? ` ${note}` : ''}`,
+  rejectedPercentage: (value, note = '', position = null) =>
+    `Unexpected ${position || 'value'} "${value}". Percentages are disabled for this rule.${note ? ` ${note}` : ''}`,
 });
 
-/** " (16.8px)" after a bound written in rem or em, so the reader sees what was compared. */
-function pxAside(value, baseFontSize) {
-  const parsed = parseLengthToken(value);
-  if (!parsed || !parsed.unit || parsed.unit === 'px' || parsed.unit === '%') {
-    return '';
-  }
-  const px = toPx(Math.abs(parsed.number), parsed.unit, baseFontSize);
-  return px === null ? '' : ` (${formatLength(parsed.number < 0 ? -px : px, 'px')})`;
-}
+// Passed as `nearest` for a value that `allowNegative` or `allowPercentages` forbids.
+const FORBIDDEN_NEGATIVE = Object.freeze({ forbidden: 'negative' });
+const FORBIDDEN_PERCENTAGE = Object.freeze({ forbidden: 'percentage' });
+
+
 
 /** Decisions from .rhythmguardrc.json; an invalid section is reported once and ignored. */
 function readDecisions(options, { result, root }) {
@@ -109,7 +111,7 @@ function checkLengthValue({
       return false;
     }
 
-    report(node.value, decl, node, null, null, '%');
+    report(node.value, decl, node, FORBIDDEN_PERCENTAGE);
     return false;
   }
 
@@ -118,7 +120,7 @@ function checkLengthValue({
   }
 
   if (!options.allowNegative && parsedLength.number < 0) {
-    report(node.value, decl, node, null, null, parsedLength.unit || 'px');
+    report(node.value, decl, node, FORBIDDEN_NEGATIVE);
     return false;
   }
 
@@ -278,12 +280,19 @@ const ruleFunction = (primary, secondaryOptions) => {
     const getScaleStateForProperty = createPropertyScaleResolver(options);
 
     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), String(value).trim().startsWith('-')) : '';
+      let message;
+      if (nearest.forbidden) {
+        const note = [fallbackNote, extraNote, options.note].filter(Boolean).join(' ');
+        message = nearest.forbidden === 'negative'
+          ? messages.rejectedNegative(value, note, position)
+          : messages.rejectedPercentage(value, note, position);
+      } else {
+        const tokenNote = tokenHoldsNote(fixedValue, formatLength(nearest.nearest, nearestUnit), String(value).trim().startsWith('-'));
+        message = messages.rejected(value, formatLength(nearest.lower, nearestUnit), formatLength(nearest.upper, nearestUnit), [fallbackNote, tokenNote, extraNote, options.note].filter(Boolean).join(' '), position, position ? pxAside(value, options.baseFontSize) : '', getScaleStateForProperty(decl.prop.toLowerCase()).group);
+      }
       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),
+        message,
         node,
         replacement: fixedValue,
         result,
@@ -328,106 +337,70 @@ const ruleFunction = (primary, secondaryOptions) => {
       // 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') {
-            const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
-            if (skipToken) {
-              return skipToken;
-            }
-
-            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
-              return true;
-            }
-
-            return false;
+      // The bounds of clamp(), min() and max() are checked in translate
+      // functions as anywhere else (issue #272).
+      const checkedBounds = new Set();
+      const visit = (node, context) => {
+        if (node.type === 'function') {
+          const skipToken = skipTokenFunction(node, options.tokenFunctions, tokenRegex);
+          if (skipToken) {
+            return skipToken;
           }
 
-          if (node.type !== 'word') {
-            return false;
-          }
-
-          if (isKeyword(node.value, options.ignoreValues)) {
-            return false;
-          }
-
-          if (!shouldLintMathArgument(context, options)) {
-            return false;
-          }
-
-          checkLengthValue({
-            avoidTokens: context.tokenFallbackOf,
-            decl,
-            fixable: !sassOperands.has(node),
-            node,
-            options,
-            report,
-            scaleByUnit,
-            scalePx,
-          });
-
-          return false;
-        });
-      } else {
-        const checkedBounds = new Set();
-        walkRootValueNodes(parsed, (node, context) => {
-
-          if (node.type === 'function') {
-            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)) {
-                  continue;
-                }
-                checkedBounds.add(bound.node);
-                if (isKeyword(bound.node.value, options.ignoreValues)) {
-                  continue;
-                }
-                const boundReport = (value, d, n, nearest, fixed, unit, extra) => report(value, d, n, nearest, fixed, unit, extra, bound.position);
-                checkLengthValue({ avoidTokens: context.tokenFallbackOf, decl, fixable: !sassOperands.has(bound.node), node: bound.node, options, report: boundReport, scaleByUnit, scalePx });
+          if (options.checkMathBounds && isBoundFunction(node)) {
+            for (const bound of collectMathBounds(node)) {
+              if (checkedBounds.has(bound.node)) {
+                continue;
               }
+              checkedBounds.add(bound.node);
+              if (isKeyword(bound.node.value, options.ignoreValues)) {
+                continue;
+              }
+              const boundReport = (value, d, n, nearest, fixed, unit, extra) => report(value, d, n, nearest, fixed, unit, extra, bound.position);
+              checkLengthValue({ avoidTokens: context.tokenFallbackOf, decl, fixable: !sassOperands.has(bound.node), node: bound.node, options, report: boundReport, scaleByUnit, scalePx });
             }
-
-            if (
-              isMathFunction(node.value) &&
-              !options.enforceInsideMathFunctions
-            ) {
-              return true;
-            }
-
-            return false;
           }
 
-          if (node.type !== 'word' || checkedBounds.has(node)) {
-            return false;
+          if (
+            isMathFunction(node.value) &&
+            !options.enforceInsideMathFunctions
+          ) {
+            return true;
           }
 
-          if (isKeyword(node.value, options.ignoreValues)) {
-            return false;
-          }
+          return false;
+        }
 
-          if (!shouldLintMathArgument(context, options)) {
-            return false;
-          }
+        if (node.type !== 'word' || checkedBounds.has(node)) {
+          return false;
+        }
 
-          checkLengthValue({
-            avoidTokens: context.tokenFallbackOf,
-            decl,
-            fixable: !sassOperands.has(node),
-            node,
-            options,
-            report,
-            scaleByUnit,
-            scalePx,
-          });
+        if (isKeyword(node.value, options.ignoreValues)) {
+          return false;
+        }
 
+        if (!shouldLintMathArgument(context, options)) {
           return false;
+        }
+
+        checkLengthValue({
+          avoidTokens: context.tokenFallbackOf,
+          decl,
+          fixable: !sassOperands.has(node),
+          node,
+          options,
+          report,
+          scaleByUnit,
+          scalePx,
         });
+
+        return false;
+      };
+
+      if (prop === 'transform') {
+        walkTransformTranslateNodes(parsed, visit);
+      } else {
+        walkRootValueNodes(parsed, visit);
       }
 
       writeDeclarationValue(decl, source, parsed);

package/src/rules/validate.js

@@ -33,10 +33,18 @@ function validateSecondaryOptionShapes(result, ruleName, secondaryOptions, schem
       continue;
     }
 
-    const literalAllowed = Array.isArray(descriptor.allowLiterals)
-      && descriptor.allowLiterals.includes(optionValue);
-
-    if (descriptor.expectsArray && !Array.isArray(optionValue) && !literalAllowed) {
+    const literals = Array.isArray(descriptor.allowLiterals) ? descriptor.allowLiterals : [];
+    const literalAllowed = literals.includes(optionValue);
+
+    // A literal such as "auto" stands for the whole option, so `["auto"]` is
+    // invalid, and an empty list where a scale is expected checks nothing
+    // (issue #273).
+    const invalidArray = Array.isArray(optionValue) && (
+      (descriptor.nonEmpty && optionValue.length === 0)
+      || optionValue.some((entry) => literals.includes(entry))
+    );
+
+    if ((descriptor.expectsArray && !Array.isArray(optionValue) && !literalAllowed) || invalidArray) {
       valid = false;
       result.warn(
         `Invalid value ${stringifyOptionValue(optionValue)} for option "${optionName}" of rule "${ruleName}"`,
@@ -126,6 +134,7 @@ function validatePrimary(result, ruleName, primary) {
 
 module.exports = {
   validatePrimary,
+  validateSecondaryOptionShapes,
   validateNoOffscaleTransformSecondaryOptions,
   validatePreferTokenSecondaryOptions,
   validateUseScaleSecondaryOptions,

package/types/__checks__/consumer.ts

@@ -9,6 +9,7 @@ import type {
   AuditReport,
   RhythmguardRuleOptions,
   RhythmguardStylelintConfig,
+  ScalePresetMetadata,
 } from 'stylelint-plugin-rhythmguard';
 import { createAuditReport, toAuditContractReport } from 'stylelint-plugin-rhythmguard/audit';
 import eslintPlugin from 'stylelint-plugin-rhythmguard/eslint';
@@ -48,6 +49,9 @@ const name: string = useScaleName;
 
 const presetNames: string[] = listScalePresetNames();
 const preset = getScalePreset('rhythmic-4');
+// Unknown names return null, as the runtime does (#281).
+const missingPreset: readonly number[] | null = getScalePreset('nope');
+const missingMetadata: ScalePresetMetadata | null = presets.getCommunityScaleMetadata('nope');
 const presetsAgain: string[] = presets.listScalePresetNames();
 
 const eslintRule = eslint.rules['tailwind-class-use-scale'];
@@ -55,8 +59,21 @@ const eslintRuleAgain = eslintPlugin.rules['tailwind-class-use-motion-scale'];
 
 async function runAudit(): Promise<AuditContractReport> {
   const report: AuditReport = await createAuditReport({ dir: './src', noConfig: true });
-  const viaPlugin: AuditReport = await audit.createAuditReport({ dir: './src' });
+  const viaPlugin: AuditReport = await audit.createAuditReport({ dir: './src', scale: undefined });
   void viaPlugin;
+  // The fields the runtime report has (#284).
+  const cleanliness: number = report.summary.scaleCleanliness + report.scaleCleanliness;
+  const counts: number = report.summary.totalFindings + report.summary.filesWithIssues + report.filesWithIssues;
+  const configFile: string | undefined = report.config?.file;
+  const firstText: string | undefined = report.findings.css[0]?.text;
+  const resolved: number | undefined = report.baseline?.resolvedFindingsCount;
+  const contractConfig: { file: string } | null = toAuditContractReport(report).command.config;
+  void cleanliness;
+  void counts;
+  void configFile;
+  void firstText;
+  void resolved;
+  void contractConfig;
   return toAuditContractReport(report);
 }
 
@@ -68,6 +85,8 @@ void docUrl;
 void name;
 void presetNames;
 void preset;
+void missingPreset;
+void missingMetadata;
 void presetsAgain;
 void eslintRule;
 void eslintRuleAgain;

package/types/__checks__/eslint-config.ts

@@ -31,7 +31,15 @@ const flatConfig: Linter.Config = {
   rules: rhythmguard.configs.recommended.rules,
 };
 
+// configs.recommended registers the plugin, so it stands alone in a config array (#279).
+const standalone = defineConfig([rhythmguard.configs.recommended]);
+const recommendedAsConfig: Linter.Config = companion.configs.recommended;
+const spreadRecommended: Linter.Config = { ...rhythmguard.configs.recommended, files: ['**/*.jsx'] };
+
 void config;
+void standalone;
+void recommendedAsConfig;
+void spreadRecommended;
 void asPlugin;
 void companionAsPlugin;
 void flatConfig;