@salesforce-ux/eslint-plugin-slds 1.0.7-internal → 1.0.8-internal

package/README.md

@@ -96,6 +96,68 @@ By default, the latest version of the plugin supports legacy and flat config sys
 - `reduce-annotations`: Identifies annotations that must be removed from the code.
 - `lwc-token-to-slds-hook`: Identifies the deprecated --lwc tokens that must be replaced with the latest --slds tokens. For more information, see lightningdesignsystem.com.
 
+## Closest Color Suggestion Logic
+
+This plugin suggests SLDS styling hooks that are perceptually closest to a given hardcoded color. The logic lives in `src/utils/color-lib-utils.ts` and is used by `no-hardcoded-values-slds2`.
+
+- **API surface**
+  - `findClosestColorHook(color, supportedColors, cssProperty): string[]`
+    Returns up to 5 hook names, ordered by category priority and perceptual distance.
+  - `isHardCodedColor(value): boolean`
+    Detects if a string likely represents a hardcoded color (excludes CSS `var(...)`).
+
+- **Perceptual metric**
+  - Uses `chroma.deltaE` (CIEDE2000) to compare the input color against known SLDS color values.
+  - A threshold (`DELTAE_THRESHOLD = 25`) controls how strict the matching is.
+  - Exact hex matches short-circuit to distance `0` to avoid float rounding differences.
+
+- **Category ordering**
+  - Hooks are ranked by category, then by distance (ascending):
+    1. Semantic hooks (e.g., surface, accent, error, success, etc.)
+    2. System hooks
+    3. Palette hooks
+  - Only the top 5 suggestions are returned.
+
+- **Property awareness**
+  - Suggestions consider the CSS property from rule context.
+  - Hooks declared for the same property (or `*`) are prioritized if within the distance threshold.
+
+- **CSS variables**
+  - Values using `var(...)` are not flagged as hardcoded colors and are excluded from matching.
+
+- **Semantic hook ordering by CSS property**
+  The sorter always applies the same category priority (semantic → system → palette). Within the semantic category, ordering is purely by perceptual distance for the current CSS property; there is no hardcoded sub-priority among semantic families (surface, accent, error, etc.). Property awareness comes from the metadata (`properties` on each hook).
+
+  - `color`
+    - Prefers semantic hooks that declare `properties: ['color']` (e.g., text/foreground-oriented tokens).
+    - If multiple semantic hooks are eligible, they are ordered by Delta E (closest first).
+    - If none are within threshold, the sorter may fall back to system, then palette.
+
+  - `background-color`
+    - Prefers semantic surface/role tokens that declare `['background-color']`.
+    - Among eligible semantic hooks, order is by Delta E.
+
+  - `border-color` (and `outline-color`)
+    - Prefers semantic or system hooks that declare `['border-color']` (or `['outline-color']`).
+    - If semantic hooks exist for borders, they are ranked before system; otherwise system hooks lead.
+    - Order within the chosen category is by Delta E.
+
+  - `box-shadow`
+    - For color components inside shadows, prefers hooks declaring `['box-shadow']` or universal `['*']`.
+    - Ordering within semantic remains by Delta E.
+
+  - Other properties
+    - If hook metadata specifies the current property, those hooks are preferred.
+    - Hooks with `['*']` (universal) are considered next.
+    - If still none within threshold, different-property hooks may be considered (still subject to category priority and Delta E).
+
+- **Example**
+  ```js
+  // Given a hex color and a CSS property like 'color'
+  const suggestions = findClosestColorHook('#ff0000', supportedColors, 'color');
+  // => ['--slds-...semantic-...', '--slds-...system-...', ...]
+  ```
+
 ## License
 
 ISC

package/build/index.js

@@ -780,11 +780,7 @@ function isCssColorFunction(value) {
 }
 
 // src/utils/color-lib-utils.ts
-var LAB_THRESHOLD = 25;
-var isHexCode = (color) => {
-  const hexPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
-  return hexPattern.test(color);
-};
+var DELTAE_THRESHOLD = 10;
 var convertToHex = (color) => {
   try {
     return (0, import_chroma_js.default)(color).hex();
@@ -792,52 +788,40 @@ var convertToHex = (color) => {
     return null;
   }
 };
+var isHookPropertyMatch = (hook, cssProperty) => {
+  return hook.properties.includes(cssProperty) || hook.properties.includes("*");
+};
+function getOrderByCssProp(cssProperty) {
+  if (cssProperty === "color" || cssProperty === "fill") {
+    return ["surface", "theme", "feedback", "reference"];
+  } else if (cssProperty.match(/background/)) {
+    return ["surface", "surface-inverse", "theme", "feedback", "reference"];
+  } else if (cssProperty.match(/border/) || cssProperty.match(/outline/) || cssProperty.match(/stroke/)) {
+    return ["borders", "borders-inverse", "feedback", "theme", "reference"];
+  }
+  return ["surface", "surface-inverse", "borders", "borders-inverse", "theme", "feedback", "reference"];
+}
 var findClosestColorHook = (color, supportedColors, cssProperty) => {
-  const returnStylingHooks = [];
-  const closestHooksWithSameProperty = [];
-  const closestHooksWithoutSameProperty = [];
-  const closestHooksWithAllProperty = [];
-  const labColor = (0, import_chroma_js.default)(color).lab();
+  const closestHooks = [];
   Object.entries(supportedColors).forEach(([sldsValue, data]) => {
-    if (sldsValue && isHexCode(sldsValue)) {
+    if (sldsValue && isValidColor(sldsValue)) {
       const hooks = data;
       hooks.forEach((hook) => {
-        const labSupportedColor = (0, import_chroma_js.default)(sldsValue).lab();
-        const distance = JSON.stringify(labColor) === JSON.stringify(labSupportedColor) ? 0 : import_chroma_js.default.distance(import_chroma_js.default.lab(...labColor), import_chroma_js.default.lab(...labSupportedColor), "lab");
-        if (hook.properties.includes(cssProperty)) {
-          if (distance <= LAB_THRESHOLD) {
-            closestHooksWithSameProperty.push({ name: hook.name, distance });
-          }
-        } else if (hook.properties.includes("*")) {
-          if (distance <= LAB_THRESHOLD) {
-            closestHooksWithAllProperty.push({ name: hook.name, distance });
-          }
-        } else {
-          if (distance <= LAB_THRESHOLD) {
-            closestHooksWithoutSameProperty.push({ name: hook.name, distance });
-          }
+        const distance = sldsValue.toLowerCase() === color.toLowerCase() ? 0 : import_chroma_js.default.deltaE(sldsValue, color);
+        if (isHookPropertyMatch(hook, cssProperty) && distance <= DELTAE_THRESHOLD) {
+          closestHooks.push({ distance, group: hook.group, name: hook.name });
         }
       });
     }
   });
-  const closesthookGroups = [
-    { hooks: closestHooksWithSameProperty, distance: 0 },
-    { hooks: closestHooksWithAllProperty, distance: 0 },
-    { hooks: closestHooksWithSameProperty, distance: Infinity },
-    // For hooks with distance > 0
-    { hooks: closestHooksWithAllProperty, distance: Infinity },
-    { hooks: closestHooksWithoutSameProperty, distance: Infinity }
-  ];
-  for (const group of closesthookGroups) {
-    const filteredHooks = group.hooks.filter(
-      (h) => group.distance === 0 ? h.distance === 0 : h.distance > 0
-    );
-    if (returnStylingHooks.length < 1 && filteredHooks.length > 0) {
-      filteredHooks.sort((a, b) => a.distance - b.distance);
-      returnStylingHooks.push(...filteredHooks.slice(0, 5).map((h) => h.name));
+  const hooksByGroupMap = closestHooks.sort((a, b) => a.distance - b.distance).reduce((acc, hook) => {
+    if (!acc[hook.group]) {
+      acc[hook.group] = [];
     }
-  }
-  return Array.from(new Set(returnStylingHooks));
+    acc[hook.group].push(hook.name);
+    return acc;
+  }, {});
+  return getOrderByCssProp(cssProperty).map((group) => hooksByGroupMap[group] || []).flat().slice(0, 5);
 };
 var isValidColor = (val) => import_chroma_js.default.valid(val);
 var extractColorValue = (node) => {
@@ -879,13 +863,33 @@ function isKnownFontWeight(value) {
   return FONT_WEIGHTS.includes(stringValue.toLowerCase());
 }
 function handleShorthandAutoFix(declarationNode, context, valueText, replacements) {
-  const sortedReplacements = replacements.sort((a, b) => a.start - b.start);
-  const hasAnyHooks = sortedReplacements.some((r) => r.hasHook);
-  const canAutoFix = hasAnyHooks;
-  sortedReplacements.forEach(({ start, end, replacement, displayValue, hasHook }) => {
+  if (!replacements || replacements.length === 0) {
+    return;
+  }
+  const sortedReplacements = replacements.sort((a, b) => b.start - a.start);
+  const reportNumericValue = context.options?.reportNumericValue || "always";
+  const fixCallback = (start, originalValue, replacement) => {
+    let newValue = valueText;
+    newValue = newValue.substring(0, start) + replacement + newValue.substring(start + originalValue.length);
+    if (newValue !== valueText) {
+      return (fixer) => {
+        return fixer.replaceText(declarationNode.value, newValue);
+      };
+    }
+  };
+  sortedReplacements.forEach(({ start, end, replacement, displayValue, hasHook, isNumeric }) => {
     const originalValue = valueText.substring(start, end);
-    const valueStartColumn = declarationNode.value.loc.start.column;
-    const valueColumn = valueStartColumn + start;
+    if (isNumeric) {
+      if (reportNumericValue === "never") {
+        return;
+      }
+      if (reportNumericValue === "hasReplacement" && !hasHook) {
+        return;
+      }
+    }
+    const valueColumnStart = declarationNode.value.loc.start.column + start;
+    const valueColumnEnd = valueColumnStart + originalValue.length;
+    const canAutoFix = originalValue !== replacement;
     const { loc: { start: locStart, end: locEnd } } = declarationNode.value;
     const reportNode = {
       ...declarationNode.value,
@@ -893,23 +897,16 @@ function handleShorthandAutoFix(declarationNode, context, valueText, replacement
         ...declarationNode.value.loc,
         start: {
           ...locStart,
-          column: valueColumn
+          column: valueColumnStart
         },
         end: {
           ...locEnd,
-          column: valueColumn + originalValue.length
+          column: valueColumnEnd
         }
       }
     };
     if (hasHook) {
-      const fix = canAutoFix ? (fixer) => {
-        let newValue = valueText;
-        for (let i = sortedReplacements.length - 1; i >= 0; i--) {
-          const { start: rStart, end: rEnd, replacement: rReplacement } = sortedReplacements[i];
-          newValue = newValue.substring(0, rStart) + rReplacement + newValue.substring(rEnd);
-        }
-        return fixer.replaceText(declarationNode.value, newValue);
-      } : void 0;
+      const fix = canAutoFix ? fixCallback(start, originalValue, replacement) : void 0;
       context.context.report({
         node: reportNode,
         messageId: "hardcodedValue",
@@ -1790,9 +1787,9 @@ function toSelector(properties) {
   });
   return selectorParts.join(", ");
 }
-function resolvePropertyToMatch(cssProperty) {
+function resolveDensityPropertyToMatch(cssProperty) {
   const propertyToMatch = cssProperty.toLowerCase();
-  if (propertyToMatch === "outline" || propertyToMatch === "outline-width" || isBorderWidthProperty(propertyToMatch)) {
+  if (isOutlineWidthProperty(propertyToMatch) || isBorderWidthProperty(propertyToMatch)) {
     return "border-width";
   } else if (isMarginProperty(propertyToMatch)) {
     return "margin";
@@ -1804,13 +1801,58 @@ function resolvePropertyToMatch(cssProperty) {
     return "width";
   } else if (isInsetProperty(propertyToMatch)) {
     return "top";
-  } else if (cssProperty === "background" || cssProperty === "background-color") {
+  }
+  return propertyToMatch;
+}
+function resolveColorPropertyToMatch(cssProperty) {
+  const propertyToMatch = cssProperty.toLowerCase();
+  if (propertyToMatch === "outline" || propertyToMatch === "outline-color") {
+    return "border-color";
+  } else if (propertyToMatch === "background" || propertyToMatch === "background-color") {
     return "background-color";
-  } else if (cssProperty === "outline" || cssProperty === "outline-color" || isBorderColorProperty(cssProperty)) {
+  } else if (isBorderColorProperty(propertyToMatch)) {
     return "border-color";
   }
   return propertyToMatch;
 }
+function isOutlineWidthProperty(propertyToMatch) {
+  return propertyToMatch === "outline" || propertyToMatch === "outline-width";
+}
+
+// src/utils/custom-mapping-utils.ts
+function matchesPropertyPattern(cssProperty, pattern) {
+  const normalizedProperty = cssProperty.toLowerCase();
+  const normalizedPattern = pattern.toLowerCase();
+  if (normalizedProperty === normalizedPattern) {
+    return true;
+  }
+  if (normalizedPattern.endsWith("*")) {
+    const prefix = normalizedPattern.slice(0, -1);
+    return normalizedProperty.startsWith(prefix);
+  }
+  return false;
+}
+function getCustomMapping(cssProperty, value, customMapping) {
+  if (!customMapping) {
+    return null;
+  }
+  const normalizedValue = value.toLowerCase().trim();
+  for (const [hookName, config] of Object.entries(customMapping)) {
+    const propertyMatches = config.properties.some(
+      (pattern) => matchesPropertyPattern(cssProperty, pattern)
+    );
+    if (!propertyMatches) {
+      continue;
+    }
+    const valueMatches = config.values.some(
+      (configValue) => configValue.toLowerCase().trim() === normalizedValue
+    );
+    if (valueMatches) {
+      return hookName;
+    }
+  }
+  return null;
+}
 
 // src/rules/v9/no-hardcoded-values/handlers/colorHandler.ts
 var handleColorDeclaration = (node, context) => {
@@ -1835,24 +1877,32 @@ function createColorReplacement(colorValue, cssProperty, context, positionInfo,
   if (!hexValue) {
     return null;
   }
-  const propToMatch = resolvePropertyToMatch(cssProperty);
-  const closestHooks = findClosestColorHook(hexValue, context.valueToStylinghook, propToMatch);
   const start = positionInfo.start.offset;
   const end = positionInfo.end.offset;
   const originalValue = originalValueText ? originalValueText.substring(start, end) : colorValue;
-  if (closestHooks.length === 1) {
-    return {
-      start,
-      end,
-      replacement: `var(${closestHooks[0]}, ${colorValue})`,
-      displayValue: closestHooks[0],
-      hasHook: true
-    };
-  } else if (closestHooks.length > 1) {
+  const customHook = getCustomMapping(cssProperty, colorValue, context.options?.customMapping);
+  let closestHooks = [];
+  if (customHook) {
+    closestHooks = [customHook];
+  } else {
+    const propToMatch = resolveColorPropertyToMatch(cssProperty);
+    closestHooks = findClosestColorHook(hexValue, context.valueToStylinghook, propToMatch);
+  }
+  let replacement = originalValue;
+  let paletteHook = null;
+  if (context.options?.preferPaletteHook && closestHooks.length > 1) {
+    paletteHook = closestHooks.filter((hook) => hook.includes("-palette-"))[0];
+  }
+  if (paletteHook) {
+    replacement = `var(${paletteHook}, ${colorValue})`;
+  } else if (closestHooks.length === 1) {
+    replacement = `var(${closestHooks[0]}, ${colorValue})`;
+  }
+  if (closestHooks.length > 0) {
     return {
       start,
       end,
-      replacement: originalValue,
+      replacement,
       // Use original value to preserve spacing
       displayValue: formatSuggestionHooks(closestHooks),
       hasHook: true
@@ -1861,7 +1911,7 @@ function createColorReplacement(colorValue, cssProperty, context, positionInfo,
     return {
       start,
       end,
-      replacement: originalValue,
+      replacement,
       // Use original value to preserve spacing
       displayValue: originalValue,
       hasHook: false
@@ -1909,8 +1959,14 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
     return null;
   }
   const rawValue = parsedDimension.unit ? `${parsedDimension.number}${parsedDimension.unit}` : parsedDimension.number.toString();
-  const propToMatch = resolvePropertyToMatch(cssProperty);
-  const closestHooks = getStylingHooksForDensityValue(parsedDimension, context.valueToStylinghook, propToMatch);
+  const customHook = getCustomMapping(cssProperty, rawValue, context.options?.customMapping);
+  let closestHooks = [];
+  if (customHook) {
+    closestHooks = [customHook];
+  } else {
+    const propToMatch = resolveDensityPropertyToMatch(cssProperty);
+    closestHooks = getStylingHooksForDensityValue(parsedDimension, context.valueToStylinghook, propToMatch);
+  }
   const start = positionInfo.start.offset;
   const end = positionInfo.end.offset;
   if (closestHooks.length === 1) {
@@ -1919,7 +1975,8 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: `var(${closestHooks[0]}, ${rawValue})`,
       displayValue: closestHooks[0],
-      hasHook: true
+      hasHook: true,
+      isNumeric: true
     };
   } else if (closestHooks.length > 1) {
     return {
@@ -1927,7 +1984,8 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: rawValue,
       displayValue: formatSuggestionHooks(closestHooks),
-      hasHook: true
+      hasHook: true,
+      isNumeric: true
     };
   } else {
     return {
@@ -1935,7 +1993,8 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: rawValue,
       displayValue: rawValue,
-      hasHook: false
+      hasHook: false,
+      isNumeric: true
     };
   }
 }
@@ -1976,8 +2035,14 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
     return null;
   }
   const rawValue = fontValue.unit ? `${fontValue.number}${fontValue.unit}` : fontValue.number.toString();
-  const propToMatch = !fontValue.unit && isKnownFontWeight(fontValue.number) ? resolvePropertyToMatch("font-weight") : resolvePropertyToMatch("font-size");
-  const closestHooks = getStylingHooksForDensityValue(fontValue, context.valueToStylinghook, propToMatch);
+  const propToMatch = !fontValue.unit && isKnownFontWeight(fontValue.number) ? "font-weight" : "font-size";
+  const customHook = getCustomMapping(propToMatch, rawValue, context.options?.customMapping);
+  let closestHooks = [];
+  if (customHook) {
+    closestHooks = [customHook];
+  } else {
+    closestHooks = getStylingHooksForDensityValue(fontValue, context.valueToStylinghook, propToMatch);
+  }
   const start = positionInfo.start.offset;
   const end = positionInfo.end.offset;
   if (closestHooks.length === 1) {
@@ -1986,7 +2051,8 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: `var(${closestHooks[0]}, ${rawValue})`,
       displayValue: closestHooks[0],
-      hasHook: true
+      hasHook: true,
+      isNumeric: true
     };
   } else if (closestHooks.length > 1) {
     return {
@@ -1994,7 +2060,8 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: rawValue,
       displayValue: formatSuggestionHooks(closestHooks),
-      hasHook: true
+      hasHook: true,
+      isNumeric: true
     };
   } else {
     return {
@@ -2002,7 +2069,8 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: rawValue,
       displayValue: rawValue,
-      hasHook: false
+      hasHook: false,
+      isNumeric: true
     };
   }
 }
@@ -2134,9 +2202,30 @@ function shadowValueToHookEntries(supportedStylinghooks) {
     return [key, value.map((hook) => hook.name)];
   });
 }
+function reportBoxShadowViolation(node, context, valueText, hooks) {
+  const positionInfo = {
+    start: { offset: 0, line: 1, column: 1 },
+    end: { offset: valueText.length, line: 1, column: valueText.length + 1 }
+  };
+  const replacement = createBoxShadowReplacement(
+    valueText,
+    hooks,
+    context,
+    positionInfo
+  );
+  if (replacement) {
+    const replacements = [replacement];
+    handleShorthandAutoFix(node, context, valueText, replacements);
+  }
+}
 var handleBoxShadowDeclaration = (node, context) => {
   const cssProperty = node.property.toLowerCase();
   const valueText = context.sourceCode.getText(node.value);
+  const customHook = getCustomMapping(cssProperty, valueText, context.options?.customMapping);
+  if (customHook) {
+    reportBoxShadowViolation(node, context, valueText, [customHook]);
+    return;
+  }
   const shadowHooks = shadowValueToHookEntries(context.valueToStylinghook);
   const parsedCssValue = toBoxShadowValue(valueText);
   if (!parsedCssValue) {
@@ -2146,20 +2235,7 @@ var handleBoxShadowDeclaration = (node, context) => {
     const parsedValueHook = toBoxShadowValue(shadow);
     if (parsedValueHook && isBoxShadowMatch(parsedCssValue, parsedValueHook)) {
       if (closestHooks.length > 0) {
-        const positionInfo = {
-          start: { offset: 0, line: 1, column: 1 },
-          end: { offset: valueText.length, line: 1, column: valueText.length + 1 }
-        };
-        const replacement = createBoxShadowReplacement(
-          valueText,
-          closestHooks,
-          context,
-          positionInfo
-        );
-        if (replacement) {
-          const replacements = [replacement];
-          handleShorthandAutoFix(node, context, valueText, replacements);
-        }
+        reportBoxShadowViolation(node, context, valueText, closestHooks);
       }
       return;
     }
@@ -2209,6 +2285,42 @@ function isRuleEnabled(context, ruleName3) {
   }
 }
 
+// src/rules/v9/no-hardcoded-values/ruleOptionsSchema.ts
+var ruleOptionsSchema = [
+  {
+    type: "object",
+    properties: {
+      reportNumericValue: {
+        type: "string",
+        enum: ["never", "always", "hasReplacement"],
+        default: "always"
+      },
+      customMapping: {
+        type: "object",
+        additionalProperties: {
+          type: "object",
+          properties: {
+            properties: {
+              type: "array",
+              items: { type: "string" }
+            },
+            values: {
+              type: "array",
+              items: { type: "string" }
+            }
+          },
+          required: ["properties", "values"]
+        }
+      },
+      preferPaletteHook: {
+        type: "boolean",
+        default: false
+      }
+    },
+    additionalProperties: false
+  }
+];
+
 // src/rules/v9/no-hardcoded-values/noHardcodedValueRule.ts
 function defineNoHardcodedValueRule(config) {
   const { ruleConfig: ruleConfig14, ruleName: ruleName3 } = config;
@@ -2222,16 +2334,24 @@ function defineNoHardcodedValueRule(config) {
         url: url15
       },
       fixable: "code",
-      messages: messages15
+      messages: messages15,
+      schema: ruleOptionsSchema
     },
     create(context) {
       if (ruleName3 === "no-hardcoded-values-slds1" && isRuleEnabled(context, "@salesforce-ux/slds/no-hardcoded-values-slds2")) {
         return {};
       }
+      const options = context.options[0] || {};
+      const ruleOptions = {
+        reportNumericValue: options.reportNumericValue || "always",
+        customMapping: options.customMapping || {},
+        preferPaletteHook: options.preferPaletteHook || false
+      };
       const handlerContext = {
         valueToStylinghook: config.valueToStylinghook,
         context,
-        sourceCode: context.sourceCode
+        sourceCode: context.sourceCode,
+        options: ruleOptions
       };
       const colorOnlySelector = toSelector(colorProperties);
       const densityOnlySelector = toSelector(densificationProperties);
@@ -2325,8 +2445,24 @@ var eslint_rules_internal_default = {
     "@salesforce-ux/slds/no-slds-namespace-for-custom-hooks": "warn",
     "@salesforce-ux/slds/enforce-component-hook-naming-convention": "error",
     "@salesforce-ux/slds/no-slds-private-var": "warn",
-    "@salesforce-ux/slds/no-hardcoded-values-slds1": "error",
-    "@salesforce-ux/slds/no-hardcoded-values-slds2": "warn",
+    "@salesforce-ux/slds/no-hardcoded-values-slds2": ["warn", {
+      reportNumericValue: "hasReplacement",
+      preferPaletteHook: true,
+      customMapping: {
+        "--slds-g-font-line-height-4": {
+          properties: ["line-height"],
+          values: ["1.5"]
+        },
+        "--slds-g-sizing-5": {
+          properties: ["width", "height", "max-width", "max-height", "border*"],
+          values: ["1rem", "16px"]
+        },
+        "--slds-g-sizing-content-1": {
+          properties: ["width", "height", "max-width", "max-height", "border*"],
+          values: ["20ch"]
+        }
+      }
+    }],
     "@salesforce-ux/slds/reduce-annotations": "warn"
   },
   html: {
@@ -2359,7 +2495,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "@salesforce-ux/eslint-plugin-slds",
-    version: "1.0.7-internal"
+    version: "1.0.8-internal"
   },
   rules,
   configs: {}