feat: enhance disabled handle logic and improve boundary checks

Author: 刘欢

src/Slider.tsx

@@ -191,25 +191,34 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
   const containerRef = React.useRef<HTMLDivElement>(null);
 
   // ============================ Disabled ============================
-  const disabled = React.useMemo(() => {
+  const normalizedDisabled = React.useMemo(() => {
     if (typeof rawDisabled === 'boolean') {
       return rawDisabled;
     }
-    if (Array.isArray(rawDisabled)) {
-      const values = Array.isArray(value) ? value : [value];
-      return values.every((_, index) => rawDisabled[index]);
+    return Array.from(rawDisabled, (d) => d ?? false);
+  }, [rawDisabled]);
+
+  const disabled = React.useMemo(() => {
+    if (typeof normalizedDisabled === 'boolean') {
+      return normalizedDisabled;
     }
-    return false;
-  }, [rawDisabled, value]);
+    return normalizedDisabled.length > 0 && normalizedDisabled.every((d) => d);
+  }, [normalizedDisabled]);
 
   const isHandleDisabled = React.useCallback(
     (index: number) => {
-      if (typeof rawDisabled === 'boolean') {
-        return rawDisabled;
+      if (typeof normalizedDisabled === 'boolean') {
+        return normalizedDisabled;
       }
-      return rawDisabled[index] || false;
+      if (process.env.NODE_ENV !== 'production' && index >= normalizedDisabled.length) {
+        warning(
+          false,
+          `[rc-slider] \`disabled\` array length (${normalizedDisabled.length}) is shorter than handle count.`,
+        );
+      }
+      return normalizedDisabled[index] || false;
     },
-    [rawDisabled],
+    [normalizedDisabled],
   );
 
   const direction = React.useMemo<Direction>(() => {
@@ -329,13 +338,24 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
     ) {
       const newDisabled = [...rawDisabled];
 
+      // Find the first index where arrays differ (handles duplicate values correctly)
+      const findDiffIndex = (longer: number[], shorter: number[]) => {
+        for (let i = 0; i < longer.length; i++) {
+          if (longer[i] !== shorter[i]) {
+            return i;
+          }
+        }
+        return longer.length;
+      };
+
       if (cloneNextValues.length > rawValues.length) {
-        const index = cloneNextValues.findIndex((item, i) => item !== rawValues[i]);
-        const insertIndex = index === -1 ? rawValues.length : index;
+        // Handle added
+        const insertIndex = findDiffIndex(cloneNextValues, rawValues);
         newDisabled.splice(insertIndex, 0, false);
-      } else if (cloneNextValues.length < rawValues.length) {
-        const index = rawValues.findIndex((item) => !cloneNextValues.includes(item));
-        newDisabled.splice(index, 1);
+      } else {
+        // Handle removed
+        const removeIndex = findDiffIndex(rawValues, cloneNextValues);
+        newDisabled.splice(removeIndex, 1);
       }
 
       onDisabledChange?.(newDisabled);
@@ -425,7 +445,8 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
 
       if (rangeEditable && valueDist !== 0 && (!maxCount || rawValues.length < maxCount)) {
         const leftDisabled = isHandleDisabled(valueBeforeIndex);
-        const rightDisabled = isHandleDisabled(valueBeforeIndex + 1);
+        const rightDisabled =
+          valueBeforeIndex + 1 < rawValues.length && isHandleDisabled(valueBeforeIndex + 1);
 
         if (leftDisabled && rightDisabled) {
           return;
@@ -455,7 +476,27 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
 
           valueIndex = nearestIndex;
         }
-        cloneNextValues[valueIndex] = newValue;
+
+        // Check boundaries: cannot cross disabled handles
+        let minBound = mergedMin;
+        let maxBound = mergedMax;
+
+        for (let i = valueIndex - 1; i >= 0; i--) {
+          if (isHandleDisabled(i)) {
+            minBound = rawValues[i];
+            break;
+          }
+        }
+        for (let i = valueIndex + 1; i < rawValues.length; i++) {
+          if (isHandleDisabled(i)) {
+            maxBound = rawValues[i];
+            break;
+          }
+        }
+
+        // Clamp new value within bounds
+        const clampedValue = Math.max(minBound, Math.min(maxBound, newValue));
+        cloneNextValues[valueIndex] = clampedValue;
         focusIndex = valueIndex;
       }