refactor: optimize disabled handle implementation based on review feedback

- Handle.tsx: rename handleDisabled to mergedDisabled, remove globalDisabled
- Slider.tsx: use ?? operator for fallback to global disabled state
- Slider.tsx: simplify boundary calculation with functional style
- useOffset.ts: treat disabled handles as fixed anchors with candidates pattern
- useOffset.ts: handle dead-lock case when minBound > maxBound

Co-Authored-By: zombieJ <zombieJ@users.noreply.github.com>

Author: 刘欢

src/Handles/Handle.tsx

@@ -55,7 +55,6 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
     min,
     max,
     direction,
-    disabled: globalDisabled,
     keyboard,
     range,
     tabIndex,
@@ -68,13 +67,13 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
     isHandleDisabled,
   } = React.useContext(SliderContext);
 
-  const handleDisabled = globalDisabled || isHandleDisabled(valueIndex);
+  const mergedDisabled = isHandleDisabled(valueIndex);
 
   const handlePrefixCls = `${prefixCls}-handle`;
 
   // ============================ Events ============================
   const onInternalStartMove = (e: React.MouseEvent | React.TouchEvent) => {
-    if (handleDisabled) {
+    if (mergedDisabled) {
       e.stopPropagation();
       return;
     }
@@ -91,7 +90,7 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
 
   // =========================== Keyboard ===========================
   const onKeyDown: React.KeyboardEventHandler<HTMLDivElement> = (e) => {
-    if (!handleDisabled && keyboard) {
+    if (!mergedDisabled && keyboard) {
       let offset: number | 'min' | 'max' = null;
 
       // Change the value
@@ -166,12 +165,12 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
 
   if (valueIndex !== null) {
     divProps = {
-      tabIndex: handleDisabled ? null : getIndex(tabIndex, valueIndex),
+      tabIndex: mergedDisabled ? null : getIndex(tabIndex, valueIndex),
       role: 'slider',
       'aria-valuemin': min,
       'aria-valuemax': max,
       'aria-valuenow': value,
-      'aria-disabled': handleDisabled,
+      'aria-disabled': mergedDisabled,
       'aria-label': getIndex(ariaLabelForHandle, valueIndex),
       'aria-labelledby': getIndex(ariaLabelledByForHandle, valueIndex),
       'aria-required': getIndex(ariaRequired, valueIndex),
@@ -195,7 +194,7 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
           [`${handlePrefixCls}-${valueIndex + 1}`]: valueIndex !== null && range,
           [`${handlePrefixCls}-dragging`]: dragging,
           [`${handlePrefixCls}-dragging-delete`]: draggingDelete,
-          [`${handlePrefixCls}-disabled`]: handleDisabled,
+          [`${handlePrefixCls}-disabled`]: mergedDisabled,
         },
         classNames.handle,
       )}

src/Slider.tsx

@@ -205,9 +205,10 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
       if (typeof rawDisabled === 'boolean') {
         return rawDisabled;
       }
-      return rawDisabled[index] || false;
+      // Return individual disabled state if defined, otherwise fallback to global disabled
+      return rawDisabled[index] ?? disabled;
     },
-    [rawDisabled],
+    [rawDisabled, disabled],
   );
 
   const direction = React.useMemo<Direction>(() => {
@@ -415,47 +416,36 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
         cloneNextValues.splice(valueBeforeIndex + 1, 0, newValue);
         focusIndex = valueBeforeIndex + 1;
       } else {
+        // Find nearest enabled handle if current is disabled
         if (isHandleDisabled(valueIndex)) {
-          let nearestIndex = -1;
-          let nearestDist = mergedMax - mergedMin;
-
-          rawValues.forEach((val, index) => {
-            if (!isHandleDisabled(index)) {
-              const dist = Math.abs(newValue - val);
-              if (dist < nearestDist) {
-                nearestDist = dist;
-                nearestIndex = index;
-              }
-            }
-          });
-
-          // If all handles are disabled, do nothing
-          if (nearestIndex === -1) {
-            return;
-          }
-
-          valueIndex = nearestIndex;
-        }
+          const enabledIndices = rawValues
+            .map((_, i) => i)
+            .filter((i) => !isHandleDisabled(i));
 
-        // Apply boundary constraints from disabled handles
-        let minBound = mergedMin;
-        let maxBound = mergedMax;
+          if (enabledIndices.length === 0) return;
 
-        for (let i = valueIndex - 1; i >= 0; i -= 1) {
-          if (isHandleDisabled(i)) {
-            const pushDistance = typeof mergedPush === 'number' ? mergedPush : 0;
-            minBound = rawValues[i] + pushDistance;
-            break;
-          }
-        }
-        for (let i = valueIndex + 1; i < rawValues.length; i += 1) {
-          if (isHandleDisabled(i)) {
-            const pushDistance = typeof mergedPush === 'number' ? mergedPush : 0;
-            maxBound = rawValues[i] - pushDistance;
-            break;
-          }
+          valueIndex = enabledIndices.reduce((nearest, i) =>
+            Math.abs(newValue - rawValues[i]) < Math.abs(newValue - rawValues[nearest]) ? i : nearest,
+          );
         }
 
+        // Calculate boundaries from disabled handles (treat as fixed anchors)
+        const pushDist = typeof mergedPush === 'number' ? mergedPush : 0;
+        const minBound = Math.max(
+          mergedMin,
+          ...rawValues
+            .slice(0, valueIndex)
+            .map((v, i) => (isHandleDisabled(i) ? v + pushDist : mergedMin))
+            .filter((v) => v > mergedMin),
+        );
+        const maxBound = Math.min(
+          mergedMax,
+          ...rawValues
+            .slice(valueIndex + 1)
+            .map((v, i) => (isHandleDisabled(i + valueIndex + 1) ? v - pushDist : mergedMax))
+            .filter((v) => v < mergedMax),
+        );
+
         cloneNextValues[valueIndex] = Math.max(minBound, Math.min(maxBound, newValue));
         focusIndex = valueIndex;
       }

src/hooks/useOffset.ts

@@ -190,24 +190,32 @@ export default function useOffset(
     return (pushable === null && dist === 0) || (typeof pushable === 'number' && dist < pushable);
   };
 
-  // Get the minimum boundary for a handle considering disabled handles
+  // Get the minimum boundary for a handle considering disabled handles as fixed anchors
   const getHandleMinBound = (values: number[], handleIndex: number): number => {
+    const gap = typeof pushable === 'number' ? pushable : 0;
+    // Collect min and all left-side disabled handle positions as candidates
+    const candidates = [min];
     for (let i = handleIndex - 1; i >= 0; i -= 1) {
       if (isHandleDisabled(i)) {
-        return values[i] + (typeof pushable === 'number' ? pushable : 0);
+        candidates.push(values[i] + gap);
+        break; // Only need the nearest disabled handle
       }
     }
-    return min;
+    return Math.max(...candidates);
   };
 
-  // Get the maximum boundary for a handle considering disabled handles
+  // Get the maximum boundary for a handle considering disabled handles as fixed anchors
   const getHandleMaxBound = (values: number[], handleIndex: number): number => {
+    const gap = typeof pushable === 'number' ? pushable : 0;
+    // Collect max and all right-side disabled handle positions as candidates
+    const candidates = [max];
     for (let i = handleIndex + 1; i < values.length; i += 1) {
       if (isHandleDisabled(i)) {
-        return values[i] - (typeof pushable === 'number' ? pushable : 0);
+        candidates.push(values[i] - gap);
+        break; // Only need the nearest disabled handle
       }
     }
-    return max;
+    return Math.min(...candidates);
   };
 
   // Values
@@ -222,7 +230,13 @@ export default function useOffset(
     nextValues[valueIndex] = nextValue;
 
     // Apply disabled handle boundaries
-    nextValues[valueIndex] = Math.max(minBound, Math.min(maxBound, nextValues[valueIndex]));
+    // If bounds conflict (min > max), the handle is locked between two disabled handles
+    // In this case, keep the original value
+    if (minBound <= maxBound) {
+      nextValues[valueIndex] = Math.max(minBound, Math.min(maxBound, nextValues[valueIndex]));
+    } else {
+      nextValues[valueIndex] = originValue;
+    }
 
     if (allowCross === false) {
       // >>>>> Allow Cross