stylelint-plugin-rhythmguard 1.8.0 → 2.0.0

package/src/utils/tailwind-motion-analysis.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const {
+  nearestScaleValues,
+  numbersEqual,
+} = require('./length');
+const {
+  formatTime,
+  fromMs,
+  normalizeDurationScale,
+  normalizeDurationUnits,
+  parseTimeToken,
+  toMs,
+} = require('./time');
+const { findClassSegments } = require('./tailwind-class-analysis');
+
+const ARBITRARY_MOTION_CLASS = /^(?<utility>duration|delay|ease)-\[(?<rawValue>[^\]]+)\]$/;
+
+function normalizeTailwindMotionOptions(option = {}) {
+  return {
+    durationScale: normalizeDurationScale(option.durationScale),
+    durationUnits: normalizeDurationUnits(option.durationUnits),
+  };
+}
+
+function findLastVariantSeparator(token) {
+  let bracketDepth = 0;
+  let separatorIndex = -1;
+
+  for (let index = 0; index < token.length; index++) {
+    const character = token[index];
+
+    if (character === '[') {
+      bracketDepth++;
+      continue;
+    }
+
+    if (character === ']' && bracketDepth > 0) {
+      bracketDepth--;
+      continue;
+    }
+
+    if (character === ':' && bracketDepth === 0) {
+      separatorIndex = index;
+    }
+  }
+
+  return separatorIndex;
+}
+
+function parseClassToken(token) {
+  const separatorIndex = findLastVariantSeparator(token);
+  const prefix = separatorIndex === -1
+    ? ''
+    : token.slice(0, separatorIndex + 1);
+  let candidate = separatorIndex === -1
+    ? token
+    : token.slice(separatorIndex + 1);
+  let leadingImportant = '';
+  let trailingImportant = '';
+
+  if (candidate.startsWith('!')) {
+    leadingImportant = '!';
+    candidate = candidate.slice(1);
+  }
+
+  if (candidate.endsWith('!')) {
+    trailingImportant = '!';
+    candidate = candidate.slice(0, -1);
+  }
+
+  return {
+    candidate,
+    leadingImportant,
+    prefix,
+    trailingImportant,
+  };
+}
+
+function analyzeMotionToken(token, options) {
+  const parsedToken = parseClassToken(token);
+  const match = parsedToken.candidate.match(ARBITRARY_MOTION_CLASS);
+  if (!match || !match.groups) {
+    return null;
+  }
+
+  if (match.groups.utility === 'ease') {
+    return {
+      fixedToken: null,
+      rawValue: match.groups.rawValue,
+      reason: 'easing',
+      utility: match.groups.utility,
+    };
+  }
+
+  const parsedTime = parseTimeToken(match.groups.rawValue);
+  if (!parsedTime) {
+    return null;
+  }
+
+  if (parsedTime.number < 0) {
+    return {
+      fixedToken: null,
+      nearest: null,
+      rawValue: match.groups.rawValue,
+      reason: 'negative',
+      utility: match.groups.utility,
+    };
+  }
+
+  if (!options.durationUnits.includes(parsedTime.unit)) {
+    return null;
+  }
+
+  const msValue = toMs(parsedTime.number, parsedTime.unit);
+  if (msValue === null) {
+    return null;
+  }
+
+  const isOnScale = options.durationScale.some((entry) => numbersEqual(entry, msValue));
+  if (isOnScale) {
+    return null;
+  }
+
+  const nearest = nearestScaleValues(msValue, options.durationScale);
+  if (!nearest) {
+    return null;
+  }
+
+  const converted = fromMs(nearest.nearest, parsedTime.unit);
+  if (converted === null) {
+    return null;
+  }
+
+  const replacementValue = formatTime(converted, parsedTime.unit);
+  const fixedCandidate = parsedToken.candidate.replace(match.groups.rawValue, replacementValue);
+  const fixedToken = `${parsedToken.prefix}${parsedToken.leadingImportant}${fixedCandidate}${parsedToken.trailingImportant}`;
+
+  return {
+    fixedToken,
+    nearest,
+    rawValue: match.groups.rawValue,
+    reason: 'duration',
+    utility: match.groups.utility,
+  };
+}
+
+function createTailwindMotionAnalyzer(option = {}) {
+  const options = normalizeTailwindMotionOptions(option);
+
+  return {
+    analyzeClassString(value) {
+      const findings = [];
+
+      for (const segment of findClassSegments(value)) {
+        const analysis = analyzeMotionToken(segment.token, options);
+        if (analysis) {
+          findings.push({ analysis, segment });
+        }
+      }
+
+      return findings;
+    },
+    analyzeToken(token) {
+      return analyzeMotionToken(token, options);
+    },
+    options,
+  };
+}
+
+module.exports = {
+  createTailwindMotionAnalyzer,
+  normalizeTailwindMotionOptions,
+};

package/src/utils/time.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const TIME_RE = /^(-?(?:\d+|\d*\.\d+))(ms|s)$/i;
+
+function parseTimeToken(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const match = value.trim().match(TIME_RE);
+  if (!match) {
+    return null;
+  }
+
+  const number = Number(match[1]);
+  if (!Number.isFinite(number)) {
+    return null;
+  }
+
+  return {
+    number,
+    unit: match[2].toLowerCase(),
+  };
+}
+
+function toMs(number, unit) {
+  if (unit === 'ms') {
+    return number;
+  }
+
+  if (unit === 's') {
+    return number * 1000;
+  }
+
+  return null;
+}
+
+function fromMs(ms, unit) {
+  if (unit === 'ms') {
+    return ms;
+  }
+
+  if (unit === 's') {
+    return ms / 1000;
+  }
+
+  return null;
+}
+
+function formatTime(number, unit) {
+  const normalized = Object.is(number, -0) ? 0 : number;
+  if (Number.isInteger(normalized)) {
+    return `${normalized}${unit}`;
+  }
+
+  return `${Number(normalized.toFixed(4)).toString()}${unit}`;
+}
+
+function normalizeDurationScale(scale) {
+  const source = Array.isArray(scale) && scale.length > 0
+    ? scale
+    : [0, 75, 100, 150, 200, 300, 500, 700, 1000];
+
+  return [...new Set(source
+    .map((entry) => Number(entry))
+    .filter((entry) => Number.isFinite(entry) && entry >= 0))]
+    .sort((a, b) => a - b);
+}
+
+function normalizeDurationUnits(units) {
+  const source = Array.isArray(units) && units.length > 0
+    ? units
+    : ['ms', 's'];
+
+  const normalized = source
+    .map((unit) => String(unit).trim().toLowerCase())
+    .filter((unit) => unit === 'ms' || unit === 's');
+
+  return normalized.length > 0 ? [...new Set(normalized)] : ['ms', 's'];
+}
+
+module.exports = {
+  formatTime,
+  fromMs,
+  normalizeDurationScale,
+  normalizeDurationUnits,
+  parseTimeToken,
+  toMs,
+};

package/src/utils/token-sources.js

@@ -22,12 +22,14 @@ const VALID_TOKEN_KINDS = new Set([
   'radius',
   'typography',
   'size',
+  'motion',
   'all',
 ]);
 
 const TOKEN_KIND_PATTERNS = Object.freeze({
   all: /^--/,
   radius: /^--radius-/,
+  motion: /^--(?:motion|duration|delay|ease|easing)-/,
   size: /^--(?:size|width|height|container)-/,
   spacing: /^--(?:space|spacing)-/,
   typography: /^--(?:font|font-size|line-height|leading|tracking|typography)-/,
@@ -53,7 +55,7 @@ function normalizeTokenSourceFormat(format) {
 function normalizeTokenKind(kind) {
   const normalized = String(kind || 'spacing').trim().toLowerCase();
   if (!VALID_TOKEN_KINDS.has(normalized)) {
-    throw new Error(`Invalid token kind "${kind}". Expected spacing, radius, typography, size, or all.`);
+    throw new Error(`Invalid token kind "${kind}". Expected spacing, radius, typography, size, motion, or all.`);
   }
 
   return normalized;