refactor: optimize disabled handle boundary calculation

- Simplify boundary calculation with for loop instead of map/filter chain
- Unify disabled array handling in useDisabled hook to avoid repetitive checks
- Remove duplicate disabledIsBoolean checks by converting upfront

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: 刘欢

src/Slider.tsx

@@ -405,20 +405,24 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
 
         // 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),
-        );
+        let minBound = mergedMin;
+        let maxBound = mergedMax;
+
+        // Find nearest disabled handle on the left as min boundary
+        for (let i = valueIndex - 1; i >= 0; i -= 1) {
+          if (isHandleDisabled(i)) {
+            minBound = Math.max(minBound, rawValues[i] + pushDist);
+            break;
+          }
+        }
+
+        // Find nearest disabled handle on the right as max boundary
+        for (let i = valueIndex + 1; i < rawValues.length; i += 1) {
+          if (isHandleDisabled(i)) {
+            maxBound = Math.min(maxBound, rawValues[i] - pushDist);
+            break;
+          }
+        }
 
         cloneNextValues[valueIndex] = Math.max(minBound, Math.min(maxBound, newValue));
         focusIndex = valueIndex;

src/hooks/useDisabled.ts

@@ -5,36 +5,32 @@ const useDisabled = (
   mergedValue?: number | number[],
 ): [boolean, (index: number) => boolean, boolean] => {
 
-  const disabledIsArray = Array.isArray(rawDisabled);
-  const disabledIsBoolean = typeof rawDisabled === 'boolean';
   const values = React.useMemo(
     () => (Array.isArray(mergedValue) ? mergedValue : [mergedValue]),
     [mergedValue],
   );
 
-  const disabled = React.useMemo(() => {
-    if (disabledIsBoolean) {
-      return rawDisabled;
+  const disabledArray = React.useMemo(() => {
+    if (typeof rawDisabled === 'boolean') {
+      return values.map(() => rawDisabled);
     }
-    return disabledIsArray ? values.every((_, index) => rawDisabled[index]) : false;
+    return Array.isArray(rawDisabled) ? rawDisabled : values.map(() => false);
   }, [rawDisabled, mergedValue]);
 
+  const disabled = React.useMemo(() => {
+    return values.every((_, index) => disabledArray[index]);
+  }, [disabledArray, values]);
+
   const isHandleDisabled = React.useCallback(
     (index: number): boolean => {
-      if (disabledIsBoolean) {
-        return rawDisabled;
-      }
-      return rawDisabled[index] ?? disabled;
+      return disabledArray[index] ?? disabled;
     },
-    [rawDisabled, disabled],
+    [disabledArray, disabled],
   );
 
   const hasDisabledHandle = React.useMemo(() => {
-    if (disabledIsBoolean) {
-      return rawDisabled;
-    }
-    return rawDisabled.some((d) => d);
-  }, [rawDisabled]);
+    return disabledArray.some((d) => d);
+  }, [disabledArray]);
 
   return [
     disabled,