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

package/build/rules/v9/no-hardcoded-values/handlers/index.js

@@ -70,7 +70,11 @@ function isCssColorFunction(value) {
 }
 
 // src/utils/color-lib-utils.ts
-var DELTAE_THRESHOLD = 10;
+var LAB_THRESHOLD = 25;
+var isHexCode = (color) => {
+  const hexPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+  return hexPattern.test(color);
+};
 var convertToHex = (color) => {
   try {
     return (0, import_chroma_js.default)(color).hex();
@@ -78,40 +82,52 @@ 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 closestHooks = [];
+  const returnStylingHooks = [];
+  const closestHooksWithSameProperty = [];
+  const closestHooksWithoutSameProperty = [];
+  const closestHooksWithAllProperty = [];
+  const labColor = (0, import_chroma_js.default)(color).lab();
   Object.entries(supportedColors).forEach(([sldsValue, data]) => {
-    if (sldsValue && isValidColor(sldsValue)) {
+    if (sldsValue && isHexCode(sldsValue)) {
       const hooks = data;
       hooks.forEach((hook) => {
-        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 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 hooksByGroupMap = closestHooks.sort((a, b) => a.distance - b.distance).reduce((acc, hook) => {
-    if (!acc[hook.group]) {
-      acc[hook.group] = [];
+  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));
     }
-    acc[hook.group].push(hook.name);
-    return acc;
-  }, {});
-  return getOrderByCssProp(cssProperty).map((group) => hooksByGroupMap[group] || []).flat().slice(0, 5);
+  }
+  return Array.from(new Set(returnStylingHooks));
 };
 var isValidColor = (val) => import_chroma_js.default.valid(val);
 var extractColorValue = (node) => {
@@ -163,9 +179,9 @@ function isDimensionProperty(cssProperty) {
 function isInsetProperty(cssProperty) {
   return INSET_REGEX.test(cssProperty);
 }
-function resolveDensityPropertyToMatch(cssProperty) {
+function resolvePropertyToMatch(cssProperty) {
   const propertyToMatch = cssProperty.toLowerCase();
-  if (isOutlineWidthProperty(propertyToMatch) || isBorderWidthProperty(propertyToMatch)) {
+  if (propertyToMatch === "outline" || propertyToMatch === "outline-width" || isBorderWidthProperty(propertyToMatch)) {
     return "border-width";
   } else if (isMarginProperty(propertyToMatch)) {
     return "margin";
@@ -177,23 +193,13 @@ function resolveDensityPropertyToMatch(cssProperty) {
     return "width";
   } else if (isInsetProperty(propertyToMatch)) {
     return "top";
-  }
-  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") {
+  } else if (cssProperty === "background" || cssProperty === "background-color") {
     return "background-color";
-  } else if (isBorderColorProperty(propertyToMatch)) {
+  } else if (cssProperty === "outline" || cssProperty === "outline-color" || isBorderColorProperty(cssProperty)) {
     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");
@@ -253,33 +259,13 @@ function isKnownFontWeight(value) {
   return FONT_WEIGHTS.includes(stringValue.toLowerCase());
 }
 function handleShorthandAutoFix(declarationNode, context, valueText, replacements) {
-  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 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 }) => {
     const originalValue = valueText.substring(start, end);
-    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 valueStartColumn = declarationNode.value.loc.start.column;
+    const valueColumn = valueStartColumn + start;
     const { loc: { start: locStart, end: locEnd } } = declarationNode.value;
     const reportNode = {
       ...declarationNode.value,
@@ -287,16 +273,23 @@ function handleShorthandAutoFix(declarationNode, context, valueText, replacement
         ...declarationNode.value.loc,
         start: {
           ...locStart,
-          column: valueColumnStart
+          column: valueColumn
         },
         end: {
           ...locEnd,
-          column: valueColumnEnd
+          column: valueColumn + originalValue.length
         }
       }
     };
     if (hasHook) {
-      const fix = canAutoFix ? fixCallback(start, originalValue, replacement) : void 0;
+      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;
       context.context.report({
         node: reportNode,
         messageId: "hardcodedValue",
@@ -450,41 +443,6 @@ 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();
@@ -508,32 +466,24 @@ 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;
-  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) {
+  if (closestHooks.length === 1) {
     return {
       start,
       end,
-      replacement,
+      replacement: `var(${closestHooks[0]}, ${colorValue})`,
+      displayValue: closestHooks[0],
+      hasHook: true
+    };
+  } else if (closestHooks.length > 1) {
+    return {
+      start,
+      end,
+      replacement: originalValue,
       // Use original value to preserve spacing
       displayValue: formatSuggestionHooks(closestHooks),
       hasHook: true
@@ -542,7 +492,7 @@ function createColorReplacement(colorValue, cssProperty, context, positionInfo,
     return {
       start,
       end,
-      replacement,
+      replacement: originalValue,
       // Use original value to preserve spacing
       displayValue: originalValue,
       hasHook: false
@@ -590,14 +540,8 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
     return null;
   }
   const rawValue = parsedDimension.unit ? `${parsedDimension.number}${parsedDimension.unit}` : parsedDimension.number.toString();
-  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 propToMatch = resolvePropertyToMatch(cssProperty);
+  const closestHooks = getStylingHooksForDensityValue(parsedDimension, context.valueToStylinghook, propToMatch);
   const start = positionInfo.start.offset;
   const end = positionInfo.end.offset;
   if (closestHooks.length === 1) {
@@ -606,8 +550,7 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: `var(${closestHooks[0]}, ${rawValue})`,
       displayValue: closestHooks[0],
-      hasHook: true,
-      isNumeric: true
+      hasHook: true
     };
   } else if (closestHooks.length > 1) {
     return {
@@ -615,8 +558,7 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: rawValue,
       displayValue: formatSuggestionHooks(closestHooks),
-      hasHook: true,
-      isNumeric: true
+      hasHook: true
     };
   } else {
     return {
@@ -624,8 +566,7 @@ function createDimensionReplacement(parsedDimension, cssProperty, context, posit
       end,
       replacement: rawValue,
       displayValue: rawValue,
-      hasHook: false,
-      isNumeric: true
+      hasHook: false
     };
   }
 }
@@ -666,14 +607,8 @@ 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) ? "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 propToMatch = !fontValue.unit && isKnownFontWeight(fontValue.number) ? resolvePropertyToMatch("font-weight") : resolvePropertyToMatch("font-size");
+  const closestHooks = getStylingHooksForDensityValue(fontValue, context.valueToStylinghook, propToMatch);
   const start = positionInfo.start.offset;
   const end = positionInfo.end.offset;
   if (closestHooks.length === 1) {
@@ -682,8 +617,7 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: `var(${closestHooks[0]}, ${rawValue})`,
       displayValue: closestHooks[0],
-      hasHook: true,
-      isNumeric: true
+      hasHook: true
     };
   } else if (closestHooks.length > 1) {
     return {
@@ -691,8 +625,7 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: rawValue,
       displayValue: formatSuggestionHooks(closestHooks),
-      hasHook: true,
-      isNumeric: true
+      hasHook: true
     };
   } else {
     return {
@@ -700,8 +633,7 @@ function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
       end,
       replacement: rawValue,
       displayValue: rawValue,
-      hasHook: false,
-      isNumeric: true
+      hasHook: false
     };
   }
 }
@@ -833,30 +765,9 @@ 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) {
@@ -866,7 +777,20 @@ var handleBoxShadowDeclaration = (node, context) => {
     const parsedValueHook = toBoxShadowValue(shadow);
     if (parsedValueHook && isBoxShadowMatch(parsedCssValue, parsedValueHook)) {
       if (closestHooks.length > 0) {
-        reportBoxShadowViolation(node, context, valueText, closestHooks);
+        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);
+        }
       }
       return;
     }