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

package/build/rules/v9/no-hardcoded-values/noHardcodedValueRule.js

@@ -67,11 +67,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();
@@ -79,52 +75,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) => {
@@ -223,9 +207,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";
@@ -237,13 +221,23 @@ 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/hardcoded-shared-utils.ts
 var import_css_tree2 = require("@eslint/css-tree");
@@ -303,13 +297,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,
@@ -317,23 +331,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",
@@ -487,6 +494,41 @@ function formatSuggestionHooks(hooks) {
   return "\n" + hooks.map((hook, index) => `${index + 1}. ${hook}`).join("\n");
 }
 
+// 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) => {
   const cssProperty = node.property.toLowerCase();
@@ -510,24 +552,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
@@ -536,7 +586,7 @@ function createColorReplacement(colorValue, cssProperty, context, positionInfo,
     return {
       start,
       end,
-      replacement: originalValue,
+      replacement,
       // Use original value to preserve spacing
       displayValue: originalValue,
       hasHook: false
@@ -584,8 +634,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) {
@@ -594,7 +650,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 {
@@ -602,7 +659,8 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: rawValue,
       displayValue: formatSuggestionHooks(closestHooks),
-      hasHook: true
+      hasHook: true,
+      isNumeric: true
     };
   } else {
     return {
@@ -610,7 +668,8 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: rawValue,
       displayValue: rawValue,
-      hasHook: false
+      hasHook: false,
+      isNumeric: true
     };
   }
 }
@@ -651,8 +710,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) {
@@ -661,7 +726,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 {
@@ -669,7 +735,8 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: rawValue,
       displayValue: formatSuggestionHooks(closestHooks),
-      hasHook: true
+      hasHook: true,
+      isNumeric: true
     };
   } else {
     return {
@@ -677,7 +744,8 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: rawValue,
       displayValue: rawValue,
-      hasHook: false
+      hasHook: false,
+      isNumeric: true
     };
   }
 }
@@ -809,9 +877,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) {
@@ -821,20 +910,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;
     }
@@ -884,6 +960,42 @@ function isRuleEnabled(context, ruleName) {
   }
 }
 
+// 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, ruleName } = config;
@@ -897,16 +1009,24 @@ function defineNoHardcodedValueRule(config) {
         url
       },
       fixable: "code",
-      messages
+      messages,
+      schema: ruleOptionsSchema
     },
     create(context) {
       if (ruleName === "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);