stylelint-plugin-rhythmguard 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -6,6 +6,43 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-02-17
+
+### Added
+
+- Strict `secondaryOptions` validation for all three rules:
+  - `rhythmguard/use-scale`
+  - `rhythmguard/prefer-token`
+  - `rhythmguard/no-offscale-transform`
+- Invalid option names (for example `sevverity`) now fail with Stylelint invalid option warnings instead of silently being ignored.
+- Type/shape validation for option payloads (for example `properties` must be an array, `tokenMap` must be an object).
+- Regression tests for invalid secondary option names and option value shapes.
+
+### Changed
+
+- Added `known-css-properties` as a direct runtime dependency to guarantee `properties` option validation in consumer installs.
+- `properties` option validation now checks supported spacing property names against known CSS property metadata (plus `translate-x`, `translate-y`, `translate-z`).
+
+## [1.2.1] - 2026-02-17
+
+### Fixed
+
+- Ignore invalid unitless non-zero literals (`margin: 13`) across all rules instead of treating them like `px` and autofixing them.
+- Reduced strict-mode transform overlap by scoping `rhythmguard/use-scale` away from transform properties in the shared strict config.
+- `rhythmguard/prefer-token` now supports `enforceInsideMathFunctions` for optional math-function enforcement.
+- Hardened `var()` token argument detection to parse the first argument structurally (rather than comma string splitting).
+- npm README link integrity: docs links now resolve to absolute GitHub URLs from the npm package page.
+- Release workflow now detects missing `NPM_TOKEN` and skips publish cleanly with an explicit notice instead of failing.
+
+### Added
+
+- Dev.to article link in README resources:
+  - https://dev.to/petrilahdelma/enforcing-your-spacing-standards-with-rhythmguard-a-custom-stylelint-plugin-1ojj
+- Regression tests covering:
+  - unitless non-zero handling in all three rules
+  - strict transform overlap guard
+  - prefer-token math-function enforcement toggle
+
 ## [1.2.0] - 2026-02-17
 
 ### Added

package/README.md

@@ -14,6 +14,16 @@ High-precision spacing governance for CSS and design systems.
 
 `stylelint-plugin-rhythmguard` enforces spacing discipline across margin, padding, gap, inset, scroll spacing, and translate motion offsets.
 
+## 60-second Demo
+
+<p align="center">
+  <a href="https://raw.githubusercontent.com/petrilahdelma/stylelint-plugin-rhythmguard/main/assets/rhythmguard-campaign-60s.webm">
+    <img src="https://raw.githubusercontent.com/petrilahdelma/stylelint-plugin-rhythmguard/main/assets/rhythmguard-campaign-60s.gif" width="100%" alt="Rhythmguard 60-second campaign demo" />
+  </a>
+</p>
+
+- Full video (WebM): [rhythmguard-campaign-60s.webm](https://raw.githubusercontent.com/petrilahdelma/stylelint-plugin-rhythmguard/main/assets/rhythmguard-campaign-60s.webm)
+
 I built Rhythmguard after 20 years of watching teams ignore spacing scales and ship arbitrary pixel values everywhere.
 
 It is built for teams that want:
@@ -47,7 +57,6 @@ npm install --save-dev stylelint stylelint-plugin-rhythmguard
 
 ```json
 {
-  "plugins": ["stylelint-plugin-rhythmguard"],
   "extends": ["stylelint-plugin-rhythmguard/configs/recommended"]
 }
 ```
@@ -56,16 +65,16 @@ npm install --save-dev stylelint stylelint-plugin-rhythmguard
 
 ```json
 {
-  "plugins": ["stylelint-plugin-rhythmguard"],
   "extends": ["stylelint-plugin-rhythmguard/configs/strict"]
 }
 ```
 
+`strict` intentionally delegates transform translation enforcement to `rhythmguard/no-offscale-transform` to reduce overlapping warnings from `use-scale`.
+
 ### Tailwind config
 
 ```json
 {
-  "plugins": ["stylelint-plugin-rhythmguard"],
   "extends": ["stylelint-plugin-rhythmguard/configs/tailwind"]
 }
 ```
@@ -147,6 +156,24 @@ Scale resolution precedence:
 3. `preset`
 4. default `rhythmic-4` scale
 
+## Option Validation
+
+Rhythmguard validates `secondaryOptions` for each rule before linting declarations.
+
+- Unknown option names fail fast with Stylelint invalid option warnings.
+- Invalid option shapes fail fast (for example string vs array mismatches).
+- `properties` string entries are validated against supported CSS spacing property names, plus `translate-x`, `translate-y`, and `translate-z`.
+
+Example typo that now fails immediately:
+
+```json
+{
+  "rules": {
+    "rhythmguard/use-scale": [true, { "sevverity": "warning" }]
+  }
+}
+```
+
 ## Built-in Scale Presets
 
 | Preset | Pattern | Scale |
@@ -191,7 +218,7 @@ Aliases:
 - Product presets are based on widely-used design-system spacing frameworks.
 - Editorial presets model baseline-grid cadence used in long-form typography and column layouts.
 - 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).
+- Full research notes and sources are documented in [`docs/SCALE_RESEARCH.md`](https://github.com/PetriLahdelma/stylelint-plugin-rhythmguard/blob/main/docs/SCALE_RESEARCH.md).
 
 ## Community Scale Registry
 
@@ -219,7 +246,7 @@ npm run scales:validate
 
 3. Open a PR with your scale JSON.
 
-Full specification and policy: [`docs/COMMUNITY_SCALES.md`](./docs/COMMUNITY_SCALES.md).
+Full specification and policy: [`docs/COMMUNITY_SCALES.md`](https://github.com/PetriLahdelma/stylelint-plugin-rhythmguard/blob/main/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.
 
@@ -268,7 +295,7 @@ Options:
 | `allowPercentages` | `boolean` | `true` | Allows `%` values without scale checks |
 | `fixToScale` | `boolean` | `true` | Enables nearest-value autofix |
 | `enforceInsideMathFunctions` | `boolean` | `false` | Lints `calc()/clamp()/min()/max()` internals |
-| `properties` | `Array<string|RegExp>` | built-in spacing patterns | Override targeted property set |
+| `properties` | `Array<string|RegExp>` | built-in spacing patterns | Override targeted property set; string values must be supported spacing property names |
 
 ### `rhythmguard/prefer-token`
 
@@ -301,9 +328,10 @@ Options:
 | `customScale` | `Array<number|string>` | `undefined` | Highest-priority custom scale override |
 | `scale` | `Array<number|string>` | `[0,4,8,12,16,24,32,40,48,64]` | Used when `allowNumericScale` is enabled |
 | `baseFontSize` | `number` | `16` | Used for scale checks with `rem`/`em` |
+| `enforceInsideMathFunctions` | `boolean` | `false` | Lints `calc()/clamp()/min()/max()` internals |
 | `tokenMap` | `Record<string,string>` | `{}` | Enables autofix from raw value to token |
 | `ignoreValues` | `string[]` | CSS global keywords + `auto` | Skips keyword literals |
-| `properties` | `Array<string|RegExp>` | built-in spacing patterns | Override targeted property set |
+| `properties` | `Array<string|RegExp>` | built-in spacing patterns | Override targeted property set; string values must be supported spacing property names |
 
 ### `rhythmguard/no-offscale-transform`
 
@@ -325,7 +353,7 @@ Example:
 
 Options:
 
-`rhythmguard/no-offscale-transform` accepts the same scale options as `rhythmguard/use-scale`, but only for transform translation properties.
+`rhythmguard/no-offscale-transform` accepts the same scale options as `rhythmguard/use-scale`, but only for transform translation properties. Its secondary options are also validated for unknown keys and invalid value shapes.
 
 ## Tailwind CSS Integration
 
@@ -365,7 +393,7 @@ 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).
+Detailed setup reference: [`docs/TAILWIND.md`](https://github.com/PetriLahdelma/stylelint-plugin-rhythmguard/blob/main/docs/TAILWIND.md).
 
 ### Tailwind token function support
 
@@ -430,15 +458,20 @@ Benchmark with autofix enabled:
 npm run bench:perf:fix
 ```
 
-Detailed methodology and custom args are documented in [`docs/BENCHMARKING.md`](./docs/BENCHMARKING.md).
+Detailed methodology and custom args are documented in [`docs/BENCHMARKING.md`](https://github.com/PetriLahdelma/stylelint-plugin-rhythmguard/blob/main/docs/BENCHMARKING.md).
+
+## Article
+
+- Dev.to: [Enforcing your spacing standards with Rhythmguard](https://dev.to/petrilahdelma/enforcing-your-spacing-standards-with-rhythmguard-a-custom-stylelint-plugin-1ojj)
 
 ## Release Workflow
 
 1. Create a GitHub release.
 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.
+4. If `NPM_TOKEN` is configured in repository secrets, the package is published to npm with provenance (`npm publish --provenance`).
+5. If `NPM_TOKEN` is not configured, publish is skipped with an explicit workflow notice.
+6. `post-publish-smoke.yml` verifies the published npm version can be installed and run in a clean project (and skips cleanly if the version is not on npm).
 
 ## Support and Bug Reports
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stylelint-plugin-rhythmguard",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Stylelint plugin for spacing scale and token enforcement",
   "keywords": [
     "stylelint",
@@ -61,6 +61,7 @@
     "stylelint": "^16.0.0"
   },
   "dependencies": {
+    "known-css-properties": "^0.37.0",
     "stylelint-config-tailwindcss": "^1.0.1"
   },
   "devDependencies": {

package/src/configs/strict.js

@@ -6,6 +6,18 @@ module.exports = {
     'rhythmguard/use-scale': [
       true,
       {
+        // Keep transform-specific enforcement in no-offscale-transform
+        // to avoid duplicate warnings in strict mode.
+        properties: [
+          /^margin(?:-.+)?$/,
+          /^padding(?:-.+)?$/,
+          /^gap$/,
+          /^row-gap$/,
+          /^column-gap$/,
+          /^inset(?:-.+)?$/,
+          /^scroll-margin(?:-.+)?$/,
+          /^scroll-padding(?:-.+)?$/,
+        ],
         scale: [0, 4, 8, 12, 16, 24, 32, 40, 48, 64],
       },
     ],

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

@@ -11,7 +11,10 @@ const {
   parseLengthToken,
   toPx,
 } = require('../../utils/length');
-const { buildScaleOptions } = require('../../utils/options');
+const {
+  buildScaleOptions,
+  validateNoOffscaleTransformSecondaryOptions,
+} = require('../../utils/options');
 const {
   declarationValueIndex,
   isMathFunction,
@@ -54,6 +57,15 @@ const ruleFunction = (primary, secondaryOptions) => {
       return;
     }
 
+    const validSecondaryOptions = validateNoOffscaleTransformSecondaryOptions(
+      result,
+      ruleName,
+      secondaryOptions,
+    );
+    if (!validSecondaryOptions) {
+      return;
+    }
+
     const options = buildScaleOptions(secondaryOptions);
     if (options.invalidPreset) {
       stylelint.utils.report({
@@ -108,6 +120,10 @@ const ruleFunction = (primary, secondaryOptions) => {
           return;
         }
 
+        if (parsedLength.unit === '') {
+          return;
+        }
+
         if (parsedLength.unit === '%' && options.allowPercentages) {
           return;
         }

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

@@ -8,7 +8,10 @@ const {
   parseLengthToken,
   toPx,
 } = require('../../utils/length');
-const { buildTokenOptions } = require('../../utils/options');
+const {
+  buildTokenOptions,
+  validatePreferTokenSecondaryOptions,
+} = require('../../utils/options');
 const {
   createTokenRegex,
   declarationValueIndex,
@@ -53,6 +56,15 @@ const ruleFunction = (primary, secondaryOptions) => {
       return;
     }
 
+    const validSecondaryOptions = validatePreferTokenSecondaryOptions(
+      result,
+      ruleName,
+      secondaryOptions,
+    );
+    if (!validSecondaryOptions) {
+      return;
+    }
+
     const options = buildTokenOptions(secondaryOptions);
     if (options.invalidPreset) {
       stylelint.utils.report({
@@ -109,7 +121,8 @@ const ruleFunction = (primary, secondaryOptions) => {
 
         if (
           parentFunctionName &&
-          isMathFunction(parentFunctionName)
+          isMathFunction(parentFunctionName) &&
+          !options.enforceInsideMathFunctions
         ) {
           return false;
         }
@@ -123,6 +136,10 @@ const ruleFunction = (primary, secondaryOptions) => {
           return false;
         }
 
+        if (parsedLength.unit === '') {
+          return false;
+        }
+
         const absPx = toPx(Math.abs(parsedLength.number), parsedLength.unit, options.baseFontSize);
         if (absPx === null) {
           return false;
@@ -148,7 +165,7 @@ const ruleFunction = (primary, secondaryOptions) => {
               return true;
             }
 
-            if (isMathFunction(node.value)) {
+            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
               return true;
             }
 
@@ -169,7 +186,7 @@ const ruleFunction = (primary, secondaryOptions) => {
               return true;
             }
 
-            if (isMathFunction(node.value)) {
+            if (isMathFunction(node.value) && !options.enforceInsideMathFunctions) {
               return true;
             }
 

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

@@ -11,7 +11,10 @@ const {
   parseLengthToken,
   toPx,
 } = require('../../utils/length');
-const { buildScaleOptions } = require('../../utils/options');
+const {
+  buildScaleOptions,
+  validateUseScaleSecondaryOptions,
+} = require('../../utils/options');
 const {
   createTokenRegex,
   declarationValueIndex,
@@ -66,6 +69,10 @@ function checkLengthValue({
     return false;
   }
 
+  if (parsedLength.unit === '') {
+    return false;
+  }
+
   if (parsedLength.unit === '%' && options.allowPercentages) {
     return false;
   }
@@ -118,6 +125,15 @@ const ruleFunction = (primary, secondaryOptions) => {
       return;
     }
 
+    const validSecondaryOptions = validateUseScaleSecondaryOptions(
+      result,
+      ruleName,
+      secondaryOptions,
+    );
+    if (!validSecondaryOptions) {
+      return;
+    }
+
     const options = buildScaleOptions(secondaryOptions);
     if (options.invalidPreset) {
       stylelint.utils.report({

package/src/utils/options.js

@@ -1,9 +1,12 @@
 'use strict';
 
+const stylelint = require('stylelint');
+const { all: knownCssProperties = [] } = require('known-css-properties');
 const {
   DEFAULT_IGNORE_KEYWORDS,
   SPACING_PROPERTY_PATTERNS,
 } = require('./constants');
+const { parseLengthToken } = require('./length');
 const {
   getScalePreset,
   listScalePresetNames,
@@ -11,6 +14,270 @@ const {
 } = require('../presets/scales');
 
 const DEFAULT_SCALE = getScalePreset('rhythmic-4') || [0, 4, 8, 12, 16, 24, 32];
+const VALID_UNITS = new Set(['px', 'rem', 'em']);
+const VALIDATE_ALWAYS = () => true;
+
+const supportedSpacingProperties = new Set(
+  knownCssProperties.filter((property) =>
+    SPACING_PROPERTY_PATTERNS.some((pattern) => pattern.test(property)),
+  ),
+);
+supportedSpacingProperties.add('translate-x');
+supportedSpacingProperties.add('translate-y');
+supportedSpacingProperties.add('translate-z');
+
+function isPlainObject(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value)
+  );
+}
+
+function isBoolean(value) {
+  return typeof value === 'boolean';
+}
+
+function isFinitePositiveNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function isSupportedUnit(value) {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+
+  return VALID_UNITS.has(value.trim().toLowerCase());
+}
+
+function isScaleEntry(value) {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) && value >= 0;
+  }
+
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+
+  const parsed = parseLengthToken(value);
+  if (!parsed || parsed.number < 0) {
+    return false;
+  }
+
+  return parsed.unit === '' || VALID_UNITS.has(parsed.unit);
+}
+
+function isPropertyPatternEntry(value) {
+  if (value instanceof RegExp) {
+    return true;
+  }
+
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  return supportedSpacingProperties.has(normalized);
+}
+
+function isTokenMap(value) {
+  if (!isPlainObject(value)) {
+    return false;
+  }
+
+  return Object.values(value).every((tokenValue) => isNonEmptyString(tokenValue));
+}
+
+function validateSecondaryOptionShapes(result, ruleName, secondaryOptions, schema) {
+  if (secondaryOptions === undefined || secondaryOptions === null) {
+    return true;
+  }
+
+  if (!isPlainObject(secondaryOptions)) {
+    return true;
+  }
+
+  let valid = true;
+
+  for (const [optionName, descriptor] of Object.entries(schema)) {
+    const optionValue = secondaryOptions[optionName];
+    if (optionValue === undefined) {
+      continue;
+    }
+
+    if (descriptor.expectsArray && !Array.isArray(optionValue)) {
+      valid = false;
+      result.warn(
+        `Invalid value ${stringifyOptionValue(optionValue)} for option "${optionName}" of rule "${ruleName}"`,
+        { stylelintType: 'invalidOption' },
+      );
+      result.stylelint.stylelintError = true;
+      continue;
+    }
+
+    if (descriptor.expectsObject && !isPlainObject(optionValue)) {
+      valid = false;
+      result.warn(
+        `Invalid value ${stringifyOptionValue(optionValue)} for option "${optionName}" of rule "${ruleName}"`,
+        { stylelintType: 'invalidOption' },
+      );
+      result.stylelint.stylelintError = true;
+    }
+  }
+
+  return valid;
+}
+
+function stringifyOptionValue(value) {
+  if (typeof value === 'string') {
+    return `"${value}"`;
+  }
+
+  return `"${JSON.stringify(value)}"`;
+}
+
+function buildPossibleOptionMap(schema) {
+  return Object.fromEntries(
+    Object.entries(schema).map(([optionName, descriptor]) => [
+      optionName,
+      [descriptor.entryValidator || VALIDATE_ALWAYS],
+    ]),
+  );
+}
+
+function validateSecondaryOptions({
+  result,
+  ruleName,
+  secondaryOptions,
+  schema,
+  possibleOptionMap,
+}) {
+  const validOptions = stylelint.utils.validateOptions(result, ruleName, {
+    actual: secondaryOptions,
+    optional: true,
+    possible: possibleOptionMap,
+  });
+  const validShapes = validateSecondaryOptionShapes(
+    result,
+    ruleName,
+    secondaryOptions,
+    schema,
+  );
+
+  return validOptions && validShapes;
+}
+
+const SCALE_VALIDATION_SCHEMA = Object.freeze({
+  allowNegative: Object.freeze({
+    entryValidator: isBoolean,
+  }),
+  allowPercentages: Object.freeze({
+    entryValidator: isBoolean,
+  }),
+  baseFontSize: Object.freeze({
+    entryValidator: isFinitePositiveNumber,
+  }),
+  customScale: Object.freeze({
+    entryValidator: isScaleEntry,
+    expectsArray: true,
+  }),
+  enforceInsideMathFunctions: Object.freeze({
+    entryValidator: isBoolean,
+  }),
+  fixToScale: Object.freeze({
+    entryValidator: isBoolean,
+  }),
+  preset: Object.freeze({
+    entryValidator: isNonEmptyString,
+  }),
+  scale: Object.freeze({
+    entryValidator: isScaleEntry,
+    expectsArray: true,
+  }),
+  units: Object.freeze({
+    entryValidator: isSupportedUnit,
+    expectsArray: true,
+  }),
+});
+
+const USE_SCALE_VALIDATION_SCHEMA = Object.freeze({
+  ...SCALE_VALIDATION_SCHEMA,
+  ignoreValues: Object.freeze({
+    entryValidator: isNonEmptyString,
+    expectsArray: true,
+  }),
+  properties: Object.freeze({
+    entryValidator: isPropertyPatternEntry,
+    expectsArray: true,
+  }),
+  tokenFunctions: Object.freeze({
+    entryValidator: isNonEmptyString,
+    expectsArray: true,
+  }),
+  tokenPattern: Object.freeze({
+    entryValidator: isNonEmptyString,
+  }),
+});
+
+const NO_OFFSCALE_TRANSFORM_VALIDATION_SCHEMA = Object.freeze({
+  ...SCALE_VALIDATION_SCHEMA,
+});
+
+const PREFER_TOKEN_VALIDATION_SCHEMA = Object.freeze({
+  allowNumericScale: Object.freeze({
+    entryValidator: isBoolean,
+  }),
+  baseFontSize: Object.freeze({
+    entryValidator: isFinitePositiveNumber,
+  }),
+  customScale: Object.freeze({
+    entryValidator: isScaleEntry,
+    expectsArray: true,
+  }),
+  enforceInsideMathFunctions: Object.freeze({
+    entryValidator: isBoolean,
+  }),
+  ignoreValues: Object.freeze({
+    entryValidator: isNonEmptyString,
+    expectsArray: true,
+  }),
+  preset: Object.freeze({
+    entryValidator: isNonEmptyString,
+  }),
+  properties: Object.freeze({
+    entryValidator: isPropertyPatternEntry,
+    expectsArray: true,
+  }),
+  scale: Object.freeze({
+    entryValidator: isScaleEntry,
+    expectsArray: true,
+  }),
+  tokenFunctions: Object.freeze({
+    entryValidator: isNonEmptyString,
+    expectsArray: true,
+  }),
+  tokenMap: Object.freeze({
+    entryValidator: isTokenMap,
+    expectsObject: true,
+  }),
+  tokenPattern: Object.freeze({
+    entryValidator: isNonEmptyString,
+  }),
+});
+
+const USE_SCALE_POSSIBLE_OPTIONS = Object.freeze(
+  buildPossibleOptionMap(USE_SCALE_VALIDATION_SCHEMA),
+);
+const NO_OFFSCALE_TRANSFORM_POSSIBLE_OPTIONS = Object.freeze(
+  buildPossibleOptionMap(NO_OFFSCALE_TRANSFORM_VALIDATION_SCHEMA),
+);
+const PREFER_TOKEN_POSSIBLE_OPTIONS = Object.freeze(
+  buildPossibleOptionMap(PREFER_TOKEN_VALIDATION_SCHEMA),
+);
 
 function buildScaleOptions(rawOptions) {
   const options = rawOptions || {};
@@ -62,6 +329,7 @@ function buildTokenOptions(rawOptions) {
       options.baseFontSize > 0
         ? options.baseFontSize
         : 16,
+    enforceInsideMathFunctions: options.enforceInsideMathFunctions === true,
     ignoreValues: Array.isArray(options.ignoreValues)
       ? options.ignoreValues.map((value) => String(value).toLowerCase())
       : DEFAULT_IGNORE_KEYWORDS,
@@ -86,7 +354,40 @@ function buildTokenOptions(rawOptions) {
   };
 }
 
+function validateUseScaleSecondaryOptions(result, ruleName, secondaryOptions) {
+  return validateSecondaryOptions({
+    result,
+    ruleName,
+    secondaryOptions,
+    schema: USE_SCALE_VALIDATION_SCHEMA,
+    possibleOptionMap: USE_SCALE_POSSIBLE_OPTIONS,
+  });
+}
+
+function validateNoOffscaleTransformSecondaryOptions(result, ruleName, secondaryOptions) {
+  return validateSecondaryOptions({
+    result,
+    ruleName,
+    secondaryOptions,
+    schema: NO_OFFSCALE_TRANSFORM_VALIDATION_SCHEMA,
+    possibleOptionMap: NO_OFFSCALE_TRANSFORM_POSSIBLE_OPTIONS,
+  });
+}
+
+function validatePreferTokenSecondaryOptions(result, ruleName, secondaryOptions) {
+  return validateSecondaryOptions({
+    result,
+    ruleName,
+    secondaryOptions,
+    schema: PREFER_TOKEN_VALIDATION_SCHEMA,
+    possibleOptionMap: PREFER_TOKEN_POSSIBLE_OPTIONS,
+  });
+}
+
 module.exports = {
   buildScaleOptions,
   buildTokenOptions,
+  validateNoOffscaleTransformSecondaryOptions,
+  validatePreferTokenSecondaryOptions,
+  validateUseScaleSecondaryOptions,
 };

package/src/utils/value-utils.js

@@ -50,7 +50,16 @@ function isTokenFunction(node, tokenFunctions, tokenRegex) {
     return true;
   }
 
-  const firstArg = valueParser.stringify(node.nodes).split(',')[0].trim();
+  const firstArgNodes = [];
+  for (const child of node.nodes) {
+    if (child.type === 'div' && child.value === ',') {
+      break;
+    }
+
+    firstArgNodes.push(child);
+  }
+
+  const firstArg = valueParser.stringify(firstArgNodes).trim();
   return tokenRegex.test(firstArg);
 }