stylelint-plugin-rhythmguard 3.10.2 → 3.12.0

package/src/core/token-map.js

@@ -71,11 +71,12 @@ function addLengthValueMapping(map, rawLength, tokenReference, baseFontSize, ori
     origins[token] = origin;
   }
 
-  const absolute = Math.abs(parsed.number);
-  const normalizedRaw = formatLength(absolute, parsed.unit || 'px');
+  // Keyed by the signed value: a -8px token stands for -8px, never for 8px
+  // (issue #221). prefer-token negates a positive token for a negative literal.
+  const normalizedRaw = formatLength(parsed.number, parsed.unit || 'px');
   map[normalizedRaw] = token;
 
-  const px = toPx(absolute, parsed.unit, baseFontSize);
+  const px = toPx(parsed.number, parsed.unit, baseFontSize);
   if (px !== null) {
     map[`${px}px`] = token;
   }
@@ -211,23 +212,36 @@ function mergeTokenMapFromCssCustomProperties({
   };
   const origin = displayOrigin(root && root.source && root.source.input ? root.source.input.file : null);
 
+  // Every value each custom property is given in the file. A property given
+  // two values (at the root and under a media query, a theme or a data
+  // attribute) renders differently there, so no fix writes it (issue #231).
+  const valuesByProp = new Map();
   root.walkDecls((decl) => {
     const prop = decl.prop.toLowerCase();
-    if (!prop.startsWith('--')) {
+    if (!prop.startsWith('--') || !tokenRegex.test(prop)) {
       return;
     }
+    const parsed = parseTokenValueLength(decl.value);
+    const px = parsed ? toPx(parsed.number, parsed.unit, baseFontSize) : null;
+    const key = px === null ? `raw:${decl.value.trim()}` : `px:${formatLength(px, 'px')}`;
+    if (!valuesByProp.has(decl.prop)) {
+      valuesByProp.set(decl.prop, { decl, keys: new Set() });
+    }
+    valuesByProp.get(decl.prop).keys.add(key);
+  });
 
-    if (!tokenRegex.test(prop)) {
-      return;
+  for (const { decl, keys } of valuesByProp.values()) {
+    if (keys.size > 1) {
+      continue;
     }
 
     const parsed = parseTokenValueLength(decl.value);
     if (!parsed || parsed.number === 0) {
-      return;
+      continue;
     }
 
     addLengthValueMapping(nextMap, decl.value, `var(${decl.prop})`, baseFontSize, origins, origin);
-  });
+  }
 
   return nextMap;
 }
@@ -375,8 +389,7 @@ function mergeTokenMapFromTailwindSpacing({
       continue;
     }
 
-    const absolute = Math.abs(parsed.number);
-    const normalizedRaw = formatLength(absolute, parsed.unit || 'px');
+    const normalizedRaw = formatLength(parsed.number, parsed.unit || 'px');
     nextMap[normalizedRaw] = `theme(spacing.${key})`;
     if (origins && !origins[nextMap[normalizedRaw]]) {
       origins[nextMap[normalizedRaw]] = displayOrigin(resolvedPath);

package/src/core/token-source-entries.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const path = require('node:path');
+
+const { normalizeTokenSourceFormat } = require('./token-sources');
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+/**
+ * One reading of a token source entry, shared by the lint (`scaleSources`,
+ * `.rhythmguardrc.json`) and the audit (config file, CLI, API), so both read
+ * the same files from the same config (issue #271). An entry is a path string
+ * or an object with `path` (or its alias `file`), and optionally `format`,
+ * `baseDir` (resolved from `baseDir` given here, the config file's directory
+ * for a config file) and `tokenPattern`.
+ *
+ * Returns `{ source }` with `{ baseDir, format, path, tokenPattern? }`, ready
+ * for parseTokenSources, or `{ error }` with a message; it never throws, so
+ * the lint can turn a bad entry into a warning and the audit into an error.
+ */
+function normalizeTokenSourceEntry(entry, baseDir, { defaultFormat = 'auto' } = {}) {
+  if (typeof entry === 'string') {
+    entry = { path: entry };
+  }
+
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+    return { error: 'audit.tokenSources entries must be strings or objects.' };
+  }
+
+  const sourcePath = entry.path || entry.file;
+  if (!isNonEmptyString(sourcePath)) {
+    return { error: 'token source objects must include a path.' };
+  }
+
+  if (entry.tokenPattern !== undefined && !isNonEmptyString(entry.tokenPattern)) {
+    return { error: 'token source tokenPattern must be a non-empty string.' };
+  }
+
+  if (entry.baseDir !== undefined && !isNonEmptyString(entry.baseDir)) {
+    return { error: 'token source baseDir must be a non-empty string.' };
+  }
+
+  let format;
+  try {
+    format = normalizeTokenSourceFormat(entry.format || defaultFormat);
+  } catch (err) {
+    return { error: err.message };
+  }
+
+  return {
+    source: {
+      baseDir: entry.baseDir ? path.resolve(baseDir, entry.baseDir) : baseDir,
+      format,
+      path: sourcePath,
+      ...(entry.tokenPattern ? { tokenPattern: entry.tokenPattern } : {}),
+    },
+  };
+}
+
+module.exports = {
+  normalizeTokenSourceEntry,
+};