@primer/stylelint-config 13.0.0-rc.77d8c5f → 13.0.0-rc.7a254e8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primer/stylelint-config",
-  "version": "13.0.0-rc.77d8c5f",
+  "version": "13.0.0-rc.7a254e8",
   "description": "Sharable stylelint config used by GitHub's CSS",
   "author": "GitHub, Inc.",
   "license": "MIT",
@@ -45,7 +45,7 @@
   "dependencies": {
     "@github/browserslist-config": "^1.0.0",
     "@primer/css": "^21.0.8",
-    "@primer/primitives": "^8.2.0",
+    "@primer/primitives": "^9.0.1",
     "anymatch": "^3.1.1",
     "postcss-scss": "^4.0.2",
     "postcss-styled-syntax": "^0.6.4",
@@ -53,37 +53,32 @@
     "string.prototype.matchall": "^4.0.2",
     "stylelint": "^16.3.1",
     "stylelint-config-standard": "^36.0.0",
-    "stylelint-css-modules-no-global-scoped-selector": "^1.0.2",
     "stylelint-no-unsupported-browser-features": "^8.0.0",
     "stylelint-order": "^6.0.4",
     "stylelint-scss": "^6.2.0",
     "stylelint-value-no-unknown-custom-properties": "^6.0.1",
     "tap-map": "^1.0.0"
   },
-  "overrides": {
-    "stylelint-css-modules-no-global-scoped-selector": {
-      "stylelint": "$stylelint"
-    }
-  },
   "prettier": "@github/prettier-config",
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.0",
-    "@changesets/cli": "2.27.1",
+    "@changesets/cli": "2.27.7",
     "@github/prettier-config": "^0.0.6",
-    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@typescript-eslint/parser": "^7.7.0",
+    "@typescript-eslint/parser": "^8.0.1",
     "dedent": "^1.5.3",
-    "eslint": "^8.0.1",
-    "eslint-plugin-github": "^4.10.2",
+    "eslint": "^8.57.0",
+    "eslint-plugin-github": "^5.0.1",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-jest": "^28.2.0",
     "eslint-plugin-prettier": "^5.1.3",
     "jest": "^29.7.0",
     "jest-preset-stylelint": "^7.0.0",
     "prettier": "^3.2.5",
-    "rimraf": "^5.0.5",
-    "rollup": "^4.14.3"
+    "rimraf": "^6.0.1",
+    "rollup": "^4.21.1"
   },
   "jest": {
     "transform": {},

package/plugins/borders.js

@@ -1,64 +1,197 @@
-import {createVariableRule} from './lib/variable-rules.js'
-
-export default createVariableRule(
-  'primer/borders',
-  {
-    border: {
-      expects: 'a border variable',
-      props: 'border{,-top,-right,-bottom,-left}',
-      values: ['$border', 'none', '0'],
-      components: ['border-width', 'border-style', 'border-color'],
-      replacements: {
-        // because shorthand border properties ¯\_(ツ)_/¯
-        '$border-width $border-style $border-gray': '$border',
-        '$border-width $border-gray $border-style': '$border',
-        '$border-style $border-width $border-gray': '$border',
-        '$border-style $border-gray $border-width': '$border',
-        '$border-gray $border-width $border-style': '$border',
-        '$border-gray $border-style $border-width': '$border',
-        '$border-width $border-style $border-color': '$border',
-        '$border-width $border-color $border-style': '$border',
-        '$border-style $border-width $border-color': '$border',
-        '$border-style $border-color $border-width': '$border',
-        '$border-color $border-width $border-style': '$border',
-        '$border-color $border-style $border-width': '$border',
-      },
-    },
-    'border color': {
-      expects: 'a border color variable',
-      props: 'border{,-top,-right,-bottom,-left}-color',
-      values: [
-        '$border-*',
-        'transparent',
-        'currentColor',
-        // Match variables in any of the following formats: --color-border-*, --color-*-border-*, --color-*-border, --borderColor-, *borderColor*
-        /var\(--color-(.+-)*border(-.+)*\)/,
-        /var\(--color-[^)]+\)/,
-        /var\(--borderColor-[^)]+\)/,
-        /var\((.+-)*borderColor(-.+)*\)/,
-      ],
-      replacements: {
-        '$border-gray': '$border-color',
-      },
-    },
-    'border style': {
-      expects: 'a border style variable',
-      props: 'border{,-top,-right,-bottom,-left}-style',
-      values: ['$border-style', 'none'],
-    },
-    'border width': {
-      expects: 'a border width variable',
-      props: 'border{,-top,-right,-bottom,-left}-width',
-      values: ['$border-width*', '0'],
-    },
-    'border radius': {
-      expects: 'a border radius variable',
-      props: 'border{,-{top,bottom}-{left,right}}-radius',
-      values: ['$border-radius', '0', '50%', 'inherit'],
-      replacements: {
-        '100%': '50%',
-      },
-    },
+import stylelint from 'stylelint'
+import declarationValueIndex from 'stylelint/lib/utils/declarationValueIndex.cjs'
+import valueParser from 'postcss-value-parser'
+import {walkGroups, primitivesVariables} from './lib/utils.js'
+
+const {
+  createPlugin,
+  utils: {report, ruleMessages, validateOptions},
+} = stylelint
+
+export const ruleName = 'primer/borders'
+export const messages = ruleMessages(ruleName, {
+  rejected: (value, replacement, propName) => {
+    if (propName && propName.includes('radius') && value.includes('borderWidth')) {
+      return `Border radius variables can not be used for border widths`
+    }
+
+    if ((propName && propName.includes('width')) || (borderShorthand(propName) && value.includes('borderRadius'))) {
+      return `Border width variables can not be used for border radii`
+    }
+
+    if (!replacement) {
+      return `Please use a Primer border variable instead of '${value}'. Consult the primer docs for a suitable replacement. https://primer.style/foundations/primitives/size#border`
+    }
+
+    return `Please replace '${value}' with a Primer border variable '${replacement['name']}'. https://primer.style/foundations/primitives/size#border`
   },
-  'https://primer.style/css/utilities/borders',
-)
+})
+
+const variables = primitivesVariables('border')
+const sizes = []
+const radii = []
+
+// Props that we want to check
+const propList = ['border', 'border-width', 'border-radius']
+// Values that we want to ignore
+const valueList = ['${']
+
+const borderShorthand = prop =>
+  /^border(-(top|right|bottom|left|block-start|block-end|inline-start|inline-end))?$/.test(prop)
+
+for (const variable of variables) {
+  const name = variable['name']
+
+  if (name.includes('borderWidth')) {
+    const value = variable['values']
+      .pop()
+      .replace(/max|\(|\)/g, '')
+      .split(',')[0]
+    sizes.push({
+      name,
+      values: [value],
+    })
+  }
+
+  if (name.includes('borderRadius')) {
+    radii.push(variable)
+  }
+}
+
+/** @type {import('stylelint').Rule} */
+const ruleFunction = (primary, secondaryOptions, context) => {
+  return (root, result) => {
+    const validOptions = validateOptions(result, ruleName, {
+      actual: primary,
+      possible: [true],
+    })
+
+    if (!validOptions) return
+
+    root.walkDecls(declNode => {
+      const {prop, value} = declNode
+
+      if (!propList.some(borderProp => prop.startsWith(borderProp))) return
+      if (/^border(-(top|right|bottom|left|block-start|block-end|inline-start|inline-end))?-color$/.test(prop)) return
+      if (valueList.some(valueToIgnore => value.includes(valueToIgnore))) return
+
+      const problems = []
+
+      const parsedValue = walkGroups(valueParser(value), node => {
+        const checkForVariable = (vars, nodeValue) =>
+          vars.some(variable =>
+            new RegExp(`${variable['name'].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(nodeValue),
+          )
+
+        // Only check word types. https://github.com/TrySound/postcss-value-parser#word
+        if (node.type !== 'word') {
+          return
+        }
+
+        // Exact values to ignore.
+        if (
+          [
+            '*',
+            '+',
+            '-',
+            '/',
+            '0',
+            'none',
+            'inherit',
+            'initial',
+            'revert',
+            'revert-layer',
+            'unset',
+            'solid',
+            'dashed',
+            'dotted',
+            'transparent',
+          ].includes(node.value)
+        ) {
+          return
+        }
+
+        const valueUnit = valueParser.unit(node.value)
+
+        if (valueUnit && (valueUnit.unit === '' || !/^-?[0-9.]+$/.test(valueUnit.number))) {
+          return
+        }
+
+        // Skip if the value unit isn't a supported unit.
+        if (valueUnit && !['px', 'rem', 'em'].includes(valueUnit.unit)) {
+          return
+        }
+
+        // if we're looking at the border property that sets color in shorthand, don't bother checking the color
+        if (
+          // using border shorthand
+          borderShorthand(prop) &&
+          // includes a color as a third space-separated value
+          value.split(' ').length > 2 &&
+          // the color in the third space-separated value includes `node.value`
+          value
+            .split(' ')
+            .slice(2)
+            .some(color => color.includes(node.value))
+        ) {
+          return
+        }
+
+        // If the variable is found in the value, skip it.
+        if (prop.includes('width') || borderShorthand(prop)) {
+          if (checkForVariable(sizes, node.value)) {
+            return
+          }
+        }
+
+        if (prop.includes('radius')) {
+          if (checkForVariable(radii, node.value)) {
+            return
+          }
+        }
+
+        const replacement = (prop.includes('radius') ? radii : sizes).find(variable =>
+          variable.values.includes(node.value.replace('-', '')),
+        )
+        const fixable = replacement && valueUnit && !valueUnit.number.includes('-')
+
+        if (fixable && context.fix) {
+          node.value = node.value.replace(node.value, `var(${replacement['name']})`)
+        } else {
+          problems.push({
+            index: declarationValueIndex(declNode) + node.sourceIndex,
+            endIndex: declarationValueIndex(declNode) + node.sourceIndex + node.value.length,
+            message: messages.rejected(node.value, replacement, prop),
+          })
+        }
+
+        return
+      })
+
+      if (context.fix) {
+        declNode.value = parsedValue.toString()
+      }
+
+      if (problems.length) {
+        for (const err of problems) {
+          report({
+            index: err.index,
+            endIndex: err.endIndex,
+            message: err.message,
+            node: declNode,
+            result,
+            ruleName,
+          })
+        }
+      }
+    })
+  }
+}
+
+ruleFunction.ruleName = ruleName
+ruleFunction.messages = messages
+ruleFunction.meta = {
+  fixable: true,
+}
+
+export default createPlugin(ruleName, ruleFunction)

package/plugins/lib/utils.js

@@ -0,0 +1,49 @@
+import {createRequire} from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+export function primitivesVariables(type) {
+  const variables = []
+
+  const files = []
+  switch (type) {
+    case 'spacing':
+      files.push('base/size/size.json')
+      break
+    case 'border':
+      files.push('functional/size/border.json')
+      break
+    case 'typography':
+      files.push('base/typography/typography.json')
+      files.push('functional/typography/typography.json')
+      break
+  }
+
+  for (const file of files) {
+    // eslint-disable-next-line import/no-dynamic-require
+    const data = require(`@primer/primitives/dist/styleLint/${file}`)
+
+    for (const key of Object.keys(data)) {
+      const size = data[key]
+      const values = typeof size['value'] === 'string' ? [size['value']] : size['value']
+
+      variables.push({
+        name: `--${size['name']}`,
+        values,
+      })
+    }
+  }
+
+  return variables
+}
+
+export function walkGroups(root, validate) {
+  for (const node of root.nodes) {
+    if (node.type === 'function') {
+      walkGroups(node, validate)
+    } else {
+      validate(node)
+    }
+  }
+  return root
+}

package/plugins/spacing.js

@@ -1,24 +1,13 @@
 import stylelint from 'stylelint'
 import declarationValueIndex from 'stylelint/lib/utils/declarationValueIndex.cjs'
 import valueParser from 'postcss-value-parser'
-import {primitivesVariables} from './lib/primitives.js'
+import {primitivesVariables, walkGroups} from './lib/utils.js'
 
 const {
   createPlugin,
   utils: {report, ruleMessages, validateOptions},
 } = stylelint
 
-const walkGroups = (root, validate) => {
-  for (const node of root.nodes) {
-    if (node.type === 'function') {
-      walkGroups(node, validate)
-    } else {
-      validate(node)
-    }
-  }
-  return root
-}
-
 export const ruleName = 'primer/spacing'
 export const messages = ruleMessages(ruleName, {
   rejected: (value, replacement) => {
@@ -30,20 +19,26 @@ export const messages = ruleMessages(ruleName, {
   },
 })
 
-const meta = {
-  fixable: true,
+// Props that we want to check
+const propList = ['padding', 'margin', 'top', 'right', 'bottom', 'left']
+// Values that we want to ignore
+const valueList = ['${']
+
+const sizes = primitivesVariables('spacing')
+
+// Add +-1px to each value
+for (const size of sizes) {
+  const values = size['values']
+  const px = parseInt(values.find(value => value.includes('px')))
+  if (![2, 6].includes(px)) {
+    values.push(`${px + 1}px`)
+    values.push(`${px - 1}px`)
+  }
 }
 
 /** @type {import('stylelint').Rule} */
 const ruleFunction = (primary, secondaryOptions, context) => {
-  return async (root, result) => {
-    // Props that we want to check
-    const propList = ['padding', 'margin', 'top', 'right', 'bottom', 'left']
-    // Values that we want to ignore
-    const valueList = ['${']
-
-    const sizes = await primitivesVariables('size')
-
+  return (root, result) => {
     const validOptions = validateOptions(result, ruleName, {
       actual: primary,
       possible: [true],
@@ -128,6 +123,8 @@ const ruleFunction = (primary, secondaryOptions, context) => {
 
 ruleFunction.ruleName = ruleName
 ruleFunction.messages = messages
-ruleFunction.meta = meta
+ruleFunction.meta = {
+  fixable: true,
+}
 
 export default createPlugin(ruleName, ruleFunction)

package/plugins/typography.js

@@ -1,24 +1,186 @@
-import {createVariableRule} from './lib/variable-rules.js'
-
-export default createVariableRule(
-  'primer/typography',
-  {
-    'font-size': {
-      expects: 'a font-size variable',
-      values: ['$body-font-size', '$h{000,00,0,1,2,3,4,5,6}-size', '$font-size-*', '1', '1em', 'inherit'],
-    },
-    'font-weight': {
-      props: 'font-weight',
-      values: ['$font-weight-*', 'inherit'],
-      replacements: {
-        bold: '$font-weight-bold',
-        normal: '$font-weight-normal',
-      },
-    },
-    'line-height': {
-      props: 'line-height',
-      values: ['$body-line-height', '$lh-*', '0', '1', '1em', 'inherit'],
-    },
+import stylelint from 'stylelint'
+import declarationValueIndex from 'stylelint/lib/utils/declarationValueIndex.cjs'
+import {primitivesVariables} from './lib/utils.js'
+
+const {
+  createPlugin,
+  utils: {report, ruleMessages, validateOptions},
+} = stylelint
+
+export const ruleName = 'primer/typography'
+export const messages = ruleMessages(ruleName, {
+  rejected: (value, replacement) => {
+    // no possible replacement
+    if (!replacement) {
+      return `Please use a Primer typography variable instead of '${value}'. Consult the primer docs for a suitable replacement. https://primer.style/foundations/primitives/typography`
+    }
+
+    // multiple possible replacements
+    if (replacement.length) {
+      return `Please use one of the following Primer typography variables instead of '${value}': ${replacement.map(replacementObj => `'${replacementObj.name}'`).join(', ')}. https://primer.style/foundations/primitives/typography`
+    }
+
+    // one possible replacement
+    return `Please replace '${value}' with Primer typography variable '${replacement['name']}'. https://primer.style/foundations/primitives/typography`
   },
-  'https://primer.style/css/utilities/typography',
-)
+})
+
+const fontWeightKeywordMap = {
+  normal: 400,
+  bold: 600,
+  bolder: 600,
+  lighter: 300,
+}
+const getClosestFontWeight = (goalWeightNumber, fontWeightsTokens) => {
+  return fontWeightsTokens.reduce((prev, curr) =>
+    Math.abs(curr.values - goalWeightNumber) < Math.abs(prev.values - goalWeightNumber) ? curr : prev,
+  ).values
+}
+
+const variables = primitivesVariables('typography')
+const fontSizes = []
+const fontWeights = []
+const lineHeights = []
+const fontStacks = []
+const fontShorthands = []
+
+// Props that we want to check for typography variables
+const propList = ['font-size', 'font-weight', 'line-height', 'font-family', 'font']
+
+for (const variable of variables) {
+  const name = variable['name']
+
+  if (name.includes('size')) {
+    fontSizes.push(variable)
+  }
+
+  if (name.includes('weight')) {
+    fontWeights.push(variable)
+  }
+
+  if (name.includes('lineHeight')) {
+    lineHeights.push(variable)
+  }
+
+  if (name.includes('fontStack')) {
+    fontStacks.push(variable)
+  }
+
+  if (name.includes('shorthand')) {
+    fontShorthands.push(variable)
+  }
+}
+
+/** @type {import('stylelint').Rule} */
+const ruleFunction = (primary, secondaryOptions, context) => {
+  return (root, result) => {
+    const validOptions = validateOptions(result, ruleName, {
+      actual: primary,
+      possible: [true],
+    })
+    let validValues = []
+
+    if (!validOptions) return
+
+    root.walkDecls(declNode => {
+      const {prop, value} = declNode
+
+      if (!propList.some(typographyProp => prop.startsWith(typographyProp))) return
+
+      const problems = []
+
+      const checkForVariable = (vars, nodeValue) =>
+        vars.some(variable =>
+          new RegExp(`${variable['name'].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(nodeValue),
+        )
+
+      // Exact values to ignore.
+      if (value === 'inherit') {
+        return
+      }
+
+      switch (prop) {
+        case 'font-size':
+          validValues = fontSizes
+          break
+        case 'font-weight':
+          validValues = fontWeights
+          break
+        case 'line-height':
+          validValues = lineHeights
+          break
+        case 'font-family':
+          validValues = fontStacks
+          break
+        case 'font':
+          validValues = fontShorthands
+          break
+        default:
+          validValues = []
+      }
+
+      if (checkForVariable(validValues, value)) {
+        return
+      }
+
+      const getReplacements = () => {
+        const replacementTokens = validValues.filter(variable => {
+          if (!(variable.values instanceof Array)) {
+            let nodeValue = value
+
+            if (prop === 'font-weight') {
+              nodeValue = getClosestFontWeight(fontWeightKeywordMap[value] || value, fontWeights)
+            }
+
+            return variable.values.toString() === nodeValue.toString()
+          }
+
+          return variable.values.includes(value.replace('-', ''))
+        })
+
+        if (!replacementTokens.length) {
+          return
+        }
+
+        if (replacementTokens.length > 1) {
+          return replacementTokens
+        }
+
+        return replacementTokens[0]
+      }
+      const replacement = getReplacements()
+      const fixable = replacement && !replacement.length
+
+      if (fixable && context.fix) {
+        declNode.value = value.replace(value, `var(${replacement['name']})`)
+      } else {
+        problems.push({
+          index: declarationValueIndex(declNode),
+          endIndex: declarationValueIndex(declNode) + value.length,
+          message: messages.rejected(value, replacement, prop),
+        })
+      }
+
+      if (problems.length) {
+        for (const err of problems) {
+          report({
+            index: err.index,
+            endIndex: err.endIndex,
+            message: err.message,
+            node: declNode,
+            result,
+            ruleName,
+          })
+        }
+      }
+    })
+  }
+}
+
+ruleFunction.ruleName = ruleName
+ruleFunction.messages = messages
+ruleFunction.meta = {
+  fixable: true,
+}
+
+export default createPlugin(ruleName, ruleFunction)