bump 5.1.0

Extend the handle classNames, and provide props so that
upper/lower handles are easily distinguishable in CSS & React.

* Use classNames() instead of string concatenation

.gitignore

@@ -23,4 +23,5 @@ node_modules
 dist
 assets/**/*.css
 build
-lib
+lib
+/coverage

.travis.yml

@@ -29,8 +29,8 @@ script:
 env:
   matrix:
   - TEST_TYPE=lint
-  - TEST_TYPE=browser-test
-  - TEST_TYPE=browser-test-cover
+  - TEST_TYPE=test
+  - TEST_TYPE=coverage
   - TEST_TYPE=saucelabs
   global:
   - secure: S1VwbaPzLnSH/IUT/wlJulxAX5VHRIDmSt53h/ycHcZsszUpWcLCJRQAe0fTVB2dAx5MdBbSZ+o+tr3tRwVB5TRAYm0oTCsYAkOZaWOB28RuUQtdGt3wf9xxTG1UiPiaLLUW3waX9zAaf3yqKBcJGf1op0RD8dksxbCFw/7xVbU=
@@ -39,4 +39,4 @@ env:
 
 matrix:
   allow_failures:
-  - env: "TEST_TYPE=saucelabs"
+  - env: "TEST_TYPE=saucelabs"

HISTORY.md

@@ -1,6 +1,10 @@
 # History
 ----
 
+## 4.0.0 / 2016-08-12
+
+[#133](https://github.com/react-component/slider/pull/133) support multi-range ([@sosz](https://github.com/sosz))
+
 ## 3.6.0 / 2016-04-01
 
 [#18](https://github.com/react-component/slider/issues/18) add `vertical` props ([@wnlee](https://github.com/WNLee))

README.md

@@ -34,6 +34,8 @@ slider ui component for react
 
 <img src="https://t.alipayobjects.com/images/T1wO8fXd4rXXXXXXXX.png" width="550"/>
 
+<img src="http://i.giphy.com/l46Cs36c9HrHMExoc.gif"/>
+
 
 ## Feature
 
@@ -50,6 +52,8 @@ slider ui component for react
 ## Usage
 
 ```js
+require('rc-slider/assets/index.css');
+
 var React = require('react');
 var ReactDOM = require('react-dom');
 var Rcslider = require('rc-slider');
@@ -102,15 +106,21 @@ ReactDOM.render(<Rcslider />, container);
         </tr>
         <tr>
           <td>range</td>
-          <td>boolean</td>
+          <td>boolean or number</td>
           <td>false</td>
-          <td>Determines the type of slider. If range is `true`, two handles will be rendered in order to select a range.</td>
+          <td>Determines the type of slider. If range is `true`, two handles will be rendered in order to select a range. If range is a number, multiple handles will be rendered (number + 1). Using `range={true}` is equivalent to `range={1}`.</td>
         </tr>
         <tr>
           <td>allowCross</td>
           <td>boolean</td>
           <td>true</td>
-          <td>When `range` is `true`, `allowCross` could be set as `true` to allow those two handles cross.</td>
+          <td>When `range` is `true`, `allowCross` could be set as `true` to allow those handles to cross.</td>
+        </tr>
+        <tr>
+          <td>pushable</td>
+          <td>boolean or number</td>
+          <td>true</td>
+          <td>When `range` is `true`, `pushable` could be set as `true` to allow pushing of surrounding handles when moving an handle. When set to a number, the number will be the minimum ensured distance between handles. Example: <img src="http://i.giphy.com/l46Cs36c9HrHMExoc.gif"/></td>
         </tr>
         <tr>
           <td>vertical</td>
@@ -120,15 +130,15 @@ ReactDOM.render(<Rcslider />, container);
         </tr>
         <tr>
           <td>defaultValue</td>
-          <td>number or [number, number]</td>
+          <td>number or [number, number, ...]</td>
           <td>0 or [0, 0]</td>
-          <td>Set initial positions of handles. If range is `false`, the type of `defaultValue` should be `number`. Otherwise, `[number, number]`</td>
+          <td>Set initial positions of handles. If range is `false`, the type of `defaultValue` should be `number`. Otherwise, `[number, number, ...]`</td>
         </tr>
         <tr>
           <td>value</td>
-          <td>number or [number, number]</td>
+          <td>number or [number, number, ...]</td>
           <td></td>
-          <td>Set current positions of handles. If range is `false`, the type of `defaultValue` should be `number`. Otherwise, `[number, number]`</td>
+          <td>Set current positions of handles. If range is `false`, the type of `defaultValue` should be `number`. Otherwise, `[number, number, ...]`</td>
         </tr>
         <tr>
           <td>handle</td>

assets/index.less

@@ -36,7 +36,6 @@
     height: 4px;
     border-radius: @border-radius-base;
     background-color: tint(@primary-color, 60%);
-    z-index: 1;
   }
 
   &-handle {
@@ -49,7 +48,6 @@
     border-radius: 50%;
     border: solid 2px tint(@primary-color, 50%);
     background-color: #fff;
-    z-index: 2;
 
     &:hover {
       border-color: tint(@primary-color, 20%);
@@ -68,7 +66,6 @@
     left: 0;
     width: 100%;
     font-size: 12px;
-    z-index: 3;
   }
 
   &-mark-text {
@@ -89,7 +86,6 @@
     width: 100%;
     height: 4px;
     background: transparent;
-    z-index: 1;
   }
 
   &-dot {
@@ -232,11 +228,10 @@
   }
 }
 
-.rc-tooltip {
+.@{prefixClass}-tooltip {
   position: absolute;
   left: -9999px;
   top: -9999px;
-  z-index: 4;
   visibility: visible;
 
   .borderBox();
@@ -278,4 +273,4 @@
     border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
     border-top-color: @tooltip-arrow-color;
   }
-}
+}

examples/custom-handles.js

@@ -4,7 +4,7 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const wrapperStyle = {width: 400, margin: 50};
+const wrapperStyle = { width: 400, margin: 50 };
 
 const handleStyle = {
   position: 'absolute',
@@ -16,11 +16,10 @@ const handleStyle = {
   background: '#fff',
   fontSize: '14px',
   textAlign: 'center',
-  zIndex: 3,
 };
 
 const CustomHandle = props => {
-  const style = Object.assign({left: props.offset + '%'}, handleStyle);
+  const style = Object.assign({ left: `${props.offset}%` }, handleStyle);
   return (
     <div style={style}>val: {props.value}</div>
   );
@@ -40,5 +39,6 @@ ReactDOM.render(
       <p>Slider with custom handle</p>
       <Slider min={0} max={20} defaultValue={3} handle={<CustomHandle />} />
     </div>
-  </div>
-  , document.getElementById('__react-content'));
+  </div>,
+  document.getElementById('__react-content')
+);

examples/marks.js

@@ -4,7 +4,7 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const style = {width: 400, margin: 50};
+const style = { width: 400, margin: 50 };
 const marks = {
   '-10': '-10°C',
   0: <strong>0°C</strong>,

examples/range.js

@@ -5,37 +5,37 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const style = {width: 400, margin: 50};
+const style = { width: 400, margin: 50 };
 
 function log(value) {
   console.log(value);
 }
 
 const CustomizedRange = React.createClass({
-  getInitialState: function() {
+  getInitialState() {
     return {
       lowerBound: 20,
       upperBound: 40,
       value: [20, 40],
     };
   },
-  onLowerBoundChange: function(e) {
+  onLowerBoundChange(e) {
     this.setState({ lowerBound: +e.target.value });
   },
-  onUpperBoundChange: function(e) {
+  onUpperBoundChange(e) {
     this.setState({ upperBound: +e.target.value });
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
     this.setState({
-      value: value,
+      value,
     });
   },
-  handleApply: function() {
+  handleApply() {
     const { lowerBound, upperBound } = this.state;
-    this.setState({ value: [lowerBound, upperBound]});
+    this.setState({ value: [lowerBound, upperBound] });
   },
-  render: function() {
+  render() {
     return (
       <div>
         <label>LowerBound: </label>
@@ -59,20 +59,20 @@ const DynamicBounds = React.createClass({
       max: 100,
     };
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
   },
-  onMinChange: function(e) {
+  onMinChange(e) {
     this.setState({
       min: +e.target.value || 0,
     });
   },
-  onMaxChange: function(e) {
+  onMaxChange(e) {
     this.setState({
       max: +e.target.value || 100,
     });
   },
-  render: function() {
+  render() {
     return (
       <div>
         <label>Min: </label>
@@ -81,7 +81,9 @@ const DynamicBounds = React.createClass({
         <label>Max: </label>
         <input type="number" value={this.state.max} onChange={this.onMaxChange} />
         <br /><br />
-        <Slider range defaultValue={[20, 50]} min={this.state.min} max={this.state.max} onChange={this.onSliderChange} />
+        <Slider range defaultValue={[20, 50]} min={this.state.min} max={this.state.max}
+          onChange={this.onSliderChange}
+        />
       </div>
     );
   },
@@ -105,6 +107,10 @@ ReactDOM.render(
       <p>Controlled Range</p>
       <Slider range value={[20, 40]} />
     </div>
+    <div style={style}>
+      <p>Multi Range</p>
+      <Slider range={3} value={[20, 40, 60, 80]} />
+    </div>
     <div style={style}>
       <p>Customized Range</p>
       <CustomizedRange />

examples/slider.js

@@ -5,7 +5,7 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const style = {width: 400, margin: 50};
+const style = { width: 400, margin: 50 };
 
 function log(value) {
   console.log(value);
@@ -13,50 +13,54 @@ function log(value) {
 
 
 function percentFormatter(v) {
-  return v + ' %';
+  return `${v} %`;
 }
 
 const CustomizedSlider = React.createClass({
-  getInitialState: function() {
+  getInitialState() {
     return {
       value: 50,
     };
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
     this.setState({
-      value: value,
+      value,
     });
   },
-  onAfterChange: function(value) {
+  onAfterChange(value) {
     console.log(value);
   },
-  render: function() {
-    return <Slider value={this.state.value} onChange={this.onSliderChange} onAfterChange={this.onAfterChange} />;
+  render() {
+    return (
+      <Slider value={this.state.value}
+        onChange={this.onSliderChange} onAfterChange={this.onAfterChange}
+      />
+    );
   },
 });
 
 const DynamicBounds = React.createClass({
-  getInitialState: function() {
+  getInitialState() {
     return {
       min: 0,
       max: 100,
     };
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
   },
-  onMinChange: function(e) {
+  onMinChange(e) {
     this.setState({
       min: +e.target.value || 0,
     });
   },
-  onMaxChange: function(e) {
+  onMaxChange(e) {
     this.setState({
       max: +e.target.value || 100,
     });
   },
-  render: function() {
+  render() {
     return (
       <div>
         <label>Min: </label>
@@ -65,7 +69,9 @@ const DynamicBounds = React.createClass({
         <label>Max: </label>
         <input type="number" value={this.state.max} onChange={this.onMaxChange} />
         <br /><br />
-        <Slider defaultValue={50} min={this.state.min} max={this.state.max} onChange={this.onSliderChange} />
+        <Slider defaultValue={50} min={this.state.min} max={this.state.max}
+          onChange={this.onSliderChange}
+        />
       </div>
     );
   },
@@ -87,7 +93,9 @@ ReactDOM.render(
     </div>
     <div style={style}>
       <p>Basic Slider with `tipFormatter`</p>
-      <Slider tipFormatter={percentFormatter} tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log} />
+      <Slider tipFormatter={percentFormatter}
+        tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log}
+      />
     </div>
     <div style={style}>
       <p>Basic Slider without tooltip</p>

examples/v-marks.js

@@ -4,8 +4,8 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const style = {float: 'left', width: 160, height: 400, marginBottom: 160, marginLeft: 50};
-const parentStyle = {overflow: 'hidden'};
+const style = { float: 'left', width: 160, height: 400, marginBottom: 160, marginLeft: 50 };
+const parentStyle = { overflow: 'hidden' };
 
 const marks = {
   '-10': '-10°C',
@@ -49,7 +49,9 @@ ReactDOM.render(
     </div>
     <div style={style}>
       <p>Range with marks and steps</p>
-      <Slider vertical min={-10} range marks={marks} step={10} onChange={log} defaultValue={[20, 40]} />
+      <Slider vertical min={-10} range marks={marks} step={10}
+        onChange={log} defaultValue={[20, 40]}
+      />
     </div>
   </div>
   , document.getElementById('__react-content'));

examples/v-range.js

@@ -5,41 +5,43 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const style = {float: 'left', width: 180, height: 400, marginBottom: 160, marginLeft: 50};
-const parentStyle = {overflow: 'hidden'};
+const style = { float: 'left', width: 180, height: 400, marginBottom: 160, marginLeft: 50 };
+const parentStyle = { overflow: 'hidden' };
 
 function log(value) {
   console.log(value);
 }
 
 const CustomizedRange = React.createClass({
-  getInitialState: function() {
+  getInitialState() {
     return {
       lowerBound: 20,
       upperBound: 40,
       value: [20, 40],
     };
   },
-  onLowerBoundChange: function(e) {
+  onLowerBoundChange(e) {
     this.setState({ lowerBound: +e.target.value });
   },
-  onUpperBoundChange: function(e) {
+  onUpperBoundChange(e) {
     this.setState({ upperBound: +e.target.value });
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
     this.setState({
-      value: value,
+      value,
     });
   },
-  handleApply: function() {
+  handleApply() {
     const { lowerBound, upperBound } = this.state;
-    this.setState({ value: [lowerBound, upperBound]});
+    this.setState({ value: [lowerBound, upperBound] });
   },
-  render: function() {
+  render() {
     return (
       <div style={style}>
-        <Slider range vertical allowCross={false} value={this.state.value} onChange={this.onSliderChange} />
+        <Slider range vertical allowCross={false} value={this.state.value}
+          onChange={this.onSliderChange}
+        />
         <label>LowerBound: </label>
         <input type="number" value={this.state.lowerBound} onChange={this.onLowerBoundChange} />
         <br />
@@ -59,23 +61,25 @@ const DynamicBounds = React.createClass({
       max: 100,
     };
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
   },
-  onMinChange: function(e) {
+  onMinChange(e) {
     this.setState({
       min: +e.target.value || 0,
     });
   },
-  onMaxChange: function(e) {
+  onMaxChange(e) {
     this.setState({
       max: +e.target.value || 100,
     });
   },
-  render: function() {
+  render() {
     return (
       <div style={style}>
-        <Slider range vertical defaultValue={[20, 50]} min={this.state.min} max={this.state.max} onChange={this.onSliderChange} />
+        <Slider range vertical defaultValue={[20, 50]} min={this.state.min} max={this.state.max}
+          onChange={this.onSliderChange}
+        />
         <label>Min: </label>
         <input type="number" value={this.state.min} onChange={this.onMinChange} />
         <br />

examples/v-slider.js

@@ -5,8 +5,8 @@ const React = require('react');
 const ReactDOM = require('react-dom');
 const Slider = require('rc-slider');
 
-const style = {float: 'left', width: 200, height: 400, marginBottom: 160, marginLeft: 50};
-const parentStyle = {overflow: 'hidden'};
+const style = { float: 'left', width: 200, height: 400, marginBottom: 160, marginLeft: 50 };
+const parentStyle = { overflow: 'hidden' };
 
 function log(value) {
   console.log(value);
@@ -14,51 +14,53 @@ function log(value) {
 
 
 function percentFormatter(v) {
-  return v + ' %';
+  return `${v} %`;
 }
 
 const CustomizedSlider = React.createClass({
-  getInitialState: function() {
+  getInitialState() {
     return {
       value: 50,
     };
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
     this.setState({
-      value: value,
+      value,
     });
   },
-  render: function() {
+  render() {
     return <Slider vertical value={this.state.value} onChange={this.onSliderChange} />;
   },
 });
 
 const DynamicBounds = React.createClass({
-  getInitialState: function() {
+  getInitialState() {
     return {
       min: 0,
       max: 100,
     };
   },
-  onSliderChange: function(value) {
+  onSliderChange(value) {
     log(value);
   },
-  onMinChange: function(e) {
+  onMinChange(e) {
     this.setState({
       min: +e.target.value || 0,
     });
   },
-  onMaxChange: function(e) {
+  onMaxChange(e) {
     this.setState({
       max: +e.target.value || 100,
     });
   },
-  render: function() {
+  render() {
     return (
       <div style={style}>
         <p>Slider with dynamic `min` `max`</p>
-        <Slider vertical defaultValue={50} min={this.state.min} max={this.state.max} onChange={this.onSliderChange} />
+        <Slider vertical defaultValue={50} min={this.state.min} max={this.state.max}
+          onChange={this.onSliderChange}
+        />
         <label>Min: </label>
         <input type="number" value={this.state.min} onChange={this.onMinChange} />
         <br />
@@ -85,7 +87,9 @@ ReactDOM.render(
     </div>
     <div style={style}>
       <p>Basic Slider with `tipFormatter`</p>
-      <Slider vertical tipFormatter={percentFormatter} tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log} />
+      <Slider vertical tipFormatter={percentFormatter}
+        tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log}
+      />
     </div>
     <div style={style}>
       <p>Basic Slider without tooltip</p>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rc-slider",
-  "version": "3.7.4",
+  "version": "5.1.0",
   "description": "slider ui component for react",
   "keywords": [
     "react",
@@ -23,25 +23,26 @@
   ],
   "licenses": "MIT",
   "main": "./lib/index.js",
+  "style": "./assets/index.css",
   "config": {
     "port": 8005
   },
   "scripts": {
     "build": "rc-tools run build",
     "gh-pages": "rc-tools run gh-pages",
-    "start": "rc-server",
-    "pub": "rc-tools run pub",
+    "start": "rc-tools run server",
+    "pub": "rc-tools run pub --babel-runtime",
     "lint": "rc-tools run lint",
     "karma": "rc-tools run karma",
     "saucelabs": "rc-tools run saucelabs",
-    "browser-test": "rc-tools run browser-test",
-    "browser-test-cover": "rc-tools run browser-test-cover"
+    "test": "rc-tools run test",
+    "chrome-test": "rc-tools run chrome-test",
+    "coverage": "rc-tools run coverage"
   },
   "devDependencies": {
     "expect.js": "0.3.x",
     "pre-commit": "1.x",
-    "rc-server": "3.x",
-    "rc-tools": "4.x",
+    "rc-tools": "^5.6.8",
     "react": "^15.2.1",
     "react-addons-test-utils": "^15.2.1",
     "react-dom": "^15.2.1"
@@ -50,6 +51,7 @@
     "lint"
   ],
   "dependencies": {
+    "babel-runtime": "6.x",
     "classnames": "^2.2.5",
     "rc-tooltip": "^3.4.2",
     "rc-util": "^3.2.1",

src/Handle.jsx

@@ -23,34 +23,51 @@ export default class Handle extends React.Component {
   }
 
   render() {
-    const props = this.props;
-    const {className, tipTransitionName, tipFormatter, vertical, offset, value} = props;
-    const {dragging, noTip} = props;
+    const {
+      prefixCls,
+      tooltipPrefixCls,
+      className,
+      tipTransitionName,
+      tipFormatter,
+      vertical,
+      offset,
+      value,
+      dragging,
+      noTip,
+    } = this.props;
 
-    const style = vertical ? { bottom: offset + '%' } : { left: offset + '%' };
-    const handle = (<div className={className} style={style}
-                      onMouseUp={this.showTooltip.bind(this)}
-                      onMouseEnter={this.showTooltip.bind(this)}
-                      onMouseLeave={this.hideTooltip.bind(this)}/>);
+    const style = vertical ? { bottom: `${offset}%` } : { left: `${offset}%` };
+    const handle = (
+      <div className={className} style={style}
+        onMouseUp={this.showTooltip.bind(this)}
+        onMouseEnter={this.showTooltip.bind(this)}
+        onMouseLeave={this.hideTooltip.bind(this)}
+      />
+    );
 
     if (noTip) {
       return handle;
     }
 
     const isTooltipVisible = dragging || this.state.isTooltipVisible;
-    return (<Tooltip
-              prefixCls={className.replace('slider-handle', 'tooltip')}
-              placement="top"
-              visible={isTooltipVisible}
-              overlay={<span>{tipFormatter(value)}</span>}
-              delay={0}
-              transitionName={tipTransitionName}>
-              {handle}
-            </Tooltip>);
+    return (
+      <Tooltip
+        prefixCls={tooltipPrefixCls || `${prefixCls}-tooltip`}
+        placement="top"
+        visible={isTooltipVisible}
+        overlay={<span>{tipFormatter(value)}</span>}
+        delay={0}
+        transitionName={tipTransitionName}
+      >
+        {handle}
+      </Tooltip>
+    );
   }
 }
 
 Handle.propTypes = {
+  prefixCls: React.PropTypes.string,
+  tooltipPrefixCls: React.PropTypes.string,
   className: React.PropTypes.string,
   vertical: React.PropTypes.bool,
   offset: React.PropTypes.number,

src/Marks.jsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import classNames from 'classnames';
 
-const Marks = ({className, vertical, marks, included, upperBound, lowerBound, max, min}) => {
+const Marks = ({ className, vertical, marks, included, upperBound, lowerBound, max, min }) => {
   const marksKeys = Object.keys(marks);
   const marksCount = marksKeys.length;
   const unit = 100 / (marksCount - 1);
@@ -12,20 +12,20 @@ const Marks = ({className, vertical, marks, included, upperBound, lowerBound, ma
     const isActived = (!included && point === upperBound) ||
             (included && point <= upperBound && point >= lowerBound);
     const markClassName = classNames({
-      [className + '-text']: true,
-      [className + '-text-active']: isActived,
+      [`${className}-text`]: true,
+      [`${className}-text-active`]: isActived,
     });
 
     const bottomStyle = {
       // height: markWidth + '%',
-      marginBottom: '-200' + '%',
-      bottom: (point - min) / range * 100 + '%',
+      marginBottom: '-200%',
+      bottom: `${(point - min) / range * 100}%`,
     };
 
     const leftStyle = {
-      width: markWidth + '%',
-      marginLeft: -markWidth / 2 + '%',
-      left: (point - min) / range * 100 + '%',
+      width: `${markWidth}%`,
+      marginLeft: `${-markWidth / 2}%`,
+      left: `${(point - min) / range * 100}%`,
     };
 
     const style = vertical ? bottomStyle : leftStyle;

src/Slider.jsx

@@ -5,6 +5,7 @@ import Track from './Track';
 import DefaultHandle from './Handle';
 import Steps from './Steps';
 import Marks from './Marks';
+import warning from 'warning';
 
 function noop() {
 }
@@ -30,64 +31,56 @@ class Slider extends React.Component {
   constructor(props) {
     super(props);
 
-    const {range, min, max} = props;
-    const initialValue = range ? [min, min] : min;
+    const { range, min, max, step } = props;
+    const initialValue = range ? Array.apply(null, Array(range + 1)).map(() => min) : min;
     const defaultValue = ('defaultValue' in props ? props.defaultValue : initialValue);
     const value = (props.value !== undefined ? props.value : defaultValue);
 
-    let upperBound;
-    let lowerBound;
-    if (props.range) {
-      lowerBound = this.trimAlignValue(value[0]);
-      upperBound = this.trimAlignValue(value[1]);
-    } else {
-      upperBound = this.trimAlignValue(value);
-    }
+    const bounds = (range ? value : [min, value]).map(v => this.trimAlignValue(v));
 
     let recent;
-    if (props.range && upperBound === lowerBound) {
-      recent = lowerBound === max ? 'lowerBound' : 'upperBound';
+    if (range && bounds[0] === bounds[bounds.length - 1] && bounds[0] === max) {
+      recent = 0;
     } else {
-      recent = 'upperBound';
+      recent = bounds.length - 1;
+    }
+
+    if (process.env.NODE_ENV !== 'production' && (max - min) % step !== 0) {
+      warning(
+        false,
+        'Slider[max] - Slider[min] (%s) should be a multiple of Slider[step] (%s)',
+        max - min,
+        step
+      );
     }
 
     this.state = {
       handle: null,
-      recent: recent,
-      upperBound: upperBound,
-      // If Slider is not range, set `lowerBound` equal to `min`.
-      lowerBound: (lowerBound || min),
+      recent,
+      bounds,
     };
   }
 
   componentWillReceiveProps(nextProps) {
     if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
 
-    const {lowerBound, upperBound} = this.state;
+    const { bounds } = this.state;
     if (nextProps.range) {
-      const value = nextProps.value || [lowerBound, upperBound];
-      const nextUpperBound = this.trimAlignValue(value[1], nextProps);
-      const nextLowerBound = this.trimAlignValue(value[0], nextProps);
-      if (nextLowerBound === lowerBound && nextUpperBound === upperBound) return;
+      const value = nextProps.value || bounds;
+      const nextBounds = value.map(v => this.trimAlignValue(v, nextProps));
+      if (nextBounds.every((v, i) => v === bounds[i])) return;
 
-      this.setState({
-        upperBound: nextUpperBound,
-        lowerBound: nextLowerBound,
-      });
-      if (this.isValueOutOfBounds(upperBound, nextProps) ||
-        this.isValueOutOfBounds(lowerBound, nextProps)) {
-        this.props.onChange([nextLowerBound, nextUpperBound]);
+      this.setState({ bounds: nextBounds });
+      if (bounds.some(v => this.isValueOutOfBounds(v, nextProps))) {
+        this.props.onChange(nextBounds);
       }
     } else {
-      const value = nextProps.value !== undefined ? nextProps.value : upperBound;
+      const value = nextProps.value !== undefined ? nextProps.value : bounds[1];
       const nextValue = this.trimAlignValue(value, nextProps);
-      if (nextValue === upperBound && lowerBound === nextProps.min) return;
+      if (nextValue === bounds[1] && bounds[0] === nextProps.min) return;
 
-      this.setState({
-        upperBound: nextValue,
-        lowerBound: nextProps.min,
-      });
-      if (this.isValueOutOfBounds(upperBound, nextProps)) {
+      this.setState({ bounds: [nextProps.min, nextValue] });
+      if (this.isValueOutOfBounds(bounds[1], nextProps)) {
         this.props.onChange(nextValue);
       }
     }
@@ -99,11 +92,11 @@ class Slider extends React.Component {
     if (isNotControlled) {
       this.setState(state);
     } else if (state.handle) {
-      this.setState({handle: state.handle});
+      this.setState({ handle: state.handle });
     }
 
-    const data = {...this.state, ...state};
-    const changedValue = props.range ? [data.lowerBound, data.upperBound] : data.upperBound;
+    const data = { ...this.state, ...state };
+    const changedValue = props.range ? data.bounds : data.bounds[1];
     props.onChange(changedValue);
   }
 
@@ -132,28 +125,22 @@ class Slider extends React.Component {
     const diffValue = diffPosition / this.getSliderLength() * (props.max - props.min);
 
     const value = this.trimAlignValue(this.startValue + diffValue);
-    const oldValue = state[state.handle];
+    const oldValue = state.bounds[state.handle];
     if (value === oldValue) return;
 
-    if (props.allowCross && value < state.lowerBound && state.handle === 'upperBound') {
-      this.onChange({
-        handle: 'lowerBound',
-        lowerBound: value,
-        upperBound: this.state.lowerBound,
-      });
-      return;
+    const nextBounds = [...state.bounds];
+    nextBounds[state.handle] = value;
+    let nextHandle = state.handle;
+    if (props.pushable !== false) {
+      const originalValue = state.bounds[nextHandle];
+      this.pushSurroundingHandles(nextBounds, nextHandle, originalValue);
+    } else if (props.allowCross) {
+      nextBounds.sort((a, b) => a - b);
+      nextHandle = nextBounds.indexOf(value);
     }
-    if (props.allowCross && value > state.upperBound && state.handle === 'lowerBound') {
-      this.onChange({
-        handle: 'upperBound',
-        upperBound: value,
-        lowerBound: this.state.upperBound,
-      });
-      return;
-    }
-
     this.onChange({
-      [state.handle]: value,
+      handle: nextHandle,
+      bounds: nextBounds,
     });
   }
 
@@ -183,22 +170,26 @@ class Slider extends React.Component {
     this.startPosition = position;
 
     const state = this.state;
-    const {upperBound, lowerBound} = state;
+    const { bounds } = state;
 
-    let valueNeedChanging = 'upperBound';
+    let valueNeedChanging = 1;
     if (this.props.range) {
-      const isLowerBoundCloser = Math.abs(upperBound - value) > Math.abs(lowerBound - value);
-      if (isLowerBoundCloser) {
-        valueNeedChanging = 'lowerBound';
+      let closestBound = 0;
+      for (let i = 1; i < bounds.length - 1; ++i) {
+        if (value > bounds[i]) { closestBound = i; }
       }
+      if (Math.abs(bounds[closestBound + 1] - value) < Math.abs(bounds[closestBound] - value)) {
+        closestBound = closestBound + 1;
+      }
+      valueNeedChanging = closestBound;
 
-      const isAtTheSamePoint = (upperBound === lowerBound);
+      const isAtTheSamePoint = (bounds[closestBound + 1] === bounds[closestBound]);
       if (isAtTheSamePoint) {
         valueNeedChanging = state.recent;
       }
 
-      if (isAtTheSamePoint && (value !== upperBound)) {
-        valueNeedChanging = value < upperBound ? 'lowerBound' : 'upperBound';
+      if (isAtTheSamePoint && (value !== bounds[closestBound + 1])) {
+        valueNeedChanging = value < bounds[closestBound + 1] ? closestBound : closestBound + 1;
       }
     }
 
@@ -207,17 +198,17 @@ class Slider extends React.Component {
       recent: valueNeedChanging,
     });
 
-    const oldValue = state[valueNeedChanging];
+    const oldValue = state.bounds[valueNeedChanging];
     if (value === oldValue) return;
 
-    this.onChange({
-      [valueNeedChanging]: value,
-    });
+    const nextBounds = [...state.bounds];
+    nextBounds[valueNeedChanging] = value;
+    this.onChange({ bounds: nextBounds });
   }
 
   getValue() {
-    const {lowerBound, upperBound} = this.state;
-    return this.props.range ? [lowerBound, upperBound] : upperBound;
+    const { bounds } = this.state;
+    return this.props.range ? bounds : bounds[1];
   }
 
   getSliderLength() {
@@ -245,14 +236,35 @@ class Slider extends React.Component {
     return precision;
   }
 
+  /**
+   * Returns an array of possible slider points, taking into account both
+   * `marks` and `step`. The result is cached.
+   */
+  getPoints() {
+    const { marks, step, min, max } = this.props;
+    const cache = this._getPointsCache;
+    if (!cache || cache.marks !== marks || cache.step !== step) {
+      const pointsObject = { ...marks };
+      if (step !== null) {
+        for (let point = min; point <= max; point += step) {
+          pointsObject[point] = point;
+        }
+      }
+      const points = Object.keys(pointsObject).map(parseFloat);
+      points.sort((a, b) => a - b);
+      this._getPointsCache = { marks, step, points };
+    }
+    return this._getPointsCache.points;
+  }
+
   isValueOutOfBounds(value, props) {
     return value < props.min || value > props.max;
   }
 
   trimAlignValue(v, nextProps) {
     const state = this.state || {};
-    const {handle, lowerBound, upperBound} = state;
-    const {marks, step, min, max, allowCross} = {...this.props, ...(nextProps || {})};
+    const { handle, bounds } = state;
+    const { marks, step, min, max, allowCross } = { ...this.props, ...(nextProps || {}) };
 
     let val = v;
     if (val <= min) {
@@ -261,12 +273,14 @@ class Slider extends React.Component {
     if (val >= max) {
       val = max;
     }
-    if (!allowCross && handle === 'upperBound' && val <= lowerBound) {
-      val = lowerBound;
+    /* eslint-disable eqeqeq */
+    if (!allowCross && handle != null && handle > 0 && val <= bounds[handle - 1]) {
+      val = bounds[handle - 1];
     }
-    if (!allowCross && handle === 'lowerBound' && val >= upperBound) {
-      val = upperBound;
+    if (!allowCross && handle != null && handle < bounds.length - 1 && val >= bounds[handle + 1]) {
+      val = bounds[handle + 1];
     }
+    /* eslint-enable eqeqeq */
 
     const points = Object.keys(marks).map(parseFloat);
     if (step !== null) {
@@ -280,14 +294,72 @@ class Slider extends React.Component {
     return step !== null ? parseFloat(closestPoint.toFixed(this.getPrecision(step))) : closestPoint;
   }
 
+  pushHandleOnePoint(bounds, handle, direction) {
+    const points = this.getPoints();
+    const pointIndex = points.indexOf(bounds[handle]);
+    const nextPointIndex = pointIndex + direction;
+    if (nextPointIndex >= points.length || nextPointIndex < 0) {
+      // reached the minimum or maximum available point, can't push anymore
+      return false;
+    }
+    const nextHandle = handle + direction;
+    const nextValue = points[nextPointIndex];
+    const { pushable: threshold } = this.props;
+    const diffToNext = direction * (bounds[nextHandle] - nextValue);
+    if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {
+      // couldn't push next handle, so we won't push this one either
+      return false;
+    }
+    // push the handle
+    bounds[handle] = nextValue;
+    return true;
+  }
+
+  pushHandle(bounds, handle, direction, amount) {
+    const originalValue = bounds[handle];
+    let currentValue = bounds[handle];
+    while (direction * (currentValue - originalValue) < amount) {
+      if (!this.pushHandleOnePoint(bounds, handle, direction)) {
+        // can't push handle enough to create the needed `amount` gap, so we
+        // revert its position to the original value
+        bounds[handle] = originalValue;
+        return false;
+      }
+      currentValue = bounds[handle];
+    }
+    // the handle was pushed enough to create the needed `amount` gap
+    return true;
+  }
+
+  pushSurroundingHandles(bounds, handle, originalValue) {
+    const { pushable: threshold } = this.props;
+    const value = bounds[handle];
+
+    let direction = 0;
+    if (bounds[handle + 1] - value < threshold) {
+      direction = +1;
+    } else if (value - bounds[handle - 1] < threshold) {
+      direction = -1;
+    }
+
+    if (direction === 0) { return; }
+
+    const nextHandle = handle + direction;
+    const diffToNext = direction * (bounds[nextHandle] - value);
+    if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {
+      // revert to original value if pushing is impossible
+      bounds[handle] = originalValue;
+    }
+  }
+
   calcOffset(value) {
-    const {min, max} = this.props;
+    const { min, max } = this.props;
     const ratio = (value - min) / (max - min);
     return ratio * 100;
   }
 
   calcValue(offset) {
-    const {vertical, min, max} = this.props;
+    const { vertical, min, max } = this.props;
     const ratio = Math.abs(offset / this.getSliderLength());
     const value = vertical ? (1 - ratio) * (max - min) + min : ratio * (max - min) + min;
     return value;
@@ -302,11 +374,15 @@ class Slider extends React.Component {
   addDocumentEvents(type) {
     if (type === 'touch') {
       // just work for chrome iOS Safari and Android Browser
-      this.onTouchMoveListener = addEventListener(document, 'touchmove', this.onTouchMove.bind(this));
-      this.onTouchUpListener = addEventListener(document, 'touchend', this.end.bind(this, 'touch'));
+      this.onTouchMoveListener =
+        addEventListener(document, 'touchmove', this.onTouchMove.bind(this));
+      this.onTouchUpListener =
+        addEventListener(document, 'touchend', this.end.bind(this, 'touch'));
     } else if (type === 'mouse') {
-      this.onMouseMoveListener = addEventListener(document, 'mousemove', this.onMouseMove.bind(this));
-      this.onMouseUpListener = addEventListener(document, 'mouseup', this.end.bind(this, 'mouse'));
+      this.onMouseMoveListener =
+        addEventListener(document, 'mousemove', this.onMouseMove.bind(this));
+      this.onMouseUpListener =
+        addEventListener(document, 'mouseup', this.end.bind(this, 'mouse'));
     }
   }
 
@@ -323,54 +399,102 @@ class Slider extends React.Component {
   end(type) {
     this.removeEvents(type);
     this.props.onAfterChange(this.getValue());
-    this.setState({handle: null});
+    this.setState({ handle: null });
   }
 
   render() {
-    const {handle, upperBound, lowerBound} = this.state;
-    const {className, prefixCls, disabled, vertical, dots, included, range, step,
-      marks, max, min, tipTransitionName, tipFormatter, children} = this.props;
+    const {
+        handle,
+        bounds,
+    } = this.state;
+    const {
+        className,
+        prefixCls,
+        tooltipPrefixCls,
+        disabled,
+        vertical,
+        dots,
+        included,
+        range,
+        step,
+        marks,
+        max, min,
+        tipTransitionName,
+        tipFormatter,
+        children,
+    } = this.props;
 
     const customHandle = this.props.handle;
 
-    const upperOffset = this.calcOffset(upperBound);
-    const lowerOffset = this.calcOffset(lowerBound);
+    const offsets = bounds.map(v => this.calcOffset(v));
+
+    const handleClassName = `${prefixCls}-handle`;
+
+    const handlesClassNames = bounds.map((v, i) => classNames({
+      [handleClassName]: true,
+      [`${handleClassName}-${i + 1}`]: true,
+      [`${handleClassName}-lower`]: i === 0,
+      [`${handleClassName}-upper`]: i === bounds.length - 1,
+    }));
 
-    const handleClassName = prefixCls + '-handle';
     const isNoTip = (step === null) || (tipFormatter === null);
 
-    const upper = cloneElement(customHandle, { className: handleClassName,
-        noTip: isNoTip, tipTransitionName: tipTransitionName, tipFormatter: tipFormatter,
-        vertical: vertical, offset: upperOffset, value: upperBound, dragging: handle === 'upperBound' });
+    const commonHandleProps = {
+      prefixCls,
+      tooltipPrefixCls,
+      noTip: isNoTip,
+      tipTransitionName,
+      tipFormatter,
+      vertical,
+    };
 
-    let lower = null;
-    if (range) {
-      lower = cloneElement(customHandle, { className: handleClassName,
-        noTip: isNoTip, tipTransitionName: tipTransitionName, tipFormatter: tipFormatter,
-        vertical: vertical, offset: lowerOffset, value: lowerBound, dragging: handle === 'lowerBound' });
+    const handles = bounds.map((v, i) => cloneElement(customHandle, {
+      ...commonHandleProps,
+      className: handlesClassNames[i],
+      value: v,
+      offset: offsets[i],
+      dragging: handle === i,
+      key: i,
+    }));
+    if (!range) { handles.shift(); }
+
+    const isIncluded = included || range;
+
+    const tracks = [];
+    for (let i = 1; i < bounds.length; ++i) {
+      const trackClassName = classNames({
+        [`${prefixCls}-track`]: true,
+        [`${prefixCls}-track-${i}`]: true,
+      });
+      tracks.push(
+        <Track className={trackClassName} vertical={vertical} included={isIncluded}
+          offset={offsets[i - 1]} length={offsets[i] - offsets[i - 1]} key={i}
+        />
+      );
     }
 
     const sliderClassName = classNames({
       [prefixCls]: true,
-      [prefixCls + '-disabled']: disabled,
+      [`${prefixCls}-disabled`]: disabled,
       [className]: !!className,
-      [prefixCls + '-vertical']: this.props.vertical,
+      [`${prefixCls}-vertical`]: this.props.vertical,
     });
-    const isIncluded = included || range;
+
     return (
       <div ref="slider" className={sliderClassName}
-           onTouchStart={disabled ? noop : this.onTouchStart.bind(this)}
-           onMouseDown={disabled ? noop : this.onMouseDown.bind(this)}>
-        {upper}
-        {lower}
-        <Track className={prefixCls + '-track'} vertical = {vertical} included={isIncluded}
-               offset={lowerOffset} length={upperOffset - lowerOffset}/>
+        onTouchStart={disabled ? noop : this.onTouchStart.bind(this)}
+        onMouseDown={disabled ? noop : this.onMouseDown.bind(this)}
+      >
+        {tracks}
         <Steps prefixCls={prefixCls} vertical = {vertical} marks={marks} dots={dots} step={step}
-              included={isIncluded} lowerBound={lowerBound}
-              upperBound={upperBound} max={max} min={min}/>
-        <Marks className={prefixCls + '-mark'} vertical = {vertical} marks={marks}
-               included={isIncluded} lowerBound={lowerBound}
-               upperBound={upperBound} max={max} min={min}/>
+          included={isIncluded} lowerBound={bounds[0]}
+          upperBound={bounds[bounds.length - 1]} max={max} min={min}
+        />
+        {handles}
+        <Marks className={`${prefixCls}-mark`} vertical = {vertical} marks={marks}
+          included={isIncluded} lowerBound={bounds[0]}
+          upperBound={bounds[bounds.length - 1]} max={max} min={min}
+        />
         {children}
       </div>
     );
@@ -393,6 +517,7 @@ Slider.propTypes = {
   included: React.PropTypes.bool,
   className: React.PropTypes.string,
   prefixCls: React.PropTypes.string,
+  tooltipPrefixCls: React.PropTypes.string,
   disabled: React.PropTypes.bool,
   children: React.PropTypes.any,
   onBeforeChange: React.PropTypes.func,
@@ -402,9 +527,16 @@ Slider.propTypes = {
   tipTransitionName: React.PropTypes.string,
   tipFormatter: React.PropTypes.func,
   dots: React.PropTypes.bool,
-  range: React.PropTypes.bool,
+  range: React.PropTypes.oneOfType([
+    React.PropTypes.bool,
+    React.PropTypes.number,
+  ]),
   vertical: React.PropTypes.bool,
   allowCross: React.PropTypes.bool,
+  pushable: React.PropTypes.oneOfType([
+    React.PropTypes.bool,
+    React.PropTypes.number,
+  ]),
 };
 
 Slider.defaultProps = {
@@ -426,6 +558,7 @@ Slider.defaultProps = {
   range: false,
   vertical: false,
   allowCross: true,
+  pushable: false,
 };
 
 export default Slider;

src/Steps.jsx

@@ -3,7 +3,10 @@ import classNames from 'classnames';
 import warning from 'warning';
 
 function calcPoints(vertical, marks, dots, step, min, max) {
-  warning(dots ? step > 0 : true, '`Slider[step]` should be a positive number in order to make Slider[dots] work.');
+  warning(
+    dots ? step > 0 : true,
+    '`Slider[step]` should be a positive number in order to make Slider[dots] work.'
+  );
   const points = Object.keys(marks).map(parseFloat);
   if (dots) {
     for (let i = min; i <= max; i = i + step) {
@@ -14,24 +17,24 @@ function calcPoints(vertical, marks, dots, step, min, max) {
   return points;
 }
 
-const Steps = ({prefixCls, vertical, marks, dots, step, included,
-                lowerBound, upperBound, max, min}) => {
+const Steps = ({ prefixCls, vertical, marks, dots, step, included,
+                lowerBound, upperBound, max, min }) => {
   const range = max - min;
   const elements = calcPoints(vertical, marks, dots, step, min, max).map((point) => {
-    const offset = Math.abs(point - min) / range * 100 + '%';
+    const offset = `${Math.abs(point - min) / range * 100}%`;
     const style = vertical ? { bottom: offset } : { left: offset };
 
     const isActived = (!included && point === upperBound) ||
             (included && point <= upperBound && point >= lowerBound);
     const pointClassName = classNames({
-      [prefixCls + '-dot']: true,
-      [prefixCls + '-dot-active']: isActived,
+      [`${prefixCls}-dot`]: true,
+      [`${prefixCls}-dot-active`]: isActived,
     });
 
     return <span className={pointClassName} style={style} key={point} />;
   });
 
-  return <div className={prefixCls + '-step'}>{elements}</div>;
+  return <div className={`${prefixCls}-step`}>{elements}</div>;
 };
 
 export default Steps;

src/Track.jsx

@@ -1,15 +1,15 @@
 import React from 'react';
 
-const Track = ({className, included, vertical, offset, length}) => {
+const Track = ({ className, included, vertical, offset, length }) => {
   const style = {
     visibility: included ? 'visible' : 'hidden',
   };
   if (vertical) {
-    style.bottom = offset + '%';
-    style.height = length + '%';
+    style.bottom = `${offset}%`;
+    style.height = `${length}%`;
   } else {
-    style.left = offset + '%';
-    style.width = length + '%';
+    style.left = `${offset}%`;
+    style.width = `${length}%`;
   }
   return <div className={className} style={style} />;
 };

tests/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 const expect = require('expect.js');
 const React = require('react');
 const ReactDOM = require('react-dom');
@@ -24,7 +25,7 @@ describe('rc-slider', function test() {
 
   it('should render a Slider with default value correctly', () => {
     const sliderWithDefaultValue = ReactDOM.render(<Slider defaultValue={50} />, div);
-    expect(sliderWithDefaultValue.state.upperBound).to.be(50);
+    expect(sliderWithDefaultValue.state.bounds[1]).to.be(50);
     expect(ReactTestUtils
            .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
            .style.cssText)
@@ -40,7 +41,7 @@ describe('rc-slider', function test() {
 
   it('should render a Slider with value corrently', () => {
     const sliderWithValue = ReactDOM.render(<Slider value={50} />, div);
-    expect(sliderWithValue.state.upperBound).to.be(50);
+    expect(sliderWithValue.state.bounds[1]).to.be(50);
     expect(ReactTestUtils
            .scryRenderedDOMComponentsWithClass(sliderWithValue, 'rc-slider-handle')[0]
            .style.cssText)
@@ -61,39 +62,100 @@ describe('rc-slider', function test() {
     expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-track').length).to.be(1);
   });
 
+  it('should render a Multi-Range with correct DOM structure', () => {
+    const multiRange = ReactDOM.render(<Slider range={3} />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider').length).to.be(1);
+
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-handle').length).to.be(4);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-handle-1').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-handle-2').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-handle-3').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-handle-4').length).to.be(1);
+
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-track').length).to.be(3);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-track-1').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-track-2').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(multiRange, 'rc-slider-track-3').length).to.be(1);
+  });
+
   it('should render a Range with default value correctly', () => {
     const rangeWithDefaultValue = ReactDOM.render(<Slider range defaultValue={[0, 50]} />, div);
-    expect(rangeWithDefaultValue.state.lowerBound).to.be(0);
-    expect(rangeWithDefaultValue.state.upperBound).to.be(50);
+    expect(rangeWithDefaultValue.state.bounds[0]).to.be(0);
+    expect(rangeWithDefaultValue.state.bounds[1]).to.be(50);
     expect(ReactTestUtils
-           .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-handle')[0]
-           .style.cssText)
-      .to.match(/left: 50%;/);
-    expect(ReactTestUtils
-           .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-handle')[1]
-           .style.cssText)
+      .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-handle')[0]
+      .style.cssText)
       .to.match(/left: 0%;/);
+    expect(ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-handle')[1]
+      .style.cssText)
+      .to.match(/left: 50%;/);
 
     const trackStyle = ReactTestUtils
-            .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-track')[0]
-            .style.cssText;
+      .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-track')[0]
+      .style.cssText;
     expect(trackStyle).to.match(/left: 0%;/);
     expect(trackStyle).to.match(/width: 50%;/);
     expect(trackStyle).to.match(/visibility: visible;/);
   });
 
+  it('should render a Multi-Range with default value correctly', () => {
+    const multiRangeWithDefaultValue = ReactDOM.render(<Slider range={3} defaultValue={[0, 25, 50, 75]} />, div);
+    expect(multiRangeWithDefaultValue.state.bounds[0]).to.be(0);
+    expect(multiRangeWithDefaultValue.state.bounds[1]).to.be(25);
+    expect(multiRangeWithDefaultValue.state.bounds[2]).to.be(50);
+    expect(multiRangeWithDefaultValue.state.bounds[3]).to.be(75);
+    expect(ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-handle')[0]
+      .style.cssText)
+      .to.match(/left: 0%;/);
+    expect(ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-handle')[1]
+      .style.cssText)
+      .to.match(/left: 25%;/);
+    expect(ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-handle')[2]
+      .style.cssText)
+      .to.match(/left: 50%;/);
+    expect(ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-handle')[3]
+      .style.cssText)
+      .to.match(/left: 75%;/);
+
+    const track1Style = ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-track-1')[0]
+      .style.cssText;
+    expect(track1Style).to.match(/left: 0%;/);
+    expect(track1Style).to.match(/width: 25%;/);
+    expect(track1Style).to.match(/visibility: visible;/);
+
+    const track2Style = ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-track-2')[0]
+      .style.cssText;
+    expect(track2Style).to.match(/left: 25%;/);
+    expect(track2Style).to.match(/width: 25%;/);
+    expect(track2Style).to.match(/visibility: visible;/);
+
+    const track3Style = ReactTestUtils
+      .scryRenderedDOMComponentsWithClass(multiRangeWithDefaultValue, 'rc-slider-track-3')[0]
+      .style.cssText;
+    expect(track3Style).to.match(/left: 50%;/);
+    expect(track3Style).to.match(/width: 25%;/);
+    expect(track3Style).to.match(/visibility: visible;/);
+  });
+
   it('should render a Range with value correctly', () => {
     const rangeWithValue = ReactDOM.render(<Slider range value={[50, 100]} />, div);
-    expect(rangeWithValue.state.lowerBound).to.be(50);
-    expect(rangeWithValue.state.upperBound).to.be(100);
+    expect(rangeWithValue.state.bounds[0]).to.be(50);
+    expect(rangeWithValue.state.bounds[1]).to.be(100);
     expect(ReactTestUtils
            .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-handle')[0]
            .style.cssText)
-      .to.match(/left: 100%;/);
+      .to.match(/left: 50%;/);
     expect(ReactTestUtils
            .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-handle')[1]
            .style.cssText)
-      .to.match(/left: 50%;/);
+      .to.match(/left: 100%;/);
 
     const trackStyle = ReactTestUtils
             .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-track')[0]
@@ -114,7 +176,7 @@ describe('rc-slider', function test() {
   });
 
   it('should render marks correctly when `marks` is not an empty object', () => {
-    const marks = {0: '0', 30: '30', 100: '100'};
+    const marks = { 0: '0', 30: '30', 100: '100' };
 
     const slider = ReactDOM.render(<Slider value={30} marks={marks} />, div);
     expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text').length).to.be(3);
@@ -128,16 +190,16 @@ describe('rc-slider', function test() {
 
   it('should not set value greater than `max` or smaller `min`', () => {
     const sliderWithMin = ReactDOM.render(<Slider value={0} min={10} />, div);
-    expect(sliderWithMin.state.upperBound).to.be(10);
+    expect(sliderWithMin.state.bounds[1]).to.be(10);
     ReactDOM.unmountComponentAtNode(div);
 
     const sliderWithMax = ReactDOM.render(<Slider value={100} max={90} />, div);
-    expect(sliderWithMax.state.upperBound).to.be(90);
+    expect(sliderWithMax.state.bounds[1]).to.be(90);
     ReactDOM.unmountComponentAtNode(div);
 
     const range = ReactDOM.render(<Slider range value={[0, 100]} min={10} max={90} />, div);
-    expect(range.state.lowerBound).to.be(10);
-    expect(range.state.upperBound).to.be(90);
+    expect(range.state.bounds[0]).to.be(10);
+    expect(range.state.bounds[1]).to.be(90);
     ReactDOM.unmountComponentAtNode(div);
   });
 
@@ -145,4 +207,29 @@ describe('rc-slider', function test() {
     const slider = ReactDOM.render(<Slider vertical />, div);
     expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-vertical').length).to.be(1);
   });
+
+  it('should not call onChange when value is the same', () => {
+    const values = [];
+    const handler = (e) => {
+      values.push(e);
+    };
+
+    ReactDOM.render(<Slider onChange={handler}/>, div);
+    const handle = div.querySelector('.rc-slider-handle');
+
+    const down = document.createEvent('MouseEvent');
+    down.initEvent('mousedown', true, true);
+
+    const move = document.createEvent('MouseEvent');
+    move.initEvent('mousemove', true, true);
+
+    const up = document.createEvent('MouseEvent');
+    up.initEvent('mouseup', true, true);
+
+    handle.dispatchEvent(down);
+    handle.dispatchEvent(move);
+    handle.dispatchEvent(up);
+
+    expect(values.length).to.be(0);
+  });
 });

tests/runner.html

@@ -1 +0,0 @@
-stub