feat: provide dist files

* Adjust handle drag position to account for the difference between handle origin and mouse or touch event origin.

* Add slider dragOffset tests.

.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,20 @@
 # History
 ----
 
+## 5.0.0 / 2016-09-12
+
+[#147](https://github.com/react-component/slider/issues/147) fix style conflicts with rc-tooltip [@benjycui](https://github.com/benjycui)
+[#145](https://github.com/react-component/slider/pull/145) fix `onChange` will be triggered while mousemove [@Fuzzyma](https://github.com/Fuzzyma)
+
+## 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))
+
+...
 
 ## 1.2.5 / 2015-07-13
 

LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2015-present Alipay.com, https://www.alipay.com/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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');
@@ -88,35 +92,59 @@ ReactDOM.render(<Rcslider />, container);
           <td>100</td>
           <td>The maximum value of the slider</td>
         </tr>
+        <tr>
+          <td>marks</td>
+          <td>object{number: string} or object{number: object{ style, label }}</td>
+          <td>{}</td>
+          <td>Mark on the slider. The key determines the position, and the value determines what will show. If you want to set the style of a specific mark point, the value should be an object which contains `style` and `label` properties.</td>
+        </tr>
         <tr>
           <td>step</td>
-          <td>number</td>
+          <td>number or `null`</td>
           <td>1</td>
-          <td>Value to be added or subtracted on each step the slider makes. Must be greater than zero. max - min should be evenly divisible by the step value.</td>
+          <td>Value to be added or subtracted on each step the slider makes. Must be greater than zero. max - min should be evenly divisible by the step value. When `marks` is not an empty object, `step` can be set to `null`, to make marks as steps.</td>
         </tr>
         <tr>
           <td>range</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. 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 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>
           <td>boolean</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>If vertical is `true`, the slider will be vertical.</td>
         </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>marks</td>
-          <td>array</td>
-          <td>[]</td>
-          <td>Mark every step for the slider, it will ignore the `step` parameter if it has been defined. Does not work with `range`</td>
+          <td>handle</td>
+          <td>Component</td>
+          <td></td>
+          <td>Provide a custom Handle to use in the slider by passing a component. This component will have a `value` and `offset` props used to define custom styling/content.</td>
         </tr>
         <tr>
           <td>included</td>
@@ -124,23 +152,11 @@ ReactDOM.render(<Rcslider />, container);
           <td>true</td>
           <td>If the value is `true`, it means a continuous value interval, otherwise, it is a independent value.</td>
         </tr>
-        <tr>
-          <td>defaultIndex</td>
-          <td>number</td>
-          <td>0</td>
-          <td>For step or marks slider, determines the initial position of the handle. Does not work with `range`</td>
-        </tr>
-        <tr>
-          <td>index</td>
-          <td>number</td>
-          <td></td>
-          <td>For step or marks slider, determines current position of the handle. Does not work with `range`</td>
-        </tr>
         <tr>
           <td>disabled</td>
           <td>boolean</td>
           <td>false</td>
-          <td>If true the handles can't be moved.</td>
+          <td>If `true`, handles can't be moved.</td>
         </tr>
         <tr>
           <td>tipTransitionName</td>
@@ -148,11 +164,29 @@ ReactDOM.render(<Rcslider />, container);
           <td>''</td>
           <td>Set the animation for tooltip if it shows.</td>
         </tr>
+        <tr>
+          <td>tipFormatter</td>
+          <td>function or `null`</td>
+          <td></td>
+          <td>Format the value of the tooltip if it shows. If `null` the tooltip will always be hidden.</td>
+        </tr>
         <tr>
           <td>dots</td>
           <td>bool</td>
           <td>false</td>
-          <td>For linear slider, when the `step` value is greater than 1, you can set the `dots` to  `true` if you want to render the slider bar with dots.</td>
+          <td>When the `step` value is greater than 1, you can set the `dots` to  `true` if you want to render the slider with dots.</td>
+        </tr>
+        <tr>
+          <td>onChange</td>
+          <td>function</td>
+          <td>NOOP</td>
+          <td>`onChange` will be triggered while the value of Slider changing.</td>
+        </tr>
+        <tr>
+          <td>onAfterChange</td>
+          <td>function</td>
+          <td>NOOP</td>
+          <td>`onAfterChange` will be triggered when `ontouchend` or `onmouseup` is triggered.</td>
         </tr>
     </tbody>
 </table>

assets/index.less

@@ -23,20 +23,25 @@
 
 .@{prefixClass} {
   position: relative;
-  height: 4px;
+  height: 14px;
+  padding: 5px 0;
   width: 100%;
   border-radius: @border-radius-base;
-  background-color: #e9e9e9;
-
   .borderBox();
 
+  &-rail {
+    position: absolute;
+    width: 100%;
+    background-color: #e9e9e9;
+    height: 4px;
+  }
+
   &-track {
     position: absolute;
     left: 0;
     height: 4px;
     border-radius: @border-radius-base;
     background-color: tint(@primary-color, 60%);
-    z-index: 1;
   }
 
   &-handle {
@@ -49,7 +54,6 @@
     border-radius: 50%;
     border: solid 2px tint(@primary-color, 50%);
     background-color: #fff;
-    z-index: 2;
 
     &:hover {
       border-color: tint(@primary-color, 20%);
@@ -64,11 +68,10 @@
 
   &-mark {
     position: absolute;
-    top: 10px;
+    top: 18px;
     left: 0;
     width: 100%;
     font-size: 12px;
-    z-index: 3;
   }
 
   &-mark-text {
@@ -89,12 +92,11 @@
     width: 100%;
     height: 4px;
     background: transparent;
-    z-index: 1;
   }
 
   &-dot {
     position: absolute;
-    top: -2px;
+    bottom: -2px;
     margin-left: -4px;
     width: 8px;
     height: 8px;
@@ -131,53 +133,50 @@
       cursor: not-allowed!important;
     }
   }
+}
 
-  // slider tooltip style
-  &-tooltip {
-    position: absolute;
-    left: -9999px;
-    top: -9999px;
-    z-index: 4;
-    visibility: visible;
+.@{prefixClass}-vertical {
+  width: 14px;
+  height: 100%;
+  padding: 0 5px;
 
-    .borderBox();
-
-    &-hidden {
-      display: none;
+  .@{prefixClass} {
+    &-rail {
+      height: 100%;
+      width: 4px;
     }
 
-    &-placement-points-bc-tc {
-      padding: @tooltip-arrow-width 0 @tooltip-distance 0;
+    &-track {
+      left: 5px;
+      bottom: 0;
+      width: 4px;
     }
 
-    &-inner {
-      padding: 6px 0;
-      width: 24px;
-      height: 24px;
-      font-size: 12px;
-      line-height: 1;
-      color: @tooltip-color;
-      text-align: center;
-      text-decoration: none;
-      background-color: @tooltip-bg;
-      border-radius: @border-radius-base;
-      box-shadow: 0 0 4px #d9d9d9;
+    &-handle {
+      margin-left: -5px;
+      margin-bottom: -7px;
     }
 
-    &-arrow {
-      position: absolute;
-      width: 0;
-      height: 0;
-      border-color: transparent;
-      border-style: solid;
+    &-mark {
+      top: 0;
+      left: 18px;
+      height: 100%;
     }
 
-    &-placement-points-bc-tc &-arrow {
-      bottom: @tooltip-distance - @tooltip-arrow-width;
-      left: 50%;
-      margin-left: -@tooltip-arrow-width;
-      border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
-      border-top-color: @tooltip-arrow-color;
+    &-step {
+      height: 100%;
+      width: 4px;
+    }
+
+    &-dot {
+      left: 2px;
+      margin-bottom: -4px;
+      &:first-child {
+        margin-bottom: -4px;
+      }
+      &:last-child {
+        margin-bottom: -4px;
+      }
     }
   }
 }
@@ -241,3 +240,50 @@
     transform: scale(0, 0);
   }
 }
+
+.@{prefixClass}-tooltip {
+  position: absolute;
+  left: -9999px;
+  top: -9999px;
+  visibility: visible;
+
+  .borderBox();
+
+  &-hidden {
+    display: none;
+  }
+
+  &-placement-top {
+    padding: @tooltip-arrow-width 0 @tooltip-distance 0;
+  }
+
+  &-inner {
+    padding: 6px 2px;
+    min-width: 24px;
+    height: 24px;
+    font-size: 12px;
+    line-height: 1;
+    color: @tooltip-color;
+    text-align: center;
+    text-decoration: none;
+    background-color: @tooltip-bg;
+    border-radius: @border-radius-base;
+    box-shadow: 0 0 4px #d9d9d9;
+  }
+
+  &-arrow {
+    position: absolute;
+    width: 0;
+    height: 0;
+    border-color: transparent;
+    border-style: solid;
+  }
+
+  &-placement-top &-arrow {
+    bottom: @tooltip-distance - @tooltip-arrow-width;
+    left: 50%;
+    margin-left: -@tooltip-arrow-width;
+    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
+    border-top-color: @tooltip-arrow-color;
+  }
+}

examples/custom-handles.js

@@ -0,0 +1,44 @@
+require('rc-slider/assets/index.less');
+
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
+
+const wrapperStyle = { width: 400, margin: 50 };
+
+const handleStyle = {
+  position: 'absolute',
+  transform: 'translate(-50%, -50%)',
+  cursor: 'pointer',
+  padding: '2px',
+  border: '2px solid #abe2fb',
+  borderRadius: '3px',
+  background: '#fff',
+  fontSize: '14px',
+  textAlign: 'center',
+};
+
+const CustomHandle = props => {
+  const style = Object.assign({ left: `${props.offset}%` }, handleStyle);
+  return (
+    <div style={style}>val: {props.value}</div>
+  );
+};
+CustomHandle.propTypes = {
+  value: React.PropTypes.any,
+  offset: React.PropTypes.number,
+};
+
+ReactDOM.render(
+  <div>
+    <div style={wrapperStyle}>
+      <p>Default slider</p>
+      <Slider min={0} max={20} defaultValue={3} />
+    </div>
+    <div style={wrapperStyle}>
+      <p>Slider with custom handle</p>
+      <Slider min={0} max={20} defaultValue={3} handle={<CustomHandle />} />
+    </div>
+  </div>,
+  document.getElementById('__react-content')
+);

examples/marks.html

@@ -0,0 +1 @@
+placeholder

examples/marks.js

@@ -0,0 +1,55 @@
+require('rc-slider/assets/index.less');
+
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
+
+const style = { width: 400, margin: 50 };
+const marks = {
+  '-10': '-10°C',
+  0: <strong>0°C</strong>,
+  26: '26°C',
+  37: '37°C',
+  50: '50°C',
+  100: {
+    style: {
+      color: 'red',
+    },
+    label: <strong>100°C</strong>,
+  },
+};
+
+function log(value) {
+  console.log(value);
+}
+
+ReactDOM.render(
+  <div>
+    <div style={style}>
+      <p>Slider with marks, `step=null`</p>
+      <Slider min={-10} marks={marks} step={null} onChange={log} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Slider with marks and steps</p>
+      <Slider dots min={-10} marks={marks} step={10} onChange={log} defaultValue={20} />
+    </div>
+
+    <div style={style}>
+      <p>Slider with marks, `included=false`</p>
+      <Slider min={-10} marks={marks} included={false} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Slider with marks and steps, `included=false`</p>
+      <Slider min={-10} marks={marks} step={10} included={false} defaultValue={20} />
+    </div>
+
+    <div style={style}>
+      <p>Range with marks</p>
+      <Slider min={-10} range marks={marks} onChange={log} defaultValue={[20, 40]} />
+    </div>
+    <div style={style}>
+      <p>Range with marks and steps</p>
+      <Slider min={-10} range marks={marks} step={10} onChange={log} defaultValue={[20, 40]} />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/range.html

@@ -0,0 +1 @@
+placeholder

examples/range.js

@@ -0,0 +1,123 @@
+/* eslint react/no-multi-comp: 0 */
+require('rc-slider/assets/index.less');
+
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
+
+const style = { width: 400, margin: 50 };
+
+function log(value) {
+  console.log(value);
+}
+
+const CustomizedRange = React.createClass({
+  getInitialState() {
+    return {
+      lowerBound: 20,
+      upperBound: 40,
+      value: [20, 40],
+    };
+  },
+  onLowerBoundChange(e) {
+    this.setState({ lowerBound: +e.target.value });
+  },
+  onUpperBoundChange(e) {
+    this.setState({ upperBound: +e.target.value });
+  },
+  onSliderChange(value) {
+    log(value);
+    this.setState({
+      value,
+    });
+  },
+  handleApply() {
+    const { lowerBound, upperBound } = this.state;
+    this.setState({ value: [lowerBound, upperBound] });
+  },
+  render() {
+    return (
+      <div>
+        <label>LowerBound: </label>
+        <input type="number" value={this.state.lowerBound} onChange={this.onLowerBoundChange} />
+        <br />
+        <label>UpperBound: </label>
+        <input type="number" value={this.state.upperBound} onChange={this.onUpperBoundChange} />
+        <br />
+        <button onClick={this.handleApply}>Apply</button>
+        <br /><br />
+        <Slider range allowCross={false} value={this.state.value} onChange={this.onSliderChange} />
+      </div>
+    );
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange(value) {
+    log(value);
+  },
+  onMinChange(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render() {
+    return (
+      <div>
+        <label>Min: </label>
+        <input type="number" value={this.state.min} onChange={this.onMinChange} />
+        <br />
+        <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}
+        />
+      </div>
+    );
+  },
+});
+
+ReactDOM.render(
+  <div>
+    <div style={style}>
+      <p>Basic Range，`allowCross=false`</p>
+      <Slider range allowCross={false} defaultValue={[0, 20]} onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Range，`step=20` </p>
+      <Slider range step={20} defaultValue={[20, 20]} onBeforeChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Range，`step=20, dots` </p>
+      <Slider range dots step={20} defaultValue={[20, 40]} onAfterChange={log} />
+    </div>
+    <div style={style}>
+      <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 />
+    </div>
+    <div style={style}>
+      <p>Range with dynamic `max` `min`</p>
+      <DynamicBounds />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/simple.js

@@ -1,45 +0,0 @@
-'use strict';
-
-require('rc-slider/assets/index.less');
-
-var React = require('react');
-var ReactDOM = require('react-dom');
-var Slider = require('rc-slider');
-var style = {width:400,margin:50};
-
-function onChange(v) {
-  console.log(v);
-}
-
-ReactDOM.render(
-  <div>
-    <div style={style}>
-      <p>基础滑块</p>
-      <Slider onChange={onChange} tipTransitionName='rc-slider-tooltip-zoom-down' />
-    </div>
-    <div style={style}>
-      <p>基础滑块，step=20</p>
-      <Slider step={20} />
-    </div>
-    <div style={style}>
-      <p>基础滑块，step=20 带原点</p>
-      <Slider dots step={20} />
-    </div>
-    <div style={style}>
-      <p>双滑块</p>
-      <Slider range min={10} max={90} defaultValue={[0, 30]} onChange={onChange} />
-    </div>
-    <div style={style}>
-      <p>双滑块，step=20 </p>
-      <Slider range dots step={20} defaultValue={[0, 30]} onChange={onChange} included={false} />
-    </div>
-    <div style={style}>
-      <p>分段式滑块（包含关系）</p>
-      <Slider marks={["状态1","状态2","状态3","状态4"]} defaultIndex={1} />
-    </div>
-    <div style={style}>
-      <p>分段式滑块（并列关系）</p>
-      <Slider marks={["状态1","状态2","状态3","状态4"]} included={false} defaultIndex={1} />
-    </div>
-  </div>
-  , document.getElementById('__react-content'));

examples/slider.html

@@ -0,0 +1 @@
+placeholder

examples/slider.js

@@ -0,0 +1,117 @@
+/* eslint react/no-multi-comp: 0 */
+require('rc-slider/assets/index.less');
+
+const React = require('react');
+const ReactDOM = require('react-dom');
+const Slider = require('rc-slider');
+
+const style = { width: 400, margin: 50 };
+
+function log(value) {
+  console.log(value);
+}
+
+
+function percentFormatter(v) {
+  return `${v} %`;
+}
+
+const CustomizedSlider = React.createClass({
+  getInitialState() {
+    return {
+      value: 50,
+    };
+  },
+  onSliderChange(value) {
+    log(value);
+    this.setState({
+      value,
+    });
+  },
+  onAfterChange(value) {
+    console.log(value);
+  },
+  render() {
+    return (
+      <Slider value={this.state.value}
+        onChange={this.onSliderChange} onAfterChange={this.onAfterChange}
+      />
+    );
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange(value) {
+    log(value);
+  },
+  onMinChange(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render() {
+    return (
+      <div>
+        <label>Min: </label>
+        <input type="number" value={this.state.min} onChange={this.onMinChange} />
+        <br />
+        <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}
+        />
+      </div>
+    );
+  },
+});
+
+ReactDOM.render(
+  <div>
+    <div style={style}>
+      <p>Basic Slider</p>
+      <Slider tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Slider，`step=20`</p>
+      <Slider step={20} defaultValue={50} onBeforeChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Slider，`step=20, dots`</p>
+      <Slider dots step={20} defaultValue={100} onAfterChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Slider with `tipFormatter`</p>
+      <Slider tipFormatter={percentFormatter}
+        tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log}
+      />
+    </div>
+    <div style={style}>
+      <p>Basic Slider without tooltip</p>
+      <Slider tipFormatter={null} onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Controlled Slider</p>
+      <Slider value={50} />
+    </div>
+    <div style={style}>
+      <p>Customized Slider</p>
+      <CustomizedSlider />
+    </div>
+    <div style={style}>
+      <p>Slider with dynamic `min` `max`</p>
+      <DynamicBounds />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/v-marks.html

@@ -0,0 +1 @@
+placeholder

examples/v-marks.js

@@ -0,0 +1,57 @@
+require('rc-slider/assets/index.less');
+
+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 marks = {
+  '-10': '-10°C',
+  0: <strong>0°C</strong>,
+  26: '26°C',
+  37: '37°C',
+  50: '50°C',
+  100: {
+    style: {
+      color: 'red',
+    },
+    label: <strong>100°C</strong>,
+  },
+};
+
+function log(value) {
+  console.log(value);
+}
+
+ReactDOM.render(
+  <div style={parentStyle}>
+    <div style={style}>
+      <p>Slider with marks, `step=null`</p>
+      <Slider vertical min={-10} marks={marks} step={null} onChange={log} defaultValue={20} />
+    </div>
+    <div style={style}>
+       <p>Slider with marks and steps</p>
+      <Slider vertical dots min={-10} marks={marks} step={10} onChange={log} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Slider with marks, `included=false`</p>
+      <Slider vertical min={-10} marks={marks} included={false} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Slider with marks and steps, `included=false`</p>
+      <Slider vertical min={-10} marks={marks} step={10} included={false} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Range with marks</p>
+      <Slider vertical min={-10} range marks={marks} onChange={log} defaultValue={[20, 40]} />
+    </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]}
+      />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/v-range.js

@@ -0,0 +1,120 @@
+/* eslint react/no-multi-comp: 0 */
+require('rc-slider/assets/index.less');
+
+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' };
+
+function log(value) {
+  console.log(value);
+}
+
+const CustomizedRange = React.createClass({
+  getInitialState() {
+    return {
+      lowerBound: 20,
+      upperBound: 40,
+      value: [20, 40],
+    };
+  },
+  onLowerBoundChange(e) {
+    this.setState({ lowerBound: +e.target.value });
+  },
+  onUpperBoundChange(e) {
+    this.setState({ upperBound: +e.target.value });
+  },
+  onSliderChange(value) {
+    log(value);
+    this.setState({
+      value,
+    });
+  },
+  handleApply() {
+    const { lowerBound, upperBound } = this.state;
+    this.setState({ value: [lowerBound, upperBound] });
+  },
+  render() {
+    return (
+      <div style={style}>
+        <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 />
+        <label>UpperBound: </label>
+        <input type="number" value={this.state.upperBound} onChange={this.onUpperBoundChange} />
+        <br />
+        <button onClick={this.handleApply}>Apply</button>
+      </div>
+    );
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange(value) {
+    log(value);
+  },
+  onMinChange(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render() {
+    return (
+      <div style={style}>
+        <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 />
+        <label>Max: </label>
+        <input type="number" value={this.state.max} onChange={this.onMaxChange} />
+      </div>
+    );
+  },
+});
+
+ReactDOM.render(
+  <div style={parentStyle}>
+    <div style={style}>
+      <p>Basic Range，`allowCross=false`</p>
+      <Slider range vertical allowCross={false} defaultValue={[0, 20]} onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Range，`step=20` </p>
+      <Slider range vertical step={20} defaultValue={[20, 40]} onBeforeChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Range，`step=20, dots` </p>
+      <Slider range vertical dots step={20} defaultValue={[20, 40]} onAfterChange={log} />
+    </div>
+    <div style={style}>
+      <p>Controlled Range</p>
+      <Slider range vertical value={[20, 40]} />
+    </div>
+    <div style={style}>
+      <p>Customized Range</p>
+      <CustomizedRange />
+    </div>
+    <div style={style}>
+      <p>Range with dynamic `max` `min`</p>
+      <DynamicBounds />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/v-slider.html

@@ -0,0 +1 @@
+placeholder

examples/v-slider.js

@@ -0,0 +1,110 @@
+/* eslint react/no-multi-comp: 0 */
+require('rc-slider/assets/index.less');
+
+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' };
+
+function log(value) {
+  console.log(value);
+}
+
+
+function percentFormatter(v) {
+  return `${v} %`;
+}
+
+const CustomizedSlider = React.createClass({
+  getInitialState() {
+    return {
+      value: 50,
+    };
+  },
+  onSliderChange(value) {
+    log(value);
+    this.setState({
+      value,
+    });
+  },
+  render() {
+    return <Slider vertical value={this.state.value} onChange={this.onSliderChange} />;
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange(value) {
+    log(value);
+  },
+  onMinChange(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  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}
+        />
+        <label>Min: </label>
+        <input type="number" value={this.state.min} onChange={this.onMinChange} />
+        <br />
+        <label>Max: </label>
+        <input type="number" value={this.state.max} onChange={this.onMaxChange} />
+      </div>
+    );
+  },
+});
+
+ReactDOM.render(
+  <div style={parentStyle}>
+    <div style={style}>
+      <p>Basic Slider</p>
+      <Slider vertical tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Slider，`step=20`</p>
+      <Slider vertical step={20} defaultValue={50} onBeforeChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Slider，`step=20, dots`</p>
+      <Slider vertical dots step={20} defaultValue={100} onAfterChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Slider with `tipFormatter`</p>
+      <Slider vertical tipFormatter={percentFormatter}
+        tipTransitionName="rc-slider-tooltip-zoom-down" onChange={log}
+      />
+    </div>
+    <div style={style}>
+      <p>Basic Slider without tooltip</p>
+      <Slider vertical tipFormatter={null} onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Controlled Slider</p>
+      <Slider vertical value={50} />
+    </div>
+    <div style={style}>
+      <p>Customized Slider</p>
+      <CustomizedSlider />
+    </div>
+    <div>
+      <DynamicBounds />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rc-slider",
-  "version": "2.0.0",
+  "version": "5.3.0",
   "description": "slider ui component for react",
   "keywords": [
     "react",
@@ -19,39 +19,46 @@
   },
   "files": [
     "assets/*.css",
-    "lib"
+    "lib",
+    "dist"
   ],
   "licenses": "MIT",
   "main": "./lib/index.js",
+  "entry": {
+    "rc-slider": ["./src/index.js", "./assets/index.less"]
+  },
+  "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",
-    "jquery": "^1.11.2",
-    "precommit-hook": "^1.0.7",
-    "rc-server": "3.x",
-    "rc-tools": "4.x",
-    "react": "~0.14.0",
-    "react-addons-test-utils": "^0.14.0",
-    "react-dom": "~0.14.0"
+    "pre-commit": "1.x",
+    "rc-tools": "^5.6.8",
+    "react": "^15.2.1",
+    "react-addons-test-utils": "^15.2.1",
+    "react-dom": "^15.2.1"
   },
-  "precommit": [
+  "pre-commit": [
     "lint"
   ],
   "dependencies": {
-    "rc-tooltip": "~3.0.4",
-    "rc-util": "2.x"
+    "babel-runtime": "6.x",
+    "classnames": "^2.2.5",
+    "rc-tooltip": "^3.4.2",
+    "rc-util": "^3.2.1",
+    "warning": "^3.0.0"
   }
 }

src/Handle.jsx

@@ -23,37 +23,56 @@ export default class Handle extends React.Component {
   }
 
   render() {
-    const props = this.props;
-    const {className, tipTransitionName, offset, value} = props;
-    const {dragging, noTip} = props;
+    const {
+      prefixCls,
+      tooltipPrefixCls,
+      className,
+      tipTransitionName,
+      tipFormatter,
+      vertical,
+      offset,
+      value,
+      dragging,
+      noTip,
+    } = this.props;
 
-    const style = { 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('handle', 'tooltip')}
-              placement={{points: ['bc', 'tc']}}
-              visible={isTooltipVisible}
-              overlay={<span>{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,
   tipTransitionName: React.PropTypes.string,
+  tipFormatter: React.PropTypes.func,
   value: React.PropTypes.number,
   dragging: React.PropTypes.bool,
   noTip: React.PropTypes.bool,

src/Marks.jsx

@@ -1,35 +1,47 @@
 import React from 'react';
-import rcUtil from 'rc-util';
+import classNames from 'classnames';
 
-const Marks = ({className, marks, index, included}) => {
-  const marksLen = marks.length;
-  const unit = 100 / (marksLen - 1);
-  const markWidth = unit / 2 + '%';
+const Marks = ({ className, vertical, marks, included, upperBound, lowerBound, max, min }) => {
+  const marksKeys = Object.keys(marks);
+  const marksCount = marksKeys.length;
+  const unit = 100 / (marksCount - 1);
+  const markWidth = unit * 0.9;
 
-  const elements = [];
-  for (let i = 0; i < marksLen; i++) {
-    const isActived = (included && i <= index) || (!included && i === index);
-    const markClassName = rcUtil.classSet({
-      [className + '-text']: true,
-      [className + '-text-active']: isActived,
+  const range = max - min;
+  const elements = marksKeys.map(parseFloat).sort((a, b) => a - b).map((point) => {
+    const isActived = (!included && point === upperBound) ||
+            (included && point <= upperBound && point >= lowerBound);
+    const markClassName = classNames({
+      [`${className}-text`]: true,
+      [`${className}-text-active`]: isActived,
     });
 
-    const style = { width: markWidth };
-    const offset = unit * i;
-    if (i === marksLen - 1) {
-      style.right = -unit / 4 + '%';
-    } else {
-      style.left = (i > 0 ? offset - unit / 4 : -unit / 4) + '%';
-    }
+    const bottomStyle = {
+      // height: markWidth + '%',
+      marginBottom: '-50%',
+      bottom: `${(point - min) / range * 100}%`,
+    };
 
-    elements.push(<span className={markClassName} style={style} key={i}>
-                    {marks[i]}
-                  </span>);
-  }
+    const leftStyle = {
+      width: `${markWidth}%`,
+      marginLeft: `${-markWidth / 2}%`,
+      left: `${(point - min) / range * 100}%`,
+    };
 
-  return (<div className={className}>
-            {elements}
-          </div>);
+    const style = vertical ? bottomStyle : leftStyle;
+
+    const markPoint = marks[point];
+    const markPointIsObject = typeof markPoint === 'object' &&
+            !React.isValidElement(markPoint);
+    const markLabel = markPointIsObject ? markPoint.label : markPoint;
+    const markStyle = markPointIsObject ?
+            { ...style, ...markPoint.style } : style;
+    return (<span className={markClassName} style={markStyle} key={point}>
+             {markLabel}
+            </span>);
+  });
+
+  return <div className={className}>{elements}</div>;
 };
 
 export default Marks;

src/Slider.jsx

@@ -1,99 +1,118 @@
-import React from 'react';
-import rcUtil, {Dom as DomUtils} from 'rc-util';
+import { findDOMNode } from 'react-dom';
+import React, { cloneElement } from 'react';
+import addEventListener from 'rc-util/lib/Dom/addEventListener';
+import classNames from 'classnames';
 import Track from './Track';
-import Handle from './Handle';
+import DefaultHandle from './Handle';
 import Steps from './Steps';
 import Marks from './Marks';
+import warning from 'warning';
 
-function noop() {}
+function noop() {
+}
 
 function isNotTouchEvent(e) {
   return e.touches.length > 1 || (e.type.toLowerCase() === 'touchend' && e.touches.length > 0);
 }
 
-function getTouchPosition(e) {
-  return e.touches[0].pageX;
+function getTouchPosition(vertical, e) {
+  return vertical ? e.touches[0].clientY : e.touches[0].pageX;
 }
 
-function getMousePosition(e) {
-  return e.pageX || (e.clientX + document.documentElement.scrollLeft); // to compat ie8
+function getMousePosition(vertical, e) {
+  return vertical ? e.clientY : e.pageX;
+}
+
+function getHandleCenterPosition(vertical, handle) {
+  const coords = handle.getBoundingClientRect();
+  return vertical ?
+    coords.top + (coords.height * 0.5) :
+    coords.left + (coords.width * 0.5);
 }
 
 function pauseEvent(e) {
-  e.cancelBubble = true;
-  e.returnValue = false;
-  if (e.stopPropagation) {
-    e.stopPropagation();
-  }
-  if (e.preventDefault) {
-    e.preventDefault();
-  }
+  e.stopPropagation();
+  e.preventDefault();
 }
 
 class Slider extends React.Component {
   constructor(props) {
     super(props);
 
-    let upperBound;
-    let lowerBound;
-    if (props.range) {
-      const value = (props.value || props.defaultValue || [0, 0]);
-      upperBound = this.trimAlignValue(value[1]);
-      lowerBound = this.trimAlignValue(value[0]);
-    } else if (props.marks.length > 0) {
-      upperBound = this.calcValueFromProps(props);
-    } else {
-      // Note: Maybe `value` is `0`.
-      //       So, check the existence of `value` with `in`.
-      const defaultValue = ('defaultValue' in props ? props.defaultValue : 0);
-      const value = ('value' in props ? props.value : defaultValue);
-      upperBound = this.trimAlignValue(value);
-    }
+    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);
+
+    const bounds = (range ? value : [min, value]).map(v => this.trimAlignValue(v));
 
     let recent;
-    if (props.range && upperBound === lowerBound) {
-      if (lowerBound === props.max) {
-        recent = 'lowerBound';
-      }
-      if (upperBound === props.min) {
-        recent = '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' &&
+        step && Math.floor(step) === step &&
+        (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 || props.min),
+      recent,
+      bounds,
     };
   }
 
   componentWillReceiveProps(nextProps) {
+    if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
+
+    const { bounds } = this.state;
     if (nextProps.range) {
-      const value = nextProps.value;
-      if (value) {
-        this.setState({
-          upperBound: value[1],
-          lowerBound: value[0],
-        });
+      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({ bounds: nextBounds });
+      if (bounds.some(v => this.isValueOutOfBounds(v, nextProps))) {
+        this.props.onChange(nextBounds);
+      }
+    } else {
+      const value = nextProps.value !== undefined ? nextProps.value : bounds[1];
+      const nextValue = this.trimAlignValue(value, nextProps);
+      if (nextValue === bounds[1] && bounds[0] === nextProps.min) return;
+
+      this.setState({ bounds: [nextProps.min, nextValue] });
+      if (this.isValueOutOfBounds(bounds[1], nextProps)) {
+        this.props.onChange(nextValue);
       }
-    } else if ('value' in nextProps) {
-      this.setState({
-        upperBound: nextProps.value,
-      });
-    } else if ('index' in nextProps) {
-      this.setState({
-        upperBound: this.calcValueFromProps(nextProps),
-      });
     }
   }
 
+  onChange(state) {
+    const props = this.props;
+    const isNotControlled = !('value' in props);
+    if (isNotControlled) {
+      this.setState(state);
+    } else if (state.handle !== undefined) {
+      this.setState({ handle: state.handle });
+    }
+
+    const data = { ...this.state, ...state };
+    const changedValue = props.range ? data.bounds : data.bounds[1];
+    props.onChange(changedValue);
+  }
+
   onMouseMove(e) {
-    const position = getMousePosition(e);
-    this.onMove(e, position);
+    const position = getMousePosition(this.props.vertical, e);
+    this.onMove(e, position - this.dragOffset);
   }
 
   onTouchMove(e) {
@@ -102,8 +121,8 @@ class Slider extends React.Component {
       return;
     }
 
-    const position = getTouchPosition(e);
-    this.onMove(e, position);
+    const position = getTouchPosition(this.props.vertical, e);
+    this.onMove(e, position - this.dragOffset);
   }
 
   onMove(e, position) {
@@ -111,102 +130,110 @@ class Slider extends React.Component {
     const props = this.props;
     const state = this.state;
 
-    const diffPosition = position - this.startPosition;
+    let diffPosition = position - this.startPosition;
+    diffPosition = this.props.vertical ? -diffPosition : diffPosition;
     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 (!('value' in props) && !('index' in props)) {
-      this.setState({[state.handle]: value});
-    }
-
-    if (props.range) {
-      // `this.state` will not be updated immediately after `this.setState`.
-      // So, create a similar object.
-      // const data = Object.assign({}, state, {[state.handle]: value});
-      const data = {
-        upperBound: state.upperBound,
-        lowerBound: state.lowerBound,
-      };
-      data[state.handle] = value;
-      this.triggerEvents('onChange', [data.lowerBound, data.upperBound]);
-    } else {
-      this.triggerEvents('onChange', value);
+    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);
     }
+    this.onChange({
+      handle: nextHandle,
+      bounds: nextBounds,
+    });
   }
 
   onTouchStart(e) {
     if (isNotTouchEvent(e)) return;
 
-    const position = getTouchPosition(e);
+    let position = getTouchPosition(this.props.vertical, e);
+    if (!this.isEventFromHandle(e)) {
+      this.dragOffset = 0;
+    } else {
+      const handlePosition = getHandleCenterPosition(this.props.vertical, e.target);
+      this.dragOffset = position - handlePosition;
+      position = handlePosition;
+    }
     this.onStart(position);
     this.addDocumentEvents('touch');
     pauseEvent(e);
   }
 
-  onSliderMouseDown(e) {
-    const position = getMousePosition(e);
+  onMouseDown(e) {
+    if (e.button !== 0) { return; }
+
+    let position = getMousePosition(this.props.vertical, e);
+    if (!this.isEventFromHandle(e)) {
+      this.dragOffset = 0;
+    } else {
+      const handlePosition = getHandleCenterPosition(this.props.vertical, e.target);
+      this.dragOffset = position - handlePosition;
+      position = handlePosition;
+    }
     this.onStart(position);
     this.addDocumentEvents('mouse');
     pauseEvent(e);
   }
 
   onStart(position) {
-    this.triggerEvents('onBeforeChange');
+    const props = this.props;
+    props.onBeforeChange(this.getValue());
 
     const value = this.calcValueByPos(position);
     this.startValue = value;
     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;
       }
     }
 
     this.setState({
       handle: valueNeedChanging,
       recent: valueNeedChanging,
-      [valueNeedChanging]: value,
     });
 
-    if (this.props.range) {
-      // const data = Object.assign({}, state, {[valueNeedChanging]: value});
-      const data = {
-        upperBound: state.upperBound,
-        lowerBound: state.lowerBound,
-      };
-      data[valueNeedChanging] = value;
-      this.triggerEvents('onChange', [data.lowerBound, data.upperBound]);
-    } else {
-      this.triggerEvents('onChange', value);
-    }
+    const oldValue = state.bounds[valueNeedChanging];
+    if (value === oldValue) return;
+
+    const nextBounds = [...state.bounds];
+    nextBounds[valueNeedChanging] = value;
+    this.onChange({ bounds: nextBounds });
   }
 
-  getIndex(value) {
-    const {marks, min, max, step} = this.props;
-
-    if (marks.length === 0) {
-      return Math.floor((value - min) / step);
-    }
-    const unit = ((max - min) / (marks.length - 1)).toFixed(5);
-    return Math.round(value / unit);
+  getValue() {
+    const { bounds } = this.state;
+    return this.props.range ? bounds : bounds[1];
   }
 
   getSliderLength() {
@@ -215,21 +242,61 @@ class Slider extends React.Component {
       return 0;
     }
 
-    return slider.clientWidth;
+    return this.props.vertical ? slider.clientHeight : slider.clientWidth;
   }
 
   getSliderStart() {
     const slider = this.refs.slider;
     const rect = slider.getBoundingClientRect();
 
-    return rect.left;
+    return this.props.vertical ? rect.top : rect.left;
   }
 
-  trimAlignValue(v) {
+  getPrecision(step) {
+    const stepString = step.toString();
+    let precision = 0;
+    if (stepString.indexOf('.') >= 0) {
+      precision = stepString.length - stepString.indexOf('.') - 1;
+    }
+    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;
+  }
+
+  isEventFromHandle(e) {
+    return this.state.bounds.some((x, i) => (
+        this.refs[`handle-${i}`] &&
+        e.target === findDOMNode(this.refs[`handle-${i}`])
+    ));
+  }
+
+  isValueOutOfBounds(value, props) {
+    return value < props.min || value > props.max;
+  }
+
+  trimAlignValue(v, nextProps) {
     const state = this.state || {};
-    const props = this.props;
-    const {marks, min, max} = props;
-    const step = marks.length > 0 ? (max - min) / (marks.length - 1) : props.step;
+    const { handle, bounds } = state;
+    const { marks, step, min, max, allowCross } = { ...this.props, ...(nextProps || {}) };
 
     let val = v;
     if (val <= min) {
@@ -238,33 +305,96 @@ class Slider extends React.Component {
     if (val >= max) {
       val = max;
     }
-    if (state.handle === 'upperBound' && val <= state.lowerBound) {
-      val = state.lowerBound;
+    /* eslint-disable eqeqeq */
+    if (!allowCross && handle != null && handle > 0 && val <= bounds[handle - 1]) {
+      val = bounds[handle - 1];
     }
-    if (state.handle === 'lowerBound' && val >= state.upperBound) {
-      val = state.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) {
+      const closestStep = (Math.round((val - min) / step) * step) + min;
+      points.push(closestStep);
     }
 
-    const valModStep = (val - min) % step;
-    let alignValue = val - valModStep;
+    const diffs = points.map((point) => Math.abs(val - point));
+    const closestPoint = points[diffs.indexOf(Math.min.apply(Math, diffs))];
 
-    if (Math.abs(valModStep) * 2 >= step) {
-      alignValue += (valModStep > 0) ? step : (-step);
+    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;
     }
 
-    return parseFloat(alignValue.toFixed(5));
+    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 {min, max} = this.props;
-    const ratio = offset / this.getSliderLength();
-    return ratio * (max - min) + min;
+    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;
   }
 
   calcValueByPos(position) {
@@ -273,45 +403,22 @@ class Slider extends React.Component {
     return nextValue;
   }
 
-  calcValueFromProps(props) {
-    const marksLen = props.marks.length;
-    if (marksLen > 0) {
-      const index = ('index' in props ? props.index : props.defaultIndex);
-      const value = ((props.max - props.min) / (marksLen - 1)) * (index);
-      // `'1' / 1 => 1`, to make sure that the returned value is a `Number`.
-      return value.toFixed(5) / 1;
-    }
-    return ('value' in props ? props.value : props.defaultValue);
-  }
-
-  triggerEvents(event, v) {
-    const props = this.props;
-    const hasMarks = (props.marks.length > 0);
-    if (props[event]) {
-      let data;
-      if (hasMarks) {
-        data = this.getIndex(v);
-      } else if (v === undefined) {
-        data = this.state.value;
-      } else {
-        data = v;
-      }
-      props[event](data);
-    }
-  }
-
   addDocumentEvents(type) {
     if (type === 'touch') {
       // just work for chrome iOS Safari and Android Browser
-      this.onTouchMoveListener = DomUtils.addEventListener(document, 'touchmove', this.onTouchMove.bind(this));
-      this.onTouchUpListener = DomUtils.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 = DomUtils.addEventListener(document, 'mousemove', this.onMouseMove.bind(this));
-      this.onMouseUpListener = DomUtils.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'));
     }
   }
 
-  removeEventons(type) {
+  removeEvents(type) {
     if (type === 'touch') {
       this.onTouchMoveListener.remove();
       this.onTouchUpListener.remove();
@@ -322,71 +429,106 @@ class Slider extends React.Component {
   }
 
   end(type) {
-    this.removeEventons(type);
-    this.triggerEvents('onAfterChange');
+    this.removeEvents(type);
+    this.props.onAfterChange(this.getValue());
     this.setState({ handle: null });
   }
 
   render() {
-    const {handle, upperBound, lowerBound} = this.state;
-    const props = this.props;
-    const {className, prefixCls, disabled, included, isIncluded, dots, withDots, range} = props;
-    const {marks, step, max, min, tipTransitionName, children} = props;
-    const marksLen = marks.length;
+    const {
+        handle,
+        bounds,
+    } = this.state;
+    const {
+        className,
+        prefixCls,
+        tooltipPrefixCls,
+        disabled,
+        vertical,
+        dots,
+        included,
+        range,
+        step,
+        marks,
+        max, min,
+        tipTransitionName,
+        tipFormatter,
+        children,
+    } = this.props;
 
-    const sliderClassName = rcUtil.classSet({
+    const customHandle = this.props.handle;
+
+    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 isNoTip = (step === null) || (tipFormatter === null);
+
+    const commonHandleProps = {
+      prefixCls,
+      tooltipPrefixCls,
+      noTip: isNoTip,
+      tipTransitionName,
+      tipFormatter,
+      vertical,
+    };
+
+    const handles = bounds.map((v, i) => cloneElement(customHandle, {
+      ...commonHandleProps,
+      className: handlesClassNames[i],
+      value: v,
+      offset: offsets[i],
+      dragging: handle === i,
+      key: i,
+      ref: `handle-${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,
     });
 
-    const upperOffset = this.calcOffset(upperBound);
-    const lowerOffset = this.calcOffset(lowerBound);
-
-    let track = null;
-    if ((included && isIncluded) || range) {
-      const trackClassName = prefixCls + '-track';
-      track = <Track className={trackClassName} offset={lowerOffset} length={upperOffset - lowerOffset} />;
-    }
-
-    const handleClassName = prefixCls + '-handle';
-    const isNoTip = marksLen > 0;
-    const upper = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip}
-                     offset={upperOffset} value={upperBound} dragging={handle === 'upperBound'} />);
-
-    let lower = null;
-    if (range) {
-      lower = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip}
-                 offset={lowerOffset} value={lowerBound} dragging={handle === 'lowerBound'} />);
-    }
-
-    const upperIndex = this.getIndex(upperBound);
-
-    let steps = null;
-    if (marksLen > 0 || (step > 1 && (dots || withDots))) {
-      const stepsClassName = prefixCls + '-step';
-      const stepNum = marksLen > 0 ? marksLen : Math.floor((max - min) / step) + 1;
-      steps = (<Steps className={stepsClassName} stepNum={stepNum}
-                 lowerIndex={this.getIndex(lowerBound)} upperIndex={upperIndex}
-                 included={(included && isIncluded) || range} />);
-    }
-
-    let mark = null;
-    if (marksLen > 0) {
-      const markClassName = prefixCls + '-mark';
-      mark = (<Marks className={markClassName} marks={marks}
-                index={upperIndex} included={(included && isIncluded)} />);
-    }
-
     return (
       <div ref="slider" className={sliderClassName}
         onTouchStart={disabled ? noop : this.onTouchStart.bind(this)}
-        onMouseDown={disabled ? noop : this.onSliderMouseDown.bind(this)}>
-        {track}
-        {upper}
-        {lower}
-        {steps}
-        {mark}
+        onMouseDown={disabled ? noop : this.onMouseDown.bind(this)}
+      >
+        <div className={`${prefixCls}-rail`} />
+        {tracks}
+        <Steps prefixCls={prefixCls} vertical = {vertical} marks={marks} dots={dots} step={step}
+          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>
     );
@@ -401,43 +543,56 @@ Slider.propTypes = {
     React.PropTypes.number,
     React.PropTypes.arrayOf(React.PropTypes.number),
   ]),
-  defaultIndex: React.PropTypes.number,
   value: React.PropTypes.oneOfType([
     React.PropTypes.number,
     React.PropTypes.arrayOf(React.PropTypes.number),
   ]),
-  index: React.PropTypes.number,
-  marks: React.PropTypes.array,
-  isIncluded: React.PropTypes.bool, // @Deprecated
+  marks: React.PropTypes.object,
   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,
   onChange: React.PropTypes.func,
   onAfterChange: React.PropTypes.func,
+  handle: React.PropTypes.element,
   tipTransitionName: React.PropTypes.string,
-  withDots: React.PropTypes.bool, // @Deprecated
+  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 = {
+  prefixCls: 'rc-slider',
+  className: '',
+  tipTransitionName: '',
   min: 0,
   max: 100,
   step: 1,
-  defaultIndex: 0,
-  marks: [],
-  isIncluded: true, // @Deprecated
+  marks: {},
+  handle: <DefaultHandle />,
+  onBeforeChange: noop,
+  onChange: noop,
+  onAfterChange: noop,
+  tipFormatter: value => value,
   included: true,
-  className: '',
-  prefixCls: 'rc-slider',
   disabled: false,
-  tipTransitionName: '',
-  withDots: false, // @Deprecated
   dots: false,
   range: false,
+  vertical: false,
+  allowCross: true,
+  pushable: false,
 };
 
 export default Slider;

src/Steps.jsx

@@ -1,28 +1,40 @@
 import React from 'react';
-import rcUtil from 'rc-util';
+import classNames from 'classnames';
+import warning from 'warning';
 
-const Steps = ({className, stepNum, included, lowerIndex, upperIndex}) => {
-  const dotClassName = className.replace('step', 'dot');
-  const unit = 100 / (stepNum - 1);
+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.'
+  );
+  const points = Object.keys(marks).map(parseFloat);
+  if (dots) {
+    for (let i = min; i <= max; i = i + step) {
+      if (points.indexOf(i) >= 0) continue;
+      points.push(i);
+    }
+  }
+  return points;
+}
 
-  const elements = [];
-  for (let i = 0; i < stepNum; i++) {
-    const offset = unit * i + '%';
-    const style = { left: offset };
+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 style = vertical ? { bottom: offset } : { left: offset };
 
-    const isActived = (included && i <= upperIndex && i >= lowerIndex ) ||
-            (!included && i === upperIndex);
-    const stepClassName = rcUtil.classSet({
-      [dotClassName]: true,
-      [dotClassName + '-active']: isActived,
+    const isActived = (!included && point === upperBound) ||
+            (included && point <= upperBound && point >= lowerBound);
+    const pointClassName = classNames({
+      [`${prefixCls}-dot`]: true,
+      [`${prefixCls}-dot-active`]: isActived,
     });
 
-    elements.push(<span className={stepClassName} style={style} key={i} />);
-  }
+    return <span className={pointClassName} style={style} key={point} />;
+  });
 
-  return (<div className={className}>
-            {elements}
-          </div>);
+  return <div className={`${prefixCls}-step`}>{elements}</div>;
 };
 
 export default Steps;

src/Track.jsx

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

tests/index.js

@@ -0,0 +1,343 @@
+/* eslint-disable max-len */
+const expect = require('expect.js');
+const React = require('react');
+const ReactDOM = require('react-dom');
+const ReactTestUtils = require('react-addons-test-utils');
+const Slider = require('..');
+
+function createSliderWrapperComponent() {
+  return class SliderWrapper extends React.Component {
+    render() {
+      return (
+        <div style={{ position: `absolute`, width: `100px`, height: `10px` }}>
+          <Slider ref="slider"/>
+        </div>
+      );
+    }
+  };
+}
+
+require('../assets/index.less');
+
+describe('rc-slider', function test() {
+  this.timeout(5000);
+  const div = document.createElement('div');
+  document.body.appendChild(div);
+
+  afterEach(() => {
+    ReactDOM.unmountComponentAtNode(div);
+  });
+
+  it('should render a Slider with correct DOM structure', () => {
+    const slider = ReactDOM.render(<Slider />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-handle').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-track').length).to.be(1);
+  });
+
+  it('should render a Slider with default value correctly', () => {
+    const sliderWithDefaultValue = ReactDOM.render(<Slider defaultValue={50} />, div);
+    expect(sliderWithDefaultValue.state.bounds[1]).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.match(/left: 50%;/);
+
+    const trackStyle = ReactTestUtils
+            .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, '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 Slider with value corrently', () => {
+    const sliderWithValue = ReactDOM.render(<Slider value={50} />, div);
+    expect(sliderWithValue.state.bounds[1]).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.match(/left: 50%;/);
+
+    const trackStyle = ReactTestUtils
+            .scryRenderedDOMComponentsWithClass(sliderWithValue, '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 Range with correct DOM structure', () => {
+    const range = ReactDOM.render(<Slider range />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider').length).to.be(1);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-handle').length).to.be(2);
+    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.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: 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;
+    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.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: 50%;/);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-handle')[1]
+           .style.cssText)
+      .to.match(/left: 100%;/);
+
+    const trackStyle = ReactTestUtils
+            .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-track')[0]
+            .style.cssText;
+    expect(trackStyle).to.match(/left: 50%;/);
+    expect(trackStyle).to.match(/width: 50%;/);
+    expect(trackStyle).to.match(/visibility: visible;/);
+  });
+
+  it('should render dots correctly when `dots=true`', () => {
+    const slider = ReactDOM.render(<Slider value={50} step={10} dots />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-dot').length).to.be(11);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-dot-active').length).to.be(6);
+
+    const range = ReactDOM.render(<Slider range value={[20, 50]} step={10} dots />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-dot').length).to.be(11);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-dot-active').length).to.be(4);
+  });
+
+  it('should render marks correctly when `marks` is not an empty object', () => {
+    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);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text')[0].innerHTML).to.be('0');
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text')[1].innerHTML).to.be('30');
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-mark-text')[2].innerHTML).to.be('100');
+
+    const range = ReactDOM.render(<Slider range value={[0, 30]} marks={marks} />, div);
+    expect(ReactTestUtils.scryRenderedDOMComponentsWithClass(range, 'rc-slider-mark-text').length).to.be(3);
+  });
+
+  it('should not set value greater than `max` or smaller `min`', () => {
+    const sliderWithMin = ReactDOM.render(<Slider value={0} min={10} />, div);
+    expect(sliderWithMin.state.bounds[1]).to.be(10);
+    ReactDOM.unmountComponentAtNode(div);
+
+    const sliderWithMax = ReactDOM.render(<Slider value={100} max={90} />, div);
+    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.bounds[0]).to.be(10);
+    expect(range.state.bounds[1]).to.be(90);
+    ReactDOM.unmountComponentAtNode(div);
+  });
+
+  it('should render a vertical slider, when `vertical` is true', () => {
+    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);
+  });
+
+  it('should set `dragOffset` to correct value when the left handle is clicked off-center', () => {
+    const slider = ReactDOM.render(<Slider />, div);
+    const leftHandle = ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-handle')[0];
+    slider.onMouseDown({
+      type: 'mousedown',
+      target: leftHandle,
+      pageX: 5, button: 0,
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.dragOffset).to.be(5);
+  });
+
+  it('should respect `dragOffset` while dragging the handle via MouseEvents', () => {
+    const SliderWrapper = createSliderWrapperComponent();
+    const slider = ReactDOM.render(<SliderWrapper/>, div).refs.slider;
+    const leftHandle = ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-handle')[0];
+    slider.onMouseDown({
+      type: 'mousedown',
+      target: leftHandle,
+      pageX: 5, button: 0,
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.dragOffset).to.be(5);
+    slider.onMouseMove({
+      type: 'mousemove',
+      target: leftHandle,
+      pageX: 14, button: 0,
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.getValue()).to.be(9);
+  });
+
+  it('should set `dragOffset` to 0 when the MouseEvent target isn\'t a handle', () => {
+    const slider = ReactDOM.render(<Slider />, div);
+    const sliderTrack = ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-track')[0];
+    slider.onMouseDown({
+      type: 'mousedown',
+      target: sliderTrack,
+      pageX: 5, button: 0,
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.dragOffset).to.be(0);
+  });
+
+  it('should set `dragOffset` to correct value when the left handle is touched off-center', () => {
+    const slider = ReactDOM.render(<Slider />, div);
+    const leftHandle = ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-handle')[0];
+    slider.onTouchStart({
+      type: 'touchstart',
+      target: leftHandle,
+      touches: [{ pageX: 5 }],
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.dragOffset).to.be(5);
+  });
+
+  it('should respect `dragOffset` while dragging the handle via TouchEvents', () => {
+    const SliderWrapper = createSliderWrapperComponent();
+    const slider = ReactDOM.render(<SliderWrapper/>, div).refs.slider;
+    const leftHandle = ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-handle')[0];
+    slider.onTouchStart({
+      type: 'touchstart',
+      target: leftHandle,
+      touches: [{ pageX: 5 }],
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.dragOffset).to.be(5);
+    slider.onTouchMove({
+      type: 'touchmove',
+      target: leftHandle,
+      touches: [{ pageX: 14 }],
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.getValue()).to.be(9);
+  });
+
+  it('should set `dragOffset` to 0 when the TouchEvent target isn\'t a handle', () => {
+    const slider = ReactDOM.render(<Slider />, div);
+    const sliderTrack = ReactTestUtils.scryRenderedDOMComponentsWithClass(slider, 'rc-slider-track')[0];
+    slider.onTouchStart({
+      type: 'touchstart',
+      target: sliderTrack,
+      touches: [{ pageX: 5 }],
+      stopPropagation() {},
+      preventDefault() {},
+    });
+    expect(slider.dragOffset).to.be(0);
+  });
+});

tests/index.spec.js

@@ -1,83 +0,0 @@
-
-var expect = require('expect.js');
-var Slider = require('../index.js');
-var React = require('react');
-var ReactDOM = require('react-dom');
-var TestUtils = require('react-addons-test-utils');
-var Simulate = TestUtils.Simulate;
-var $ = require('jquery');
-require('../assets/index.less');
-
-describe('rc-slider', function () {
-  this.timeout(5000);
-  var div = document.createElement('div');
-  document.body.appendChild(div);
-
-  afterEach(function () {
-    React.unmountComponentAtNode(div);
-  });
-
-  it('should render a simple slider with value correctly!', function () {
-    var slider = ReactDOM.render(
-      <Slider className='rc-slider' defaultValue={40}/>,
-      div
-    );
-    var node = $(div);
-    expect(node.find('.rc-slider').length).to.be(1);
-    expect(node.find('.rc-slider-handle').length).to.be(1);
-    expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(slider.state.upperBound).to.be(40);
-    var trackWidth = node.find('.rc-slider-track')[0].style.width;
-    expect(trackWidth).to.eql(node.find('.rc-slider-handle')[0].style.left);
-  });
-
-  it('should render a slider with correct numbers of step!', function () {
-    var slider = ReactDOM.render(
-      <Slider className='rc-slider' step={20}/>,
-      div
-    );
-    var node = $(div);
-    expect(node.find('.rc-slider').length).to.be(1);
-    expect(node.find('.rc-slider-handle').length).to.be(1);
-    expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(slider.state.upperBound).to.be(0);
-
-    var sliderWithDots = ReactDOM.render(
-      <Slider className='rc-slider' step={20} dots/>,
-      div
-    );
-    var node1 = $(div);
-    expect(node1.find('.rc-slider-dot').length).to.be(6);
-  });
-
-  it('should render a slider with marks correctly!', function () {
-    var slider = ReactDOM.render(
-      <Slider marks={["一","二","三","四","五"]} defaultIndex={3} />,
-      div
-    );
-    var node = $(div);
-    expect(node.find('.rc-slider').length).to.be(1);
-    expect(node.find('.rc-slider-handle').length).to.be(1);
-    expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(node.find('.rc-slider-dot').length).to.be(slider.props.marks.length);
-    expect(node.find('.rc-slider-mark').length).to.be(1);
-    expect(node.find('.rc-slider-mark-text').length).to.be(slider.props.marks.length);
-    expect(slider.getIndex(slider.state.upperBound)).to.be(3);
-  });
-
-  // it('should mouseDown works!', function (done) {
-  //   var slider = ReactDOM.render(
-  //     <Slider marks={["一","二","三","四","五"]} />,
-  //     div
-  //   );
-  //   var selectedStep = slider.refs.step3.getDOMNode();
-
-  //   Simulate.mouseDown(selectedStep);
-
-  //   setTimeout( function() {
-  //     expect(slider.state.active).to.be('active');
-  //     done();
-  //   }, 200);
-  // });
-
-});

tests/runner.html

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