bump 3.5.1

feat: support set style of specific mark point

README.md

@@ -88,11 +88,17 @@ 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>
@@ -100,6 +106,12 @@ ReactDOM.render(<Rcslider />, container);
           <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>
         </tr>
+        <tr>
+          <td>allowCross</td>
+          <td>boolean</td>
+          <td>true</td>
+          <td>When `range` is `true`, `allowCross` could be set as `true` to allow those two handles cross.</td>
+        </tr>
         <tr>
           <td>defaultValue</td>
           <td>number or [number, number]</td>
@@ -112,35 +124,17 @@ ReactDOM.render(<Rcslider />, container);
           <td></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>
-        </tr>
         <tr>
           <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>
         </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>
@@ -150,15 +144,27 @@ ReactDOM.render(<Rcslider />, container);
         </tr>
         <tr>
           <td>tipFormatter</td>
-          <td>func</td>
+          <td>function or `null`</td>
           <td></td>
-          <td>Format the value of the tooltip if it shows.</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

@@ -131,55 +131,6 @@
       cursor: not-allowed!important;
     }
   }
-
-  // slider tooltip style
-  &-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;
-      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;
-    }
-  }
 }
 
 .motion-common() {
@@ -241,3 +192,51 @@
     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;
+    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/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,93 @@
+/* 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: function() {
+    return {
+      value: [20, 40],
+    };
+  },
+  onSliderChange: function(value) {
+    log(value);
+    this.setState({
+      value: value,
+    });
+  },
+  render: function() {
+    return <Slider range value={this.state.value} onChange={this.onSliderChange} />;
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange: function(value) {
+    log(value);
+  },
+  onMinChange: function(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange: function(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render: function() {
+    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, 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 style={style}>
+      <p>Range with dynamic `max` `min`</p>
+      <DynamicBounds />
+    </div>
+  </div>
+  , document.getElementById('__react-content'));

examples/simple.js

@@ -1,51 +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};
-
-var log = console.log.bind(console);
-
-function percentFormatter(v) {
-  return v + " %";
-}
-
-ReactDOM.render(
-  <div>
-    <div style={style}>
-      <p>基础滑块</p>
-      <Slider onChange={log} 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={log} />
-    </div>
-    <div style={style}>
-      <p>双滑块，step=20 </p>
-      <Slider range dots step={20} defaultValue={[0, 30]} onAfterChange={log} 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 style={style}>
-      <p>基础滑块</p>
-      <Slider onChange={log} tipFormatter={percentFormatter} tipTransitionName='rc-slider-tooltip-zoom-down' />
-    </div>
-  </div>
-  , document.getElementById('__react-content'));

examples/slider.js

@@ -0,0 +1,106 @@
+/* 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: function() {
+    return {
+      value: 50,
+    };
+  },
+  onSliderChange: function(value) {
+    log(value);
+    this.setState({
+      value: value,
+    });
+  },
+  render: function() {
+    return <Slider value={this.state.value} onChange={this.onSliderChange} />;
+  },
+});
+
+const DynamicBounds = React.createClass({
+  getInitialState: function() {
+    return {
+      min: 0,
+      max: 100,
+    };
+  },
+  onSliderChange: function(value) {
+    log(value);
+  },
+  onMinChange: function(e) {
+    this.setState({
+      min: +e.target.value || 0,
+    });
+  },
+  onMaxChange: function(e) {
+    this.setState({
+      max: +e.target.value || 100,
+    });
+  },
+  render: function() {
+    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'));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rc-slider",
-  "version": "2.2.1",
+  "version": "3.5.1",
   "description": "slider ui component for react",
   "keywords": [
     "react",
@@ -39,7 +39,6 @@
   },
   "devDependencies": {
     "expect.js": "0.3.x",
-    "jquery": "^1.11.2",
     "pre-commit": "1.x",
     "rc-server": "3.x",
     "rc-tools": "4.x",
@@ -51,6 +50,8 @@
     "lint"
   ],
   "dependencies": {
+    "classnames": "^2.2.1",
+    "object-assign": "^4.0.1",
     "rc-tooltip": "3.x",
     "rc-util": "3.x"
   }

src/Handle.jsx

@@ -39,10 +39,10 @@ export default class Handle extends React.Component {
 
     const isTooltipVisible = dragging || this.state.isTooltipVisible;
     return (<Tooltip
-              prefixCls={className.replace('handle', 'tooltip')}
+              prefixCls={className.replace('slider-handle', 'tooltip')}
               placement="top"
               visible={isTooltipVisible}
-              overlay={<span>{tipFormatter ? tipFormatter(value) : value}</span>}
+              overlay={<span>{tipFormatter(value)}</span>}
               delay={0}
               transitionName={tipTransitionName}>
               {handle}

src/Marks.jsx

@@ -1,35 +1,39 @@
 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, 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({
+  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 style = {
+      width: markWidth + '%',
+      marginLeft: -markWidth / 2 + '%',
+    };
+    style.left = (point - min) / range * 100 + '%';
 
-    elements.push(<span className={markClassName} style={style} key={i}>
-                    {marks[i]}
-                  </span>);
-  }
+    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>);
+  return <div className={className}>{elements}</div>;
 };
 
 export default Marks;

src/Slider.jsx

@@ -1,5 +1,7 @@
 import React from 'react';
-import {Dom as DomUtils, classSet} from 'rc-util';
+import {Dom as DomUtils} from 'rc-util';
+import classNames from 'classnames';
+import objectAssign from 'object-assign';
 import Track from './Track';
 import Handle from './Handle';
 import Steps from './Steps';
@@ -29,28 +31,26 @@ class Slider extends React.Component {
   constructor(props) {
     super(props);
 
+    const {range, min, max} = props;
+    const initialValue = range ? [min, min] : min;
+    const defaultValue = ('defaultValue' in props ? props.defaultValue : initialValue);
+    const value = (props.value !== undefined ? props.value : defaultValue);
+
     let upperBound;
     let lowerBound;
     if (props.range) {
-      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);
+      upperBound = this.trimAlignValue(value[1]);
     } 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);
     }
 
     let recent;
     if (props.range && upperBound === lowerBound) {
-      if (lowerBound === props.max) {
+      if (lowerBound === max) {
         recent = 'lowerBound';
       }
-      if (upperBound === props.min) {
+      if (upperBound === min) {
         recent = 'upperBound';
       }
     } else {
@@ -62,30 +62,57 @@ class Slider extends React.Component {
       recent: recent,
       upperBound: upperBound,
       // If Slider is not range, set `lowerBound` equal to `min`.
-      lowerBound: (lowerBound || props.min),
+      lowerBound: (lowerBound || min),
     };
   }
 
   componentWillReceiveProps(nextProps) {
+    if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
+
+    const {lowerBound, upperBound} = this.state;
     if (nextProps.range) {
-      const value = nextProps.value;
-      if (value) {
-        this.setState({
-          upperBound: value[1],
-          lowerBound: value[0],
-        });
+      const value = nextProps.value || [lowerBound, upperBound];
+      const nextUpperBound = this.trimAlignValue(value[1], nextProps);
+      const nextLowerBound = this.trimAlignValue(value[0], nextProps);
+      if (nextLowerBound === lowerBound && nextUpperBound === upperBound) return;
+
+      this.setState({
+        upperBound: nextUpperBound,
+        lowerBound: nextLowerBound,
+      });
+      if (this.isValueOutOfBounds(upperBound, nextProps) ||
+        this.isValueOutOfBounds(lowerBound, nextProps)) {
+        this.props.onChange([nextLowerBound, nextUpperBound]);
       }
-    } else if ('value' in nextProps) {
+    } else {
+      const value = nextProps.value !== undefined ? nextProps.value : upperBound;
+      const nextValue = this.trimAlignValue(value, nextProps);
+      if (nextValue === upperBound && lowerBound === nextProps.min) return;
+
       this.setState({
-        upperBound: nextProps.value,
-      });
-    } else if ('index' in nextProps) {
-      this.setState({
-        upperBound: this.calcValueFromProps(nextProps),
+        upperBound: nextValue,
+        lowerBound: nextProps.min,
       });
+      if (this.isValueOutOfBounds(upperBound, nextProps)) {
+        this.props.onChange(nextValue);
+      }
     }
   }
 
+  onChange(state) {
+    const props = this.props;
+    const isNotControlled = !('value' in props);
+    if (isNotControlled) {
+      this.setState(state);
+    } else if (state.handle) {
+      this.setState({handle: state.handle});
+    }
+
+    const data = objectAssign({}, this.state, state);
+    const changedValue = props.range ? [data.lowerBound, data.upperBound] : data.upperBound;
+    props.onChange(changedValue);
+  }
+
   onMouseMove(e) {
     const position = getMousePosition(e);
     this.onMove(e, position);
@@ -113,11 +140,26 @@ class Slider extends React.Component {
     const oldValue = state[state.handle];
     if (value === oldValue) return;
 
-    if (!('value' in props) && !('index' in props)) {
-      this.setState({[state.handle]: value}, () => {
-        this.triggerEvents('onChange', this.getValue());
+    if (props.allowCross && value < state.lowerBound && state.handle === 'upperBound') {
+      this.onChange({
+        handle: 'lowerBound',
+        lowerBound: value,
+        upperBound: this.state.lowerBound,
       });
+      return;
     }
+    if (props.allowCross && value > state.upperBound && state.handle === 'lowerBound') {
+      this.onChange({
+        handle: 'upperBound',
+        upperBound: value,
+        lowerBound: this.state.upperBound,
+      });
+      return;
+    }
+
+    this.onChange({
+      [state.handle]: value,
+    });
   }
 
   onTouchStart(e) {
@@ -129,7 +171,7 @@ class Slider extends React.Component {
     pauseEvent(e);
   }
 
-  onSliderMouseDown(e) {
+  onMouseDown(e) {
     const position = getMousePosition(e);
     this.onStart(position);
     this.addDocumentEvents('mouse');
@@ -137,7 +179,8 @@ class Slider extends React.Component {
   }
 
   onStart(position) {
-    this.triggerEvents('onBeforeChange');
+    const props = this.props;
+    props.onBeforeChange(this.getValue());
 
     const value = this.calcValueByPos(position);
     this.startValue = value;
@@ -166,9 +209,13 @@ class Slider extends React.Component {
     this.setState({
       handle: valueNeedChanging,
       recent: valueNeedChanging,
+    });
+
+    const oldValue = state[valueNeedChanging];
+    if (value === oldValue) return;
+
+    this.onChange({
       [valueNeedChanging]: value,
-    }, () => {
-      this.triggerEvents('onChange', this.getValue());
     });
   }
 
@@ -177,16 +224,6 @@ class Slider extends React.Component {
     return this.props.range ? [lowerBound, upperBound] : upperBound;
   }
 
-  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);
-  }
-
   getSliderLength() {
     const slider = this.refs.slider;
     if (!slider) {
@@ -203,11 +240,24 @@ class Slider extends React.Component {
     return rect.left;
   }
 
-  trimAlignValue(v) {
-    const state = this.state || {};
+  getPrecision() {
     const props = this.props;
-    const {marks, min, max} = props;
-    const step = marks.length > 0 ? (max - min) / (marks.length - 1) : props.step;
+    const stepString = props.step.toString();
+    let precision = 0;
+    if (stepString.indexOf('.') >= 0) {
+      precision = stepString.length - stepString.indexOf('.') - 1;
+    }
+    return precision;
+  }
+
+  isValueOutOfBounds(value, props) {
+    return value < props.min || value > props.max;
+  }
+
+  trimAlignValue(v, nextProps) {
+    const state = this.state || {};
+    const {handle, lowerBound, upperBound} = state;
+    const {marks, step, min, max, allowCross} = objectAssign({}, this.props, nextProps || {});
 
     let val = v;
     if (val <= min) {
@@ -216,21 +266,23 @@ class Slider extends React.Component {
     if (val >= max) {
       val = max;
     }
-    if (state.handle === 'upperBound' && val <= state.lowerBound) {
-      val = state.lowerBound;
+    if (!allowCross && handle === 'upperBound' && val <= lowerBound) {
+      val = lowerBound;
     }
-    if (state.handle === 'lowerBound' && val >= state.upperBound) {
-      val = state.upperBound;
+    if (!allowCross && handle === 'lowerBound' && val >= upperBound) {
+      val = upperBound;
     }
 
-    const valModStep = (val - min) % step;
-    let alignValue = val - valModStep;
-
-    if (Math.abs(valModStep) * 2 >= step) {
-      alignValue += (valModStep > 0) ? step : (-step);
+    const points = Object.keys(marks).map(parseFloat);
+    if (step !== null) {
+      const closestStep = Math.round(val / step) * step;
+      points.push(closestStep);
     }
 
-    return parseFloat(alignValue.toFixed(5));
+    const diffs = points.map((point) => Math.abs(val - point));
+    const closestPoint = points[diffs.indexOf(Math.min.apply(Math, diffs))];
+
+    return step !== null ? parseFloat(closestPoint.toFixed(this.getPrecision())) : closestPoint;
   }
 
   calcOffset(value) {
@@ -251,33 +303,6 @@ 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
@@ -289,7 +314,7 @@ class Slider extends React.Component {
     }
   }
 
-  removeEventons(type) {
+  removeEvents(type) {
     if (type === 'touch') {
       this.onTouchMoveListener.remove();
       this.onTouchUpListener.remove();
@@ -300,71 +325,53 @@ class Slider extends React.Component {
   }
 
   end(type) {
-    this.removeEventons(type);
-    this.triggerEvents('onAfterChange', this.getValue());
+    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, range} = props;
-    const {marks, step, max, min, tipTransitionName, tipFormatter, children} = props;
-    const marksLen = marks.length;
-
-    const sliderClassName = classSet({
-      [prefixCls]: true,
-      [prefixCls + '-disabled']: disabled,
-      [className]: !!className,
-    });
+    const {className, prefixCls, disabled, dots, included, range, step,
+      marks, max, min, tipTransitionName, tipFormatter, children} = this.props;
 
     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) && !tipFormatter;
-    const upper = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip} tipFormatter={tipFormatter}
-                     offset={upperOffset} value={upperBound} dragging={handle === 'upperBound'} />);
+    const isNoTip = (step === null) || (tipFormatter === null);
+
+    const upper = (<Handle className={handleClassName}
+                           noTip={isNoTip} tipTransitionName={tipTransitionName} 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 upperIndex = this.getIndex(upperBound);
-
-    let steps = null;
-    if (marksLen > 0 || (step > 1 && dots)) {
-      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)}/>);
+      lower = (<Handle className={handleClassName}
+                       noTip={isNoTip} tipTransitionName={tipTransitionName} tipFormatter={tipFormatter}
+                       offset={lowerOffset} value={lowerBound} dragging={handle === 'lowerBound'}/>);
     }
 
+    const sliderClassName = classNames({
+      [prefixCls]: true,
+      [prefixCls + '-disabled']: disabled,
+      [className]: !!className,
+    });
+    const isIncluded = included || range;
     return (
       <div ref="slider" className={sliderClassName}
            onTouchStart={disabled ? noop : this.onTouchStart.bind(this)}
-           onMouseDown={disabled ? noop : this.onSliderMouseDown.bind(this)}>
-        {track}
+           onMouseDown={disabled ? noop : this.onMouseDown.bind(this)}>
         {upper}
         {lower}
-        {steps}
-        {mark}
+        <Track className={prefixCls + '-track'} included={isIncluded}
+               offset={lowerOffset} length={upperOffset - lowerOffset}/>
+        <Steps prefixCls={prefixCls} marks={marks} dots={dots} step={step}
+              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>
     );
@@ -379,14 +386,11 @@ 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,
@@ -399,22 +403,26 @@ Slider.propTypes = {
   tipFormatter: React.PropTypes.func,
   dots: React.PropTypes.bool,
   range: React.PropTypes.bool,
+  allowCross: React.PropTypes.bool,
 };
 
 Slider.defaultProps = {
+  prefixCls: 'rc-slider',
+  className: '',
+  tipTransitionName: '',
   min: 0,
   max: 100,
   step: 1,
-  defaultIndex: 0,
-  marks: [],
-  isIncluded: true, // @Deprecated
+  marks: {},
+  onBeforeChange: noop,
+  onChange: noop,
+  onAfterChange: noop,
+  tipFormatter: value => value,
   included: true,
-  className: '',
-  prefixCls: 'rc-slider',
   disabled: false,
-  tipTransitionName: '',
   dots: false,
   range: false,
+  allowCross: true,
 };
 
 export default Slider;

src/Steps.jsx

@@ -1,28 +1,35 @@
 import React from 'react';
-import rcUtil from 'rc-util';
+import classNames from 'classnames';
 
-const Steps = ({className, stepNum, included, lowerIndex, upperIndex}) => {
-  const dotClassName = className.replace('step', 'dot');
-  const unit = 100 / (stepNum - 1);
+function calcPoints(marks, dots, step, min, max) {
+  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 Steps = ({prefixCls, marks, dots, step, included,
+                lowerBound, upperBound, max, min}) => {
+  const range = max - min;
+  const elements = calcPoints(marks, dots, step, min, max).map((point) => {
+    const offset = (point - min) / range * 100 + '%';
     const style = { 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,9 +1,10 @@
 import React from 'react';
 
-const Track = ({className, offset, length}) => {
+const Track = ({className, included, offset, length}) => {
   const style = {
     left: offset + '%',
     width: length + '%',
+    visibility: included ? 'visible' : 'hidden',
   };
   return <div className={className} style={style} />;
 };

tests/index.spec.js

@@ -1,83 +1,143 @@
+const expect = require('expect.js');
+const React = require('react');
+const ReactDOM = require('react-dom');
+const ReactTestUtils = require('react-addons-test-utils');
+const Slider = require('..');
 
-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 () {
+describe('rc-slider', function() {
   this.timeout(5000);
-  var div = document.createElement('div');
+  const div = document.createElement('div');
   document.body.appendChild(div);
 
-  afterEach(function () {
-    React.unmountComponentAtNode(div);
+  afterEach(() => {
+    ReactDOM.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 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 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);
+  it('should render a Slider with default value correctly', () => {
+    const sliderWithDefaultValue = ReactDOM.render(<Slider defaultValue={50} />, div);
+    expect(sliderWithDefaultValue.state.upperBound).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(sliderWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.match(/left: 50%;/);
 
-    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);
+    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 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 render a Slider with value corrently', () => {
+    const sliderWithValue = ReactDOM.render(<Slider value={50} />, div);
+    expect(sliderWithValue.state.upperBound).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 mouseDown works!', function (done) {
-  //   var slider = ReactDOM.render(
-  //     <Slider marks={["一","二","三","四","五"]} />,
-  //     div
-  //   );
-  //   var selectedStep = slider.refs.step3.getDOMNode();
+  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);
+  });
 
-  //   Simulate.mouseDown(selectedStep);
+  it('should render a Range with default value correctly', () => {
+    const rangeWithDefaultValue = ReactDOM.render(<Slider range defaultValue={[0, 50]} />, div);
+    expect(rangeWithDefaultValue.state.lowerBound).to.be(0);
+    expect(rangeWithDefaultValue.state.upperBound).to.be(50);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.match(/left: 50%;/);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(rangeWithDefaultValue, 'rc-slider-handle')[1]
+           .style.cssText)
+      .to.match(/left: 0%;/);
 
-  //   setTimeout( function() {
-  //     expect(slider.state.active).to.be('active');
-  //     done();
-  //   }, 200);
-  // });
+    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 Range with value correctly', () => {
+    const rangeWithValue = ReactDOM.render(<Slider range value={[50, 100]} />, div);
+    expect(rangeWithValue.state.lowerBound).to.be(50);
+    expect(rangeWithValue.state.upperBound).to.be(100);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-handle')[0]
+           .style.cssText)
+      .to.match(/left: 100%;/);
+    expect(ReactTestUtils
+           .scryRenderedDOMComponentsWithClass(rangeWithValue, 'rc-slider-handle')[1]
+           .style.cssText)
+      .to.match(/left: 50%;/);
+
+    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.upperBound).to.be(10);
+    ReactDOM.unmountComponentAtNode(div);
+
+    const sliderWithMax = ReactDOM.render(<Slider value={100} max={90} />, div);
+    expect(sliderWithMax.state.upperBound).to.be(90);
+    ReactDOM.unmountComponentAtNode(div);
+
+    const range = ReactDOM.render(<Slider range value={[0, 100]} min={10} max={90} />, div);
+    expect(range.state.lowerBound).to.be(10);
+    expect(range.state.upperBound).to.be(90);
+    ReactDOM.unmountComponentAtNode(div);
+  });
 });