@salesforce-ux/eslint-plugin-slds 0.5.2 → 1.0.0-internal-alpha.0

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

@@ -0,0 +1,834 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/rules/v9/no-hardcoded-values/handlers/index.ts
+var handlers_exports = {};
+__export(handlers_exports, {
+  handleBoxShadowDeclaration: () => handleBoxShadowDeclaration,
+  handleColorDeclaration: () => handleColorDeclaration,
+  handleDensityDeclaration: () => handleDensityDeclaration,
+  handleFontDeclaration: () => handleFontDeclaration
+});
+module.exports = __toCommonJS(handlers_exports);
+
+// src/utils/color-lib-utils.ts
+var import_chroma_js = __toESM(require("chroma-js"));
+var import_css_tree = require("@eslint/css-tree");
+
+// src/utils/css-functions.ts
+var CSS_FUNCTIONS = [
+  "attr",
+  "calc",
+  "color-mix",
+  "conic-gradient",
+  "counter",
+  "cubic-bezier",
+  "linear-gradient",
+  "max",
+  "min",
+  "radial-gradient",
+  "repeating-conic-gradient",
+  "repeating-linear-gradient",
+  "repeating-radial-gradient",
+  "var"
+];
+var CSS_MATH_FUNCTIONS = ["calc", "min", "max"];
+var RGB_COLOR_FUNCTIONS = ["rgb", "rgba", "hsl", "hsla"];
+var cssFunctionsRegex = new RegExp(`(?:${CSS_FUNCTIONS.join("|")})`);
+var cssFunctionsExactRegex = new RegExp(`^(?:${CSS_FUNCTIONS.join("|")})$`);
+var cssMathFunctionsRegex = new RegExp(`^(?:${CSS_MATH_FUNCTIONS.join("|")})$`);
+function isCssFunction(value) {
+  return cssFunctionsExactRegex.test(value);
+}
+function isCssColorFunction(value) {
+  return RGB_COLOR_FUNCTIONS.includes(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 convertToHex = (color) => {
+  try {
+    return (0, import_chroma_js.default)(color).hex();
+  } catch (e) {
+    return null;
+  }
+};
+var findClosestColorHook = (color, supportedColors, cssProperty) => {
+  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 && isHexCode(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 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));
+    }
+  }
+  return Array.from(new Set(returnStylingHooks));
+};
+var isValidColor = (val) => import_chroma_js.default.valid(val);
+var extractColorValue = (node) => {
+  let colorValue = null;
+  switch (node.type) {
+    case "Hash":
+      colorValue = `#${node.value}`;
+      break;
+    case "Identifier":
+      colorValue = node.name;
+      break;
+    case "Function":
+      if (isCssColorFunction(node.name)) {
+        colorValue = (0, import_css_tree.generate)(node);
+      }
+      break;
+  }
+  return colorValue && isValidColor(colorValue) ? colorValue : null;
+};
+
+// src/utils/property-matcher.ts
+var DIRECTION_VALUES = "(?:top|right|bottom|left|inline|block|inline-start|inline-end|start|end|block-start|block-end)";
+var CORNER_VALUES = "(?:top-left|top-right|bottom-right|bottom-left|start-start|start-end|end-start|end-end)";
+var INSET_VALUES = "(?:inline|block|inline-start|inline-end|block-start|block-end)";
+var BORDER_COLOR_REGEX = new RegExp(`^border(?:-${DIRECTION_VALUES})?-color$`);
+var BORDER_WIDTH_REGEX = new RegExp(`^border(?:-${DIRECTION_VALUES})?-width$`);
+var MARGIN_REGEX = new RegExp(`^margin(?:-${DIRECTION_VALUES})?$`);
+var PADDING_REGEX = new RegExp(`^padding(?:-${DIRECTION_VALUES})?$`);
+var BORDER_RADIUS_REGEX = new RegExp(`^border(?:-${CORNER_VALUES})?-radius$`);
+var INSET_REGEX = new RegExp(`^inset(?:-${INSET_VALUES})?$`);
+function isBorderColorProperty(cssProperty) {
+  return BORDER_COLOR_REGEX.test(cssProperty);
+}
+function isBorderWidthProperty(cssProperty) {
+  return BORDER_WIDTH_REGEX.test(cssProperty);
+}
+function isMarginProperty(cssProperty) {
+  return MARGIN_REGEX.test(cssProperty);
+}
+function isPaddingProperty(cssProperty) {
+  return PADDING_REGEX.test(cssProperty);
+}
+function isBorderRadius(cssProperty) {
+  return BORDER_RADIUS_REGEX.test(cssProperty);
+}
+function isDimensionProperty(cssProperty) {
+  return ["width", "height", "min-width", "max-width", "min-height", "max-height"].includes(cssProperty);
+}
+function isInsetProperty(cssProperty) {
+  return INSET_REGEX.test(cssProperty);
+}
+function resolvePropertyToMatch(cssProperty) {
+  const propertyToMatch = cssProperty.toLowerCase();
+  if (propertyToMatch === "outline" || propertyToMatch === "outline-width" || isBorderWidthProperty(propertyToMatch)) {
+    return "border-width";
+  } else if (isMarginProperty(propertyToMatch)) {
+    return "margin";
+  } else if (isPaddingProperty(propertyToMatch)) {
+    return "padding";
+  } else if (isBorderRadius(propertyToMatch)) {
+    return "border-radius";
+  } else if (isDimensionProperty(propertyToMatch)) {
+    return "width";
+  } else if (isInsetProperty(propertyToMatch)) {
+    return "top";
+  } else if (cssProperty === "background" || cssProperty === "background-color") {
+    return "background-color";
+  } else if (cssProperty === "outline" || cssProperty === "outline-color" || isBorderColorProperty(cssProperty)) {
+    return "border-color";
+  }
+  return propertyToMatch;
+}
+
+// src/utils/hardcoded-shared-utils.ts
+var import_css_tree2 = require("@eslint/css-tree");
+var FONT_WEIGHTS = [
+  "normal",
+  "bold",
+  "bolder",
+  "lighter",
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900"
+];
+function isKnownFontWeight(value) {
+  const stringValue = value.toString();
+  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 }) => {
+    const originalValue = valueText.substring(start, end);
+    const valueStartColumn = declarationNode.value.loc.start.column;
+    const valueColumn = valueStartColumn + start;
+    const { loc: { start: locStart, end: locEnd } } = declarationNode.value;
+    const reportNode = {
+      ...declarationNode.value,
+      loc: {
+        ...declarationNode.value.loc,
+        start: {
+          ...locStart,
+          column: valueColumn
+        },
+        end: {
+          ...locEnd,
+          column: valueColumn + originalValue.length
+        }
+      }
+    };
+    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;
+      context.context.report({
+        node: reportNode,
+        messageId: "hardcodedValue",
+        data: {
+          oldValue: originalValue,
+          newValue: displayValue
+        },
+        fix
+      });
+    } else {
+      context.context.report({
+        node: reportNode,
+        messageId: "noReplacement",
+        data: {
+          oldValue: originalValue
+        }
+      });
+    }
+  });
+}
+function forEachValue(valueText, extractValue, shouldSkipNode, callback) {
+  if (!valueText || typeof valueText !== "string") {
+    return;
+  }
+  try {
+    const ast = (0, import_css_tree2.parse)(valueText, { context: "value", positions: true });
+    (0, import_css_tree2.walk)(ast, {
+      enter(node) {
+        if (shouldSkipNode(node)) {
+          return this.skip;
+        }
+        const value = extractValue(node);
+        if (value !== null) {
+          const positionInfo = {
+            start: node.loc?.start,
+            end: node.loc?.end
+          };
+          callback(value, positionInfo);
+        }
+      }
+    });
+  } catch (error) {
+    return;
+  }
+}
+function shouldSkipColorNode(node) {
+  return node.type === "Function" && isCssFunction(node.name);
+}
+function shouldSkipDimensionNode(node) {
+  return node.type === "Function";
+}
+function extractDimensionValue(valueNode, cssProperty) {
+  if (!valueNode) return null;
+  switch (valueNode.type) {
+    case "Dimension":
+      const numValue = Number(valueNode.value);
+      if (numValue === 0) return null;
+      const unit = valueNode.unit.toLowerCase();
+      if (unit !== "px" && unit !== "rem" && unit !== "%") return null;
+      return {
+        number: numValue,
+        unit
+      };
+    case "Number":
+      const numberValue = Number(valueNode.value);
+      if (numberValue === 0) return null;
+      return {
+        number: numberValue,
+        unit: null
+      };
+    case "Percentage":
+      const percentValue = Number(valueNode.value);
+      if (percentValue === 0) return null;
+      return {
+        number: percentValue,
+        unit: "%"
+      };
+    case "Value":
+      return valueNode.children?.[0] ? extractDimensionValue(valueNode.children[0], cssProperty) : null;
+  }
+  return null;
+}
+function forEachColorValue(valueText, callback) {
+  forEachValue(valueText, extractColorValue, shouldSkipColorNode, callback);
+}
+function forEachDensityValue(valueText, cssProperty, callback) {
+  forEachValue(
+    valueText,
+    (node) => extractDimensionValue(node, cssProperty),
+    shouldSkipDimensionNode,
+    callback
+  );
+}
+function extractFontValue(node) {
+  if (!node) return null;
+  switch (node.type) {
+    case "Dimension":
+      const numValue = Number(node.value);
+      if (numValue <= 0) return null;
+      const unit = node.unit.toLowerCase();
+      if (unit !== "px" && unit !== "rem" && unit !== "%") return null;
+      return {
+        number: numValue,
+        unit
+      };
+    case "Number":
+      const numberValue = Number(node.value);
+      if (numberValue <= 0) {
+        return null;
+      }
+      if (!isKnownFontWeight(numberValue)) {
+        return null;
+      }
+      return {
+        number: numberValue,
+        unit: null
+      };
+    case "Identifier":
+      const namedValue = node.name.toLowerCase();
+      if (!isKnownFontWeight(namedValue)) {
+        return null;
+      }
+      if (namedValue === "normal") {
+        return { number: 400, unit: null };
+      }
+      return { number: namedValue, unit: null };
+    case "Percentage":
+      const percentValue = Number(node.value);
+      if (percentValue === 0) return null;
+      return {
+        number: percentValue,
+        unit: "%"
+      };
+    case "Value":
+      return node.children?.[0] ? extractFontValue(node.children[0]) : null;
+  }
+  return null;
+}
+function shouldSkipFontNode(node) {
+  return node.type === "Function";
+}
+function forEachFontValue(valueText, callback) {
+  forEachValue(valueText, extractFontValue, shouldSkipFontNode, callback);
+}
+
+// src/rules/v9/no-hardcoded-values/handlers/colorHandler.ts
+var handleColorDeclaration = (node, context) => {
+  const cssProperty = node.property.toLowerCase();
+  const valueText = context.sourceCode.getText(node.value);
+  const replacements = [];
+  forEachColorValue(valueText, (colorValue, positionInfo) => {
+    if (colorValue !== "transparent" && isValidColor(colorValue)) {
+      const replacement = createColorReplacement(colorValue, cssProperty, context, positionInfo, valueText);
+      if (replacement) {
+        replacements.push(replacement);
+      }
+    }
+  });
+  handleShorthandAutoFix(node, context, valueText, replacements);
+};
+function createColorReplacement(colorValue, cssProperty, context, positionInfo, originalValueText) {
+  if (!positionInfo?.start) {
+    return null;
+  }
+  const hexValue = convertToHex(colorValue);
+  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) {
+    return {
+      start,
+      end,
+      replacement: originalValue,
+      // Use original value to preserve spacing
+      displayValue: closestHooks.join(", "),
+      hasHook: true
+      // ← THE FIX: Multiple hooks still means "has hooks"
+    };
+  } else {
+    return {
+      start,
+      end,
+      replacement: originalValue,
+      // Use original value to preserve spacing
+      displayValue: originalValue,
+      hasHook: false
+    };
+  }
+}
+
+// src/utils/value-utils.ts
+function parseUnitValue(value) {
+  if (!value) return null;
+  const match = value.match(/^(-?\d*\.?\d+)(px|rem|%)?$/);
+  if (!match) return null;
+  const number = parseFloat(match[1]);
+  const unit = match[2] ? match[2] : null;
+  if (isNaN(number)) return null;
+  return { number, unit };
+}
+function toAlternateUnitValue(numberVal, unitType) {
+  if (unitType === "px") {
+    let floatValue = parseFloat(`${numberVal / 16}`);
+    if (!isNaN(floatValue)) {
+      return {
+        unit: "rem",
+        number: parseFloat(floatValue.toFixed(4))
+      };
+    }
+  } else if (unitType === "rem") {
+    const intValue = parseInt(`${numberVal * 16}`);
+    if (!isNaN(intValue)) {
+      return {
+        unit: "px",
+        number: intValue
+      };
+    }
+  }
+  return null;
+}
+
+// src/utils/styling-hook-utils.ts
+function isValueMatch(valueToMatch, sldsValue) {
+  if (!valueToMatch || !sldsValue) {
+    return false;
+  }
+  return valueToMatch.unit == sldsValue.unit && valueToMatch.number === sldsValue.number;
+}
+function getStylingHooksForDensityValue(parsedValue, supportedStylinghooks, cssProperty) {
+  if (!parsedValue) return [];
+  const alternateValue = toAlternateUnitValue(parsedValue.number, parsedValue.unit);
+  const matchedHooks = [];
+  for (const [sldsValue, hooks] of Object.entries(supportedStylinghooks)) {
+    const parsedSldsValue = parseUnitValue(sldsValue);
+    if (isValueMatch(parsedValue, parsedSldsValue) || alternateValue && isValueMatch(alternateValue, parsedSldsValue)) {
+      hooks.filter((hook) => hook.properties.includes(cssProperty)).forEach((hook) => matchedHooks.push(hook.name));
+    }
+  }
+  return matchedHooks;
+}
+
+// src/rules/v9/no-hardcoded-values/handlers/densityHandler.ts
+var handleDensityDeclaration = (node, context) => {
+  const cssProperty = node.property.toLowerCase();
+  const valueText = context.sourceCode.getText(node.value);
+  const replacements = [];
+  forEachDensityValue(valueText, cssProperty, (parsedDimension, positionInfo) => {
+    if (parsedDimension) {
+      const replacement = createDimensionReplacement(parsedDimension, cssProperty, context, positionInfo);
+      if (replacement) {
+        replacements.push(replacement);
+      }
+    }
+  });
+  handleShorthandAutoFix(node, context, valueText, replacements);
+};
+function createDimensionReplacement(parsedDimension, cssProperty, context, positionInfo) {
+  if (!parsedDimension || !positionInfo?.start) {
+    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 start = positionInfo.start.offset;
+  const end = positionInfo.end.offset;
+  if (closestHooks.length === 1) {
+    return {
+      start,
+      end,
+      replacement: `var(${closestHooks[0]}, ${rawValue})`,
+      displayValue: closestHooks[0],
+      hasHook: true
+    };
+  } else if (closestHooks.length > 1) {
+    return {
+      start,
+      end,
+      replacement: rawValue,
+      displayValue: closestHooks.join(", "),
+      hasHook: true
+    };
+  } else {
+    return {
+      start,
+      end,
+      replacement: rawValue,
+      displayValue: rawValue,
+      hasHook: false
+    };
+  }
+}
+
+// src/rules/v9/no-hardcoded-values/handlers/fontHandler.ts
+var handleFontDeclaration = (node, context) => {
+  const cssProperty = node.property.toLowerCase();
+  const valueText = context.sourceCode.getText(node.value);
+  const replacements = [];
+  forEachFontValue(valueText, (fontValue, positionInfo) => {
+    if (fontValue && isValidFontValue(fontValue, cssProperty)) {
+      const replacement = createFontReplacement(fontValue, cssProperty, context, positionInfo);
+      if (replacement) {
+        replacements.push(replacement);
+      }
+    }
+  });
+  handleShorthandAutoFix(node, context, valueText, replacements);
+};
+function isValidFontValue(fontValue, cssProperty) {
+  if (cssProperty === "font-size") {
+    return !!fontValue.unit;
+  } else if (cssProperty === "font-weight") {
+    return !fontValue.unit && isKnownFontWeight(fontValue.number);
+  } else if (cssProperty === "font") {
+    if (!fontValue.unit && isKnownFontWeight(fontValue.number)) {
+      return true;
+    } else if (fontValue.unit) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+function createFontReplacement(fontValue, cssProperty, context, positionInfo) {
+  if (!positionInfo?.start) {
+    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 start = positionInfo.start.offset;
+  const end = positionInfo.end.offset;
+  if (closestHooks.length === 1) {
+    return {
+      start,
+      end,
+      replacement: `var(${closestHooks[0]}, ${rawValue})`,
+      displayValue: closestHooks[0],
+      hasHook: true
+    };
+  } else if (closestHooks.length > 1) {
+    return {
+      start,
+      end,
+      replacement: rawValue,
+      displayValue: closestHooks.join(", "),
+      hasHook: true
+    };
+  } else {
+    return {
+      start,
+      end,
+      replacement: rawValue,
+      displayValue: rawValue,
+      hasHook: false
+    };
+  }
+}
+
+// src/utils/boxShadowValueParser.ts
+var import_css_tree3 = require("@eslint/css-tree");
+function isColorValue(node) {
+  if (!node) return false;
+  switch (node.type) {
+    case "Hash":
+      return true;
+    // #hex colors
+    case "Identifier":
+      return isValidColor(node.name);
+    case "Function":
+      return isCssColorFunction(node.name.toLowerCase());
+    default:
+      return false;
+  }
+}
+function isLengthValue(node) {
+  if (!node) return false;
+  switch (node.type) {
+    case "Dimension":
+      const dimensionStr = `${node.value}${node.unit}`;
+      return parseUnitValue(dimensionStr) !== null;
+    case "Number":
+      return Number(node.value) === 0;
+    default:
+      return false;
+  }
+}
+function isInsetKeyword(node) {
+  return node?.type === "Identifier" && node.name.toLowerCase() === "inset";
+}
+function extractShadowParts(valueText) {
+  const shadows = [];
+  let currentShadow = {
+    lengthParts: [],
+    colorParts: [],
+    inset: false
+  };
+  try {
+    const ast = (0, import_css_tree3.parse)(valueText, { context: "value" });
+    (0, import_css_tree3.walk)(ast, {
+      enter(node) {
+        if (node.type === "Function") {
+          return this.skip;
+        }
+        if (isInsetKeyword(node)) {
+          currentShadow.inset = true;
+        } else if (isLengthValue(node)) {
+          currentShadow.lengthParts.push((0, import_css_tree3.generate)(node));
+        } else if (isColorValue(node)) {
+          currentShadow.colorParts.push((0, import_css_tree3.generate)(node));
+        }
+      }
+    });
+    if (currentShadow.lengthParts.length > 0 || currentShadow.colorParts.length > 0 || currentShadow.inset) {
+      shadows.push(currentShadow);
+    }
+  } catch (error) {
+    return [];
+  }
+  return shadows;
+}
+function parseBoxShadowValue(value) {
+  const shadowStrings = value.split(",").map((s) => s.trim());
+  const allShadows = [];
+  for (const shadowString of shadowStrings) {
+    const shadows = extractShadowParts(shadowString);
+    const parsedShadows = shadows.map((shadow) => {
+      const shadowValue = {};
+      const lengthProps = ["offsetX", "offsetY", "blurRadius", "spreadRadius"];
+      lengthProps.forEach((prop, index) => {
+        if (shadow.lengthParts.length > index) {
+          shadowValue[prop] = shadow.lengthParts[index];
+        }
+      });
+      if (shadow.colorParts.length > 0) {
+        shadowValue.color = shadow.colorParts[0];
+      }
+      if (shadow.inset) {
+        shadowValue.inset = true;
+      }
+      return shadowValue;
+    });
+    allShadows.push(...parsedShadows);
+  }
+  return allShadows;
+}
+function normalizeLengthValue(value) {
+  if (!value) return "0px";
+  if (value === "0") return "0px";
+  return value;
+}
+function isBoxShadowMatch(parsedCssValue, parsedValueHook) {
+  if (parsedCssValue.length !== parsedValueHook.length) {
+    return false;
+  }
+  for (let i = 0; i < parsedCssValue.length; i++) {
+    const cssShadow = parsedCssValue[i];
+    const hookShadow = parsedValueHook[i];
+    if (cssShadow.color !== hookShadow.color || cssShadow.inset !== hookShadow.inset) {
+      return false;
+    }
+    const lengthProps = ["offsetX", "offsetY", "blurRadius", "spreadRadius"];
+    for (const prop of lengthProps) {
+      if (normalizeLengthValue(cssShadow[prop]) !== normalizeLengthValue(hookShadow[prop])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/rules/v9/no-hardcoded-values/handlers/boxShadowHandler.ts
+function containsCssVariable(valueText) {
+  return valueText.includes("var(");
+}
+var handleBoxShadowDeclaration = (node, context) => {
+  const cssProperty = node.property.toLowerCase();
+  const valueText = context.sourceCode.getText(node.value);
+  if (containsCssVariable(valueText)) {
+    return;
+  }
+  const replacements = [];
+  const parsedCssValue = parseAndValidateBoxShadow(valueText);
+  if (parsedCssValue) {
+    const shadowHooks = getBoxShadowHooks(context.valueToStylinghook);
+    const closestHooks = findMatchingBoxShadowHooks(parsedCssValue, shadowHooks);
+    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) {
+      replacements.push(replacement);
+    }
+  }
+  handleShorthandAutoFix(node, context, valueText, replacements);
+};
+function getBoxShadowHooks(supportedStylinghooks) {
+  return Object.entries(supportedStylinghooks).filter(([key, value]) => {
+    return value.some((hook) => hook.properties.includes("box-shadow"));
+  }).map(([key, value]) => {
+    return [key, value.map((hook) => hook.name)];
+  });
+}
+function parseAndValidateBoxShadow(cssValue) {
+  const parsedCssValue = parseBoxShadowValue(cssValue).filter((shadow) => Object.keys(shadow).length > 0);
+  if (parsedCssValue.length === 0) {
+    return null;
+  }
+  return parsedCssValue;
+}
+function findMatchingBoxShadowHooks(parsedCssValue, shadowHooks) {
+  for (const [shadowHookValue, closestHooks] of shadowHooks) {
+    const parsedHookValue = parseAndValidateBoxShadow(shadowHookValue);
+    if (parsedHookValue && isBoxShadowMatch(parsedCssValue, parsedHookValue)) {
+      return closestHooks;
+    }
+  }
+  return [];
+}
+function createBoxShadowReplacement(originalValue, hooks, context, positionInfo) {
+  if (!positionInfo?.start) {
+    return null;
+  }
+  const start = positionInfo.start.offset;
+  const end = positionInfo.end.offset;
+  if (hooks.length === 1) {
+    return {
+      start,
+      end,
+      replacement: `var(${hooks[0]}, ${originalValue})`,
+      displayValue: hooks[0],
+      hasHook: true
+    };
+  } else if (hooks.length > 1) {
+    return {
+      start,
+      end,
+      replacement: originalValue,
+      displayValue: hooks.join(", "),
+      hasHook: true
+    };
+  } else {
+    return {
+      start,
+      end,
+      replacement: originalValue,
+      displayValue: originalValue,
+      hasHook: false
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleBoxShadowDeclaration,
+  handleColorDeclaration,
+  handleDensityDeclaration,
+  handleFontDeclaration
+});
+//# sourceMappingURL=index.js.map