|
| 1 | +'use strict'; |
| 2 | + |
| 3 | +Object.defineProperty(exports, '__esModule', { |
| 4 | + value: true, |
| 5 | +}); |
| 6 | + |
| 7 | +var _extends = |
| 8 | + Object.assign || |
| 9 | + function(target) { |
| 10 | + for (var i = 1; i < arguments.length; i++) { |
| 11 | + var source = arguments[i]; |
| 12 | + for (var key in source) { |
| 13 | + if (Object.prototype.hasOwnProperty.call(source, key)) { |
| 14 | + target[key] = source[key]; |
| 15 | + } |
| 16 | + } |
| 17 | + } |
| 18 | + return target; |
| 19 | + }; |
| 20 | + |
| 21 | +var _createClass = (function() { |
| 22 | + function defineProperties(target, props) { |
| 23 | + for (var i = 0; i < props.length; i++) { |
| 24 | + var descriptor = props[i]; |
| 25 | + descriptor.enumerable = descriptor.enumerable || false; |
| 26 | + descriptor.configurable = true; |
| 27 | + if ('value' in descriptor) descriptor.writable = true; |
| 28 | + Object.defineProperty(target, descriptor.key, descriptor); |
| 29 | + } |
| 30 | + } |
| 31 | + return function(Constructor, protoProps, staticProps) { |
| 32 | + if (protoProps) defineProperties(Constructor.prototype, protoProps); |
| 33 | + if (staticProps) defineProperties(Constructor, staticProps); |
| 34 | + return Constructor; |
| 35 | + }; |
| 36 | +})(); |
| 37 | + |
| 38 | +var _react = require('react'); |
| 39 | + |
| 40 | +var _react2 = _interopRequireDefault(_react); |
| 41 | + |
| 42 | +var _propTypes = require('prop-types'); |
| 43 | + |
| 44 | +var _propTypes2 = _interopRequireDefault(_propTypes); |
| 45 | + |
| 46 | +var _styles = require('../styles'); |
| 47 | + |
| 48 | +var _styles2 = _interopRequireDefault(_styles); |
| 49 | + |
| 50 | +var _defaultRanges = require('../defaultRanges'); |
| 51 | + |
| 52 | +var _DayCell = require('./DayCell'); |
| 53 | + |
| 54 | +var _classnames = require('classnames'); |
| 55 | + |
| 56 | +var _classnames2 = _interopRequireDefault(_classnames); |
| 57 | + |
| 58 | +function _interopRequireDefault(obj) { |
| 59 | + return obj && obj.__esModule ? obj : { default: obj }; |
| 60 | +} |
| 61 | + |
| 62 | +function _defineProperty(obj, key, value) { |
| 63 | + if (key in obj) { |
| 64 | + Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); |
| 65 | + } else { |
| 66 | + obj[key] = value; |
| 67 | + } |
| 68 | + return obj; |
| 69 | +} |
| 70 | + |
| 71 | +function _classCallCheck(instance, Constructor) { |
| 72 | + if (!(instance instanceof Constructor)) { |
| 73 | + throw new TypeError('Cannot call a class as a function'); |
| 74 | + } |
| 75 | +} |
| 76 | + |
| 77 | +function _possibleConstructorReturn(self, call) { |
| 78 | + if (!self) { |
| 79 | + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); |
| 80 | + } |
| 81 | + return call && (typeof call === 'object' || typeof call === 'function') ? call : self; |
| 82 | +} |
| 83 | + |
| 84 | +function _inherits(subClass, superClass) { |
| 85 | + if (typeof superClass !== 'function' && superClass !== null) { |
| 86 | + throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); |
| 87 | + } |
| 88 | + subClass.prototype = Object.create(superClass && superClass.prototype, { |
| 89 | + constructor: { value: subClass, enumerable: false, writable: true, configurable: true }, |
| 90 | + }); |
| 91 | + if (superClass) |
| 92 | + Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : (subClass.__proto__ = superClass); |
| 93 | +} |
| 94 | + |
| 95 | +var DefinedRanges = (function(_Component) { |
| 96 | + _inherits(DefinedRanges, _Component); |
| 97 | + |
| 98 | + function DefinedRanges(props) { |
| 99 | + _classCallCheck(this, DefinedRanges); |
| 100 | + |
| 101 | + var _this = _possibleConstructorReturn( |
| 102 | + this, |
| 103 | + (DefinedRanges.__proto__ || Object.getPrototypeOf(DefinedRanges)).call(this, props) |
| 104 | + ); |
| 105 | + |
| 106 | + _this.state = { |
| 107 | + rangeOffset: 0, |
| 108 | + focusedInput: -1, |
| 109 | + }; |
| 110 | + _this.handleRangeChange = _this.handleRangeChange.bind(_this); |
| 111 | + return _this; |
| 112 | + } |
| 113 | + |
| 114 | + _createClass(DefinedRanges, [ |
| 115 | + { |
| 116 | + key: 'handleRangeChange', |
| 117 | + value: function handleRangeChange(range) { |
| 118 | + var _props = this.props, |
| 119 | + onChange = _props.onChange, |
| 120 | + ranges = _props.ranges, |
| 121 | + focusedRange = _props.focusedRange; |
| 122 | + |
| 123 | + var selectedRange = ranges[focusedRange[0]]; |
| 124 | + if (!onChange || !selectedRange) return; |
| 125 | + onChange( |
| 126 | + _defineProperty( |
| 127 | + {}, |
| 128 | + selectedRange.key || 'range' + (focusedRange[0] + 1), |
| 129 | + _extends({}, selectedRange, range) |
| 130 | + ) |
| 131 | + ); |
| 132 | + }, |
| 133 | + }, |
| 134 | + { |
| 135 | + key: 'getSelectedRange', |
| 136 | + value: function getSelectedRange(ranges, staticRange) { |
| 137 | + var focusedRangeIndex = ranges.findIndex(function(range) { |
| 138 | + if (!range.startDate || !range.endDate || range.disabled) return false; |
| 139 | + return staticRange.isSelected(range); |
| 140 | + }); |
| 141 | + var selectedRange = ranges[focusedRangeIndex]; |
| 142 | + return { selectedRange: selectedRange, focusedRangeIndex: focusedRangeIndex }; |
| 143 | + }, |
| 144 | + }, |
| 145 | + { |
| 146 | + key: 'render', |
| 147 | + value: function render() { |
| 148 | + var _this2 = this; |
| 149 | + |
| 150 | + var _props2 = this.props, |
| 151 | + onPreviewChange = _props2.onPreviewChange, |
| 152 | + ranges = _props2.ranges, |
| 153 | + rangeColors = _props2.rangeColors, |
| 154 | + className = _props2.className; |
| 155 | + |
| 156 | + return _react2.default.createElement( |
| 157 | + 'div', |
| 158 | + { className: (0, _classnames2.default)(_styles2.default.definedRangesWrapper, className) }, |
| 159 | + this.props.headerContent, |
| 160 | + _react2.default.createElement( |
| 161 | + 'div', |
| 162 | + { className: _styles2.default.staticRanges }, |
| 163 | + this.props.staticRanges.map(function(staticRange, i) { |
| 164 | + var _getSelectedRange = _this2.getSelectedRange(ranges, staticRange), |
| 165 | + selectedRange = _getSelectedRange.selectedRange, |
| 166 | + focusedRangeIndex = _getSelectedRange.focusedRangeIndex; |
| 167 | + |
| 168 | + return _react2.default.createElement( |
| 169 | + 'button', |
| 170 | + { |
| 171 | + type: 'button', |
| 172 | + className: (0, _classnames2.default)( |
| 173 | + _styles2.default.staticRange, |
| 174 | + _defineProperty( |
| 175 | + {}, |
| 176 | + _styles2.default.staticRangeSelected, |
| 177 | + Boolean(selectedRange) |
| 178 | + ) |
| 179 | + ), |
| 180 | + style: { |
| 181 | + color: selectedRange |
| 182 | + ? selectedRange.color || rangeColors[focusedRangeIndex] |
| 183 | + : null, |
| 184 | + }, |
| 185 | + key: i, |
| 186 | + onClick: function onClick() { |
| 187 | + return _this2.handleRangeChange(staticRange.range(_this2.props)); |
| 188 | + }, |
| 189 | + onFocus: function onFocus() { |
| 190 | + return onPreviewChange && onPreviewChange(staticRange.range(_this2.props)); |
| 191 | + }, |
| 192 | + onMouseOver: function onMouseOver() { |
| 193 | + return onPreviewChange && onPreviewChange(staticRange.range(_this2.props)); |
| 194 | + }, |
| 195 | + onMouseLeave: function onMouseLeave() { |
| 196 | + _this2.props.onPreviewChange && _this2.props.onPreviewChange(); |
| 197 | + }, |
| 198 | + }, |
| 199 | + _react2.default.createElement( |
| 200 | + 'span', |
| 201 | + { tabIndex: -1, className: _styles2.default.staticRangeLabel }, |
| 202 | + staticRange.label |
| 203 | + ) |
| 204 | + ); |
| 205 | + }) |
| 206 | + ), |
| 207 | + _react2.default.createElement( |
| 208 | + 'div', |
| 209 | + { className: _styles2.default.inputRanges }, |
| 210 | + this.props.inputRanges.map(function(rangeOption, i) { |
| 211 | + return _react2.default.createElement( |
| 212 | + 'div', |
| 213 | + { className: _styles2.default.inputRange, key: i }, |
| 214 | + _react2.default.createElement( |
| 215 | + 'label', |
| 216 | + { className: _styles2.default.inputRangeLabel }, |
| 217 | + _react2.default.createElement('input', { |
| 218 | + className: _styles2.default.inputRangeInput, |
| 219 | + onFocus: function onFocus() { |
| 220 | + return _this2.setState({ focusedInput: i, rangeOffset: 0 }); |
| 221 | + }, |
| 222 | + onBlur: function onBlur() { |
| 223 | + return _this2.setState({ rangeOffset: 0 }); |
| 224 | + }, |
| 225 | + onChange: function onChange(e) { |
| 226 | + var value = parseInt(e.target.value, 10); |
| 227 | + value = isNaN(value) ? 0 : Math.max(Math.min(99999, value), 0); |
| 228 | + _this2.handleRangeChange(rangeOption.range(value, _this2.props)); |
| 229 | + }, |
| 230 | + onClick: function onClick(e) { |
| 231 | + event.target.setSelectionRange(0, event.target.value.length); |
| 232 | + }, |
| 233 | + placeHolder: '-', |
| 234 | + min: 0, |
| 235 | + max: 366, |
| 236 | + value: rangeOption.getCurrentValue |
| 237 | + ? rangeOption.getCurrentValue(ranges[_this2.props.focusedRange[0]] || {}) |
| 238 | + : '', |
| 239 | + }), |
| 240 | + |
| 241 | + rangeOption.label |
| 242 | + ) |
| 243 | + ); |
| 244 | + }) |
| 245 | + ), |
| 246 | + this.props.footerContent |
| 247 | + ); |
| 248 | + }, |
| 249 | + }, |
| 250 | + ]); |
| 251 | + |
| 252 | + return DefinedRanges; |
| 253 | +})(_react.Component); |
| 254 | + |
| 255 | +DefinedRanges.propTypes = { |
| 256 | + inputRanges: _propTypes2.default.array, |
| 257 | + staticRanges: _propTypes2.default.array, |
| 258 | + ranges: _propTypes2.default.arrayOf(_DayCell.rangeShape), |
| 259 | + focusedRange: _propTypes2.default.arrayOf(_propTypes2.default.number), |
| 260 | + onPreviewChange: _propTypes2.default.func, |
| 261 | + onChange: _propTypes2.default.func, |
| 262 | + footerContent: _propTypes2.default.any, |
| 263 | + headerContent: _propTypes2.default.any, |
| 264 | + rangeColors: _propTypes2.default.arrayOf(_propTypes2.default.string), |
| 265 | + className: _propTypes2.default.string, |
| 266 | +}; |
| 267 | + |
| 268 | +DefinedRanges.defaultProps = { |
| 269 | + inputRanges: _defaultRanges.defaultInputRanges, |
| 270 | + staticRanges: _defaultRanges.defaultStaticRanges, |
| 271 | + ranges: [], |
| 272 | + rangeColors: ['#3d91ff', '#3ecf8e', '#fed14c'], |
| 273 | + focusedRange: [0, 0], |
| 274 | +}; |
| 275 | + |
| 276 | +exports.default = DefinedRanges; |
0 commit comments