Merge pull request #42 from react-component/3.0.0-beta

bump 3.0.0

.travis.yml

@@ -7,7 +7,7 @@ notifications:
   - yiminghe@gmail.com
 
 node_js:
-- 0.12
+- 4.0.0
 
 before_install:
 - |
@@ -16,7 +16,6 @@ before_install:
       echo "Only docs were updated, stopping build process."
       exit
     fi
-    npm install mocha-phantomjs -g
     phantomjs --version
 
 script:
@@ -36,3 +35,8 @@ env:
   global:
   - secure: S1VwbaPzLnSH/IUT/wlJulxAX5VHRIDmSt53h/ycHcZsszUpWcLCJRQAe0fTVB2dAx5MdBbSZ+o+tr3tRwVB5TRAYm0oTCsYAkOZaWOB28RuUQtdGt3wf9xxTG1UiPiaLLUW3waX9zAaf3yqKBcJGf1op0RD8dksxbCFw/7xVbU=
   - secure: EBEDg8k///IlEsnx0AE8X3mbFl0QE5+xGKbG4AxXlGZda12uTIPUSMKJzdZQ2hVbZXduTzf1cQl9rcu9nGoSnkL/DWnIax9cvHi+1orx5+YPlxPHNWAwWByTnHosBn2MJhfy1s5paJfHC9cUzmmEL6x4fYthWxjsPUo+irEZH6E=
+
+
+matrix:
+  allow_failures:
+  - env: "TEST_TYPE=saucelabs"

README.md

@@ -4,7 +4,6 @@
 slider ui component for react
 
 [![NPM version][npm-image]][npm-url]
-[![SPM version](http://spmjs.io/badge/rc-slider)](http://spmjs.io/package/rc-slider)
 [![build status][travis-image]][travis-url]
 [![Test coverage][coveralls-image]][coveralls-url]
 [![gemnasium deps][gemnasium-image]][gemnasium-url]
@@ -51,9 +50,10 @@ slider ui component for react
 ## Usage
 
 ```js
-var Rcslider = require('rc-slider');
 var React = require('react');
-React.render(<Rcslider />, container);
+var ReactDOM = require('react-dom');
+var Rcslider = require('rc-slider');
+ReactDOM.render(<Rcslider />, container);
 ```
 
 ## API
@@ -74,7 +74,7 @@ React.render(<Rcslider />, container);
           <td>className</td>
           <td>String</td>
           <td>rc-slider</td>
-          <td>additional css class of root dom node</td>
+          <td>Additional css class for the root dom node</td>
         </tr>
         <tr>
           <td>min</td>
@@ -94,41 +94,47 @@ React.render(<Rcslider />, container);
           <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>
         </tr>
-         <tr>
+        <tr>
-          <td>defaultValue</td>
+          <td>range</td>
-          <td>number</td>
+          <td>boolean</td>
-          <td>0</td>
+          <td>false</td>
-          <td>Determines the initial positions of the handles.</td>
+          <td>Determines the type of slider. If range is `true`, two handles will be rendered in order to select a range.</td>
         </tr>
-         <tr>
+        <tr>
+          <td>defaultValue</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>
+        </tr>
+        <tr>
           <td>value</td>
-          <td>number</td>
+          <td>number or [number, number]</td>
           <td></td>
-          <td>Determines the current positions of the handles.</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</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>
         </tr>
         <tr>
-          <td>isIncluded</td>
+          <td>included</td>
           <td>boolean</td>
           <td>true</td>
-          <td>if the value is true, it means a continuous value interval, otherwise, it is a independent value.</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, determine the initial positions of the handles.</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, determine current positions of the handles.</td>
+          <td>For step or marks slider, determines current position of the handle. Does not work with `range`</td>
         </tr>
         <tr>
           <td>disabled</td>
@@ -136,6 +142,24 @@ React.render(<Rcslider />, container);
           <td>false</td>
           <td>If true the handles can't be moved.</td>
         </tr>
+        <tr>
+          <td>tipTransitionName</td>
+          <td>string</td>
+          <td>''</td>
+          <td>Set the animation for tooltip if it shows.</td>
+        </tr>
+        <tr>
+          <td>tipFormatter</td>
+          <td>func</td>
+          <td></td>
+          <td>Format the value of the tooltip if it shows.</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>
+        </tr>
     </tbody>
 </table>
 
@@ -148,17 +172,17 @@ npm start
 
 ## Example
 
-http://localhost:8000/examples/
+http://localhost:8005/examples/
 
 online example: http://react-component.github.io/slider/
 
 ## Test Case
 
-http://localhost:8000/tests/runner.html?coverage
+http://localhost:8005/tests/runner.html?coverage
 
 ## Coverage
 
-http://localhost:8000/node_modules/rc-server/node_modules/node-jscover/lib/front-end/jscoverage.html?w=http://localhost:8088/tests/runner.html?coverage
+http://localhost:8005/node_modules/rc-server/node_modules/node-jscover/lib/front-end/jscoverage.html?w=http://localhost:8088/tests/runner.html?coverage
 
 ## License
 

assets/index.less

@@ -8,15 +8,17 @@
 @tooltip-arrow-width: 4px;
 @tooltip-distance: @tooltip-arrow-width+4;
 @tooltip-arrow-color: @tooltip-bg;
+@ease-out-quint      : cubic-bezier(0.23, 1, 0.32, 1);
+@ease-in-quint       : cubic-bezier(0.755, 0.05, 0.855, 0.06);
 
-* {
+.borderBox() {
   box-sizing: border-box;
   -webkit-tap-highlight-color: rgba(0, 0, 0, 0); //  remove tap highlight color for mobile safari
-}
 
-*:before,
+  * {
-*:after {
+    box-sizing: border-box;
-  box-sizing: border-box;
+    -webkit-tap-highlight-color: rgba(0, 0, 0, 0); //  remove tap highlight color for mobile safari
+  }
 }
 
 .@{prefixClass} {
@@ -26,6 +28,8 @@
   border-radius: @border-radius-base;
   background-color: #e9e9e9;
 
+  .borderBox();
+
   &-track {
     position: absolute;
     left: 0;
@@ -117,61 +121,122 @@
       background-color: @disabledColor;
     }
 
-    .@{prefixClass}-handle {
+    .@{prefixClass}-handle, .@{prefixClass}-dot {
       border-color: @disabledColor;
       background-color: #fff;
       cursor: not-allowed;
     }
 
-    .@{prefixClass}-mark-text, .dot {
+    .@{prefixClass}-mark-text, .@{prefixClass}-dot {
       cursor: not-allowed!important;
     }
   }
+}
 
-  // slider tooltip style
+.motion-common() {
-  &-tooltip {
+  animation-duration: .3s;
+  animation-fill-mode: both;
+  display: block !important;
+}
+
+.make-motion(@className, @keyframeName) {
+  .@{className}-enter, .@{className}-appear {
+    .motion-common();
+    animation-play-state: paused;
+  }
+  .@{className}-leave {
+    .motion-common();
+    animation-play-state: paused;
+  }
+  .@{className}-enter.@{className}-enter-active, .@{className}-appear.@{className}-appear-active {
+    animation-name: ~"@{keyframeName}In";
+    animation-play-state: running;
+  }
+  .@{className}-leave.@{className}-leave-active {
+    animation-name: ~"@{keyframeName}Out";
+    animation-play-state: running;
+  }
+}
+.zoom-motion(@className, @keyframeName) {
+  .make-motion(@className, @keyframeName);
+  .@{className}-enter, .@{className}-appear {
+    transform: scale(0, 0); // need this by yiminghe
+    animation-timing-function: @ease-out-quint;
+  }
+  .@{className}-leave {
+    animation-timing-function: @ease-in-quint;
+  }
+}
+.zoom-motion(rc-slider-tooltip-zoom-down, rcSliderTooltipZoomDown);
+
+@keyframes rcSliderTooltipZoomDownIn {
+  0% {
+    opacity: 0;
+    transform-origin: 50% 100%;
+    transform: scale(0, 0);
+  }
+  100% {
+    transform-origin: 50% 100%;
+    transform: scale(1, 1);
+  }
+}
+
+@keyframes rcSliderTooltipZoomDownOut {
+  0% {
+    transform-origin: 50% 100%;
+    transform: scale(1, 1);
+  }
+  100% {
+    opacity: 0;
+    transform-origin: 50% 100%;
+    transform: scale(0, 0);
+  }
+}
+
+.rc-tooltip {
+  position: absolute;
+  left: -9999px;
+  top: -9999px;
+  z-index: 4;
+  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;
-    left: -9999px;
+    width: 0;
-    top: -9999px;
+    height: 0;
-    z-index: 4;
+    border-color: transparent;
-    visibility: visible;
+    border-style: solid;
+  }
 
-    &-hidden {
+  &-placement-top &-arrow {
-      display: none;
+    bottom: @tooltip-distance - @tooltip-arrow-width;
-    }
+    left: 50%;
-
+    margin-left: -@tooltip-arrow-width;
-    &-placement-points-bc-tc {
+    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
-      padding: @tooltip-arrow-width 0 @tooltip-distance 0;
+    border-top-color: @tooltip-arrow-color;
-    }
-
-    &-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;
-    }
-
-    &-arrow {
-      position: absolute;
-      width: 0;
-      height: 0;
-      border-color: transparent;
-      border-style: solid;
-    }
-
-    &-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;
-    }
   }
 }

examples/marks.html

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

examples/marks.js

@@ -0,0 +1,50 @@
+'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};
+var marks = {
+  0: '0°C',
+  26: '26°C',
+  37: '37°C',
+  100: '100°C'
+};
+
+var log = function(value) {
+  console.log(value);
+};
+
+ReactDOM.render(
+  <div>
+    <div style={style}>
+      <p>Slider with marks, `included=true`</p>
+      <Slider marks={marks} onChange={log} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Slider with marks and steps, `included=true`</p>
+      <Slider marks={marks} step={10} onChange={log} defaultValue={20} />
+    </div>
+
+    <div style={style}>
+      <p>Slider with marks, `included=false`</p>
+      <Slider marks={marks} included={false} defaultValue={20} />
+    </div>
+    <div style={style}>
+      <p>Slider with marks and steps, `included=false`</p>
+      <Slider marks={marks} step={10} included={false} defaultValue={20} />
+    </div>
+
+    <div style={style}>
+      <p>Range with marks</p>
+    <Slider range marks={marks} onChange={log} defaultValue={[20, 40]} />
+    </div>
+    <div style={style}>
+      <p>Range with marks and steps</p>
+      <Slider 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,54 @@
+'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};
+var log = function(value) {
+  console.log(value);
+};
+
+var CustomizedRange = React.createClass({
+  getInitialState: function() {
+    return {
+      value: [20, 40]
+    }
+  },
+  onChange: function(value) {
+    log(value);
+    this.setState({
+      value: value
+    });
+  },
+  render: function() {
+    return <Slider range value={this.state.value} onChange={this.onChange} />;
+  }
+});
+
+ReactDOM.render(
+  <div>
+    <div style={style}>
+      <p>Basic Range</p>
+      <Slider range defaultValue={[0, 20]} onChange={log} />
+    </div>
+    <div style={style}>
+      <p>Basic Range，`step=20` </p>
+      <Slider range step={20} defaultValue={[20, 40]} 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>Customized Range</p>
+      <CustomizedRange />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/simple.js

@@ -1,14 +0,0 @@
-'use strict';
-
-require('rc-slider/assets/index.less');
-
-var Slider = require('rc-slider');
-var React = require('react');
-
-function onChange(v){
-  console.log(v);
-}
-
-// React.render(<div style={{width:400,margin:100}}><Slider marks={["一","二","三","四","五"]} defaultIndex={2} /></div>, document.getElementById('__react-content'));
-// React.render(<div style={{width:400,margin:100}}><Slider className='rc-slider' step={20}/></div>, document.getElementById('__react-content'));
-React.render(<div style={{width:400,margin:100}}><Slider onChange={onChange}/></div>, document.getElementById('__react-content'));

examples/slider.js

@@ -0,0 +1,63 @@
+'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};
+var log = function(value) {
+  console.log(value);
+};
+
+
+function percentFormatter(v) {
+  return v + ' %';
+}
+
+var CustomizedSlider = React.createClass({
+  getInitialState: function() {
+    return {
+      value: 50
+    }
+  },
+  onChange: function(value) {
+    log(value);
+    this.setState({
+      value: value
+    });
+  },
+  render: function() {
+    return <Slider value={this.state.value} onChange={this.onChange} />;
+  }
+});
+
+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>Controlled Slider</p>
+      <Slider value={50} />
+    </div>
+    <div style={style}>
+      <p>Customized Slider</p>
+      <CustomizedSlider />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rc-slider",
-  "version": "1.4.3",
+  "version": "3.0.0",
   "description": "slider ui component for react",
   "keywords": [
     "react",
@@ -24,33 +24,34 @@
   "licenses": "MIT",
   "main": "./lib/index.js",
   "config": {
-    "port": 8000
+    "port": 8005
   },
   "scripts": {
     "build": "rc-tools run build",
     "gh-pages": "rc-tools run gh-pages",
-    "start": "node --harmony node_modules/.bin/rc-server",
+    "start": "rc-server",
     "pub": "rc-tools run pub",
     "lint": "rc-tools run lint",
     "karma": "rc-tools run karma",
-    "saucelabs": "node --harmony node_modules/.bin/rc-tools run saucelabs",
+    "saucelabs": "rc-tools run saucelabs",
-    "browser-test": "node --harmony node_modules/.bin/rc-tools run browser-test",
+    "browser-test": "rc-tools run browser-test",
-    "browser-test-cover": "node --harmony node_modules/.bin/rc-tools run browser-test-cover"
+    "browser-test-cover": "rc-tools run browser-test-cover"
   },
   "devDependencies": {
     "expect.js": "0.3.x",
-    "precommit-hook": "^1.0.7",
+    "jquery": "^1.11.2",
+    "pre-commit": "1.x",
     "rc-server": "3.x",
     "rc-tools": "4.x",
-    "react": "^0.13.x",
+    "react": "~0.14.0",
-    "node-dev": "2.x",
+    "react-addons-test-utils": "^0.14.0",
-    "jquery": "^1.11.2"
+    "react-dom": "~0.14.0"
   },
-  "precommit": [
+  "pre-commit": [
     "lint"
   ],
   "dependencies": {
-    "rc-tooltip": "2.x",
+    "rc-tooltip": "3.x",
-    "rc-util": "2.x"
+    "rc-util": "3.x"
   }
 }

src/Handle.jsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import Tooltip from 'rc-tooltip';
+
+export default class Handle extends React.Component {
+  constructor(props) {
+    super(props);
+
+    this.state = {
+      isTooltipVisible: false,
+    };
+  }
+
+  showTooltip() {
+    this.setState({
+      isTooltipVisible: true,
+    });
+  }
+
+  hideTooltip() {
+    this.setState({
+      isTooltipVisible: false,
+    });
+  }
+
+  render() {
+    const props = this.props;
+    const {className, tipTransitionName, tipFormatter, offset, value} = props;
+    const {dragging, noTip} = 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)}/>);
+
+    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 ? tipFormatter(value) : value}</span>}
+              delay={0}
+              transitionName={tipTransitionName}>
+              {handle}
+            </Tooltip>);
+  }
+}
+
+Handle.propTypes = {
+  className: React.PropTypes.string,
+  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

@@ -0,0 +1,36 @@
+import React from 'react';
+import rcUtil from 'rc-util';
+
+const Marks = ({className, marks, included, upperBound, lowerBound, max, min}) => {
+  const marksKeys = Object.keys(marks);
+  const marksCount = marksKeys.length;
+  const unit = 100 / (marksCount - 1);
+  const markWidth = unit / 2 + '%';
+
+  const range = max - min;
+  const elements = marksKeys.map(parseFloat).map((point) => {
+    const isActived = (!included && point === upperBound) ||
+            (included && point <= upperBound && point >= lowerBound);
+    const markClassName = rcUtil.classSet({
+      [className + '-text']: true,
+      [className + '-text-active']: isActived,
+    });
+
+    const style = { width: markWidth };
+    if (point === marksCount - 1) {
+      style.right = -unit / 4 + '%';
+    } else if (point === 0) {
+      style.left = -unit / 4 + '%';
+    } else {
+      style.left = (point - min) / range * 100 - unit / 4 + '%';
+    }
+
+    return (<span className={markClassName} style={style} key={point}>
+             {marks[point]}
+            </span>);
+  });
+
+  return <div className={className}>{elements}</div>;
+};
+
+export default Marks;

src/Slider.jsx

@@ -1,185 +1,206 @@
 import React from 'react';
-import Tooltip from 'rc-tooltip';
+import {Dom as DomUtils, classSet} from 'rc-util';
-import rcUtil, {Dom as DomUtils} from 'rc-util';
+import Track from './Track';
+import Handle from './Handle';
+import Steps from './Steps';
+import Marks from './Marks';
 
 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 getMousePosition(e) {
+  return e.pageX;
+}
+
 function pauseEvent(e) {
-  e.cancelBubble = true;
+  e.stopPropagation();
-  e.returnValue = false;
+  e.preventDefault();
-  if (e.stopPropagation) {
-    e.stopPropagation();
-  }
-  if (e.preventDefault) {
-    e.preventDefault();
-  }
 }
 
-function prefixClsFn(prefixCls, ...args) {
+function isEmpty(collection) {
-  return args.map((s)=> {
+  return Object.keys(collection).length === 0;
-    return prefixCls + '-' + s;
-  }).join(' ');
 }
 
-function getValueFromIndex(props) {
+class Slider extends React.Component {
-  let value;
+  constructor(props) {
-  const marksLen = props.marks.length;
+    super(props);
-  let index;
-  if ('index' in props) {
-    index = props.index;
-  } else {
-    index = props.defaultIndex;
-  }
-  if (marksLen > 0) {
-    value = ((props.max - props.min) / (marksLen - 1)) * (index);
-    value = value.toFixed(5) / 1;
-  }
-  return value;
-}
 
-const Slider = React.createClass({
+    const {range, min, max} = props;
-  propTypes: {
+    const initialValue = range ? [min, min] : min;
-    min: React.PropTypes.number,
+    const defaultValue = ('defaultValue' in props ? props.defaultValue : initialValue);
-    max: React.PropTypes.number,
+    const value = ('value' in props ? props.value : defaultValue);
-    step: React.PropTypes.number,
-    defaultValue: React.PropTypes.number,
-    defaultIndex: React.PropTypes.number,
-    value: React.PropTypes.number,
-    index: React.PropTypes.number,
-    marks: React.PropTypes.array,
-    isIncluded: React.PropTypes.bool,
-    className: React.PropTypes.string,
-    prefixCls: React.PropTypes.string,
-    disabled: React.PropTypes.bool,
-    children: React.PropTypes.any,
-    onBeforeChange: React.PropTypes.func,
-    onChange: React.PropTypes.func,
-    onAfterChange: React.PropTypes.func,
-  },
 
-  getDefaultProps() {
+    let upperBound;
-    return {
+    let lowerBound;
-      min: 0,
+    if (props.range) {
-      max: 100,
+      lowerBound = this.trimAlignValue(value[0]);
-      step: 1,
+      upperBound = this.trimAlignValue(value[1]);
-      defaultValue: 0,
+    } else {
-      marks: [],
+      upperBound = this.trimAlignValue(value);
-      isIncluded: true,
-      className: '',
-      prefixCls: 'rc-slider',
-      disabled: false,
-      defaultIndex: 0,
-    };
-  },
-
-  getInitialState() {
-    const props = this.props;
-    let value = props.defaultValue;
-    if ('value' in props) {
-      value = props.value;
     }
-    value = this._trimAlignValue(value);
+
-    const marksLen = props.marks.length;
+    let recent;
-    if (marksLen > 0) {
+    if (props.range && upperBound === lowerBound) {
-      value = getValueFromIndex(props);
+      if (lowerBound === max) {
+        recent = 'lowerBound';
+      }
+      if (upperBound === min) {
+        recent = 'upperBound';
+      }
+    } else {
+      recent = 'upperBound';
     }
-    return {
+
-      dragging: false,
+    this.state = {
-      showTooltip: false,
+      handle: null,
-      value: value,
+      recent: recent,
+      upperBound: upperBound,
+      // If Slider is not range, set `lowerBound` equal to `min`.
+      lowerBound: (lowerBound || min),
     };
-  },
+  }
 
   componentWillReceiveProps(nextProps) {
-    if ('value' in nextProps) {
+    if (nextProps.range) {
+      const value = nextProps.value;
+      if (value) {
+        this.setState({
+          upperBound: value[1],
+          lowerBound: value[0],
+        });
+      }
+    } else if ('value' in nextProps) {
       this.setState({
-        value: nextProps.value,
+        upperBound: nextProps.value,
-      });
-    } else if ('index' in nextProps) {
-      this.setState({
-        value: getValueFromIndex(nextProps),
       });
     }
-  },
+  }
 
-  onMouseUp() {
+  onChange(handle, value) {
-    this._end('mouse');
+    const props = this.props;
-  },
+    const isNotControlled = !('value' in props);
+    if (isNotControlled) {
+      this.setState({[handle]: value});
+    }
 
-  onTouchUp() {
+    const state = this.state;
-    this._end('touch');
+    const data = {
-  },
+      upperBound: state.upperBound,
+      lowerBound: state.lowerBound,
+    };
+    data[handle] = value;
+    const changedValue = props.range ? [data.lowerBound, data.upperBound] : data.upperBound;
+    props.onChange(changedValue);
+  }
 
   onMouseMove(e) {
-    const position = e.pageX || (e.clientX + document.documentElement.scrollLeft); // to compat ie8
+    const position = getMousePosition(e);
     this.onMove(e, position);
-  },
+  }
 
   onTouchMove(e) {
-    if (e.touches.length > 1 || (e.type === 'touchend' && e.touches.length > 0)) {
+    if (isNotTouchEvent(e)) {
-      this._end('touch');
+      this.end('touch');
       return;
     }
 
-    const position = this._getTouchPosition(e);
+    const position = getTouchPosition(e);
-
     this.onMove(e, position);
-  },
+  }
 
   onMove(e, position) {
     pauseEvent(e);
     const props = this.props;
     const state = this.state;
 
-    let value = state.value;
-    const oldValue = value;
-
     const diffPosition = position - this.startPosition;
-
     const diffValue = diffPosition / this.getSliderLength() * (props.max - props.min);
-    value = this._trimAlignValue(this.startValue + diffValue);
 
-    if (value !== oldValue && !('value' in props) && !('index' in props)) {
+    const value = this.trimAlignValue(this.startValue + diffValue);
-      this.setState({value: value});
+    const oldValue = state[state.handle];
-    }
+    if (value === oldValue) return;
-    if (value !== oldValue) {
+
-      this._triggerEvents('onChange', value);
+    this.onChange(state.handle, value);
-    }
+  }
-  },
 
   onTouchStart(e) {
-    if (e.touches.length > 1 || (e.type.toLowerCase() === 'touchend' && e.touches.length > 0)) {
+    if (isNotTouchEvent(e)) return;
-      return;
-    }
 
-    const position = this._getTouchPosition(e);
+    const position = getTouchPosition(e);
-    const value = this._calValueByPos(position);
+    this.onStart(position);
-    this._triggerEvents('onChange', value);
+    this.addDocumentEvents('touch');
-    this._start(position);
-    this._addDocumentEvents('touch');
     pauseEvent(e);
-  },
+  }
 
-  onSliderMouseDown(e) {
+  onMouseDown(e) {
-    const position = e.pageX || (e.clientX + document.documentElement.scrollLeft); // to compat ie8
+    const position = getMousePosition(e);
-    const value = this._calValueByPos(position);
+    this.onStart(position);
-    this._triggerEvents('onChange', value);
+    this.addDocumentEvents('mouse');
-    this._start(position);
-    this._addDocumentEvents('mouse');
     pauseEvent(e);
-  },
+  }
 
-  getIndex(v) {
+  onStart(position) {
     const props = this.props;
-    const value = v === undefined ? this.state.value : v;
+    props.onBeforeChange(this.getValue());
 
-    if (props.marks.length === 0) {
+    const value = this.calcValueByPos(position);
-      return Math.floor((value - props.min) / props.step);
+    this.startValue = value;
+    this.startPosition = position;
+
+    const state = this.state;
+    const {upperBound, lowerBound} = state;
+
+    let valueNeedChanging = 'upperBound';
+    if (this.props.range) {
+      const isLowerBoundCloser = Math.abs(upperBound - value) > Math.abs(lowerBound - value);
+      if (isLowerBoundCloser) {
+        valueNeedChanging = 'lowerBound';
+      }
+
+      const isAtTheSamePoint = (upperBound === lowerBound);
+      if (isAtTheSamePoint) {
+        valueNeedChanging = state.recent;
+      }
+
+      if (isAtTheSamePoint && (value !== upperBound)) {
+        valueNeedChanging = value < upperBound ? 'lowerBound' : 'upperBound';
+      }
     }
-    const unit = ((props.max - props.min) / (props.marks.length - 1)).toFixed(5);
+
-    return Math.round(value / unit);
+    this.setState({
-  },
+      handle: valueNeedChanging,
+      recent: valueNeedChanging,
+    });
+
+    const oldValue = state[valueNeedChanging];
+    if (value === oldValue) return;
+
+    this.onChange(valueNeedChanging, value);
+  }
+
+  getValue() {
+    const {lowerBound, upperBound} = this.state;
+    return this.props.range ? [lowerBound, upperBound] : upperBound;
+  }
+
+  getPoints() {
+    const {marks, step, min, max} = this.props;
+    const points = Object.keys(marks);
+    if (isEmpty(marks) || step > 1) {
+      for (let i = min; i <= max; i = i + step) {
+        points.push(i);
+      }
+    }
+    return points;
+  }
 
   getSliderLength() {
     const slider = this.refs.slider;
@@ -187,269 +208,72 @@ const Slider = React.createClass({
       return 0;
     }
 
-    return slider.getDOMNode().clientWidth;
+    return slider.clientWidth;
-  },
+  }
 
   getSliderStart() {
-    const slider = this.refs.slider.getDOMNode();
+    const slider = this.refs.slider;
     const rect = slider.getBoundingClientRect();
 
     return rect.left;
-  },
+  }
 
-  renderSteps() {
+  trimAlignValue(v) {
-    const props = this.props;
+    const state = this.state || {};
-    const marksLen = props.marks.length;
+    const {handle, lowerBound, upperBound} = state;
-    const stepNum = marksLen > 0 ? marksLen : Math.floor((props.max - props.min) / props.step) + 1;
+    const {min, max} = this.props;
-    const unit = 100 / (stepNum - 1);
 
-    const prefixCls = props.prefixCls;
-    const stepClassName = prefixClsFn(prefixCls, 'step');
-
-    const elements = [];
-    for (let i = 0; i < stepNum; i++) {
-      const offset = unit * i + '%';
-      const style = {
-        left: offset,
-      };
-      let className = prefixClsFn(prefixCls, 'dot');
-      if (props.isIncluded) {
-        if (i <= this.getIndex()) {
-          className = prefixClsFn(prefixCls, 'dot', 'dot-active');
-        }
-      } else {
-        className = (i === this.getIndex()) ? prefixClsFn(prefixCls, 'dot', 'dot-active') : className;
-      }
-
-      elements[i] = (
-        <span className={className} style={style} ref={'step' + i} key={'step' + i}></span>
-      );
-    }
-
-    return (
-      <div className={stepClassName}>
-        {elements}
-      </div>
-    );
-  },
-
-  renderMark(i) {
-    const marks = this.props.marks;
-    const marksLen = marks.length;
-    const unit = 100 / (marksLen - 1);
-    const offset = unit * i;
-
-    const style = {
-      width: unit / 2 + '%',
-    };
-
-    if (i === marksLen - 1) {
-      style.right = -unit / 4 + '%';
-    } else {
-      style.left = i > 0 ? offset - unit / 4 + '%' : -unit / 4 + '%';
-    }
-
-    const prefixCls = this.props.prefixCls;
-    let className = prefixClsFn(prefixCls, 'mark-text');
-
-    if (this.props.isIncluded) {
-      if (i <= this.getIndex()) {
-        className = prefixClsFn(prefixCls, 'mark-text', 'mark-text-active');
-      }
-    } else {
-      className = (i === this.getIndex()) ? prefixClsFn(prefixCls, 'mark-text', 'mark-text-active') : className;
-    }
-
-    return (
-      <span className={className} style={style} key={i}>{this.props.marks[i]}</span>
-    );
-  },
-
-  renderMarks() {
-    const marks = this.props.marks;
-    const marksLen = marks.length;
-    const elements = [];
-    for (let i = 0; i < marksLen; i++) {
-      elements[i] = this.renderMark(i);
-    }
-
-    const prefixCls = this.props.prefixCls;
-    const className = prefixClsFn(prefixCls, 'mark');
-
-    return (
-      <div className={className}>
-        {elements}
-      </div>
-    );
-  },
-
-  renderHandler(offset) {
-    const onStyle = {
-      left: offset,
-    };
-
-    const prefixCls = this.props.prefixCls;
-    const className = prefixClsFn(prefixCls, 'handle');
-
-    let events = {};
-
-    let tooltipVisible;
-
-    if (this.state.dragging) {
-      tooltipVisible = true;
-    } else {
-      events = {
-        onClick: this.showTooltip.bind(this, true),
-        onMouseEnter: this.showTooltip.bind(this, true),
-        onMouseLeave: this.showTooltip.bind(this, false),
-      };
-      tooltipVisible = this.state.showTooltip;
-    }
-
-    const handle = (<div className={className}
-      {...events}
-                          ref="handle"
-                          style={onStyle}></div>);
-
-    if (this.props.marks.length > 0) {
-      return handle;
-    }
-    return (
-      <Tooltip
-        placement={{points: ['bc', 'tc']}}
-        visible={tooltipVisible}
-        overlay={<span>{this.state.value}</span>}
-        delay={0}
-        prefixCls={prefixClsFn(prefixCls, 'tooltip')}>
-        {handle}
-      </Tooltip>
-    );
-  },
-
-  renderTrack(offset) {
-    const style = {
-      width: offset,
-    };
-
-    const prefixCls = this.props.prefixCls;
-    const trackClassName = prefixClsFn(prefixCls, 'track');
-
-    return (
-      <div className={trackClassName} ref="track" style={style}></div>
-    );
-  },
-
-  render() {
-    const state = this.state;
-    const props = this.props;
-    const value = state.value;
-    const offset = this._calcOffset(value);
-    const track = this.props.isIncluded ? this.renderTrack(offset) : null;
-    const ons = this.renderHandler(offset);
-    const steps = (props.step > 1 || props.marks.length > 0) ? this.renderSteps() : null;
-    const sliderMarks = (props.marks.length > 0) ? this.renderMarks() : null;
-    const prefixCls = props.prefixCls;
-    const disabled = props.disabled;
-    const sliderClassName = {
-      [prefixCls]: 1,
-      [props.className]: !!props.className,
-      [`${prefixCls}-disabled`]: disabled,
-    };
-
-    return (
-      <div className={rcUtil.classSet(sliderClassName)} ref="slider"
-           onTouchStart={disabled ? noop : this.onTouchStart}
-           onMouseDown={disabled ? noop : this.onSliderMouseDown}>
-        {track}
-        {ons}
-        {steps}
-        {sliderMarks}
-        {this.props.children}
-      </div>
-    );
-  },
-
-  showTooltip(show) {
-    this.setState({
-      showTooltip: show,
-    });
-  },
-
-  _trimAlignValue(v, propsArg) {
     let val = v;
-    const props = propsArg || this.props;
+    if (val <= min) {
-    const step = props.marks.length > 0 ? (props.max - props.min) / (props.marks.length - 1) : props.step;
+      val = min;
-
-    if (val <= props.min) {
-      val = props.min;
     }
-    if (val >= props.max) {
+    if (val >= max) {
-      val = props.max;
+      val = max;
+    }
+    if (handle === 'upperBound' && val <= lowerBound) {
+      val = lowerBound;
+    }
+    if (handle === 'lowerBound' && val >= upperBound) {
+      val = upperBound;
     }
 
-    const valModStep = (val - props.min) % step;
+    const points = this.getPoints().map(parseFloat);
-    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) {
+    return closestPoint;
-      alignValue += (valModStep > 0) ? step : (-step);
+  }
-    }
 
-    return parseFloat(alignValue.toFixed(5));
+  calcOffset(value) {
-  },
+    const {min, max} = this.props;
+    const ratio = (value - min) / (max - min);
+    return ratio * 100;
+  }
 
-  _calcOffset(value) {
+  calcValue(offset) {
-    const ratio = (value - this.props.min) / (this.props.max - this.props.min);
+    const {min, max} = this.props;
-    return ratio * 100 + '%';
-  },
-
-  _calcValue(offset) {
     const ratio = offset / this.getSliderLength();
-    return ratio * (this.props.max - this.props.min) + this.props.min;
+    return ratio * (max - min) + min;
-  },
+  }
 
-  _calValueByPos(position) {
+  calcValueByPos(position) {
     const pixelOffset = position - this.getSliderStart();
-    // pixelOffset -= (this.state.onSize / 2);
+    const nextValue = this.trimAlignValue(this.calcValue(pixelOffset));
-    const nextValue = this._trimAlignValue(this._calcValue(pixelOffset));
-    this.setState({
-      value: nextValue,
-    });
     return nextValue;
-  },
+  }
 
-  _getTouchPosition(e) {
+  addDocumentEvents(type) {
-    const touch = e.touches[0];
-    return touch.pageX;
-  },
-
-  _triggerEvents(event, v) {
-    const props = this.props;
-    const hasMarks = props.marks && 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);
+      this.onTouchMoveListener = DomUtils.addEventListener(document, 'touchmove', this.onTouchMove.bind(this));
-      this.onTouchUpListener = DomUtils.addEventListener(document, 'touchend', this.onTouchUp);
+      this.onTouchUpListener = DomUtils.addEventListener(document, 'touchend', this.end.bind(this, 'touch'));
     } else if (type === 'mouse') {
-      this.onMouseMoveListener = DomUtils.addEventListener(document, 'mousemove', this.onMouseMove);
+      this.onMouseMoveListener = DomUtils.addEventListener(document, 'mousemove', this.onMouseMove.bind(this));
-      this.onMouseUpListener = DomUtils.addEventListener(document, 'mouseup', this.onMouseUp);
+      this.onMouseUpListener = DomUtils.addEventListener(document, 'mouseup', this.end.bind(this, 'mouse'));
     }
-  },
+  }
 
-  _removeEventons(type) {
+  removeEventons(type) {
     if (type === 'touch') {
       this.onTouchMoveListener.remove();
       this.onTouchUpListener.remove();
@@ -457,25 +281,108 @@ const Slider = React.createClass({
       this.onMouseMoveListener.remove();
       this.onMouseUpListener.remove();
     }
-  },
+  }
 
-  _start(position) {
+  end(type) {
-    this._triggerEvents('onBeforeChange');
+    this.removeEventons(type);
-    this.startValue = this.state.value;
+    this.props.onAfterChange(this.getValue());
-    this.startPosition = position;
+    this.setState({handle: null});
-    this.setState({
+  }
-      dragging: true,
-    });
-  },
 
-  _end(type) {
+  render() {
-    this._removeEventons(type);
+    const {handle, upperBound, lowerBound} = this.state;
-    this._triggerEvents('onAfterChange');
+    const {className, prefixCls, disabled, dots, included, range,
-    this.setState({
+           marks, max, min, tipTransitionName, tipFormatter, children} = this.props;
-      dragging: false,
+    const marksCount = Object.keys(marks).length;
-      showTooltip: false,
+
+    const sliderClassName = classSet({
+      [prefixCls]: true,
+      [prefixCls + '-disabled']: disabled,
+      [className]: !!className,
     });
-  },
+
-});
+    const upperOffset = this.calcOffset(upperBound);
+    const lowerOffset = this.calcOffset(lowerBound);
+
+    let track = null;
+    if (included || range) {
+      const trackClassName = prefixCls + '-track';
+      track = <Track className={trackClassName} offset={lowerOffset} length={upperOffset - lowerOffset}/>;
+    }
+
+    const handleClassName = prefixCls + '-handle';
+    const isNoTip = (marksCount > 0) && !tipFormatter;
+    const upper = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip} tipFormatter={tipFormatter}
+                     offset={upperOffset} value={upperBound} dragging={handle === 'upperBound'} />);
+
+    let lower = null;
+    if (range) {
+      lower = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip} tipFormatter={tipFormatter}
+                 offset={lowerOffset} value={lowerBound} dragging={handle === 'lowerBound'} />);
+    }
+
+    const isIncluded = included || range;
+    return (
+      <div ref="slider" className={sliderClassName}
+           onTouchStart={disabled ? noop : this.onTouchStart.bind(this)}
+           onMouseDown={disabled ? noop : this.onMouseDown.bind(this)}>
+        {track}
+        {upper}
+        {lower}
+        <Steps prefixCls={prefixCls} points={this.getPoints()} dots={dots}
+               included={isIncluded} lowerBound={lowerBound}
+               upperBound={upperBound} max={max} min={min} />
+        <Marks className={prefixCls + '-mark'} marks={marks}
+               included={isIncluded} lowerBound={lowerBound}
+               upperBound={upperBound} max={max} min={min} />
+        {children}
+      </div>
+    );
+  }
+}
+
+Slider.propTypes = {
+  min: React.PropTypes.number,
+  max: React.PropTypes.number,
+  step: React.PropTypes.number,
+  defaultValue: React.PropTypes.oneOfType([
+    React.PropTypes.number,
+    React.PropTypes.arrayOf(React.PropTypes.number),
+  ]),
+  value: React.PropTypes.oneOfType([
+    React.PropTypes.number,
+    React.PropTypes.arrayOf(React.PropTypes.number),
+  ]),
+  marks: React.PropTypes.object,
+  included: React.PropTypes.bool,
+  className: React.PropTypes.string,
+  prefixCls: React.PropTypes.string,
+  disabled: React.PropTypes.bool,
+  children: React.PropTypes.any,
+  onBeforeChange: React.PropTypes.func,
+  onChange: React.PropTypes.func,
+  onAfterChange: React.PropTypes.func,
+  tipTransitionName: React.PropTypes.string,
+  tipFormatter: React.PropTypes.func,
+  dots: React.PropTypes.bool,
+  range: React.PropTypes.bool,
+};
+
+Slider.defaultProps = {
+  prefixCls: 'rc-slider',
+  className: '',
+  tipTransitionName: '',
+  min: 0,
+  max: 100,
+  step: 1,
+  marks: {},
+  onBeforeChange: noop,
+  onChange: noop,
+  onAfterChange: noop,
+  included: true,
+  disabled: false,
+  dots: false,
+  range: false,
+};
 
 export default Slider;

src/Steps.jsx

@@ -0,0 +1,24 @@
+import React from 'react';
+import { classSet } from 'rc-util';
+
+const Steps = ({prefixCls, points, dots, included, lowerBound, upperBound, max, min}) => {
+  const range = max - min;
+  const elements = points.filter((point) => typeof point === 'string' || dots).map(parseFloat)
+          .map((point) => {
+            const offset = (point - min) / range * 100 + '%';
+            const style = { left: offset };
+
+            const isActived = (!included && point === upperBound) ||
+                    (included && point <= upperBound && point >= lowerBound);
+            const pointClassName = classSet({
+              [prefixCls + '-dot']: true,
+              [prefixCls + '-dot-active']: isActived,
+            });
+
+            return <span className={pointClassName} style={style} key={point} />;
+          });
+
+  return <div className={prefixCls + '-step'}>{elements}</div>;
+};
+
+export default Steps;

src/Track.jsx

@@ -0,0 +1,11 @@
+import React from 'react';
+
+const Track = ({className, offset, length}) => {
+  const style = {
+    left: offset + '%',
+    width: length + '%',
+  };
+  return <div className={className} style={style} />;
+};
+
+export default Track;

tests/index.spec.js

@@ -2,7 +2,8 @@
 var expect = require('expect.js');
 var Slider = require('../index.js');
 var React = require('react');
-var TestUtils = React.addons.TestUtils;
+var ReactDOM = require('react-dom');
+var TestUtils = require('react-addons-test-utils');
 var Simulate = TestUtils.Simulate;
 var $ = require('jquery');
 require('../assets/index.less');
@@ -13,11 +14,11 @@ describe('rc-slider', function () {
   document.body.appendChild(div);
 
   afterEach(function () {
-    React.unmountComponentAtNode(div);
+    ReactDOM.unmountComponentAtNode(div);
   });
 
   it('should render a simple slider with value correctly!', function () {
-    var slider = React.render(
+    var slider = ReactDOM.render(
       <Slider className='rc-slider' defaultValue={40}/>,
       div
     );
@@ -25,13 +26,13 @@ describe('rc-slider', function () {
     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.value).to.be(40);
+    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 = React.render(
+    var slider = ReactDOM.render(
       <Slider className='rc-slider' step={20}/>,
       div
     );
@@ -39,32 +40,38 @@ describe('rc-slider', function () {
     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(6);
+    expect(slider.state.upperBound).to.be(0);
-    expect(slider.state.value).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 = React.render(
+    var slider = ReactDOM.render(
-      <Slider marks={["一","二","三","四","五"]} defaultIndex={3} />,
+      <Slider marks={{0: "一", 20: "二", 40: "三", 60: "四", 100: "五"}} 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(node.find('.rc-slider-dot').length).to.be(slider.props.marks.length);
+    expect(node.find('.rc-slider-dot').length).to.be(Object.keys(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(node.find('.rc-slider-mark-text').length).to.be(Object.keys(slider.props.marks).length);
-    expect(slider.getIndex()).to.be(3);
+    expect(slider.state.upperBound).to.be(40);
   });
 
   // it('should mouseDown works!', function (done) {
-  //   var slider = React.render(
+  //   var slider = ReactDOM.render(
   //     <Slider marks={["一","二","三","四","五"]} />,
   //     div
   //   );
   //   var selectedStep = slider.refs.step3.getDOMNode();
-    
+
   //   Simulate.mouseDown(selectedStep);
 
   //   setTimeout( function() {