stylelint-plugin-rhythmguard 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to `stylelint-plugin-rhythmguard` will be documented in this
 
 The format follows Keep a Changelog principles and semantic versioning.
 
+## [Unreleased]
+
+## [1.2.0] - 2026-02-17
+
+### Added
+
+- Tailwind integration guidance in README:
+  - exact enforcement boundary (CSS declarations vs class strings)
+  - recommended layered setup with `stylelint-config-tailwindcss`, `eslint-plugin-tailwindcss`, and `prettier-plugin-tailwindcss`
+  - architecture direction for thorough Tailwind coverage.
+- New shared config entry point: `stylelint-plugin-rhythmguard/configs/tailwind`.
+- Tailwind-oriented test coverage for transform token functions and nested translate values.
+
+### Changed
+
+- Hardened transform translate parsing to handle nested function values consistently.
+- `use-scale` and `no-offscale-transform` now respect `enforceInsideMathFunctions` in transform translation contexts.
+
+## [1.1.0] - 2026-02-17
+
+### Added
+
+- `CODEOWNERS` for repository ownership and review routing.
+- Post-publish npm smoke workflow to validate clean-project install and lint execution from the registry.
+- Non-blocking full-suite observability on Stylelint `16.0.0` in CI/release verification.
+- Community scale registry with JSON schema, CI validation, and scaffolding script.
+- Community contribution workflow assets:
+  - `docs/COMMUNITY_SCALES.md`
+  - `scales/community/*.json`
+  - `scripts/scales/add-scale.mjs`
+  - `scripts/scales/validate-community-scales.mjs`
+  - scale request issue template.
+
+### Changed
+
+- Preset loader now includes validated community scale files from `scales/community`.
+- Exported preset helpers now include:
+  - `listCommunityScalePresetNames()`
+  - `getCommunityScaleMetadata(name)`
+
 ## [1.0.0] - 2026-02-17
 
 ### Changed

package/CONTRIBUTING.md

@@ -0,0 +1,65 @@
+# Contributing
+
+Thanks for contributing to `stylelint-plugin-rhythmguard`.
+
+## Development Setup
+
+```bash
+npm ci
+npm run lint
+npm test
+```
+
+Optional checks:
+
+```bash
+npm run test:compat-floor
+npm run test:coverage
+npm run test:pack-smoke
+npm run scales:validate
+```
+
+## Community Scale Contributions
+
+Rhythmguard accepts community presets through JSON files in `scales/community`.
+
+Create a new scale file:
+
+```bash
+npm run scales:add -- --name my-team-scale --base 8 --steps 0,4,8,12,16,24,32
+```
+
+Then validate:
+
+```bash
+npm run scales:validate
+```
+
+Scale files must pass schema and collision checks. See [`docs/COMMUNITY_SCALES.md`](./docs/COMMUNITY_SCALES.md) for the full spec and policy.
+
+## Semver Rules
+
+- Patch (`x.y.Z`): bug fixes, docs updates, non-breaking internal changes.
+- Minor (`x.Y.z`): backward-compatible new options, presets, or behavior.
+- Major (`X.y.z`): any breaking behavior change for existing rules/configs.
+
+Breaking examples:
+
+- changing default scale behavior
+- changing autofix behavior in a non-compatible way
+- changing/removing exported config entry points
+
+## Rule Change Requirements
+
+When changing rule logic:
+
+1. add/adjust tests for the behavior
+2. validate deterministic fix behavior
+3. update README option or behavior docs if needed
+4. update CHANGELOG
+
+## Release Notes
+
+- Keep `stylelint-plugin-rhythmguard/configs/recommended` and `stylelint-plugin-rhythmguard/configs/strict` stable.
+- Verify CI matrix is green before publishing.
+- Publish with provenance through the release workflow.

package/README.md

@@ -61,10 +61,20 @@ npm install --save-dev stylelint stylelint-plugin-rhythmguard
 }
 ```
 
+### Tailwind config
+
+```json
+{
+  "plugins": ["stylelint-plugin-rhythmguard"],
+  "extends": ["stylelint-plugin-rhythmguard/configs/tailwind"]
+}
+```
+
 Stable shared config entry points:
 
 - `stylelint-plugin-rhythmguard/configs/recommended`
 - `stylelint-plugin-rhythmguard/configs/strict`
+- `stylelint-plugin-rhythmguard/configs/tailwind`
 
 ### Full custom setup
 
@@ -183,6 +193,36 @@ Aliases:
 - Theory presets expose mathematically-derived modular scales from design theory and typographic proportion systems.
 - Full research notes and sources are documented in [`docs/SCALE_RESEARCH.md`](./docs/SCALE_RESEARCH.md).
 
+## Community Scale Registry
+
+Rhythmguard supports community-contributed scale presets from `scales/community/*.json`.
+
+### Current community scales
+
+| Preset | Base | Pattern | Contributor |
+| --- | --- | --- | --- |
+| `product-decimal-10` | `10` | Decimal-friendly dashboard/product cadence | [Petri Lahdelma](https://github.com/PetriLahdelma) |
+
+### Contribute a scale
+
+1. Scaffold a new scale file:
+
+```bash
+npm run scales:add -- --name my-team-scale --base 8 --steps 0,4,8,12,16,24,32
+```
+
+2. Validate:
+
+```bash
+npm run scales:validate
+```
+
+3. Open a PR with your scale JSON.
+
+Full specification and policy: [`docs/COMMUNITY_SCALES.md`](./docs/COMMUNITY_SCALES.md).
+
+If your scale is private or very niche, keep it in your project config with `customScale` instead of contributing it to the shared registry.
+
 ## Rule Details
 
 ### `rhythmguard/use-scale`
@@ -287,12 +327,67 @@ Options:
 
 `rhythmguard/no-offscale-transform` accepts the same scale options as `rhythmguard/use-scale`, but only for transform translation properties.
 
+## Tailwind CSS Integration
+
+Rhythmguard works well in Tailwind projects, but it enforces what Stylelint can parse: CSS declarations.
+
+### What Rhythmguard covers in Tailwind projects
+
+- custom CSS in `globals.css`, `components.css`, `utilities.css`
+- CSS Modules (for example `*.module.css`)
+- declarations inside `@layer` blocks
+
+### What Rhythmguard does not cover
+
+- Tailwind class strings in templates/JSX/TSX, for example:
+  - `class="p-4 gap-2"`
+  - `class="p-[13px] translate-y-[18px]"`
+
+Those are not Stylelint declaration nodes, so they are outside this plugin's scope.
+
+### Recommended stack for full Tailwind enforcement
+
+Use both layers:
+
+1. Stylelint + Rhythmguard for CSS declaration governance.
+2. Tailwind-aware class-string linting/formatting for template utility usage.
+
+Suggested setup:
+
+```json
+{
+  "extends": ["stylelint-plugin-rhythmguard/configs/tailwind"]
+}
+```
+
+Then pair with:
+
+- `eslint-plugin-tailwindcss` for class-string rules (including arbitrary-value governance).
+- `prettier-plugin-tailwindcss` for deterministic class ordering.
+
+Detailed setup reference: [`docs/TAILWIND.md`](./docs/TAILWIND.md).
+
+### Tailwind token function support
+
+By default, `tokenFunctions` includes `theme`, so values like `theme(spacing.4)` are treated as tokenized values.
+
+### Product direction
+
+We should extend Tailwind coverage thoroughly, but in the right architecture:
+
+- keep `stylelint-plugin-rhythmguard` focused on CSS declaration enforcement
+- add a complementary Tailwind class-string layer (ESLint/plugin side) for utility classes
+
+This avoids brittle parsing hacks and gives full coverage without compromising rule quality.
+
 ## Programmatic Presets
 
 ```js
 const rhythmguard = require('stylelint-plugin-rhythmguard');
 
 console.log(rhythmguard.presets.listScalePresetNames());
+console.log(rhythmguard.presets.listCommunityScalePresetNames());
+console.log(rhythmguard.presets.getCommunityScaleMetadata('product-decimal-10'));
 console.log(rhythmguard.presets.scales['rhythmic-4']);
 ```
 
@@ -310,6 +405,7 @@ It will not guess token mappings without your map.
 - Stylelint: `^16.0.0`
 - Node.js: `>=18.18.0`
 - Module format: CommonJS plugin package
+- Note: Stylelint `16.0.0` has known autofix/API behavior differences; CI enforces floor compatibility and runs non-blocking full-suite observability on the floor version.
 
 ## Development
 
@@ -342,6 +438,7 @@ Detailed methodology and custom args are documented in [`docs/BENCHMARKING.md`](
 2. `release.yml` runs the Node/Stylelint matrix validation.
 3. A tarball smoke test validates package exports and install behavior.
 4. The package is published to npm with provenance (`npm publish --provenance`).
+5. `post-publish-smoke.yml` verifies the published npm version can be installed and run in a clean project.
 
 ## Support and Bug Reports
 

package/SECURITY.md

@@ -0,0 +1,30 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+| --- | --- |
+| 0.1.x | Yes |
+| < 0.1.0 | No |
+
+## Reporting a Vulnerability
+
+Please do **not** open public GitHub issues for security reports.
+
+Use one of these channels:
+
+1. GitHub private vulnerability reporting (preferred): open a GitHub Security Advisory draft in this repository.
+2. Email: `hello@petrilahdelma.com`
+
+Please include:
+
+- affected version
+- reproduction steps or proof of concept
+- impact assessment
+- any suggested mitigation
+
+## Response Targets
+
+- Initial acknowledgment: within 72 hours
+- Triage decision: within 7 days
+- Remediation/release timeline: communicated after triage based on severity and exploitability

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stylelint-plugin-rhythmguard",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Stylelint plugin for spacing scale and token enforcement",
   "keywords": [
     "stylelint",
@@ -8,6 +8,7 @@
     "css",
     "design-system",
     "design-tokens",
+    "spacing-scale",
     "spacing",
     "linting"
   ],
@@ -17,6 +18,7 @@
     ".": "./src/index.js",
     "./configs/recommended": "./src/configs/recommended.js",
     "./configs/strict": "./src/configs/strict.js",
+    "./configs/tailwind": "./src/configs/tailwind.js",
     "./presets": "./src/presets/index.js",
     "./rules/use-scale": "./src/rules/use-scale/index.js",
     "./rules/prefer-token": "./src/rules/prefer-token/index.js",
@@ -24,16 +26,23 @@
   },
   "files": [
     "assets",
+    "scales",
+    "schemas",
     "src",
     "README.md",
     "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
     "LICENSE"
   ],
   "scripts": {
     "bench:perf": "node scripts/bench/compare.mjs",
     "bench:perf:fix": "node scripts/bench/compare.mjs --fix",
     "lint": "eslint .",
+    "scales:add": "node scripts/scales/add-scale.mjs",
+    "scales:validate": "node scripts/scales/validate-community-scales.mjs",
     "test:pack-smoke": "node scripts/ci/pack-smoke.mjs",
+    "test:npm-smoke": "node scripts/ci/npm-registry-smoke.mjs --package stylelint-plugin-rhythmguard --version latest",
     "test": "node --test test/*.test.js",
     "test:compat-floor": "node --test test/floor-compat.test.js",
     "test:watch": "node --test --watch test/*.test.js",
@@ -51,6 +60,9 @@
   "peerDependencies": {
     "stylelint": "^16.0.0"
   },
+  "dependencies": {
+    "stylelint-config-tailwindcss": "^1.0.1"
+  },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
     "c8": "^10.1.3",

package/scales/community/product-decimal-10.json

@@ -0,0 +1,10 @@
+{
+  "name": "product-decimal-10",
+  "description": "Decimal-friendly product spacing scale for dashboard-heavy enterprise UIs.",
+  "base": 10,
+  "steps": [0, 2, 4, 6, 8, 10, 12, 16, 20, 24, 32, 40, 48, 64, 80],
+  "aliases": ["decimal-10", "enterprise-10"],
+  "tags": ["product", "dashboard", "community"],
+  "contributor": "Petri Lahdelma",
+  "contributorUrl": "https://github.com/PetriLahdelma"
+}

package/schemas/community-scale.schema.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/PetriLahdelma/stylelint-plugin-rhythmguard/schemas/community-scale.schema.json",
+  "title": "Rhythmguard Community Scale",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "name",
+    "description",
+    "base",
+    "steps"
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Preset identifier used with the `preset` option.",
+      "pattern": "^[a-z0-9][a-z0-9-]{2,63}$"
+    },
+    "description": {
+      "type": "string",
+      "description": "Short purpose statement for docs and gallery.",
+      "minLength": 12,
+      "maxLength": 220
+    },
+    "base": {
+      "type": "number",
+      "description": "Primary grid base in px.",
+      "minimum": 0
+    },
+    "steps": {
+      "type": "array",
+      "description": "Ascending px scale values. Must start at 0.",
+      "minItems": 3,
+      "maxItems": 48,
+      "uniqueItems": true,
+      "items": {
+        "type": "number",
+        "minimum": 0,
+        "maximum": 2048
+      }
+    },
+    "aliases": {
+      "type": "array",
+      "description": "Optional shorthand aliases for preset lookup.",
+      "maxItems": 16,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z0-9][a-z0-9-]{1,63}$"
+      },
+      "default": []
+    },
+    "tags": {
+      "type": "array",
+      "description": "Discovery tags shown in docs/gallery.",
+      "maxItems": 16,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z0-9][a-z0-9-]{1,63}$"
+      },
+      "default": []
+    },
+    "contributor": {
+      "type": "string",
+      "description": "Contributor name used in gallery attribution.",
+      "minLength": 2,
+      "maxLength": 120
+    },
+    "contributorUrl": {
+      "type": "string",
+      "description": "Optional contributor profile URL.",
+      "format": "uri"
+    }
+  }
+}

package/src/configs/tailwind.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  extends: [
+    'stylelint-config-tailwindcss',
+    'stylelint-plugin-rhythmguard/configs/strict',
+  ],
+};

package/src/index.js

@@ -15,5 +15,6 @@ module.exports.rules = {
 module.exports.configs = {
   recommended: require('./configs/recommended'),
   strict: require('./configs/strict'),
+  tailwind: require('./configs/tailwind'),
 };
 module.exports.presets = require('./presets');

package/src/presets/index.js

@@ -1,13 +1,19 @@
 'use strict';
 
 const {
+  COMMUNITY_SCALE_METADATA,
   SCALE_PRESETS,
+  getCommunityScaleMetadata,
   getScalePreset,
+  listCommunityScalePresetNames,
   listScalePresetNames,
 } = require('./scales');
 
 module.exports = {
-  scales: SCALE_PRESETS,
+  communityScaleMetadata: COMMUNITY_SCALE_METADATA,
+  getCommunityScaleMetadata,
   getScalePreset,
+  listCommunityScalePresetNames,
   listScalePresetNames,
+  scales: SCALE_PRESETS,
 };

package/src/presets/scales.js

@@ -1,5 +1,16 @@
 'use strict';
 
+const fs = require('node:fs');
+const path = require('node:path');
+
+function normalizePresetName(name) {
+  if (typeof name !== 'string') {
+    return '';
+  }
+
+  return name.trim().toLowerCase();
+}
+
 function createModularScale({ base, ratio, steps }) {
   const values = [0];
   let current = base;
@@ -12,7 +23,7 @@ function createModularScale({ base, ratio, steps }) {
   return [...new Set(values)].sort((a, b) => a - b);
 }
 
-const SCALE_PRESETS = Object.freeze({
+const CORE_SCALE_PRESETS = Object.freeze({
   'rhythmic-4': Object.freeze([0, 4, 8, 12, 16, 24, 32, 40, 48, 64]),
   'rhythmic-8': Object.freeze([0, 8, 16, 24, 32, 40, 48, 64, 80, 96]),
   'product-material-8dp': Object.freeze([0, 4, 8, 12, 16, 24, 32, 40, 48, 56, 64, 72, 80]),
@@ -32,7 +43,7 @@ const SCALE_PRESETS = Object.freeze({
   'modular-perfect-fifth': Object.freeze(createModularScale({ base: 4, ratio: 1.5, steps: 12 })),
 });
 
-const PRESET_ALIASES = Object.freeze({
+const CORE_PRESET_ALIASES = Object.freeze({
   '4pt': 'rhythmic-4',
   '8pt': 'rhythmic-8',
   'atlassian-8': 'product-atlassian-8px',
@@ -49,10 +60,151 @@ const PRESET_ALIASES = Object.freeze({
   'perfect-fourth': 'modular-perfect-fourth',
 });
 
-function normalizePresetName(name) {
-  return String(name).trim().toLowerCase();
+function normalizeCommunitySteps(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) {
+    return null;
+  }
+
+  const normalized = [];
+  let previous = null;
+
+  for (const value of steps) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+      return null;
+    }
+
+    if (previous !== null && value <= previous) {
+      return null;
+    }
+
+    normalized.push(value);
+    previous = value;
+  }
+
+  if (normalized[0] !== 0) {
+    return null;
+  }
+
+  return Object.freeze(normalized);
 }
 
+function loadCommunityScales() {
+  const communityDirectory = path.resolve(__dirname, '../../scales/community');
+  if (!fs.existsSync(communityDirectory)) {
+    return [];
+  }
+
+  const namesInUse = new Set(Object.keys(CORE_SCALE_PRESETS));
+  const aliasesInUse = new Set([...Object.keys(CORE_SCALE_PRESETS), ...Object.keys(CORE_PRESET_ALIASES)]);
+
+  const fileNames = fs
+    .readdirSync(communityDirectory, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b));
+
+  const definitions = [];
+
+  for (const fileName of fileNames) {
+    const absolutePath = path.join(communityDirectory, fileName);
+
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(absolutePath, 'utf8'));
+    } catch {
+      continue;
+    }
+
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      continue;
+    }
+
+    const presetName = normalizePresetName(parsed.name);
+    if (!presetName || namesInUse.has(presetName)) {
+      continue;
+    }
+
+    const steps = normalizeCommunitySteps(parsed.steps);
+    if (!steps) {
+      continue;
+    }
+
+    const aliases = [];
+    if (Array.isArray(parsed.aliases)) {
+      for (const aliasEntry of parsed.aliases) {
+        const alias = normalizePresetName(aliasEntry);
+        if (!alias || alias === presetName || aliasesInUse.has(alias)) {
+          continue;
+        }
+
+        aliases.push(alias);
+        aliasesInUse.add(alias);
+      }
+    }
+
+    namesInUse.add(presetName);
+    aliasesInUse.add(presetName);
+
+    definitions.push(
+      Object.freeze({
+        aliases: Object.freeze(aliases),
+        base: typeof parsed.base === 'number' && Number.isFinite(parsed.base) ? parsed.base : null,
+        contributor: typeof parsed.contributor === 'string' ? parsed.contributor : null,
+        contributorUrl: typeof parsed.contributorUrl === 'string' ? parsed.contributorUrl : null,
+        description: typeof parsed.description === 'string' ? parsed.description : null,
+        fileName,
+        name: presetName,
+        steps,
+        tags: Object.freeze(Array.isArray(parsed.tags) ? parsed.tags.filter((tag) => typeof tag === 'string') : []),
+      }),
+    );
+  }
+
+  return definitions;
+}
+
+const COMMUNITY_SCALE_DEFINITIONS = Object.freeze(loadCommunityScales());
+
+const COMMUNITY_SCALE_PRESETS = Object.freeze(
+  Object.fromEntries(COMMUNITY_SCALE_DEFINITIONS.map((definition) => [definition.name, definition.steps])),
+);
+
+const COMMUNITY_PRESET_ALIASES = Object.freeze(
+  Object.assign(
+    {},
+    ...COMMUNITY_SCALE_DEFINITIONS.map((definition) =>
+      Object.fromEntries(definition.aliases.map((alias) => [alias, definition.name])),
+    ),
+  ),
+);
+
+const COMMUNITY_SCALE_METADATA = Object.freeze(
+  Object.fromEntries(
+    COMMUNITY_SCALE_DEFINITIONS.map((definition) => [
+      definition.name,
+      Object.freeze({
+        aliases: definition.aliases,
+        base: definition.base,
+        contributor: definition.contributor,
+        contributorUrl: definition.contributorUrl,
+        description: definition.description,
+        fileName: definition.fileName,
+        tags: definition.tags,
+      }),
+    ]),
+  ),
+);
+
+const SCALE_PRESETS = Object.freeze({
+  ...CORE_SCALE_PRESETS,
+  ...COMMUNITY_SCALE_PRESETS,
+});
+
+const PRESET_ALIASES = Object.freeze({
+  ...CORE_PRESET_ALIASES,
+  ...COMMUNITY_PRESET_ALIASES,
+});
+
 function resolvePresetName(name) {
   if (typeof name !== 'string' || name.trim().length === 0) {
     return null;
@@ -72,7 +224,20 @@ function getScalePreset(name) {
 }
 
 function listScalePresetNames() {
-  return Object.keys(SCALE_PRESETS);
+  return Object.keys(SCALE_PRESETS).sort((a, b) => a.localeCompare(b));
+}
+
+function listCommunityScalePresetNames() {
+  return Object.keys(COMMUNITY_SCALE_PRESETS).sort((a, b) => a.localeCompare(b));
+}
+
+function getCommunityScaleMetadata(name) {
+  const normalizedName = resolvePresetName(name);
+  if (!normalizedName) {
+    return null;
+  }
+
+  return COMMUNITY_SCALE_METADATA[normalizedName] || null;
 }
 
 function resolveScaleSelection(options, defaultScale) {
@@ -115,8 +280,16 @@ function resolveScaleSelection(options, defaultScale) {
 }
 
 module.exports = {
+  COMMUNITY_SCALE_DEFINITIONS,
+  COMMUNITY_SCALE_METADATA,
+  COMMUNITY_SCALE_PRESETS,
+  CORE_PRESET_ALIASES,
+  CORE_SCALE_PRESETS,
+  PRESET_ALIASES,
   SCALE_PRESETS,
+  getCommunityScaleMetadata,
   getScalePreset,
+  listCommunityScalePresetNames,
   listScalePresetNames,
   resolveScaleSelection,
 };

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

@@ -14,6 +14,8 @@ const {
 const { buildScaleOptions } = require('../../utils/options');
 const {
   declarationValueIndex,
+  isMathFunction,
+  walkRootValueNodes,
   walkTransformTranslateNodes,
 } = require('../../utils/value-utils');
 
@@ -138,15 +140,55 @@ const ruleFunction = (primary, secondaryOptions) => {
       };
 
       if (prop === 'transform') {
-        walkTransformTranslateNodes(parsed, (node) => {
+        walkTransformTranslateNodes(parsed, (node, parentFunctionName) => {
+          if (node.type === 'function') {
+            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
+              return true;
+            }
+
+            return false;
+          }
+
+          if (node.type !== 'word') {
+            return false;
+          }
+
+          if (
+            parentFunctionName &&
+            isMathFunction(parentFunctionName) &&
+            !options.enforceInsideMathFunctions
+          ) {
+            return false;
+          }
+
           checkNode(node);
+          return false;
         });
       } else {
-        for (const node of parsed.nodes) {
-          if (node.type === 'word') {
-            checkNode(node);
+        walkRootValueNodes(parsed, (node, parentFunctionName) => {
+          if (node.type === 'function') {
+            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
+              return true;
+            }
+
+            return false;
           }
-        }
+
+          if (node.type !== 'word') {
+            return false;
+          }
+
+          if (
+            parentFunctionName &&
+            isMathFunction(parentFunctionName) &&
+            !options.enforceInsideMathFunctions
+          ) {
+            return false;
+          }
+
+          checkNode(node);
+          return false;
+        });
       }
 
       if (changed) {

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

@@ -142,8 +142,25 @@ const ruleFunction = (primary, secondaryOptions) => {
       };
 
       if (prop === 'transform') {
-        walkTransformTranslateNodes(parsed, (node) => {
-          changed = checkWordNode(node) || changed;
+        walkTransformTranslateNodes(parsed, (node, parentFunctionName) => {
+          if (node.type === 'function') {
+            if (isTokenFunction(node, options.tokenFunctions, tokenRegex)) {
+              return true;
+            }
+
+            if (isMathFunction(node.value)) {
+              return true;
+            }
+
+            return false;
+          }
+
+          if (node.type !== 'word') {
+            return false;
+          }
+
+          changed = checkWordNode(node, parentFunctionName) || changed;
+          return false;
         });
       } else {
         walkRootValueNodes(parsed, (node, parentFunctionName) => {

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

@@ -170,7 +170,35 @@ const ruleFunction = (primary, secondaryOptions) => {
       let changed = false;
 
       if (prop === 'transform') {
-        walkTransformTranslateNodes(parsed, (node) => {
+        walkTransformTranslateNodes(parsed, (node, parentFunctionName) => {
+          if (node.type === 'function') {
+            if (isTokenFunction(node, options.tokenFunctions, tokenRegex)) {
+              return true;
+            }
+
+            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
+              return true;
+            }
+
+            return false;
+          }
+
+          if (node.type !== 'word') {
+            return false;
+          }
+
+          if (isKeyword(node.value, options.ignoreValues)) {
+            return false;
+          }
+
+          if (
+            parentFunctionName &&
+            isMathFunction(parentFunctionName) &&
+            !options.enforceInsideMathFunctions
+          ) {
+            return false;
+          }
+
           changed =
             checkLengthValue({
               decl,
@@ -179,6 +207,8 @@ const ruleFunction = (primary, secondaryOptions) => {
               report,
               scalePx,
             }) || changed;
+
+          return false;
         });
       } else {
         walkRootValueNodes(parsed, (node, parentFunctionName) => {

package/src/utils/value-utils.js

@@ -77,6 +77,23 @@ function walkRootValueNodes(parsed, walkNode, state) {
 }
 
 function walkTransformTranslateNodes(parsed, walkNode) {
+  const walkNodes = (nodes, parentFunctionName) => {
+    for (const node of nodes) {
+      if (node.type === 'function') {
+        const fnName = node.value.toLowerCase();
+        const skipChildren = walkNode(node, parentFunctionName);
+        if (skipChildren) {
+          continue;
+        }
+
+        walkNodes(node.nodes, fnName);
+        continue;
+      }
+
+      walkNode(node, parentFunctionName);
+    }
+  };
+
   for (const node of parsed.nodes) {
     if (node.type !== 'function') {
       continue;
@@ -86,11 +103,7 @@ function walkTransformTranslateNodes(parsed, walkNode) {
       continue;
     }
 
-    for (const child of node.nodes) {
-      if (child.type === 'word') {
-        walkNode(child, node.value.toLowerCase());
-      }
-    }
+    walkNodes(node.nodes, node.value.toLowerCase());
   }
 }