/*
|
react-datetime v2.6.1
|
https://github.com/arqex/react-datetime
|
MIT: https://github.com/arqex/react-datetime/raw/master/LICENSE
|
*/
|
(function webpackUniversalModuleDefinition(root, factory) {
|
if(typeof exports === 'object' && typeof module === 'object')
|
module.exports = factory(require("React"), require("moment"), require("ReactDOM"));
|
else if(typeof define === 'function' && define.amd)
|
define(["React", "moment", "ReactDOM"], factory);
|
else if(typeof exports === 'object')
|
exports["Datetime"] = factory(require("React"), require("moment"), require("ReactDOM"));
|
else
|
root["Datetime"] = factory(root["React"], root["moment"], root["ReactDOM"]);
|
})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_9__) {
|
return /******/ (function(modules) { // webpackBootstrap
|
/******/ // The module cache
|
/******/ var installedModules = {};
|
|
/******/ // The require function
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/ // Check if module is in cache
|
/******/ if(installedModules[moduleId])
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ // Create a new module (and put it into the cache)
|
/******/ var module = installedModules[moduleId] = {
|
/******/ exports: {},
|
/******/ id: moduleId,
|
/******/ loaded: false
|
/******/ };
|
|
/******/ // Execute the module function
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/ // Flag the module as loaded
|
/******/ module.loaded = true;
|
|
/******/ // Return the exports of the module
|
/******/ return module.exports;
|
/******/ }
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
/******/ __webpack_require__.m = modules;
|
|
/******/ // expose the module cache
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/ // __webpack_public_path__
|
/******/ __webpack_require__.p = "";
|
|
/******/ // Load entry module and return exports
|
/******/ return __webpack_require__(0);
|
/******/ })
|
/************************************************************************/
|
/******/ ([
|
/* 0 */
|
/***/ function(module, exports, __webpack_require__) {
|
|
'use strict';
|
|
var assign = __webpack_require__(1),
|
React = __webpack_require__(2),
|
DaysView = __webpack_require__(3),
|
MonthsView = __webpack_require__(5),
|
YearsView = __webpack_require__(6),
|
TimeView = __webpack_require__(7),
|
moment = __webpack_require__(4)
|
;
|
|
var TYPES = React.PropTypes;
|
var Datetime = React.createClass({
|
mixins: [
|
__webpack_require__(8)
|
],
|
viewComponents: {
|
days: DaysView,
|
months: MonthsView,
|
years: YearsView,
|
time: TimeView
|
},
|
propTypes: {
|
// value: TYPES.object | TYPES.string,
|
// defaultValue: TYPES.object | TYPES.string,
|
onFocus: TYPES.func,
|
onBlur: TYPES.func,
|
onChange: TYPES.func,
|
locale: TYPES.string,
|
input: TYPES.bool,
|
// dateFormat: TYPES.string | TYPES.bool,
|
// timeFormat: TYPES.string | TYPES.bool,
|
inputProps: TYPES.object,
|
timeConstraints: TYPES.object,
|
viewMode: TYPES.oneOf(['years', 'months', 'days', 'time']),
|
isValidDate: TYPES.func,
|
open: TYPES.bool,
|
strictParsing: TYPES.bool,
|
closeOnSelect: TYPES.bool,
|
closeOnTab: TYPES.bool
|
},
|
|
getDefaultProps: function() {
|
var nof = function(){};
|
return {
|
className: '',
|
defaultValue: '',
|
inputProps: {},
|
input: true,
|
onFocus: nof,
|
onBlur: nof,
|
onChange: nof,
|
timeFormat: true,
|
timeConstraints: {},
|
dateFormat: true,
|
strictParsing: true,
|
closeOnSelect: false,
|
closeOnTab: true
|
};
|
},
|
|
getInitialState: function() {
|
var state = this.getStateFromProps( this.props );
|
|
if ( state.open === undefined )
|
state.open = !this.props.input;
|
|
state.currentView = this.props.dateFormat ? (this.props.viewMode || state.updateOn || 'days') : 'time';
|
|
return state;
|
},
|
|
getStateFromProps: function( props ){
|
var formats = this.getFormats( props ),
|
date = props.value || props.defaultValue,
|
selectedDate, viewDate, updateOn, inputValue
|
;
|
|
if ( date && typeof date === 'string' )
|
selectedDate = this.localMoment( date, formats.datetime );
|
else if ( date )
|
selectedDate = this.localMoment( date );
|
|
if ( selectedDate && !selectedDate.isValid() )
|
selectedDate = null;
|
|
viewDate = selectedDate ?
|
selectedDate.clone().startOf('month') :
|
this.localMoment().startOf('month')
|
;
|
|
updateOn = this.getUpdateOn(formats);
|
|
if ( selectedDate )
|
inputValue = selectedDate.format(formats.datetime);
|
else if ( date.isValid && !date.isValid() )
|
inputValue = '';
|
else
|
inputValue = date || '';
|
|
return {
|
updateOn: updateOn,
|
inputFormat: formats.datetime,
|
viewDate: viewDate,
|
selectedDate: selectedDate,
|
inputValue: inputValue,
|
open: props.open
|
};
|
},
|
|
getUpdateOn: function(formats){
|
if ( formats.date.match(/[lLD]/) ){
|
return 'days';
|
}
|
else if ( formats.date.indexOf('M') !== -1 ){
|
return 'months';
|
}
|
else if ( formats.date.indexOf('Y') !== -1 ){
|
return 'years';
|
}
|
|
return 'days';
|
},
|
|
getFormats: function( props ){
|
var formats = {
|
date: props.dateFormat || '',
|
time: props.timeFormat || ''
|
},
|
locale = this.localMoment( props.date ).localeData()
|
;
|
|
if ( formats.date === true ){
|
formats.date = locale.longDateFormat('L');
|
}
|
else if ( this.getUpdateOn(formats) !== 'days' ){
|
formats.time = '';
|
}
|
|
if ( formats.time === true ){
|
formats.time = locale.longDateFormat('LT');
|
}
|
|
formats.datetime = formats.date && formats.time ?
|
formats.date + ' ' + formats.time :
|
formats.date || formats.time
|
;
|
|
return formats;
|
},
|
|
componentWillReceiveProps: function(nextProps) {
|
var formats = this.getFormats( nextProps ),
|
update = {}
|
;
|
|
if ( nextProps.value !== this.props.value ){
|
update = this.getStateFromProps( nextProps );
|
}
|
if ( formats.datetime !== this.getFormats( this.props ).datetime ) {
|
update.inputFormat = formats.datetime;
|
}
|
|
if ( update.open === undefined ){
|
if ( this.props.closeOnSelect && this.state.currentView !== 'time' ){
|
update.open = false;
|
}
|
else {
|
update.open = this.state.open;
|
}
|
}
|
|
this.setState( update );
|
},
|
|
onInputChange: function( e ) {
|
var value = e.target === null ? e : e.target.value,
|
localMoment = this.localMoment( value, this.state.inputFormat ),
|
update = { inputValue: value }
|
;
|
|
if ( localMoment.isValid() && !this.props.value ) {
|
update.selectedDate = localMoment;
|
update.viewDate = localMoment.clone().startOf('month');
|
}
|
else {
|
update.selectedDate = null;
|
}
|
|
return this.setState( update, function() {
|
return this.props.onChange( localMoment.isValid() ? localMoment : this.state.inputValue );
|
});
|
},
|
|
onInputKey: function( e ){
|
if ( e.which === 9 && this.props.closeOnTab ){
|
this.closeCalendar();
|
}
|
},
|
|
showView: function( view ){
|
var me = this;
|
return function(){
|
me.setState({ currentView: view });
|
};
|
},
|
|
setDate: function( type ){
|
var me = this,
|
nextViews = {
|
month: 'days',
|
year: 'months'
|
}
|
;
|
return function( e ){
|
me.setState({
|
viewDate: me.state.viewDate.clone()[ type ]( parseInt(e.target.getAttribute('data-value'), 10) ).startOf( type ),
|
currentView: nextViews[ type ]
|
});
|
};
|
},
|
|
addTime: function( amount, type, toSelected ){
|
return this.updateTime( 'add', amount, type, toSelected );
|
},
|
|
subtractTime: function( amount, type, toSelected ){
|
return this.updateTime( 'subtract', amount, type, toSelected );
|
},
|
|
updateTime: function( op, amount, type, toSelected ){
|
var me = this;
|
|
return function(){
|
var update = {},
|
date = toSelected ? 'selectedDate' : 'viewDate'
|
;
|
|
update[ date ] = me.state[ date ].clone()[ op ]( amount, type );
|
|
me.setState( update );
|
};
|
},
|
|
allowedSetTime: ['hours', 'minutes', 'seconds', 'milliseconds'],
|
setTime: function( type, value ){
|
var index = this.allowedSetTime.indexOf( type ) + 1,
|
state = this.state,
|
date = (state.selectedDate || state.viewDate).clone(),
|
nextType
|
;
|
|
// It is needed to set all the time properties
|
// to not to reset the time
|
date[ type ]( value );
|
for (; index < this.allowedSetTime.length; index++) {
|
nextType = this.allowedSetTime[index];
|
date[ nextType ]( date[nextType]() );
|
}
|
|
if ( !this.props.value ){
|
this.setState({
|
selectedDate: date,
|
inputValue: date.format( state.inputFormat )
|
});
|
}
|
this.props.onChange( date );
|
},
|
|
updateSelectedDate: function( e, close ) {
|
var target = e.target,
|
modifier = 0,
|
viewDate = this.state.viewDate,
|
currentDate = this.state.selectedDate || viewDate,
|
date
|
;
|
|
if (target.className.indexOf('rdtDay') !== -1){
|
if (target.className.indexOf('rdtNew') !== -1)
|
modifier = 1;
|
else if (target.className.indexOf('rdtOld') !== -1)
|
modifier = -1;
|
|
date = viewDate.clone()
|
.month( viewDate.month() + modifier )
|
.date( parseInt( target.getAttribute('data-value'), 10 ) );
|
} else if (target.className.indexOf('rdtMonth') !== -1){
|
date = viewDate.clone()
|
.month( parseInt( target.getAttribute('data-value'), 10 ) )
|
.date( currentDate.date() );
|
} else if (target.className.indexOf('rdtYear') !== -1){
|
date = viewDate.clone()
|
.month( currentDate.month() )
|
.date( currentDate.date() )
|
.year( parseInt( target.getAttribute('data-value'), 10 ) );
|
}
|
|
date.hours( currentDate.hours() )
|
.minutes( currentDate.minutes() )
|
.seconds( currentDate.seconds() )
|
.milliseconds( currentDate.milliseconds() );
|
|
if ( !this.props.value ){
|
this.setState({
|
selectedDate: date,
|
viewDate: date.clone().startOf('month'),
|
inputValue: date.format( this.state.inputFormat ),
|
open: !(this.props.closeOnSelect && close )
|
});
|
} else {
|
if (this.props.closeOnSelect && close) {
|
this.closeCalendar();
|
}
|
}
|
|
this.props.onChange( date );
|
},
|
|
openCalendar: function() {
|
if (!this.state.open) {
|
this.props.onFocus();
|
this.setState({ open: true });
|
}
|
},
|
|
closeCalendar: function() {
|
this.setState({ open: false });
|
this.props.onBlur( this.state.selectedDate || this.state.inputValue );
|
},
|
|
handleClickOutside: function(){
|
if ( this.props.input && this.state.open && !this.props.open ){
|
this.setState({ open: false });
|
this.props.onBlur( this.state.selectedDate || this.state.inputValue );
|
}
|
},
|
|
localMoment: function( date, format ){
|
var m = moment( date, format, this.props.strictParsing );
|
if ( this.props.locale )
|
m.locale( this.props.locale );
|
return m;
|
},
|
|
componentProps: {
|
fromProps: ['value', 'isValidDate', 'renderDay', 'renderMonth', 'renderYear', 'timeConstraints'],
|
fromState: ['viewDate', 'selectedDate', 'updateOn'],
|
fromThis: ['setDate', 'setTime', 'showView', 'addTime', 'subtractTime', 'updateSelectedDate', 'localMoment']
|
},
|
|
getComponentProps: function(){
|
var me = this,
|
formats = this.getFormats( this.props ),
|
props = {dateFormat: formats.date, timeFormat: formats.time}
|
;
|
|
this.componentProps.fromProps.forEach( function( name ){
|
props[ name ] = me.props[ name ];
|
});
|
this.componentProps.fromState.forEach( function( name ){
|
props[ name ] = me.state[ name ];
|
});
|
this.componentProps.fromThis.forEach( function( name ){
|
props[ name ] = me[ name ];
|
});
|
|
return props;
|
},
|
|
render: function() {
|
var Component = this.viewComponents[ this.state.currentView ],
|
DOM = React.DOM,
|
className = 'rdt' + (this.props.className ?
|
( Array.isArray( this.props.className ) ?
|
' ' + this.props.className.join( ' ' ) : ' ' + this.props.className) : ''),
|
children = []
|
;
|
|
if ( this.props.input ){
|
children = [ DOM.input( assign({
|
key: 'i',
|
type:'text',
|
className: 'form-control',
|
onFocus: this.openCalendar,
|
onChange: this.onInputChange,
|
onKeyDown: this.onInputKey,
|
value: this.state.inputValue
|
}, this.props.inputProps ))];
|
} else {
|
className += ' rdtStatic';
|
}
|
|
if ( this.state.open )
|
className += ' rdtOpen';
|
|
return DOM.div({className: className}, children.concat(
|
DOM.div(
|
{ key: 'dt', className: 'rdtPicker' },
|
React.createElement( Component, this.getComponentProps())
|
)
|
));
|
}
|
});
|
|
// Make moment accessible through the Datetime class
|
Datetime.moment = moment;
|
|
module.exports = Datetime;
|
|
|
/***/ },
|
/* 1 */
|
/***/ function(module, exports) {
|
|
'use strict';
|
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
|
|
function ToObject(val) {
|
if (val == null) {
|
throw new TypeError('Object.assign cannot be called with null or undefined');
|
}
|
|
return Object(val);
|
}
|
|
function ownEnumerableKeys(obj) {
|
var keys = Object.getOwnPropertyNames(obj);
|
|
if (Object.getOwnPropertySymbols) {
|
keys = keys.concat(Object.getOwnPropertySymbols(obj));
|
}
|
|
return keys.filter(function (key) {
|
return propIsEnumerable.call(obj, key);
|
});
|
}
|
|
module.exports = Object.assign || function (target, source) {
|
var from;
|
var keys;
|
var to = ToObject(target);
|
|
for (var s = 1; s < arguments.length; s++) {
|
from = arguments[s];
|
keys = ownEnumerableKeys(Object(from));
|
|
for (var i = 0; i < keys.length; i++) {
|
to[keys[i]] = from[keys[i]];
|
}
|
}
|
|
return to;
|
};
|
|
|
/***/ },
|
/* 2 */
|
/***/ function(module, exports) {
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_2__;
|
|
/***/ },
|
/* 3 */
|
/***/ function(module, exports, __webpack_require__) {
|
|
'use strict';
|
|
var React = __webpack_require__(2),
|
moment = __webpack_require__(4)
|
;
|
|
var DOM = React.DOM;
|
var DateTimePickerDays = React.createClass({
|
|
render: function() {
|
var footer = this.renderFooter(),
|
date = this.props.viewDate,
|
locale = date.localeData(),
|
tableChildren
|
;
|
|
tableChildren = [
|
DOM.thead({ key: 'th'}, [
|
DOM.tr({ key: 'h'}, [
|
DOM.th({ key: 'p', className: 'rdtPrev' }, DOM.span({onClick: this.props.subtractTime(1, 'months')}, '‹')),
|
DOM.th({ key: 's', className: 'rdtSwitch', onClick: this.props.showView('months'), colSpan: 5, 'data-value': this.props.viewDate.month() }, locale.months( date ) + ' ' + date.year() ),
|
DOM.th({ key: 'n', className: 'rdtNext' }, DOM.span({onClick: this.props.addTime(1, 'months')}, '›'))
|
]),
|
DOM.tr({ key: 'd'}, this.getDaysOfWeek( locale ).map( function( day, index ){ return DOM.th({ key: day + index, className: 'dow'}, day ); }) )
|
]),
|
DOM.tbody({key: 'tb'}, this.renderDays())
|
];
|
|
if ( footer )
|
tableChildren.push( footer );
|
|
return DOM.div({ className: 'rdtDays' },
|
DOM.table({}, tableChildren )
|
);
|
},
|
|
/**
|
* Get a list of the days of the week
|
* depending on the current locale
|
* @return {array} A list with the shortname of the days
|
*/
|
getDaysOfWeek: function( locale ){
|
var days = locale._weekdaysMin,
|
first = locale.firstDayOfWeek(),
|
dow = [],
|
i = 0
|
;
|
|
days.forEach( function( day ){
|
dow[ (7 + (i++) - first) % 7 ] = day;
|
});
|
|
return dow;
|
},
|
|
renderDays: function() {
|
var date = this.props.viewDate,
|
selected = this.props.selectedDate && this.props.selectedDate.clone(),
|
prevMonth = date.clone().subtract( 1, 'months' ),
|
currentYear = date.year(),
|
currentMonth = date.month(),
|
weeks = [],
|
days = [],
|
renderer = this.props.renderDay || this.renderDay,
|
isValid = this.props.isValidDate || this.isValidDate,
|
classes, disabled, dayProps, currentDate
|
;
|
|
// Go to the last week of the previous month
|
prevMonth.date( prevMonth.daysInMonth() ).startOf('week');
|
var lastDay = prevMonth.clone().add(42, 'd');
|
|
while ( prevMonth.isBefore( lastDay ) ){
|
classes = 'rdtDay';
|
currentDate = prevMonth.clone();
|
|
if ( ( prevMonth.year() === currentYear && prevMonth.month() < currentMonth ) || ( prevMonth.year() < currentYear ) )
|
classes += ' rdtOld';
|
else if ( ( prevMonth.year() === currentYear && prevMonth.month() > currentMonth ) || ( prevMonth.year() > currentYear ) )
|
classes += ' rdtNew';
|
|
if ( selected && prevMonth.isSame(selected, 'day') )
|
classes += ' rdtActive';
|
|
if (prevMonth.isSame(moment(), 'day') )
|
classes += ' rdtToday';
|
|
disabled = !isValid( currentDate, selected );
|
if ( disabled )
|
classes += ' rdtDisabled';
|
|
dayProps = {
|
key: prevMonth.format('M_D'),
|
'data-value': prevMonth.date(),
|
className: classes
|
};
|
if ( !disabled )
|
dayProps.onClick = this.updateSelectedDate;
|
|
days.push( renderer( dayProps, currentDate, selected ) );
|
|
if ( days.length === 7 ){
|
weeks.push( DOM.tr( {key: prevMonth.format('M_D')}, days ) );
|
days = [];
|
}
|
|
prevMonth.add( 1, 'd' );
|
}
|
|
return weeks;
|
},
|
|
updateSelectedDate: function( event ) {
|
this.props.updateSelectedDate(event, true);
|
},
|
|
renderDay: function( props, currentDate ){
|
return DOM.td( props, currentDate.date() );
|
},
|
|
renderFooter: function(){
|
if ( !this.props.timeFormat )
|
return '';
|
|
var date = this.props.selectedDate || this.props.viewDate;
|
|
return DOM.tfoot({ key: 'tf'},
|
DOM.tr({},
|
DOM.td({ onClick: this.props.showView('time'), colSpan: 7, className: 'rdtTimeToggle'}, date.format( this.props.timeFormat ))
|
)
|
);
|
},
|
isValidDate: function(){ return 1; }
|
});
|
|
module.exports = DateTimePickerDays;
|
|
|
/***/ },
|
/* 4 */
|
/***/ function(module, exports) {
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_4__;
|
|
/***/ },
|
/* 5 */
|
/***/ function(module, exports, __webpack_require__) {
|
|
'use strict';
|
|
var React = __webpack_require__(2);
|
|
var DOM = React.DOM;
|
var DateTimePickerMonths = React.createClass({
|
render: function() {
|
return DOM.div({ className: 'rdtMonths' }, [
|
DOM.table({ key: 'a'}, DOM.thead({}, DOM.tr({}, [
|
DOM.th({ key: 'prev', className: 'rdtPrev' }, DOM.span({onClick: this.props.subtractTime(1, 'years')}, '‹')),
|
DOM.th({ key: 'year', className: 'rdtSwitch', onClick: this.props.showView('years'), colSpan: 2, 'data-value': this.props.viewDate.year()}, this.props.viewDate.year() ),
|
DOM.th({ key: 'next', className: 'rdtNext' }, DOM.span({onClick: this.props.addTime(1, 'years')}, '›'))
|
]))),
|
DOM.table({ key: 'months'}, DOM.tbody({ key: 'b'}, this.renderMonths()))
|
]);
|
},
|
|
renderMonths: function() {
|
var date = this.props.selectedDate,
|
month = this.props.viewDate.month(),
|
year = this.props.viewDate.year(),
|
rows = [],
|
i = 0,
|
months = [],
|
renderer = this.props.renderMonth || this.renderMonth,
|
classes, props
|
;
|
|
while (i < 12) {
|
classes = 'rdtMonth';
|
if ( date && i === month && year === date.year() )
|
classes += ' rdtActive';
|
|
props = {
|
key: i,
|
'data-value': i,
|
className: classes,
|
onClick: this.props.updateOn === 'months'? this.updateSelectedMonth : this.props.setDate('month')
|
};
|
|
months.push( renderer( props, i, year, date && date.clone() ));
|
|
if ( months.length === 4 ){
|
rows.push( DOM.tr({ key: month + '_' + rows.length }, months) );
|
months = [];
|
}
|
|
i++;
|
}
|
|
return rows;
|
},
|
|
updateSelectedMonth: function( event ) {
|
this.props.updateSelectedDate(event, true);
|
},
|
|
renderMonth: function( props, month ) {
|
var monthsShort = this.props.viewDate.localeData()._monthsShort;
|
return DOM.td( props, monthsShort.standalone
|
? capitalize( monthsShort.standalone[ month ] )
|
: monthsShort[ month ]
|
);
|
}
|
});
|
|
function capitalize(str) {
|
return str.charAt(0).toUpperCase() + str.slice(1);
|
}
|
|
module.exports = DateTimePickerMonths;
|
|
|
/***/ },
|
/* 6 */
|
/***/ function(module, exports, __webpack_require__) {
|
|
'use strict';
|
|
var React = __webpack_require__(2);
|
|
var DOM = React.DOM;
|
var DateTimePickerYears = React.createClass({
|
render: function() {
|
var year = parseInt(this.props.viewDate.year() / 10, 10) * 10;
|
|
return DOM.div({ className: 'rdtYears' }, [
|
DOM.table({ key: 'a'}, DOM.thead({}, DOM.tr({}, [
|
DOM.th({ key: 'prev', className: 'rdtPrev' }, DOM.span({onClick: this.props.subtractTime(10, 'years')}, '‹')),
|
DOM.th({ key: 'year', className: 'rdtSwitch', onClick: this.props.showView('years'), colSpan: 2 }, year + '-' + (year + 9) ),
|
DOM.th({ key: 'next', className: 'rdtNext'}, DOM.span({onClick: this.props.addTime(10, 'years')}, '›'))
|
]))),
|
DOM.table({ key: 'years'}, DOM.tbody({}, this.renderYears( year )))
|
]);
|
},
|
|
renderYears: function( year ) {
|
var years = [],
|
i = -1,
|
rows = [],
|
renderer = this.props.renderYear || this.renderYear,
|
selectedDate = this.props.selectedDate,
|
classes, props
|
;
|
|
year--;
|
while (i < 11) {
|
classes = 'rdtYear';
|
if ( i === -1 | i === 10 )
|
classes += ' rdtOld';
|
if ( selectedDate && selectedDate.year() === year )
|
classes += ' rdtActive';
|
|
props = {
|
key: year,
|
'data-value': year,
|
className: classes,
|
onClick: this.props.updateOn === 'years' ? this.updateSelectedYear : this.props.setDate('year')
|
};
|
|
years.push( renderer( props, year, selectedDate && selectedDate.clone() ));
|
|
if ( years.length === 4 ){
|
rows.push( DOM.tr({ key: i }, years ) );
|
years = [];
|
}
|
|
year++;
|
i++;
|
}
|
|
return rows;
|
},
|
|
updateSelectedYear: function( event ) {
|
this.props.updateSelectedDate(event, true);
|
},
|
|
renderYear: function( props, year ){
|
return DOM.td( props, year );
|
}
|
});
|
|
module.exports = DateTimePickerYears;
|
|
|
/***/ },
|
/* 7 */
|
/***/ function(module, exports, __webpack_require__) {
|
|
'use strict';
|
|
var React = __webpack_require__(2),
|
assign = __webpack_require__(1);
|
|
var DOM = React.DOM;
|
var DateTimePickerTime = React.createClass({
|
getInitialState: function(){
|
return this.calculateState( this.props );
|
},
|
calculateState: function( props ){
|
var date = props.selectedDate || props.viewDate,
|
format = props.timeFormat,
|
counters = []
|
;
|
|
if ( format.indexOf('H') !== -1 || format.indexOf('h') !== -1 ){
|
counters.push('hours');
|
if ( format.indexOf('m') !== -1 ){
|
counters.push('minutes');
|
if ( format.indexOf('s') !== -1 ){
|
counters.push('seconds');
|
}
|
}
|
}
|
|
var daypart = false;
|
if ( this.props.timeFormat.indexOf(' A') !== -1 && this.state !== null ){
|
daypart = ( this.state.hours >= 12 ) ? 'PM' : 'AM';
|
}
|
|
return {
|
hours: date.format('H'),
|
minutes: date.format('mm'),
|
seconds: date.format('ss'),
|
milliseconds: date.format('SSS'),
|
daypart: daypart,
|
counters: counters
|
};
|
},
|
renderCounter: function( type ){
|
if (type !== 'daypart') {
|
var value = this.state[ type ];
|
if (type === 'hours' && this.props.timeFormat.indexOf(' A') !== -1) {
|
value = (value - 1) % 12 + 1;
|
|
if (value === 0) {
|
value = 12;
|
}
|
}
|
return DOM.div({ key: type, className: 'rdtCounter'}, [
|
DOM.span({ key:'up', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'increase', type ) }, 'â–²' ),
|
DOM.div({ key:'c', className: 'rdtCount' }, value ),
|
DOM.span({ key:'do', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'decrease', type ) }, 'â–¼' )
|
]);
|
}
|
return '';
|
},
|
renderDayPart: function() {
|
return DOM.div({ className: 'rdtCounter', key: 'dayPart'}, [
|
DOM.span({ key:'up', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'toggleDayPart', 'hours') }, 'â–²' ),
|
DOM.div({ key: this.state.daypart, className: 'rdtCount'}, this.state.daypart ),
|
DOM.span({ key:'do', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'toggleDayPart', 'hours') }, 'â–¼' )
|
]);
|
},
|
render: function() {
|
var me = this,
|
counters = []
|
;
|
|
this.state.counters.forEach( function(c){
|
if ( counters.length )
|
counters.push( DOM.div( {key: 'sep' + counters.length, className: 'rdtCounterSeparator' }, ':' ));
|
counters.push( me.renderCounter( c ) );
|
});
|
|
if (this.state.daypart !== false) {
|
counters.push( me.renderDayPart() );
|
}
|
|
if ( this.state.counters.length === 3 && this.props.timeFormat.indexOf('S') !== -1 ){
|
counters.push( DOM.div( {className: 'rdtCounterSeparator', key: 'sep5' }, ':' ));
|
counters.push(
|
DOM.div( {className: 'rdtCounter rdtMilli', key:'m'},
|
DOM.input({ value: this.state.milliseconds, type: 'text', onChange: this.updateMilli })
|
)
|
);
|
}
|
|
return DOM.div( {className: 'rdtTime'},
|
DOM.table( {}, [
|
this.renderHeader(),
|
DOM.tbody({key: 'b'}, DOM.tr({}, DOM.td({},
|
DOM.div({ className: 'rdtCounters' }, counters )
|
)))
|
])
|
);
|
},
|
componentWillMount: function() {
|
var me = this;
|
me.timeConstraints = {
|
hours: {
|
min: 0,
|
max: 23,
|
step: 1
|
},
|
minutes: {
|
min: 0,
|
max: 59,
|
step: 1
|
},
|
seconds: {
|
min: 0,
|
max: 59,
|
step: 1,
|
},
|
milliseconds: {
|
min: 0,
|
max: 999,
|
step: 1
|
}
|
};
|
['hours', 'minutes', 'seconds', 'milliseconds'].forEach(function(type) {
|
assign(me.timeConstraints[type], me.props.timeConstraints[type]);
|
});
|
this.setState( this.calculateState( this.props ) );
|
},
|
componentWillReceiveProps: function( nextProps ){
|
this.setState( this.calculateState( nextProps ) );
|
},
|
updateMilli: function( e ){
|
var milli = parseInt( e.target.value, 10 );
|
if ( milli === e.target.value && milli >= 0 && milli < 1000 ){
|
this.props.setTime( 'milliseconds', milli );
|
this.setState({ milliseconds: milli });
|
}
|
},
|
renderHeader: function(){
|
if ( !this.props.dateFormat )
|
return null;
|
|
var date = this.props.selectedDate || this.props.viewDate;
|
return DOM.thead({ key: 'h'}, DOM.tr({},
|
DOM.th( {className: 'rdtSwitch', colSpan: 4, onClick: this.props.showView('days')}, date.format( this.props.dateFormat ) )
|
));
|
},
|
onStartClicking: function( action, type ){
|
var me = this;
|
|
return function(){
|
var update = {};
|
update[ type ] = me[ action ]( type );
|
me.setState( update );
|
|
me.timer = setTimeout( function(){
|
me.increaseTimer = setInterval( function(){
|
update[ type ] = me[ action ]( type );
|
me.setState( update );
|
}, 70);
|
}, 500);
|
|
me.mouseUpListener = function(){
|
clearTimeout( me.timer );
|
clearInterval( me.increaseTimer );
|
me.props.setTime( type, me.state[ type ] );
|
document.body.removeEventListener('mouseup', me.mouseUpListener);
|
};
|
|
document.body.addEventListener('mouseup', me.mouseUpListener);
|
};
|
},
|
padValues: {
|
hours: 1,
|
minutes: 2,
|
seconds: 2,
|
milliseconds: 3
|
},
|
toggleDayPart: function( type ){ // type is always 'hours'
|
var value = parseInt(this.state[ type ], 10) + 12;
|
if ( value > this.timeConstraints[ type ].max )
|
value = this.timeConstraints[ type ].min + (value - (this.timeConstraints[ type ].max + 1));
|
return this.pad( type, value );
|
},
|
increase: function( type ){
|
var value = parseInt(this.state[ type ], 10) + this.timeConstraints[ type ].step;
|
if ( value > this.timeConstraints[ type ].max )
|
value = this.timeConstraints[ type ].min + ( value - ( this.timeConstraints[ type ].max + 1) );
|
return this.pad( type, value );
|
},
|
decrease: function( type ){
|
var value = parseInt(this.state[ type ], 10) - this.timeConstraints[ type ].step;
|
if ( value < this.timeConstraints[ type ].min )
|
value = this.timeConstraints[ type ].max + 1 - ( this.timeConstraints[ type ].min - value );
|
return this.pad( type, value );
|
},
|
pad: function( type, value ){
|
var str = value + '';
|
while ( str.length < this.padValues[ type ] )
|
str = '0' + str;
|
return str;
|
}
|
});
|
|
module.exports = DateTimePickerTime;
|
|
|
/***/ },
|
/* 8 */
|
/***/ function(module, exports, __webpack_require__) {
|
|
'use strict';
|
|
// This is extracted from https://github.com/Pomax/react-onclickoutside
|
// And modified to support react 0.13 and react 0.14
|
|
var React = __webpack_require__(2),
|
version = React.version && React.version.split('.')
|
;
|
|
if ( version && ( version[0] > 0 || version[1] > 13 ) )
|
React = __webpack_require__(9);
|
|
// Use a parallel array because we can't use
|
// objects as keys, they get toString-coerced
|
var registeredComponents = [];
|
var handlers = [];
|
|
var IGNORE_CLASS = 'ignore-react-onclickoutside';
|
|
var isSourceFound = function(source, localNode) {
|
if (source === localNode) {
|
return true;
|
}
|
// SVG <use/> elements do not technically reside in the rendered DOM, so
|
// they do not have classList directly, but they offer a link to their
|
// corresponding element, which can have classList. This extra check is for
|
// that case.
|
// See: http://www.w3.org/TR/SVG11/struct.html#InterfaceSVGUseElement
|
// Discussion: https://github.com/Pomax/react-onclickoutside/pull/17
|
if (source.correspondingElement) {
|
return source.correspondingElement.classList.contains(IGNORE_CLASS);
|
}
|
return source.classList.contains(IGNORE_CLASS);
|
};
|
|
module.exports = {
|
componentDidMount: function() {
|
if (typeof this.handleClickOutside !== 'function')
|
throw new Error('Component lacks a handleClickOutside(event) function for processing outside click events.');
|
|
var fn = this.__outsideClickHandler = (function(localNode, eventHandler) {
|
return function(evt) {
|
evt.stopPropagation();
|
var source = evt.target;
|
var found = false;
|
// If source=local then this event came from "somewhere"
|
// inside and should be ignored. We could handle this with
|
// a layered approach, too, but that requires going back to
|
// thinking in terms of Dom node nesting, running counter
|
// to React's "you shouldn't care about the DOM" philosophy.
|
while (source.parentNode) {
|
found = isSourceFound(source, localNode);
|
if (found) return;
|
source = source.parentNode;
|
}
|
eventHandler(evt);
|
};
|
}(React.findDOMNode(this), this.handleClickOutside));
|
|
var pos = registeredComponents.length;
|
registeredComponents.push(this);
|
handlers[pos] = fn;
|
|
// If there is a truthy disableOnClickOutside property for this
|
// component, don't immediately start listening for outside events.
|
if (!this.props.disableOnClickOutside) {
|
this.enableOnClickOutside();
|
}
|
},
|
|
componentWillUnmount: function() {
|
this.disableOnClickOutside();
|
this.__outsideClickHandler = false;
|
var pos = registeredComponents.indexOf(this);
|
if ( pos>-1) {
|
if (handlers[pos]) {
|
// clean up so we don't leak memory
|
handlers.splice(pos, 1);
|
registeredComponents.splice(pos, 1);
|
}
|
}
|
},
|
|
/**
|
* Can be called to explicitly enable event listening
|
* for clicks and touches outside of this element.
|
*/
|
enableOnClickOutside: function() {
|
var fn = this.__outsideClickHandler;
|
document.addEventListener('mousedown', fn);
|
document.addEventListener('touchstart', fn);
|
},
|
|
/**
|
* Can be called to explicitly disable event listening
|
* for clicks and touches outside of this element.
|
*/
|
disableOnClickOutside: function() {
|
var fn = this.__outsideClickHandler;
|
document.removeEventListener('mousedown', fn);
|
document.removeEventListener('touchstart', fn);
|
}
|
};
|
|
|
/***/ },
|
/* 9 */
|
/***/ function(module, exports) {
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_9__;
|
|
/***/ }
|
/******/ ])
|
});
|
;
|
//# sourceMappingURL=react-datetime.js.map
|
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"names":[],"mappings":"","sources":["react-datetime.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"React\"), require(\"moment\"), require(\"ReactDOM\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"React\", \"moment\", \"ReactDOM\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Datetime\"] = factory(require(\"React\"), require(\"moment\"), require(\"ReactDOM\"));\n\telse\n\t\troot[\"Datetime\"] = factory(root[\"React\"], root[\"moment\"], root[\"ReactDOM\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_9__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar assign = __webpack_require__(1),\n\t\tReact = __webpack_require__(2),\n\t\tDaysView = __webpack_require__(3),\n\t\tMonthsView = __webpack_require__(5),\n\t\tYearsView = __webpack_require__(6),\n\t\tTimeView = __webpack_require__(7),\n\t\tmoment = __webpack_require__(4)\n\t;\n\n\tvar TYPES = React.PropTypes;\n\tvar Datetime = React.createClass({\n\t\tmixins: [\n\t\t\t__webpack_require__(8)\n\t\t],\n\t\tviewComponents: {\n\t\t\tdays: DaysView,\n\t\t\tmonths: MonthsView,\n\t\t\tyears: YearsView,\n\t\t\ttime: TimeView\n\t\t},\n\t\tpropTypes: {\n\t\t\t// value: TYPES.object | TYPES.string,\n\t\t\t// defaultValue: TYPES.object | TYPES.string,\n\t\t\tonFocus: TYPES.func,\n\t\t\tonBlur: TYPES.func,\n\t\t\tonChange: TYPES.func,\n\t\t\tlocale: TYPES.string,\n\t\t\tinput: TYPES.bool,\n\t\t\t// dateFormat: TYPES.string | TYPES.bool,\n\t\t\t// timeFormat: TYPES.string | TYPES.bool,\n\t\t\tinputProps: TYPES.object,\n\t\t\ttimeConstraints: TYPES.object,\n\t\t\tviewMode: TYPES.oneOf(['years', 'months', 'days', 'time']),\n\t\t\tisValidDate: TYPES.func,\n\t\t\topen: TYPES.bool,\n\t\t\tstrictParsing: TYPES.bool,\n\t\t\tcloseOnSelect: TYPES.bool,\n\t\t\tcloseOnTab: TYPES.bool\n\t\t},\n\n\t\tgetDefaultProps: function() {\n\t\t\tvar nof = function(){};\n\t\t\treturn {\n\t\t\t\tclassName: '',\n\t\t\t\tdefaultValue: '',\n\t\t\t\tinputProps: {},\n\t\t\t\tinput: true,\n\t\t\t\tonFocus: nof,\n\t\t\t\tonBlur: nof,\n\t\t\t\tonChange: nof,\n\t\t\t\ttimeFormat: true,\n\t\t\t\ttimeConstraints: {},\n\t\t\t\tdateFormat: true,\n\t\t\t\tstrictParsing: true,\n\t\t\t\tcloseOnSelect: false,\n\t\t\t\tcloseOnTab: true\n\t\t\t};\n\t\t},\n\n\t\tgetInitialState: function() {\n\t\t\tvar state = this.getStateFromProps( this.props );\n\n\t\t\tif ( state.open === undefined )\n\t\t\t\tstate.open = !this.props.input;\n\n\t\t\tstate.currentView = this.props.dateFormat ? (this.props.viewMode || state.updateOn || 'days') : 'time';\n\n\t\t\treturn state;\n\t\t},\n\n\t\tgetStateFromProps: function( props ){\n\t\t\tvar formats = this.getFormats( props ),\n\t\t\t\tdate = props.value || props.defaultValue,\n\t\t\t\tselectedDate, viewDate, updateOn, inputValue\n\t\t\t;\n\n\t\t\tif ( date && typeof date === 'string' )\n\t\t\t\tselectedDate = this.localMoment( date, formats.datetime );\n\t\t\telse if ( date )\n\t\t\t\tselectedDate = this.localMoment( date );\n\n\t\t\tif ( selectedDate && !selectedDate.isValid() )\n\t\t\t\tselectedDate = null;\n\n\t\t\tviewDate = selectedDate ?\n\t\t\t\tselectedDate.clone().startOf('month') :\n\t\t\t\tthis.localMoment().startOf('month')\n\t\t\t;\n\n\t\t\tupdateOn = this.getUpdateOn(formats);\n\n\t\t\tif ( selectedDate )\n\t\t\t\tinputValue = selectedDate.format(formats.datetime);\n\t\t\telse if ( date.isValid && !date.isValid() )\n\t\t\t\tinputValue = '';\n\t\t\telse\n\t\t\t\tinputValue = date || '';\n\n\t\t\treturn {\n\t\t\t\tupdateOn: updateOn,\n\t\t\t\tinputFormat: formats.datetime,\n\t\t\t\tviewDate: viewDate,\n\t\t\t\tselectedDate: selectedDate,\n\t\t\t\tinputValue: inputValue,\n\t\t\t\topen: props.open\n\t\t\t};\n\t\t},\n\n\t\tgetUpdateOn: function(formats){\n\t\t\tif ( formats.date.match(/[lLD]/) ){\n\t\t\t\treturn 'days';\n\t\t\t}\n\t\t\telse if ( formats.date.indexOf('M') !== -1 ){\n\t\t\t\treturn 'months';\n\t\t\t}\n\t\t\telse if ( formats.date.indexOf('Y') !== -1 ){\n\t\t\t\treturn 'years';\n\t\t\t}\n\n\t\t\treturn 'days';\n\t\t},\n\n\t\tgetFormats: function( props ){\n\t\t\tvar formats = {\n\t\t\t\t\tdate: props.dateFormat || '',\n\t\t\t\t\ttime: props.timeFormat || ''\n\t\t\t\t},\n\t\t\t\tlocale = this.localMoment( props.date ).localeData()\n\t\t\t;\n\n\t\t\tif ( formats.date === true ){\n\t\t\t\tformats.date = locale.longDateFormat('L');\n\t\t\t}\n\t\t\telse if ( this.getUpdateOn(formats) !== 'days' ){\n\t\t\t\tformats.time = '';\n\t\t\t}\n\n\t\t\tif ( formats.time === true ){\n\t\t\t\tformats.time = locale.longDateFormat('LT');\n\t\t\t}\n\n\t\t\tformats.datetime = formats.date && formats.time ?\n\t\t\t\tformats.date + ' ' + formats.time :\n\t\t\t\tformats.date || formats.time\n\t\t\t;\n\n\t\t\treturn formats;\n\t\t},\n\n\t\tcomponentWillReceiveProps: function(nextProps) {\n\t\t\tvar formats = this.getFormats( nextProps ),\n\t\t\t\tupdate = {}\n\t\t\t;\n\n\t\t\tif ( nextProps.value !== this.props.value ){\n\t\t\t\tupdate = this.getStateFromProps( nextProps );\n\t\t\t}\n\t\t\tif ( formats.datetime !== this.getFormats( this.props ).datetime ) {\n\t\t\t\tupdate.inputFormat = formats.datetime;\n\t\t\t}\n\n\t\t\tif ( update.open === undefined ){\n\t\t\t\tif ( this.props.closeOnSelect && this.state.currentView !== 'time' ){\n\t\t\t\t\tupdate.open = false;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tupdate.open = this.state.open;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tthis.setState( update );\n\t\t},\n\n\t\tonInputChange: function( e ) {\n\t\t\tvar value = e.target === null ? e : e.target.value,\n\t\t\t\tlocalMoment = this.localMoment( value, this.state.inputFormat ),\n\t\t\t\tupdate = { inputValue: value }\n\t\t\t;\n\n\t\t\tif ( localMoment.isValid() && !this.props.value ) {\n\t\t\t\tupdate.selectedDate = localMoment;\n\t\t\t\tupdate.viewDate = localMoment.clone().startOf('month');\n\t\t\t}\n\t\t\telse {\n\t\t\t\tupdate.selectedDate = null;\n\t\t\t}\n\n\t\t\treturn this.setState( update, function() {\n\t\t\t\treturn this.props.onChange( localMoment.isValid() ? localMoment : this.state.inputValue );\n\t\t\t});\n\t\t},\n\n\t\tonInputKey: function( e ){\n\t\t\tif ( e.which === 9 && this.props.closeOnTab ){\n\t\t\t\tthis.closeCalendar();\n\t\t\t}\n\t\t},\n\n\t\tshowView: function( view ){\n\t\t\tvar me = this;\n\t\t\treturn function(){\n\t\t\t\tme.setState({ currentView: view });\n\t\t\t};\n\t\t},\n\n\t\tsetDate: function( type ){\n\t\t\tvar me = this,\n\t\t\t\tnextViews = {\n\t\t\t\t\tmonth: 'days',\n\t\t\t\t\tyear: 'months'\n\t\t\t\t}\n\t\t\t;\n\t\t\treturn function( e ){\n\t\t\t\tme.setState({\n\t\t\t\t\tviewDate: me.state.viewDate.clone()[ type ]( parseInt(e.target.getAttribute('data-value'), 10) ).startOf( type ),\n\t\t\t\t\tcurrentView: nextViews[ type ]\n\t\t\t\t});\n\t\t\t};\n\t\t},\n\n\t\taddTime: function( amount, type, toSelected ){\n\t\t\treturn this.updateTime( 'add', amount, type, toSelected );\n\t\t},\n\n\t\tsubtractTime: function( amount, type, toSelected ){\n\t\t\treturn this.updateTime( 'subtract', amount, type, toSelected );\n\t\t},\n\n\t\tupdateTime: function( op, amount, type, toSelected ){\n\t\t\tvar me = this;\n\n\t\t\treturn function(){\n\t\t\t\tvar update = {},\n\t\t\t\t\tdate = toSelected ? 'selectedDate' : 'viewDate'\n\t\t\t\t;\n\n\t\t\t\tupdate[ date ] = me.state[ date ].clone()[ op ]( amount, type );\n\n\t\t\t\tme.setState( update );\n\t\t\t};\n\t\t},\n\n\t\tallowedSetTime: ['hours', 'minutes', 'seconds', 'milliseconds'],\n\t\tsetTime: function( type, value ){\n\t\t\tvar index = this.allowedSetTime.indexOf( type ) + 1,\n\t\t\t\tstate = this.state,\n\t\t\t\tdate = (state.selectedDate || state.viewDate).clone(),\n\t\t\t\tnextType\n\t\t\t;\n\n\t\t\t// It is needed to set all the time properties\n\t\t\t// to not to reset the time\n\t\t\tdate[ type ]( value );\n\t\t\tfor (; index < this.allowedSetTime.length; index++) {\n\t\t\t\tnextType = this.allowedSetTime[index];\n\t\t\t\tdate[ nextType ]( date[nextType]() );\n\t\t\t}\n\n\t\t\tif ( !this.props.value ){\n\t\t\t\tthis.setState({\n\t\t\t\t\tselectedDate: date,\n\t\t\t\t\tinputValue: date.format( state.inputFormat )\n\t\t\t\t});\n\t\t\t}\n\t\t\tthis.props.onChange( date );\n\t\t},\n\n\t\tupdateSelectedDate: function( e, close ) {\n\t\t\tvar target = e.target,\n\t\t\t\tmodifier = 0,\n\t\t\t\tviewDate = this.state.viewDate,\n\t\t\t\tcurrentDate = this.state.selectedDate || viewDate,\n\t\t\t\tdate\n\t    ;\n\n\t\t\tif (target.className.indexOf('rdtDay') !== -1){\n\t\t\t\tif (target.className.indexOf('rdtNew') !== -1)\n\t\t\t\t\tmodifier = 1;\n\t\t\t\telse if (target.className.indexOf('rdtOld') !== -1)\n\t\t\t\t\tmodifier = -1;\n\n\t\t\t\tdate = viewDate.clone()\n\t\t\t\t\t.month( viewDate.month() + modifier )\n\t\t\t\t\t.date( parseInt( target.getAttribute('data-value'), 10 ) );\n\t\t\t} else if (target.className.indexOf('rdtMonth') !== -1){\n\t\t\t\tdate = viewDate.clone()\n\t\t\t\t\t.month( parseInt( target.getAttribute('data-value'), 10 ) )\n\t\t\t\t\t.date( currentDate.date() );\n\t\t\t} else if (target.className.indexOf('rdtYear') !== -1){\n\t\t\t\tdate = viewDate.clone()\n\t\t\t\t\t.month( currentDate.month() )\n\t\t\t\t\t.date( currentDate.date() )\n\t\t\t\t\t.year( parseInt( target.getAttribute('data-value'), 10 ) );\n\t\t\t}\n\n\t\t\tdate.hours( currentDate.hours() )\n\t\t\t\t.minutes( currentDate.minutes() )\n\t\t\t\t.seconds( currentDate.seconds() )\n\t\t\t\t.milliseconds( currentDate.milliseconds() );\n\n\t\t\tif ( !this.props.value ){\n\t\t\t\tthis.setState({\n\t\t\t\t\tselectedDate: date,\n\t\t\t\t\tviewDate: date.clone().startOf('month'),\n\t\t\t\t\tinputValue: date.format( this.state.inputFormat ),\n\t\t\t\t\topen: !(this.props.closeOnSelect && close )\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tif (this.props.closeOnSelect && close) {\n\t\t\t\t\tthis.closeCalendar();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tthis.props.onChange( date );\n\t\t},\n\n\t\topenCalendar: function() {\n\t\t\tif (!this.state.open) {\n\t\t\t\tthis.props.onFocus();\n\t\t\t\tthis.setState({ open: true });\n\t\t\t}\n\t\t},\n\n\t\tcloseCalendar: function() {\n\t\t\tthis.setState({ open: false });\n\t\t\tthis.props.onBlur( this.state.selectedDate || this.state.inputValue );\n\t\t},\n\n\t\thandleClickOutside: function(){\n\t\t\tif ( this.props.input && this.state.open && !this.props.open ){\n\t\t\t\tthis.setState({ open: false });\n\t\t\t\tthis.props.onBlur( this.state.selectedDate || this.state.inputValue );\n\t\t\t}\n\t\t},\n\n\t\tlocalMoment: function( date, format ){\n\t\t\tvar m = moment( date, format, this.props.strictParsing );\n\t\t\tif ( this.props.locale )\n\t\t\t\tm.locale( this.props.locale );\n\t\t\treturn m;\n\t\t},\n\n\t\tcomponentProps: {\n\t\t\tfromProps: ['value', 'isValidDate', 'renderDay', 'renderMonth', 'renderYear', 'timeConstraints'],\n\t\t\tfromState: ['viewDate', 'selectedDate', 'updateOn'],\n\t\t\tfromThis: ['setDate', 'setTime', 'showView', 'addTime', 'subtractTime', 'updateSelectedDate', 'localMoment']\n\t\t},\n\n\t\tgetComponentProps: function(){\n\t\t\tvar me = this,\n\t\t\t\tformats = this.getFormats( this.props ),\n\t\t\t\tprops = {dateFormat: formats.date, timeFormat: formats.time}\n\t\t\t;\n\n\t\t\tthis.componentProps.fromProps.forEach( function( name ){\n\t\t\t\tprops[ name ] = me.props[ name ];\n\t\t\t});\n\t\t\tthis.componentProps.fromState.forEach( function( name ){\n\t\t\t\tprops[ name ] = me.state[ name ];\n\t\t\t});\n\t\t\tthis.componentProps.fromThis.forEach( function( name ){\n\t\t\t\tprops[ name ] = me[ name ];\n\t\t\t});\n\n\t\t\treturn props;\n\t\t},\n\n\t\trender: function() {\n\t\t\tvar Component = this.viewComponents[ this.state.currentView ],\n\t\t\t\tDOM = React.DOM,\n\t\t\t\tclassName = 'rdt' + (this.props.className ?\n\t                  ( Array.isArray( this.props.className ) ?\n\t                  ' ' + this.props.className.join( ' ' ) : ' ' + this.props.className) : ''),\n\t\t\t\tchildren = []\n\t\t\t;\n\n\t\t\tif ( this.props.input ){\n\t\t\t\tchildren = [ DOM.input( assign({\n\t\t\t\t\tkey: 'i',\n\t\t\t\t\ttype:'text',\n\t\t\t\t\tclassName: 'form-control',\n\t\t\t\t\tonFocus: this.openCalendar,\n\t\t\t\t\tonChange: this.onInputChange,\n\t\t\t\t\tonKeyDown: this.onInputKey,\n\t\t\t\t\tvalue: this.state.inputValue\n\t\t\t\t}, this.props.inputProps ))];\n\t\t\t} else {\n\t\t\t\tclassName += ' rdtStatic';\n\t\t\t}\n\n\t\t\tif ( this.state.open )\n\t\t\t\tclassName += ' rdtOpen';\n\n\t\t\treturn DOM.div({className: className}, children.concat(\n\t\t\t\tDOM.div(\n\t\t\t\t\t{ key: 'dt', className: 'rdtPicker' },\n\t\t\t\t\tReact.createElement( Component, this.getComponentProps())\n\t\t\t\t)\n\t\t\t));\n\t\t}\n\t});\n\n\t// Make moment accessible through the Datetime class\n\tDatetime.moment = moment;\n\n\tmodule.exports = Datetime;\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\tvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\n\tfunction ToObject(val) {\n\t\tif (val == null) {\n\t\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t\t}\n\n\t\treturn Object(val);\n\t}\n\n\tfunction ownEnumerableKeys(obj) {\n\t\tvar keys = Object.getOwnPropertyNames(obj);\n\n\t\tif (Object.getOwnPropertySymbols) {\n\t\t\tkeys = keys.concat(Object.getOwnPropertySymbols(obj));\n\t\t}\n\n\t\treturn keys.filter(function (key) {\n\t\t\treturn propIsEnumerable.call(obj, key);\n\t\t});\n\t}\n\n\tmodule.exports = Object.assign || function (target, source) {\n\t\tvar from;\n\t\tvar keys;\n\t\tvar to = ToObject(target);\n\n\t\tfor (var s = 1; s < arguments.length; s++) {\n\t\t\tfrom = arguments[s];\n\t\t\tkeys = ownEnumerableKeys(Object(from));\n\n\t\t\tfor (var i = 0; i < keys.length; i++) {\n\t\t\t\tto[keys[i]] = from[keys[i]];\n\t\t\t}\n\t\t}\n\n\t\treturn to;\n\t};\n\n\n/***/ },\n/* 2 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_2__;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar React = __webpack_require__(2),\n\t\tmoment = __webpack_require__(4)\n\t;\n\n\tvar DOM = React.DOM;\n\tvar DateTimePickerDays = React.createClass({\n\n\t\trender: function() {\n\t\t\tvar footer = this.renderFooter(),\n\t\t\t\tdate = this.props.viewDate,\n\t\t\t\tlocale = date.localeData(),\n\t\t\t\ttableChildren\n\t\t\t;\n\n\t\t\ttableChildren = [\n\t\t\t\tDOM.thead({ key: 'th'}, [\n\t\t\t\t\tDOM.tr({ key: 'h'}, [\n\t\t\t\t\t\tDOM.th({ key: 'p', className: 'rdtPrev' }, DOM.span({onClick: this.props.subtractTime(1, 'months')}, '‹')),\n\t\t\t\t\t\tDOM.th({ key: 's', className: 'rdtSwitch', onClick: this.props.showView('months'), colSpan: 5, 'data-value': this.props.viewDate.month() }, locale.months( date ) + ' ' + date.year() ),\n\t\t\t\t\t\tDOM.th({ key: 'n', className: 'rdtNext' }, DOM.span({onClick: this.props.addTime(1, 'months')}, '›'))\n\t\t\t\t\t]),\n\t\t\t\t\tDOM.tr({ key: 'd'}, this.getDaysOfWeek( locale ).map( function( day, index ){ return DOM.th({ key: day + index, className: 'dow'}, day ); }) )\n\t\t\t\t]),\n\t\t\t\tDOM.tbody({key: 'tb'}, this.renderDays())\n\t\t\t];\n\n\t\t\tif ( footer )\n\t\t\t\ttableChildren.push( footer );\n\n\t\t\treturn DOM.div({ className: 'rdtDays' },\n\t\t\t\tDOM.table({}, tableChildren )\n\t\t\t);\n\t\t},\n\n\t\t/**\n\t\t * Get a list of the days of the week\n\t\t * depending on the current locale\n\t\t * @return {array} A list with the shortname of the days\n\t\t */\n\t\tgetDaysOfWeek: function( locale ){\n\t\t\tvar days = locale._weekdaysMin,\n\t\t\t\tfirst = locale.firstDayOfWeek(),\n\t\t\t\tdow = [],\n\t\t\t\ti = 0\n\t\t\t;\n\n\t\t\tdays.forEach( function( day ){\n\t\t\t\tdow[ (7 + (i++) - first) % 7 ] = day;\n\t\t\t});\n\n\t\t\treturn dow;\n\t\t},\n\n\t\trenderDays: function() {\n\t\t\tvar date = this.props.viewDate,\n\t\t\t\tselected = this.props.selectedDate && this.props.selectedDate.clone(),\n\t\t\t\tprevMonth = date.clone().subtract( 1, 'months' ),\n\t\t\t\tcurrentYear = date.year(),\n\t\t\t\tcurrentMonth = date.month(),\n\t\t\t\tweeks = [],\n\t\t\t\tdays = [],\n\t\t\t\trenderer = this.props.renderDay || this.renderDay,\n\t\t\t\tisValid = this.props.isValidDate || this.isValidDate,\n\t\t\t\tclasses, disabled, dayProps, currentDate\n\t\t\t;\n\n\t\t\t// Go to the last week of the previous month\n\t\t\tprevMonth.date( prevMonth.daysInMonth() ).startOf('week');\n\t\t\tvar lastDay = prevMonth.clone().add(42, 'd');\n\n\t\t\twhile ( prevMonth.isBefore( lastDay ) ){\n\t\t\t\tclasses = 'rdtDay';\n\t\t\t\tcurrentDate = prevMonth.clone();\n\n\t\t\t\tif ( ( prevMonth.year() === currentYear && prevMonth.month() < currentMonth ) || ( prevMonth.year() < currentYear ) )\n\t\t\t\t\tclasses += ' rdtOld';\n\t\t\t\telse if ( ( prevMonth.year() === currentYear && prevMonth.month() > currentMonth ) || ( prevMonth.year() > currentYear ) )\n\t\t\t\t\tclasses += ' rdtNew';\n\n\t\t\t\tif ( selected && prevMonth.isSame(selected, 'day') )\n\t\t\t\t\tclasses += ' rdtActive';\n\n\t\t\t\tif (prevMonth.isSame(moment(), 'day') )\n\t\t\t\t\tclasses += ' rdtToday';\n\n\t\t\t\tdisabled = !isValid( currentDate, selected );\n\t\t\t\tif ( disabled )\n\t\t\t\t\tclasses += ' rdtDisabled';\n\n\t\t\t\tdayProps = {\n\t\t\t\t\tkey: prevMonth.format('M_D'),\n\t\t\t\t\t'data-value': prevMonth.date(),\n\t\t\t\t\tclassName: classes\n\t\t\t\t};\n\t\t\t\tif ( !disabled )\n\t\t\t\t\tdayProps.onClick = this.updateSelectedDate;\n\n\t\t\t\tdays.push( renderer( dayProps, currentDate, selected ) );\n\n\t\t\t\tif ( days.length === 7 ){\n\t\t\t\t\tweeks.push( DOM.tr( {key: prevMonth.format('M_D')}, days ) );\n\t\t\t\t\tdays = [];\n\t\t\t\t}\n\n\t\t\t\tprevMonth.add( 1, 'd' );\n\t\t\t}\n\n\t\t\treturn weeks;\n\t\t},\n\n\t\tupdateSelectedDate: function( event ) {\n\t\t\tthis.props.updateSelectedDate(event, true);\n\t\t},\n\n\t\trenderDay: function( props, currentDate ){\n\t\t\treturn DOM.td( props, currentDate.date() );\n\t\t},\n\n\t\trenderFooter: function(){\n\t\t\tif ( !this.props.timeFormat )\n\t\t\t\treturn '';\n\n\t\t\tvar date = this.props.selectedDate || this.props.viewDate;\n\n\t\t\treturn DOM.tfoot({ key: 'tf'},\n\t\t\t\tDOM.tr({},\n\t\t\t\t\tDOM.td({ onClick: this.props.showView('time'), colSpan: 7, className: 'rdtTimeToggle'}, date.format( this.props.timeFormat ))\n\t\t\t\t)\n\t\t\t);\n\t\t},\n\t\tisValidDate: function(){ return 1; }\n\t});\n\n\tmodule.exports = DateTimePickerDays;\n\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_4__;\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar React = __webpack_require__(2);\n\n\tvar DOM = React.DOM;\n\tvar DateTimePickerMonths = React.createClass({\n\t\trender: function() {\n\t\t\treturn DOM.div({ className: 'rdtMonths' }, [\n\t\t\t\tDOM.table({ key: 'a'}, DOM.thead({}, DOM.tr({}, [\n\t\t\t\t\tDOM.th({ key: 'prev', className: 'rdtPrev' }, DOM.span({onClick: this.props.subtractTime(1, 'years')}, '‹')),\n\t\t\t\t\tDOM.th({ key: 'year', className: 'rdtSwitch', onClick: this.props.showView('years'), colSpan: 2, 'data-value': this.props.viewDate.year()}, this.props.viewDate.year() ),\n\t\t\t\t\tDOM.th({ key: 'next', className: 'rdtNext' }, DOM.span({onClick: this.props.addTime(1, 'years')}, '›'))\n\t\t\t\t]))),\n\t\t\t\tDOM.table({ key: 'months'}, DOM.tbody({ key: 'b'}, this.renderMonths()))\n\t\t\t]);\n\t\t},\n\n\t\trenderMonths: function() {\n\t\t\tvar date = this.props.selectedDate,\n\t\t\t\tmonth = this.props.viewDate.month(),\n\t\t\t\tyear = this.props.viewDate.year(),\n\t\t\t\trows = [],\n\t\t\t\ti = 0,\n\t\t\t\tmonths = [],\n\t\t\t\trenderer = this.props.renderMonth || this.renderMonth,\n\t\t\t\tclasses, props\n\t\t\t;\n\n\t\t\twhile (i < 12) {\n\t\t\t\tclasses = 'rdtMonth';\n\t\t\t\tif ( date && i === month && year === date.year() )\n\t\t\t\t\tclasses += ' rdtActive';\n\n\t\t\t\tprops = {\n\t\t\t\t\tkey: i,\n\t\t\t\t\t'data-value': i,\n\t\t\t\t\tclassName: classes,\n\t\t\t\t\tonClick: this.props.updateOn === 'months'? this.updateSelectedMonth : this.props.setDate('month')\n\t\t\t\t};\n\n\t\t\t\tmonths.push( renderer( props, i, year, date && date.clone() ));\n\n\t\t\t\tif ( months.length === 4 ){\n\t\t\t\t\trows.push( DOM.tr({ key: month + '_' + rows.length }, months) );\n\t\t\t\t\tmonths = [];\n\t\t\t\t}\n\n\t\t\t\ti++;\n\t\t\t}\n\n\t\t\treturn rows;\n\t\t},\n\n\t\tupdateSelectedMonth: function( event ) {\n\t\t\tthis.props.updateSelectedDate(event, true);\n\t\t},\n\n\t\trenderMonth: function( props, month ) {\n\t\t\tvar monthsShort = this.props.viewDate.localeData()._monthsShort;\n\t\t\treturn DOM.td( props, monthsShort.standalone\n\t\t\t\t? capitalize( monthsShort.standalone[ month ] )\n\t\t\t\t: monthsShort[ month ]\n\t\t\t);\n\t\t}\n\t});\n\n\tfunction capitalize(str) {\n\t\treturn str.charAt(0).toUpperCase() + str.slice(1);\n\t}\n\n\tmodule.exports = DateTimePickerMonths;\n\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar React = __webpack_require__(2);\n\n\tvar DOM = React.DOM;\n\tvar DateTimePickerYears = React.createClass({\n\t\trender: function() {\n\t\t\tvar year = parseInt(this.props.viewDate.year() / 10, 10) * 10;\n\n\t\t\treturn DOM.div({ className: 'rdtYears' }, [\n\t\t\t\tDOM.table({ key: 'a'}, DOM.thead({}, DOM.tr({}, [\n\t\t\t\t\tDOM.th({ key: 'prev', className: 'rdtPrev' }, DOM.span({onClick: this.props.subtractTime(10, 'years')}, '‹')),\n\t\t\t\t\tDOM.th({ key: 'year', className: 'rdtSwitch', onClick: this.props.showView('years'), colSpan: 2 }, year + '-' + (year + 9) ),\n\t\t\t\t\tDOM.th({ key: 'next', className: 'rdtNext'}, DOM.span({onClick: this.props.addTime(10, 'years')}, '›'))\n\t\t\t\t\t]))),\n\t\t\t\tDOM.table({ key: 'years'}, DOM.tbody({}, this.renderYears( year )))\n\t\t\t]);\n\t\t},\n\n\t\trenderYears: function( year ) {\n\t\t\tvar years = [],\n\t\t\t\ti = -1,\n\t\t\t\trows = [],\n\t\t\t\trenderer = this.props.renderYear || this.renderYear,\n\t\t\t\tselectedDate = this.props.selectedDate,\n\t\t\t\tclasses, props\n\t\t\t;\n\n\t\t\tyear--;\n\t\t\twhile (i < 11) {\n\t\t\t\tclasses = 'rdtYear';\n\t\t\t\tif ( i === -1 | i === 10 )\n\t\t\t\t\tclasses += ' rdtOld';\n\t\t\t\tif ( selectedDate && selectedDate.year() === year )\n\t\t\t\t\tclasses += ' rdtActive';\n\n\t\t\t\tprops = {\n\t\t\t\t\tkey: year,\n\t\t\t\t\t'data-value': year,\n\t\t\t\t\tclassName: classes,\n\t\t\t\t\tonClick: this.props.updateOn === 'years' ? this.updateSelectedYear : this.props.setDate('year')\n\t\t\t\t};\n\n\t\t\t\tyears.push( renderer( props, year, selectedDate && selectedDate.clone() ));\n\n\t\t\t\tif ( years.length === 4 ){\n\t\t\t\t\trows.push( DOM.tr({ key: i }, years ) );\n\t\t\t\t\tyears = [];\n\t\t\t\t}\n\n\t\t\t\tyear++;\n\t\t\t\ti++;\n\t\t\t}\n\n\t\t\treturn rows;\n\t\t},\n\n\t\tupdateSelectedYear: function( event ) {\n\t\t\tthis.props.updateSelectedDate(event, true);\n\t\t},\n\n\t\trenderYear: function( props, year ){\n\t\t\treturn DOM.td( props, year );\n\t\t}\n\t});\n\n\tmodule.exports = DateTimePickerYears;\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tvar React = __webpack_require__(2),\n\t\tassign = __webpack_require__(1);\n\n\tvar DOM = React.DOM;\n\tvar DateTimePickerTime = React.createClass({\n\t\tgetInitialState: function(){\n\t\t\treturn this.calculateState( this.props );\n\t\t},\n\t\tcalculateState: function( props ){\n\t\t\tvar date = props.selectedDate || props.viewDate,\n\t\t\t\tformat = props.timeFormat,\n\t\t\t\tcounters = []\n\t\t\t;\n\n\t\t\tif ( format.indexOf('H') !== -1 || format.indexOf('h') !== -1 ){\n\t\t\t\tcounters.push('hours');\n\t\t\t\tif ( format.indexOf('m') !== -1 ){\n\t\t\t\t\tcounters.push('minutes');\n\t\t\t\t\tif ( format.indexOf('s') !== -1 ){\n\t\t\t\t\t\tcounters.push('seconds');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar daypart = false;\n\t\t\tif ( this.props.timeFormat.indexOf(' A') !== -1  && this.state !== null ){\n\t\t\t\tdaypart = ( this.state.hours >= 12 ) ? 'PM' : 'AM';\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\thours: date.format('H'),\n\t\t\t\tminutes: date.format('mm'),\n\t\t\t\tseconds: date.format('ss'),\n\t\t\t\tmilliseconds: date.format('SSS'),\n\t\t\t\tdaypart: daypart,\n\t\t\t\tcounters: counters\n\t\t\t};\n\t\t},\n\t\trenderCounter: function( type ){\n\t\t\tif (type !== 'daypart') {\n\t\t\t\tvar value = this.state[ type ];\n\t\t\t\tif (type === 'hours' && this.props.timeFormat.indexOf(' A') !== -1) {\n\t\t\t\t\tvalue = (value - 1) % 12 + 1;\n\n\t\t\t\t\tif (value === 0) {\n\t\t\t\t\t\tvalue = 12;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn DOM.div({ key: type, className: 'rdtCounter'}, [\n\t\t\t\t\tDOM.span({ key:'up', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'increase', type ) }, '▲' ),\n\t\t\t\t\tDOM.div({ key:'c', className: 'rdtCount' }, value ),\n\t\t\t\t\tDOM.span({ key:'do', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'decrease', type ) }, '▼' )\n\t\t\t\t]);\n\t\t\t}\n\t\t\treturn '';\n\t\t},\n\t\trenderDayPart: function() {\n\t\t\treturn DOM.div({ className: 'rdtCounter', key: 'dayPart'}, [\n\t\t\t\tDOM.span({ key:'up', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'toggleDayPart', 'hours') }, '▲' ),\n\t\t\t\tDOM.div({ key: this.state.daypart, className: 'rdtCount'}, this.state.daypart ),\n\t\t\t\tDOM.span({ key:'do', className: 'rdtBtn', onMouseDown: this.onStartClicking( 'toggleDayPart', 'hours') }, '▼' )\n\t\t\t]);\n\t\t},\n\t\trender: function() {\n\t\t\tvar me = this,\n\t\t\t\tcounters = []\n\t\t\t;\n\n\t\t\tthis.state.counters.forEach( function(c){\n\t\t\t\tif ( counters.length )\n\t\t\t\t\tcounters.push( DOM.div( {key: 'sep' + counters.length, className: 'rdtCounterSeparator' }, ':' ));\n\t\t\t\tcounters.push( me.renderCounter( c ) );\n\t\t\t});\n\n\t\t\tif (this.state.daypart !== false) {\n\t\t\t\tcounters.push( me.renderDayPart() );\n\t\t\t}\n\n\t\t\tif ( this.state.counters.length === 3 && this.props.timeFormat.indexOf('S') !== -1 ){\n\t\t\t\tcounters.push( DOM.div( {className: 'rdtCounterSeparator', key: 'sep5' }, ':' ));\n\t\t\t\tcounters.push(\n\t\t\t\t\tDOM.div( {className: 'rdtCounter rdtMilli', key:'m'},\n\t\t\t\t\t\tDOM.input({ value: this.state.milliseconds, type: 'text', onChange: this.updateMilli })\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t}\n\n\t\t\treturn DOM.div( {className: 'rdtTime'},\n\t\t\t\tDOM.table( {}, [\n\t\t\t\t\tthis.renderHeader(),\n\t\t\t\t\tDOM.tbody({key: 'b'}, DOM.tr({}, DOM.td({},\n\t\t\t\t\t\tDOM.div({ className: 'rdtCounters' }, counters )\n\t\t\t\t\t)))\n\t\t\t\t])\n\t\t\t);\n\t\t},\n\t\tcomponentWillMount: function() {\n\t\t\tvar me = this;\n\t\t\tme.timeConstraints = {\n\t\t\t\thours: {\n\t\t\t\t\tmin: 0,\n\t\t\t\t\tmax: 23,\n\t\t\t\t\tstep: 1\n\t\t\t\t},\n\t\t\t\tminutes: {\n\t\t\t\t\tmin: 0,\n\t\t\t\t\tmax: 59,\n\t\t\t\t\tstep: 1\n\t\t\t\t},\n\t\t\t\tseconds: {\n\t\t\t\t\tmin: 0,\n\t\t\t\t\tmax: 59,\n\t\t\t\t\tstep: 1,\n\t\t\t\t},\n\t\t\t\tmilliseconds: {\n\t\t\t\t\tmin: 0,\n\t\t\t\t\tmax: 999,\n\t\t\t\t\tstep: 1\n\t\t\t\t}\n\t\t\t};\n\t\t\t['hours', 'minutes', 'seconds', 'milliseconds'].forEach(function(type) {\n\t\t\t\tassign(me.timeConstraints[type], me.props.timeConstraints[type]);\n\t\t\t});\n\t\t\tthis.setState( this.calculateState( this.props ) );\n\t\t},\n\t\tcomponentWillReceiveProps: function( nextProps ){\n\t\t\tthis.setState( this.calculateState( nextProps ) );\n\t\t},\n\t\tupdateMilli: function( e ){\n\t\t\tvar milli = parseInt( e.target.value, 10 );\n\t\t\tif ( milli === e.target.value && milli >= 0 && milli < 1000 ){\n\t\t\t\tthis.props.setTime( 'milliseconds', milli );\n\t\t\t\tthis.setState({ milliseconds: milli });\n\t\t\t}\n\t\t},\n\t\trenderHeader: function(){\n\t\t\tif ( !this.props.dateFormat )\n\t\t\t\treturn null;\n\n\t\t\tvar date = this.props.selectedDate || this.props.viewDate;\n\t\t\treturn DOM.thead({ key: 'h'}, DOM.tr({},\n\t\t\t\tDOM.th( {className: 'rdtSwitch', colSpan: 4, onClick: this.props.showView('days')}, date.format( this.props.dateFormat ) )\n\t\t\t));\n\t\t},\n\t\tonStartClicking: function( action, type ){\n\t\t\tvar me = this;\n\n\t\t\treturn function(){\n\t\t\t\tvar update = {};\n\t\t\t\tupdate[ type ] = me[ action ]( type );\n\t\t\t\tme.setState( update );\n\n\t\t\t\tme.timer = setTimeout( function(){\n\t\t\t\t\tme.increaseTimer = setInterval( function(){\n\t\t\t\t\t\tupdate[ type ] = me[ action ]( type );\n\t\t\t\t\t\tme.setState( update );\n\t\t\t\t\t}, 70);\n\t\t\t\t}, 500);\n\n\t\t\t\tme.mouseUpListener = function(){\n\t\t\t\t\tclearTimeout( me.timer );\n\t\t\t\t\tclearInterval( me.increaseTimer );\n\t\t\t\t\tme.props.setTime( type, me.state[ type ] );\n\t\t\t\t\tdocument.body.removeEventListener('mouseup', me.mouseUpListener);\n\t\t\t\t};\n\n\t\t\t\tdocument.body.addEventListener('mouseup', me.mouseUpListener);\n\t\t\t};\n\t\t},\n\t\tpadValues: {\n\t\t\thours: 1,\n\t\t\tminutes: 2,\n\t\t\tseconds: 2,\n\t\t\tmilliseconds: 3\n\t\t},\n\t\ttoggleDayPart: function( type ){ // type is always 'hours'\n\t\t\tvar value = parseInt(this.state[ type ], 10) + 12;\n\t\t\tif ( value > this.timeConstraints[ type ].max )\n\t\t\t\tvalue = this.timeConstraints[ type ].min + (value - (this.timeConstraints[ type ].max + 1));\n\t\t\treturn this.pad( type, value );\n\t\t},\n\t\tincrease: function( type ){\n\t\t\tvar value = parseInt(this.state[ type ], 10) + this.timeConstraints[ type ].step;\n\t\t\tif ( value > this.timeConstraints[ type ].max )\n\t\t\t\tvalue = this.timeConstraints[ type ].min + ( value - ( this.timeConstraints[ type ].max  + 1) );\n\t\t\treturn this.pad( type, value );\n\t\t},\n\t\tdecrease: function( type ){\n\t\t\tvar value = parseInt(this.state[ type ], 10) - this.timeConstraints[ type ].step;\n\t\t\tif ( value < this.timeConstraints[ type ].min )\n\t\t\t\tvalue = this.timeConstraints[ type ].max + 1 - ( this.timeConstraints[ type ].min - value );\n\t\t\treturn this.pad( type, value );\n\t\t},\n\t\tpad: function( type, value ){\n\t\t\tvar str = value + '';\n\t\t\twhile ( str.length < this.padValues[ type ] )\n\t\t\t\tstr = '0' + str;\n\t\t\treturn str;\n\t\t}\n\t});\n\n\tmodule.exports = DateTimePickerTime;\n\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\t// This is extracted from https://github.com/Pomax/react-onclickoutside\n\t// And modified to support react 0.13 and react 0.14\n\n\tvar React = __webpack_require__(2),\n\t\tversion = React.version && React.version.split('.')\n\t;\n\n\tif ( version && ( version[0] > 0 || version[1] > 13 ) )\n\t\tReact = __webpack_require__(9);\n\n\t// Use a parallel array because we can't use\n\t// objects as keys, they get toString-coerced\n\tvar registeredComponents = [];\n\tvar handlers = [];\n\n\tvar IGNORE_CLASS = 'ignore-react-onclickoutside';\n\n\tvar isSourceFound = function(source, localNode) {\n\t if (source === localNode) {\n\t   return true;\n\t }\n\t // SVG <use/> elements do not technically reside in the rendered DOM, so\n\t // they do not have classList directly, but they offer a link to their\n\t // corresponding element, which can have classList. This extra check is for\n\t // that case.\n\t // See: http://www.w3.org/TR/SVG11/struct.html#InterfaceSVGUseElement\n\t // Discussion: https://github.com/Pomax/react-onclickoutside/pull/17\n\t if (source.correspondingElement) {\n\t   return source.correspondingElement.classList.contains(IGNORE_CLASS);\n\t }\n\t return source.classList.contains(IGNORE_CLASS);\n\t};\n\n\tmodule.exports = {\n\t componentDidMount: function() {\n\t   if (typeof this.handleClickOutside !== 'function')\n\t     throw new Error('Component lacks a handleClickOutside(event) function for processing outside click events.');\n\n\t   var fn = this.__outsideClickHandler = (function(localNode, eventHandler) {\n\t     return function(evt) {\n\t       evt.stopPropagation();\n\t       var source = evt.target;\n\t       var found = false;\n\t       // If source=local then this event came from \"somewhere\"\n\t       // inside and should be ignored. We could handle this with\n\t       // a layered approach, too, but that requires going back to\n\t       // thinking in terms of Dom node nesting, running counter\n\t       // to React's \"you shouldn't care about the DOM\" philosophy.\n\t       while (source.parentNode) {\n\t         found = isSourceFound(source, localNode);\n\t         if (found) return;\n\t         source = source.parentNode;\n\t       }\n\t       eventHandler(evt);\n\t     };\n\t   }(React.findDOMNode(this), this.handleClickOutside));\n\n\t   var pos = registeredComponents.length;\n\t   registeredComponents.push(this);\n\t   handlers[pos] = fn;\n\n\t   // If there is a truthy disableOnClickOutside property for this\n\t   // component, don't immediately start listening for outside events.\n\t   if (!this.props.disableOnClickOutside) {\n\t     this.enableOnClickOutside();\n\t   }\n\t },\n\n\t componentWillUnmount: function() {\n\t   this.disableOnClickOutside();\n\t   this.__outsideClickHandler = false;\n\t   var pos = registeredComponents.indexOf(this);\n\t   if ( pos>-1) {\n\t     if (handlers[pos]) {\n\t       // clean up so we don't leak memory\n\t       handlers.splice(pos, 1);\n\t       registeredComponents.splice(pos, 1);\n\t     }\n\t   }\n\t },\n\n\t /**\n\t  * Can be called to explicitly enable event listening\n\t  * for clicks and touches outside of this element.\n\t  */\n\t enableOnClickOutside: function() {\n\t   var fn = this.__outsideClickHandler;\n\t   document.addEventListener('mousedown', fn);\n\t   document.addEventListener('touchstart', fn);\n\t },\n\n\t /**\n\t  * Can be called to explicitly disable event listening\n\t  * for clicks and touches outside of this element.\n\t  */\n\t disableOnClickOutside: function() {\n\t   var fn = this.__outsideClickHandler;\n\t   document.removeEventListener('mousedown', fn);\n\t   document.removeEventListener('touchstart', fn);\n\t }\n\t};\n\n\n/***/ },\n/* 9 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_9__;\n\n/***/ }\n/******/ ])\n});\n;\n//# sourceMappingURL=react-datetime.js.map"],"file":"react-datetime.js"}
|
