feat: Range 组件支持 disabled 数组形式

assets/index.less

@@ -105,6 +105,20 @@
       cursor: -webkit-grabbing;
       cursor: grabbing;
     }
+
+    &-disabled {
+      background-color: #fff;
+      border-color: @disabledColor;
+      box-shadow: none;
+      cursor: not-allowed;
+
+      &:hover,
+      &:active {
+        border-color: @disabledColor;
+        box-shadow: none;
+        cursor: not-allowed;
+      }
+    }
   }
 
   &-mark {

docs/demo/disabled-handle.md

@@ -0,0 +1,9 @@
+---
+title: Disabled Handle
+title.zh-CN: 禁用特定滑块
+nav:
+  title: Demo
+  path: /demo
+---
+
+<code src="../examples/disabled-handle.tsx"></code>

docs/examples/disabled-handle.tsx

@@ -0,0 +1,85 @@
+/* eslint react/no-multi-comp: 0, no-console: 0 */
+import Slider from '@rc-component/slider';
+import React, { useState } from 'react';
+import '../../assets/index.less';
+
+const style: React.CSSProperties = {
+  width: 400,
+  margin: 50,
+};
+
+const BasicDisabledHandle = () => {
+  const [value, setValue] = useState([0, 30, 60, 100]);
+  const [disabled, setDisabled] = useState([true, false, false, true]);
+
+  return (
+    <div>
+      <Slider range value={value} onChange={setValue} disabled={disabled} />
+      <div style={{ marginTop: 16 }}>
+        {value.map((val, index) => (
+          <label key={index} style={{ marginRight: 16 }}>
+            <input
+              type="checkbox"
+              checked={disabled[index]}
+              onChange={() => {
+                const newDisabled = [...disabled];
+                newDisabled[index] = !newDisabled[index];
+                setDisabled(newDisabled);
+              }}
+            />
+            Handle {index + 1} ({val}) {disabled[index] ? 'Disabled' : 'Enabled'}
+          </label>
+        ))}
+      </div>
+    </div>
+  );
+};
+
+const DisabledHandleAsBoundary = () => {
+  const [value, setValue] = useState([10, 50, 90]);
+
+  return (
+    <div>
+      <Slider range value={value} onChange={setValue} disabled={[false, true, false]} />
+      <p style={{ marginTop: 8, color: '#999' }}>
+        Middle handle (50) is disabled and acts as a boundary.
+        First handle cannot go beyond 50, third handle cannot go below 50.
+        Disabled handle has gray border and not-allowed cursor.
+      </p>
+    </div>
+  );
+};
+
+const MultipleDisabledBoundaries = () => {
+  const [value, setValue] = useState([10, 30, 50, 70, 90]);
+
+  return (
+    <div>
+      <Slider range value={value} onChange={setValue} disabled={[true, false, true, false, true]} />
+      <p style={{ marginTop: 8, color: '#999' }}>
+        Handles at 10, 50, 90 are disabled.
+        Handle at 30 can only move between 10-50, handle at 70 can only move between 50-90.
+      </p>
+    </div>
+  );
+};
+
+export default () => (
+  <div>
+    <div style={style}>
+      <h3>Basic Disabled Handle</h3>
+      <p>Toggle checkboxes to disable/enable specific handles</p>
+      <BasicDisabledHandle />
+    </div>
+
+    <div style={style}>
+      <h3>Disabled Handle as Boundary</h3>
+      <DisabledHandleAsBoundary />
+    </div>
+
+    <div style={style}>
+      <h3>Multiple Disabled Boundaries</h3>
+      <MultipleDisabledBoundaries />
+    </div>
+  </div>
+);

src/Handles/Handle.tsx

@@ -55,7 +55,7 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
     min,
     max,
     direction,
-    disabled,
+    disabled: globalDisabled,
     keyboard,
     range,
     tabIndex,
@@ -65,15 +65,21 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
     ariaValueTextFormatterForHandle,
     styles,
     classNames,
+    isHandleDisabled,
   } = React.useContext(SliderContext);
 
+  const handleDisabled =
+    globalDisabled || (isHandleDisabled ? isHandleDisabled(valueIndex) : false);
+
   const handlePrefixCls = `${prefixCls}-handle`;
 
   // ============================ Events ============================
   const onInternalStartMove = (e: React.MouseEvent | React.TouchEvent) => {
-    if (!disabled) {
-      onStartMove(e, valueIndex);
+    if (handleDisabled) {
+      e.stopPropagation();
+      return;
     }
+    onStartMove(e, valueIndex);
   };
 
   const onInternalFocus = (e: React.FocusEvent<HTMLDivElement>) => {
@@ -86,7 +92,7 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
 
   // =========================== Keyboard ===========================
   const onKeyDown: React.KeyboardEventHandler<HTMLDivElement> = (e) => {
-    if (!disabled && keyboard) {
+    if (!handleDisabled && keyboard) {
       let offset: number | 'min' | 'max' = null;
 
       // Change the value
@@ -161,12 +167,12 @@ const Handle = React.forwardRef<HTMLDivElement, HandleProps>((props, ref) => {
 
   if (valueIndex !== null) {
     divProps = {
-      tabIndex: disabled ? null : getIndex(tabIndex, valueIndex),
+      tabIndex: handleDisabled ? null : getIndex(tabIndex, valueIndex),
       role: 'slider',
       'aria-valuemin': min,
       'aria-valuemax': max,
       'aria-valuenow': value,
-      'aria-disabled': disabled,
+      'aria-disabled': handleDisabled,
       'aria-label': getIndex(ariaLabelForHandle, valueIndex),
       'aria-labelledby': getIndex(ariaLabelledByForHandle, valueIndex),
       'aria-required': getIndex(ariaRequired, valueIndex),
@@ -190,6 +196,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,
         },
         classNames.handle,
       )}

src/Slider.tsx

@@ -57,7 +57,7 @@ export interface SliderProps<ValueType = number | number[]> {
   id?: string;
 
   // Status
-  disabled?: boolean;
+  disabled?: boolean | boolean[];
   keyboard?: boolean;
   autoFocus?: boolean;
   onFocus?: (e: React.FocusEvent<HTMLDivElement>) => void;
@@ -131,8 +131,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
 
     id,
 
-    // Status
-    disabled = false,
+    disabled: rawDisabled = false,
     keyboard = true,
     autoFocus,
     onFocus,
@@ -188,6 +187,24 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
   const handlesRef = React.useRef<HandlesRef>(null);
   const containerRef = React.useRef<HTMLDivElement>(null);
 
+  // ============================ Disabled ============================
+  const disabled = React.useMemo(() => {
+    if (typeof rawDisabled === 'boolean') {
+      return rawDisabled;
+    }
+    return rawDisabled.every((d) => d);
+  }, [rawDisabled]);
+
+  const isHandleDisabled = React.useCallback(
+    (index: number) => {
+      if (typeof rawDisabled === 'boolean') {
+        return rawDisabled;
+      }
+      return rawDisabled[index] || false;
+    },
+    [rawDisabled],
+  );
+
   const direction = React.useMemo<Direction>(() => {
     if (vertical) {
       return reverse ? 'ttb' : 'btt';
@@ -247,6 +264,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
     markList,
     allowCross,
     mergedPush,
+    isHandleDisabled,
   );
 
   // ============================ Values ============================
@@ -321,7 +339,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
   });
 
   const onDelete = (index: number) => {
-    if (disabled || !rangeEditable || rawValues.length <= minCount) {
+    if (disabled || !rangeEditable || rawValues.length <= minCount || isHandleDisabled(index)) {
       return;
     }
 
@@ -348,6 +366,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
     offsetValues,
     rangeEditable,
     minCount,
+    isHandleDisabled,
   );
 
   /**
@@ -378,10 +397,39 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
       let focusIndex = valueIndex;
 
       if (rangeEditable && valueDist !== 0 && (!maxCount || rawValues.length < maxCount)) {
+        const leftDisabled = isHandleDisabled(valueBeforeIndex);
+        const rightDisabled = isHandleDisabled(valueBeforeIndex + 1);
+
+        if (leftDisabled && rightDisabled) {
+          return;
+        }
+
         cloneNextValues.splice(valueBeforeIndex + 1, 0, newValue);
         focusIndex = valueBeforeIndex + 1;
       } else {
+        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;
+        }
         cloneNextValues[valueIndex] = newValue;
+        focusIndex = valueIndex;
       }
 
       // Fill value to match default 2 (only when `rawValues` is empty)
@@ -443,7 +491,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
   const [keyboardValue, setKeyboardValue] = React.useState<number>(null);
 
   const onHandleOffsetChange = (offset: number | 'min' | 'max', valueIndex: number) => {
-    if (!disabled) {
+    if (!disabled && !isHandleDisabled(valueIndex)) {
       const next = offsetValues(rawValues, offset, valueIndex);
 
       onBeforeChange?.(getTriggerValue(rawValues));
@@ -546,6 +594,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
       ariaValueTextFormatterForHandle,
       styles: styles || {},
       classNames: classNames || {},
+      isHandleDisabled,
     }),
     [
       mergedMin,
@@ -565,6 +614,7 @@ const Slider = React.forwardRef<SliderRef, SliderProps<number | number[]>>((prop
       ariaValueTextFormatterForHandle,
       styles,
       classNames,
+      isHandleDisabled,
     ],
   );
 

src/Tracks/index.tsx

@@ -14,8 +14,18 @@ export interface TrackProps {
 }
 
 const Tracks: React.FC<TrackProps> = (props) => {
-  const { prefixCls, style, values, startPoint, onStartMove } = props;
-  const { included, range, min, styles, classNames } = React.useContext(SliderContext);
+  const { prefixCls, style, values, startPoint, onStartMove: propsOnStartMove } = props;
+  const { included, range, min, styles, classNames, isHandleDisabled } = React.useContext(SliderContext);
+
+  const hasDisabledHandle = React.useMemo(() => {
+    if (!isHandleDisabled) return false;
+    for (let i = 0; i < values.length; i++) {
+      if (isHandleDisabled(i)) return true;
+    }
+    return false;
+  }, [isHandleDisabled, values.length]);
+
+  const onStartMove = hasDisabledHandle ? undefined : propsOnStartMove;
 
   // =========================== List ===========================
   const trackList = React.useMemo(() => {

src/context.ts

@@ -19,6 +19,7 @@ export interface SliderContextProps {
   ariaValueTextFormatterForHandle?: AriaValueFormat | AriaValueFormat[];
   classNames: SliderClassNames;
   styles: SliderStyles;
+  isHandleDisabled?: (index: number) => boolean;
 }
 
 const SliderContext = React.createContext<SliderContextProps>({

src/hooks/useDrag.ts

@@ -26,6 +26,7 @@ function useDrag(
   offsetValues: OffsetValues,
   editable: boolean,
   minCount: number,
+  isHandleDisabled?: (index: number) => boolean,
 ): [
   draggingIndex: number,
   draggingValue: number,
@@ -91,6 +92,10 @@ function useDrag(
     (valueIndex: number, offsetPercent: number, deleteMark: boolean) => {
       if (valueIndex === -1) {
         // >>>> Dragging on the track
+        if (isHandleDisabled && originValues.some((_, index) => isHandleDisabled(index))) {
+          return;
+        }
+
         const startValue = originValues[0];
         const endValue = originValues[originValues.length - 1];
         const maxStartOffset = min - startValue;
@@ -126,6 +131,10 @@ function useDrag(
 
     // 如果是点击 track 触发的，需要传入变化后的初始值，而不能直接用 rawValues
     const initialValues = startValues || rawValues;
+    if (isHandleDisabled && isHandleDisabled(valueIndex)) {
+      return;
+    }
+
     const originValue = initialValues[valueIndex];
 
     setDraggingIndex(valueIndex);