stylelint-plugin-rhythmguard 2.1.0 → 3.0.0

package/src/audit/report.js

@@ -1,6 +1,9 @@
 'use strict';
 
+const fs = require('node:fs');
+
 const {
+  createTokenKindMatcher,
   parseTokenSources,
 } = require('../utils/token-sources');
 const {
@@ -13,7 +16,9 @@ const {
   loadAuditConfig,
   loadIgnorePatterns,
 } = require('./config');
-const { buildReport } = require('./contract');
+const { buildReport, collectTokenDefinitions } = require('./contract');
+const { DEFAULT_SCALE, formatPath } = require('./shared');
+const { discoverTokenPackages, scaleFromDefinitions } = require('../utils/scale-inference');
 const {
   assertDirectory,
   collectCssFindings,
@@ -35,19 +40,27 @@ async function createAuditReport(options) {
   const scanFiles = getScanFiles(resolvedDir, ignorePatterns, parsed);
 
   const { cssFiles, scanScope, templateFiles } = scanFiles;
-  const lintOptions = {
-    baseFontSize: parsed.baseFontSize,
-    includeMotion: parsed.includeMotion,
-    scale: parsed.scale,
-  };
-
-  const cssResults = await runStylelintAudit(cssFiles, lintOptions);
 
   const tokenSourceResult = parseTokenSources({
     baseFontSize: parsed.baseFontSize,
     sources: parsed.tokenSources,
     tokenKind: parsed.tokenKind,
   });
+
+  const scale = resolveAuditScale({
+    baseFontSize: parsed.baseFontSize,
+    cssFiles,
+    requested: parsed.scale,
+    tokenSourceResult,
+  });
+
+  const lintOptions = {
+    baseFontSize: parsed.baseFontSize,
+    includeMotion: parsed.includeMotion,
+    scale: scale.values,
+  };
+
+  const cssResults = await runStylelintAudit(cssFiles, lintOptions);
   const stylelintFindings = collectCssFindings(cssResults);
   const cssFindings = stylelintFindings.filter((finding) => !finding.type.startsWith('motion-'));
   const motionFindings = [
@@ -64,7 +77,10 @@ async function createAuditReport(options) {
     externalTokenDefinitions: tokenSourceResult.definitions,
     includeMotion: parsed.includeMotion,
     motionFindings,
+    scale,
     scanScope,
+    scssFiles: cssResults.scssFiles || 0,
+    scssSkipped: cssResults.scssSkipped || 0,
     tailwindFindings: collectTailwindFindings(templateFiles, lintOptions),
     templateFiles,
     tokenCandidateMinCount: parsed.tokenCandidateMinCount,
@@ -84,6 +100,87 @@ async function createAuditReport(options) {
   return report;
 }
 
+const NON_AUTHORED_SEGMENT = /(^|\/)(test|tests|__tests__|spec|specs|fixtures?|__fixtures__|__snapshots__|vendor|third[-_]?party|storybook-static)(\/|$)/i;
+
+/**
+ * One project-level scale for the whole audit, with provenance.
+ * "auto": external token sources, then spacing custom properties across the scanned
+ * CSS, then the default scale. First source that yields values wins.
+ */
+function resolveAuditScale({ baseFontSize, cssFiles, requested, tokenSourceResult }) {
+  if (Array.isArray(requested)) {
+    return {
+      files: [],
+      source: requested === DEFAULT_SCALE ? 'default' : 'explicit',
+      tokenCount: 0,
+      values: requested,
+    };
+  }
+
+  if (tokenSourceResult.definitions.size > 0) {
+    const values = scaleFromDefinitions(tokenSourceResult.definitions, baseFontSize);
+    if (values) {
+      return {
+        files: tokenSourceResult.sources.map((source) => source.file),
+        source: 'token-sources',
+        tokenCount: tokenSourceResult.definitions.size,
+        values,
+      };
+    }
+  }
+
+  const definitions = new Map();
+  const matchesKind = createTokenKindMatcher('spacing');
+  for (const filePath of cssFiles) {
+    // Test, fixture and vendored stylesheets often redefine tokens to exercise
+    // overrides; they are findings noise and must not shape the inferred scale.
+    if (NON_AUTHORED_SEGMENT.test(formatPath(filePath))) {
+      continue;
+    }
+    let text;
+    try {
+      text = fs.readFileSync(filePath, 'utf8');
+    } catch {
+      continue;
+    }
+    collectTokenDefinitions(text, formatPath(filePath), definitions, matchesKind, baseFontSize);
+  }
+
+  if (definitions.size > 0) {
+    const values = scaleFromDefinitions(definitions, baseFontSize);
+    if (values) {
+      const files = new Set();
+      for (const definition of definitions.values()) {
+        for (const file of definition.files) {
+          files.add(file);
+        }
+      }
+      return {
+        files: Array.from(files).sort(),
+        source: 'scanned-css',
+        tokenCount: definitions.size,
+        values,
+      };
+    }
+  }
+
+  const packageSources = discoverTokenPackages(process.cwd());
+  if (packageSources.length > 0) {
+    const parsedPackages = parseTokenSources({ baseFontSize, sources: packageSources, tokenKind: 'spacing' });
+    const values = scaleFromDefinitions(parsedPackages.definitions, baseFontSize);
+    if (values) {
+      return {
+        files: parsedPackages.sources.map((source) => source.file),
+        source: 'token-package',
+        tokenCount: parsedPackages.definitions.size,
+        values,
+      };
+    }
+  }
+
+  return { files: [], source: 'fallback', tokenCount: 0, values: DEFAULT_SCALE };
+}
+
 function normalizeCreateAuditOptions(options = {}) {
   const parsed = {
     ...createDefaultAuditOptions(),

package/src/audit/scan.js

@@ -230,8 +230,33 @@ function toPosixRelativePath(rootDir, filePath) {
   return path.relative(rootDir, filePath).split(path.sep).join('/');
 }
 
+function isScssFile(filePath) {
+  return filePath.endsWith('.scss');
+}
+
+// "CSS files" in the audit means authored stylesheets: .css always, .scss when
+// postcss-scss can be resolved (see resolveScssSyntax).
 function isCssFile(filePath) {
-  return filePath.endsWith('.css');
+  return filePath.endsWith('.css') || isScssFile(filePath);
+}
+
+let scssSyntaxCache;
+
+/**
+ * postcss-scss is an optional peer. Resolve it from the audited project first,
+ * then from this package. Returns null when unavailable; SCSS files are then
+ * counted as skipped instead of failing the audit.
+ */
+function resolveScssSyntax() {
+  if (scssSyntaxCache !== undefined) {
+    return scssSyntaxCache;
+  }
+  try {
+    scssSyntaxCache = require.resolve('postcss-scss', { paths: [process.cwd(), __dirname] });
+  } catch {
+    scssSyntaxCache = null;
+  }
+  return scssSyntaxCache;
 }
 
 function isTemplateFile(filePath) {
@@ -240,7 +265,10 @@ function isTemplateFile(filePath) {
 
 async function runStylelintAudit(cssFiles, options) {
   if (cssFiles.length === 0) {
-    return [];
+    const empty = [];
+    empty.scssFiles = 0;
+    empty.scssSkipped = 0;
+    return empty;
   }
 
   const { default: stylelint } = await import('stylelint');
@@ -274,15 +302,42 @@ async function runStylelintAudit(cssFiles, options) {
     ];
   }
 
-  const result = await stylelint.lint({
-    files: cssFiles,
-    config: {
-      plugins: [pluginPath],
-      rules,
-    },
-  });
+  const plainFiles = cssFiles.filter((file) => !isScssFile(file));
+  const scssFiles = cssFiles.filter(isScssFile);
+  const results = [];
+
+  if (plainFiles.length > 0) {
+    const result = await stylelint.lint({
+      files: plainFiles,
+      config: {
+        plugins: [pluginPath],
+        rules,
+      },
+    });
+    results.push(...(result.results || []));
+  }
+
+  let scssSkipped = 0;
+  if (scssFiles.length > 0) {
+    const scssSyntax = resolveScssSyntax();
+    if (scssSyntax) {
+      const result = await stylelint.lint({
+        files: scssFiles,
+        config: {
+          customSyntax: scssSyntax,
+          plugins: [pluginPath],
+          rules,
+        },
+      });
+      results.push(...(result.results || []));
+    } else {
+      scssSkipped = scssFiles.length;
+    }
+  }
 
-  return result.results || [];
+  results.scssFiles = scssFiles.length;
+  results.scssSkipped = scssSkipped;
+  return results;
 }
 
 function collectCssFindings(fileResults) {
@@ -535,6 +590,8 @@ module.exports = {
   globToRegExp,
   hasGlob,
   isCssFile,
+  isScssFile,
+  resolveScssSyntax,
   isPathInside,
   isTemplateFile,
   offsetToLineColumn,

package/src/cli/index.js

@@ -3,9 +3,13 @@
 
 const command = process.argv[2];
 
-const HELP = `Usage: rhythmguard <command>
+const HELP = `Usage: rhythmguard [command]
+
+With no command: zero-config quickstart. Detects your stack and tokens, infers
+the spacing scale, audits the current directory and prints a config to paste.
 
 Commands:
+  quickstart    Same as running with no command
   audit <dir>   Report design-system drift across CSS and Tailwind class strings
   init          Scaffold a Rhythmguard config for your project
   doctor        Validate your Rhythmguard setup
@@ -14,22 +18,24 @@ Options:
   --help        Show this help message
 
 Examples:
+  npx rhythmguard
   npx rhythmguard audit ./src
-  npx rhythmguard audit ./src --json
   npx rhythmguard audit ./src --format markdown
   npx rhythmguard init
   npx rhythmguard doctor
 `;
 
-if (!command || command === '--help' || command === '-h') {
+if (command === '--help' || command === '-h') {
   process.stdout.write(HELP);
   process.exit(0);
 }
 
-if (command === 'audit') {
+if (!command || command === 'quickstart') {
+  require('./quickstart').run();
+} else if (command === 'audit') {
   require('./audit').run();
 } else if (command === 'init') {
-  require('./init');
+  require('./init').run();
 } else if (command === 'doctor') {
   require('./doctor');
 } else {

package/src/cli/init.js

@@ -92,9 +92,6 @@ function detect() {
 }
 
 function selectProfile(stack) {
-  if (stack.nextjs && stack.tailwind) {
-    return 'react-tailwind';
-  }
   if (stack.tailwind) {
     return 'tailwind';
   }
@@ -140,6 +137,8 @@ async function run() {
 
     const config = {
       extends: [`stylelint-plugin-rhythmguard/configs/${profile}`],
+      // Next.js build output is generated CSS; never lint it.
+      ...(stack.nextjs ? { ignoreFiles: ['.next/**', 'out/**', 'node_modules/**'] } : {}),
     };
 
     const configPath = path.join(process.cwd(), '.stylelintrc.json');
@@ -153,4 +152,8 @@ async function run() {
   }
 }
 
-run();
+module.exports = { detect, run, selectProfile };
+
+if (require.main === module) {
+  run();
+}

package/src/cli/quickstart.js

@@ -0,0 +1,207 @@
+'use strict';
+
+/**
+ * `npx rhythmguard` with no arguments.
+ *
+ * The first minute, with nothing to configure: detect the stack and any token
+ * files, infer the spacing scale from the project's own tokens, audit the
+ * current directory, and end with the exact config to paste. Never fails the
+ * process on findings; this is a report, not a gate.
+ */
+
+const fs = require('node:fs');
+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')];
+const MAX_LISTED = 5;
+
+function readPackage(cwd) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function tailwindMajor(pkg) {
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps['@tailwindcss/postcss'] || deps['@tailwindcss/vite']) {
+    return 4;
+  }
+  const spec = deps.tailwindcss;
+  if (!spec) {
+    return null;
+  }
+  const match = String(spec).match(/(\d+)/);
+  return match ? Number(match[1]) : null;
+}
+
+function findTokenFiles(cwd) {
+  const found = new Set();
+  const consider = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && TOKEN_FILE_PATTERN.test(entry.name)) {
+        found.add(path.relative(cwd, path.join(dir, entry.name)));
+      }
+    }
+  };
+  consider(cwd);
+  for (const sub of TOKEN_DIRS) {
+    consider(path.join(cwd, sub));
+  }
+  return Array.from(found).sort();
+}
+
+function hasRhythmguardConfig(cwd) {
+  return fs.existsSync(path.join(cwd, '.rhythmguardrc.json'));
+}
+
+function toPosix(relativePath) {
+  return `./${relativePath.split(path.sep).join('/')}`;
+}
+
+function topEntries(counts, limit = MAX_LISTED) {
+  return Object.entries(counts || {})
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit);
+}
+
+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],
+    },
+  };
+}
+
+function eslintSnippet(scaleValues) {
+  const scale = scaleValues.filter((value) => typeof value === 'number').join(', ');
+  return [
+    "// eslint.config.js",
+    "import rhythmguard from 'stylelint-plugin-rhythmguard/eslint';",
+    '',
+    'export default [',
+    '  {',
+    "    plugins: { 'rhythmguard-tailwind': rhythmguard },",
+    `    rules: { 'rhythmguard-tailwind/tailwind-class-use-scale': ['warn', { scale: [${scale}] }] },`,
+    '  },',
+    '];',
+  ].join('\n');
+}
+
+function describeScale(scale) {
+  if (!scale) {
+    return 'default';
+  }
+  const files = scale.files && scale.files.length > 0 ? ` (${scale.files.slice(0, 3).join(', ')}${scale.files.length > 3 ? ', …' : ''})` : '';
+  return `${scale.source}${files}`;
+}
+
+async function run() {
+  const cwd = process.cwd();
+  const pkg = readPackage(cwd);
+  const stack = detect();
+  const twMajor = stack.tailwind ? tailwindMajor(pkg) : null;
+  const tokenFiles = findTokenFiles(cwd);
+  const rcPresent = hasRhythmguardConfig(cwd);
+  const out = [];
+
+  out.push('', '  Rhythmguard quickstart', `  ${cwd}`, '');
+  out.push('  Detected');
+  out.push(`    Tailwind        ${stack.tailwind ? `v${twMajor || '?'}` : 'no'}`);
+  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('');
+
+  let report;
+  try {
+    report = await createAuditReport({
+      dir: '.',
+      scale: 'auto',
+      ...(tokenFiles.length > 0 && !rcPresent
+        ? { tokenSources: tokenFiles }
+        : {}),
+    });
+  } catch (error) {
+    process.stderr.write(`Quickstart could not audit ${cwd}: ${error.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (report.cssFilesScanned === 0 && report.templateFilesScanned === 0) {
+    out.push('  No CSS files found here. Run from your project root, or audit a directory directly:');
+    out.push('    npx rhythmguard audit ./src', '');
+    process.stdout.write(`${out.join('\n')}\n`);
+    return;
+  }
+
+  const scale = report.scale;
+  out.push('  Scale');
+  out.push(`    Scale           ${scale.values.join(', ')}`);
+  out.push(`    Source          ${describeScale(scale)}`);
+  if (scale.source === 'fallback') {
+    out.push('    Note            No spacing tokens found; the rhythmic-4 preset is being used.');
+    out.push('                    Add scaleSources or define --space-*/--spacing-* custom properties to lint against your own scale.');
+  }
+  out.push('');
+
+  const offScale = report.findings.css.filter((finding) => finding.type === 'off-scale');
+  out.push('  Findings');
+  out.push(`    CSS files       ${report.cssFilesScanned}`);
+  out.push(`    Template files  ${report.templateFilesScanned}`);
+  out.push(`    Off-scale       ${offScale.length} in CSS, ${report.findings.tailwind.length} in class strings`);
+  out.push(`    Token opps      ${report.findings.css.length - offScale.length} raw values that match or deserve a token`);
+  out.push(`    Cleanliness     ${report.scaleCleanliness}%`);
+  const topValues = topEntries(report.offScaleValues);
+  if (topValues.length > 0) {
+    out.push(`    Top values      ${topValues.map(([value, count]) => `${value} ×${count}`).join(', ')}`);
+  }
+  const topFiles = (report.topAffectedFiles || []).slice(0, 3);
+  if (topFiles.length > 0) {
+    out.push(`    Top files       ${topFiles.map((entry) => `${entry.file} (${entry.count})`).join(', ')}`);
+  }
+  out.push('');
+
+  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({ nextjs: stack.nextjs, profile, tokenFiles }), null, 2).replace(/^/gm, '    '));
+  out.push('');
+
+  if (stack.tailwind) {
+    out.push('  Tailwind class strings need the ESLint companion. Paste this into eslint.config.js:', '');
+    out.push(eslintSnippet(scale.values).replace(/^/gm, '    '));
+    out.push('');
+  }
+
+  out.push('  Next');
+  out.push('    npx stylelint "**/*.css"                      lint with the config above');
+  out.push('    npx rhythmguard audit . --format markdown     PR-ready report');
+  out.push('    npx rhythmguard audit . --write-baseline      then gate only new drift in CI');
+  out.push('    npx rhythmguard doctor                        check the setup');
+  out.push('');
+
+  process.stdout.write(`${out.join('\n')}\n`);
+}
+
+module.exports = { findTokenFiles, run, suggestedStylelintConfig, tailwindMajor };

package/src/configs/embed.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * The one-liner for shared-config authors.
+ *
+ * One rule, warning level, scale inferred from the consuming project's own
+ * spacing tokens (scaleSources, .rhythmguardrc.json token sources, the
+ * stylesheet's custom properties, a Tailwind config, then rhythmic-4).
+ * No `extends`, no dependency beyond this plugin, and the shape is frozen for
+ * the life of the 2.x line so a config that embeds it never changes behaviour
+ * on a minor bump.
+ */
+module.exports = {
+  plugins: ['stylelint-plugin-rhythmguard'],
+  rules: {
+    'rhythmguard/use-scale': [
+      true,
+      {
+        scale: 'auto',
+        severity: 'warning',
+      },
+    ],
+  },
+};

package/src/configs/{logical.mjs → embed.mjs}

@@ -1,4 +1,4 @@
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
-const config = require('./logical.js');
+const config = require('./embed.js');
 export default config;

package/src/index.js

@@ -15,14 +15,11 @@ module.exports.rules = {
   [useMotionScale.ruleName]: useMotionScale,
 };
 module.exports.configs = {
+  embed: require('./configs/embed'),
   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/rules/no-offscale-transform/index.js

@@ -5,6 +5,7 @@ const valueParser = require('postcss-value-parser');
 const {
   formatLength,
   fromPx,
+  isHairlineLength,
   nearestScaleValues,
   normalizeScale,
   normalizeScaleByUnit,
@@ -25,6 +26,11 @@ const {
   walkTransformTranslateNodes,
 } = require('../../utils/value-utils');
 
+const {
+  DEFAULT_AUTO_TOKEN_PATTERN,
+  resolveAutoScale,
+} = require('../../utils/scale-inference');
+
 const ruleName = 'rhythmguard/no-offscale-transform';
 const messages = stylelint.utils.ruleMessages(ruleName, {
   invalidPreset: (presetName, presetNames) =>
@@ -84,6 +90,18 @@ const ruleFunction = (primary, secondaryOptions) => {
       });
     }
 
+    if (options.scaleAuto) {
+      const inference = resolveAutoScale({
+        baseFontSize: options.baseFontSize,
+        root,
+        scaleSources: options.scaleSources,
+        tailwindConfigPath: options.tailwindConfigPath,
+        tokenPattern: options.tokenPatternExplicit ? options.tokenPattern : DEFAULT_AUTO_TOKEN_PATTERN,
+      });
+      options.scale = inference.scale;
+      options.scaleInference = inference;
+    }
+
     const scaleCache = new Map();
     const getScaleStateForProperty = (prop) => {
       const cached = scaleCache.get(prop);
@@ -152,6 +170,10 @@ const ruleFunction = (primary, secondaryOptions) => {
           return;
         }
 
+        if (options.allowHairlines && isHairlineLength(parsedLength, options.baseFontSize)) {
+          return;
+        }
+
         if (!options.allowNegative && parsedLength.number < 0) {
           return;
         }

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

@@ -4,6 +4,7 @@ const stylelint = require('stylelint');
 const valueParser = require('postcss-value-parser');
 const {
   formatLength,
+  isHairlineLength,
   normalizeScale,
   normalizeScaleByUnit,
   numbersEqual,
@@ -28,6 +29,11 @@ const {
 } = require('../../utils/value-utils');
 const { buildEffectiveTokenMap } = require('../../utils/token-map');
 
+const {
+  DEFAULT_AUTO_TOKEN_PATTERN,
+  resolveAutoScale,
+} = require('../../utils/scale-inference');
+
 const ruleName = 'rhythmguard/prefer-token';
 
 const messages = stylelint.utils.ruleMessages(ruleName, {
@@ -112,6 +118,18 @@ const ruleFunction = (primary, secondaryOptions) => {
       });
     }
 
+    if (options.scaleAuto) {
+      const inference = resolveAutoScale({
+        baseFontSize: options.baseFontSize,
+        root,
+        scaleSources: options.scaleSources,
+        tailwindConfigPath: options.tailwindConfigPath,
+        tokenPattern: options.tokenPatternExplicit ? options.tokenPattern : DEFAULT_AUTO_TOKEN_PATTERN,
+      });
+      options.scale = inference.scale;
+      options.scaleInference = inference;
+    }
+
     const tokenRegex = createTokenRegex(options.tokenPattern, result, ruleName);
     const tokenMap = buildEffectiveTokenMap({
       options,
@@ -196,6 +214,16 @@ const ruleFunction = (primary, secondaryOptions) => {
           return false;
         }
 
+        // Percentages are relative to the container or the element itself; they are
+        // never spacing-token candidates (translate(-50%, -50%) centering, inset: 100%).
+        if (parsedLength.unit === '%') {
+          return false;
+        }
+
+        if (options.allowHairlines && isHairlineLength(parsedLength, options.baseFontSize)) {
+          return false;
+        }
+
         if (
           parsedLength.unit &&
           parsedLength.unit !== '%' &&