| | |
| | | /* |
| | | react-datetime v2.6.2 |
| | | https://github.com/arqex/react-datetime |
| | | MIT: https://github.com/arqex/react-datetime/raw/master/LICENSE |
| | | react-datetime v2.14.0 |
| | | https://github.com/YouCanBookMe/react-datetime |
| | | MIT: https://github.com/YouCanBookMe/react-datetime/raw/master/LICENSE |
| | | */ |
| | | (function webpackUniversalModuleDefinition(root, factory) { |
| | | if(typeof exports === 'object' && typeof module === '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__) { |
| | | })(this, function(__WEBPACK_EXTERNAL_MODULE_13__, __WEBPACK_EXTERNAL_MODULE_17__, __WEBPACK_EXTERNAL_MODULE_21__) { |
| | | return /******/ (function(modules) { // webpackBootstrap |
| | | /******/ // The module cache |
| | | /******/ var installedModules = {}; |
| | |
| | | /************************************************************************/ |
| | | /******/ ([ |
| | | /* 0 */ |
| | | /***/ function(module, exports, __webpack_require__) { |
| | | /***/ (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) |
| | | ; |
| | | PropTypes = __webpack_require__(2), |
| | | createClass = __webpack_require__(12), |
| | | moment = __webpack_require__(17), |
| | | React = __webpack_require__(13), |
| | | CalendarContainer = __webpack_require__(18) |
| | | ; |
| | | |
| | | var TYPES = React.PropTypes; |
| | | var Datetime = React.createClass({ |
| | | mixins: [ |
| | | __webpack_require__(8) |
| | | ], |
| | | viewComponents: { |
| | | days: DaysView, |
| | | months: MonthsView, |
| | | years: YearsView, |
| | | time: TimeView |
| | | }, |
| | | var viewModes = Object.freeze({ |
| | | YEARS: 'years', |
| | | MONTHS: 'months', |
| | | DAYS: 'days', |
| | | TIME: 'time', |
| | | }); |
| | | |
| | | var TYPES = PropTypes; |
| | | var Datetime = createClass({ |
| | | propTypes: { |
| | | // value: TYPES.object | TYPES.string, |
| | | // defaultValue: TYPES.object | TYPES.string, |
| | | // viewDate: TYPES.object | TYPES.string, |
| | | onFocus: TYPES.func, |
| | | onBlur: TYPES.func, |
| | | onChange: TYPES.func, |
| | | onViewModeChange: TYPES.func, |
| | | locale: TYPES.string, |
| | | utc: TYPES.bool, |
| | | 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']), |
| | | viewMode: TYPES.oneOf([viewModes.YEARS, viewModes.MONTHS, viewModes.DAYS, viewModes.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() { |
| | |
| | | if ( state.open === undefined ) |
| | | state.open = !this.props.input; |
| | | |
| | | state.currentView = this.props.dateFormat ? (this.props.viewMode || state.updateOn || 'days') : 'time'; |
| | | state.currentView = this.props.dateFormat ? |
| | | (this.props.viewMode || state.updateOn || viewModes.DAYS) : viewModes.TIME; |
| | | |
| | | return state; |
| | | }, |
| | | |
| | | getStateFromProps: function( props ){ |
| | | parseDate: function (date, formats) { |
| | | var parsedDate; |
| | | |
| | | if (date && typeof date === 'string') |
| | | parsedDate = this.localMoment(date, formats.datetime); |
| | | else if (date) |
| | | parsedDate = this.localMoment(date); |
| | | |
| | | if (parsedDate && !parsedDate.isValid()) |
| | | parsedDate = null; |
| | | |
| | | return parsedDate; |
| | | }, |
| | | |
| | | 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 ); |
| | | selectedDate = this.parseDate(date, formats); |
| | | |
| | | if ( selectedDate && !selectedDate.isValid() ) |
| | | selectedDate = null; |
| | | viewDate = this.parseDate(props.viewDate, formats); |
| | | |
| | | viewDate = selectedDate ? |
| | | selectedDate.clone().startOf('month') : |
| | | this.localMoment().startOf('month') |
| | | ; |
| | | viewDate ? viewDate.clone().startOf('month') : this.localMoment().startOf('month'); |
| | | |
| | | updateOn = this.getUpdateOn(formats); |
| | | |
| | |
| | | }; |
| | | }, |
| | | |
| | | 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'; |
| | | getUpdateOn: function( formats ) { |
| | | if ( formats.date.match(/[lLD]/) ) { |
| | | return viewModes.DAYS; |
| | | } else if ( formats.date.indexOf('M') !== -1 ) { |
| | | return viewModes.MONTHS; |
| | | } else if ( formats.date.indexOf('Y') !== -1 ) { |
| | | return viewModes.YEARS; |
| | | } |
| | | |
| | | return 'days'; |
| | | return viewModes.DAYS; |
| | | }, |
| | | |
| | | getFormats: function( props ){ |
| | | getFormats: function( props ) { |
| | | var formats = { |
| | | date: props.dateFormat || '', |
| | | time: props.timeFormat || '' |
| | | }, |
| | | locale = this.localMoment( props.date ).localeData() |
| | | ; |
| | | locale = this.localMoment( props.date, null, props ).localeData() |
| | | ; |
| | | |
| | | if ( formats.date === true ){ |
| | | if ( formats.date === true ) { |
| | | formats.date = locale.longDateFormat('L'); |
| | | } |
| | | else if ( this.getUpdateOn(formats) !== 'days' ){ |
| | | else if ( this.getUpdateOn(formats) !== viewModes.DAYS ) { |
| | | formats.time = ''; |
| | | } |
| | | |
| | | if ( formats.time === true ){ |
| | | if ( formats.time === true ) { |
| | | formats.time = locale.longDateFormat('LT'); |
| | | } |
| | | |
| | |
| | | return formats; |
| | | }, |
| | | |
| | | componentWillReceiveProps: function(nextProps) { |
| | | componentWillReceiveProps: function( nextProps ) { |
| | | var formats = this.getFormats( nextProps ), |
| | | update = {} |
| | | updatedState = {} |
| | | ; |
| | | |
| | | if ( nextProps.value !== this.props.value ){ |
| | | update = this.getStateFromProps( nextProps ); |
| | | } |
| | | if ( formats.datetime !== this.getFormats( this.props ).datetime ) { |
| | | update.inputFormat = formats.datetime; |
| | | if ( nextProps.value !== this.props.value || |
| | | formats.datetime !== this.getFormats( this.props ).datetime ) { |
| | | updatedState = this.getStateFromProps( nextProps ); |
| | | } |
| | | |
| | | if ( update.open === undefined ){ |
| | | if ( this.props.closeOnSelect && this.state.currentView !== 'time' ){ |
| | | update.open = false; |
| | | } |
| | | else { |
| | | update.open = this.state.open; |
| | | if ( updatedState.open === undefined ) { |
| | | if ( typeof nextProps.open !== 'undefined' ) { |
| | | updatedState.open = nextProps.open; |
| | | } else if ( this.props.closeOnSelect && this.state.currentView !== viewModes.TIME ) { |
| | | updatedState.open = false; |
| | | } else { |
| | | updatedState.open = this.state.open; |
| | | } |
| | | } |
| | | |
| | | this.setState( update ); |
| | | if ( nextProps.viewMode !== this.props.viewMode ) { |
| | | updatedState.currentView = nextProps.viewMode; |
| | | } |
| | | |
| | | if ( nextProps.locale !== this.props.locale ) { |
| | | if ( this.state.viewDate ) { |
| | | var updatedViewDate = this.state.viewDate.clone().locale( nextProps.locale ); |
| | | updatedState.viewDate = updatedViewDate; |
| | | } |
| | | if ( this.state.selectedDate ) { |
| | | var updatedSelectedDate = this.state.selectedDate.clone().locale( nextProps.locale ); |
| | | updatedState.selectedDate = updatedSelectedDate; |
| | | updatedState.inputValue = updatedSelectedDate.format( formats.datetime ); |
| | | } |
| | | } |
| | | |
| | | if ( nextProps.utc !== this.props.utc ) { |
| | | if ( nextProps.utc ) { |
| | | if ( this.state.viewDate ) |
| | | updatedState.viewDate = this.state.viewDate.clone().utc(); |
| | | if ( this.state.selectedDate ) { |
| | | updatedState.selectedDate = this.state.selectedDate.clone().utc(); |
| | | updatedState.inputValue = updatedState.selectedDate.format( formats.datetime ); |
| | | } |
| | | } else { |
| | | if ( this.state.viewDate ) |
| | | updatedState.viewDate = this.state.viewDate.clone().local(); |
| | | if ( this.state.selectedDate ) { |
| | | updatedState.selectedDate = this.state.selectedDate.clone().local(); |
| | | updatedState.inputValue = updatedState.selectedDate.format(formats.datetime); |
| | | } |
| | | } |
| | | } |
| | | |
| | | if ( nextProps.viewDate !== this.props.viewDate ) { |
| | | updatedState.viewDate = moment(nextProps.viewDate); |
| | | } |
| | | //we should only show a valid date if we are provided a isValidDate function. Removed in 2.10.3 |
| | | /*if (this.props.isValidDate) { |
| | | updatedState.viewDate = updatedState.viewDate || this.state.viewDate; |
| | | while (!this.props.isValidDate(updatedState.viewDate)) { |
| | | updatedState.viewDate = updatedState.viewDate.add(1, 'day'); |
| | | } |
| | | }*/ |
| | | this.setState( updatedState ); |
| | | }, |
| | | |
| | | 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 { |
| | | } else { |
| | | update.selectedDate = null; |
| | | } |
| | | |
| | |
| | | }); |
| | | }, |
| | | |
| | | onInputKey: function( e ){ |
| | | if ( e.which === 9 && this.props.closeOnTab ){ |
| | | onInputKey: function( e ) { |
| | | if ( e.which === 9 && this.props.closeOnTab ) { |
| | | this.closeCalendar(); |
| | | } |
| | | }, |
| | | |
| | | showView: function( view ){ |
| | | showView: function( view ) { |
| | | var me = this; |
| | | return function(){ |
| | | return function() { |
| | | me.state.currentView !== view && me.props.onViewModeChange( view ); |
| | | me.setState({ currentView: view }); |
| | | }; |
| | | }, |
| | | |
| | | setDate: function( type ){ |
| | | setDate: function( type ) { |
| | | var me = this, |
| | | nextViews = { |
| | | month: 'days', |
| | | year: 'months' |
| | | month: viewModes.DAYS, |
| | | year: viewModes.MONTHS, |
| | | } |
| | | ; |
| | | return function( e ){ |
| | | return function( e ) { |
| | | me.setState({ |
| | | viewDate: me.state.viewDate.clone()[ type ]( parseInt(e.target.getAttribute('data-value'), 10) ).startOf( type ), |
| | | currentView: nextViews[ type ] |
| | | }); |
| | | me.props.onViewModeChange( nextViews[ type ] ); |
| | | }; |
| | | }, |
| | | |
| | | addTime: function( amount, type, toSelected ){ |
| | | addTime: function( amount, type, toSelected ) { |
| | | return this.updateTime( 'add', amount, type, toSelected ); |
| | | }, |
| | | |
| | | subtractTime: function( amount, type, toSelected ){ |
| | | subtractTime: function( amount, type, toSelected ) { |
| | | return this.updateTime( 'subtract', amount, type, toSelected ); |
| | | }, |
| | | |
| | | updateTime: function( op, amount, type, toSelected ){ |
| | | updateTime: function( op, amount, type, toSelected ) { |
| | | var me = this; |
| | | |
| | | return function(){ |
| | | return function() { |
| | | var update = {}, |
| | | date = toSelected ? 'selectedDate' : 'viewDate' |
| | | ; |
| | |
| | | }, |
| | | |
| | | allowedSetTime: ['hours', 'minutes', 'seconds', 'milliseconds'], |
| | | setTime: function( type, value ){ |
| | | 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[ nextType ]( date[nextType]() ); |
| | | } |
| | | |
| | | if ( !this.props.value ){ |
| | | if ( !this.props.value ) { |
| | | this.setState({ |
| | | selectedDate: date, |
| | | inputValue: date.format( state.inputFormat ) |
| | |
| | | viewDate = this.state.viewDate, |
| | | currentDate = this.state.selectedDate || viewDate, |
| | | date |
| | | ; |
| | | ; |
| | | |
| | | if (target.className.indexOf('rdtDay') !== -1){ |
| | | if (target.className.indexOf('rdtDay') !== -1) { |
| | | if (target.className.indexOf('rdtNew') !== -1) |
| | | modifier = 1; |
| | | else if (target.className.indexOf('rdtOld') !== -1) |
| | |
| | | date = viewDate.clone() |
| | | .month( viewDate.month() + modifier ) |
| | | .date( parseInt( target.getAttribute('data-value'), 10 ) ); |
| | | } else if (target.className.indexOf('rdtMonth') !== -1){ |
| | | } 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){ |
| | | } else if (target.className.indexOf('rdtYear') !== -1) { |
| | | date = viewDate.clone() |
| | | .month( currentDate.month() ) |
| | | .date( currentDate.date() ) |
| | |
| | | .seconds( currentDate.seconds() ) |
| | | .milliseconds( currentDate.milliseconds() ); |
| | | |
| | | if ( !this.props.value ){ |
| | | if ( !this.props.value ) { |
| | | var open = !( this.props.closeOnSelect && close ); |
| | | if ( !open ) { |
| | | this.props.onBlur( date ); |
| | | } |
| | | |
| | | this.setState({ |
| | | selectedDate: date, |
| | | viewDate: date.clone().startOf('month'), |
| | | inputValue: date.format( this.state.inputFormat ), |
| | | open: !(this.props.closeOnSelect && close ) |
| | | open: open |
| | | }); |
| | | } else { |
| | | if (this.props.closeOnSelect && close) { |
| | | if ( this.props.closeOnSelect && close ) { |
| | | this.closeCalendar(); |
| | | } |
| | | } |
| | |
| | | this.props.onChange( date ); |
| | | }, |
| | | |
| | | openCalendar: function() { |
| | | if (!this.state.open) { |
| | | this.props.onFocus(); |
| | | this.setState({ open: true }); |
| | | openCalendar: function( e ) { |
| | | if ( !this.state.open ) { |
| | | this.setState({ open: true }, function() { |
| | | this.props.onFocus( e ); |
| | | }); |
| | | } |
| | | }, |
| | | |
| | | closeCalendar: function() { |
| | | this.setState({ open: false }); |
| | | this.props.onBlur( this.state.selectedDate || this.state.inputValue ); |
| | | this.setState({ open: false }, function () { |
| | | 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 ); |
| | | handleClickOutside: function() { |
| | | if ( this.props.input && this.state.open && !this.props.open && !this.props.disableOnClickOutside ) { |
| | | this.setState({ open: false }, function() { |
| | | 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 ); |
| | | localMoment: function( date, format, props ) { |
| | | props = props || this.props; |
| | | var momentFn = props.utc ? moment.utc : moment; |
| | | var m = momentFn( date, format, props.strictParsing ); |
| | | if ( props.locale ) |
| | | m.locale( props.locale ); |
| | | return m; |
| | | }, |
| | | |
| | | componentProps: { |
| | | fromProps: ['value', 'isValidDate', 'renderDay', 'renderMonth', 'renderYear', 'timeConstraints'], |
| | | fromState: ['viewDate', 'selectedDate', 'updateOn'], |
| | | fromThis: ['setDate', 'setTime', 'showView', 'addTime', 'subtractTime', 'updateSelectedDate', 'localMoment'] |
| | | fromThis: ['setDate', 'setTime', 'showView', 'addTime', 'subtractTime', 'updateSelectedDate', 'localMoment', 'handleClickOutside'] |
| | | }, |
| | | |
| | | getComponentProps: function(){ |
| | | getComponentProps: function() { |
| | | var me = this, |
| | | formats = this.getFormats( this.props ), |
| | | props = {dateFormat: formats.date, timeFormat: formats.time} |
| | | ; |
| | | ; |
| | | |
| | | this.componentProps.fromProps.forEach( function( name ){ |
| | | this.componentProps.fromProps.forEach( function( name ) { |
| | | props[ name ] = me.props[ name ]; |
| | | }); |
| | | this.componentProps.fromState.forEach( function( name ){ |
| | | this.componentProps.fromState.forEach( function( name ) { |
| | | props[ name ] = me.state[ name ]; |
| | | }); |
| | | this.componentProps.fromThis.forEach( function( name ){ |
| | | this.componentProps.fromThis.forEach( function( name ) { |
| | | props[ name ] = me[ name ]; |
| | | }); |
| | | |
| | |
| | | }, |
| | | |
| | | render: function() { |
| | | var Component = this.viewComponents[ this.state.currentView ], |
| | | DOM = React.DOM, |
| | | className = 'rdt' + (this.props.className ? |
| | | // TODO: Make a function or clean up this code, |
| | | // logic right now is really hard to follow |
| | | var className = 'rdt' + (this.props.className ? |
| | | ( Array.isArray( this.props.className ) ? |
| | | ' ' + this.props.className.join( ' ' ) : ' ' + this.props.className) : ''), |
| | | children = [] |
| | | ; |
| | | children = []; |
| | | |
| | | if ( this.props.input ){ |
| | | children = [ DOM.input( assign({ |
| | | key: 'i', |
| | | type:'text', |
| | | if ( this.props.input ) { |
| | | var finalInputProps = assign({ |
| | | type: 'text', |
| | | className: 'form-control', |
| | | onClick: this.openCalendar, |
| | | onFocus: this.openCalendar, |
| | | onChange: this.onInputChange, |
| | | onKeyDown: this.onInputKey, |
| | | value: this.state.inputValue |
| | | }, this.props.inputProps ))]; |
| | | value: this.state.inputValue, |
| | | }, this.props.inputProps); |
| | | if ( this.props.renderInput ) { |
| | | children = [ React.createElement('div', { key: 'i' }, this.props.renderInput( finalInputProps, this.openCalendar, this.closeCalendar )) ]; |
| | | } else { |
| | | children = [ React.createElement('input', assign({ key: 'i' }, finalInputProps ))]; |
| | | } |
| | | } else { |
| | | className += ' rdtStatic'; |
| | | } |
| | |
| | | if ( this.state.open ) |
| | | className += ' rdtOpen'; |
| | | |
| | | return DOM.div({className: className}, children.concat( |
| | | DOM.div( |
| | | return React.createElement( 'div', { className: className }, children.concat( |
| | | React.createElement( 'div', |
| | | { key: 'dt', className: 'rdtPicker' }, |
| | | React.createElement( Component, this.getComponentProps()) |
| | | React.createElement( CalendarContainer, { view: this.state.currentView, viewProps: this.getComponentProps(), onClickOutside: this.handleClickOutside }) |
| | | ) |
| | | )); |
| | | } |
| | | }); |
| | | |
| | | Datetime.defaultProps = { |
| | | className: '', |
| | | defaultValue: '', |
| | | inputProps: {}, |
| | | input: true, |
| | | onFocus: function() {}, |
| | | onBlur: function() {}, |
| | | onChange: function() {}, |
| | | onViewModeChange: function() {}, |
| | | timeFormat: true, |
| | | timeConstraints: {}, |
| | | dateFormat: true, |
| | | strictParsing: true, |
| | | closeOnSelect: false, |
| | | closeOnTab: true, |
| | | utc: false |
| | | }; |
| | | |
| | | // Make moment accessible through the Datetime class |
| | | Datetime.moment = moment; |
| | |
| | | module.exports = Datetime; |
| | | |
| | | |
| | | /***/ }, |
| | | /***/ }), |
| | | /* 1 */ |
| | | /***/ function(module, exports) { |
| | | /***/ (function(module, exports) { |
| | | |
| | | 'use strict'; |
| | | var propIsEnumerable = Object.prototype.propertyIsEnumerable; |
| | |
| | | }; |
| | | |
| | | |
| | | /***/ }, |
| | | /***/ }), |
| | | /* 2 */ |
| | | /***/ function(module, exports) { |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | module.exports = __WEBPACK_EXTERNAL_MODULE_2__; |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | */ |
| | | |
| | | /***/ }, |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' && |
| | | Symbol.for && |
| | | Symbol.for('react.element')) || |
| | | 0xeac7; |
| | | |
| | | var isValidElement = function(object) { |
| | | return typeof object === 'object' && |
| | | object !== null && |
| | | object.$$typeof === REACT_ELEMENT_TYPE; |
| | | }; |
| | | |
| | | // By explicitly using `prop-types` you are opting into new development behavior. |
| | | // http://fb.me/prop-types-in-prod |
| | | var throwOnDirectAccess = true; |
| | | module.exports = __webpack_require__(4)(isValidElement, throwOnDirectAccess); |
| | | } else { |
| | | // By explicitly using `prop-types` you are opting into new production behavior. |
| | | // http://fb.me/prop-types-in-prod |
| | | module.exports = __webpack_require__(11)(); |
| | | } |
| | | |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 3 */ |
| | | /***/ function(module, exports, __webpack_require__) { |
| | | /***/ (function(module, exports) { |
| | | |
| | | // shim for using process in browser |
| | | var process = module.exports = {}; |
| | | |
| | | // cached from whatever global is present so that test runners that stub it |
| | | // don't break things. But we need to wrap it in a try catch in case it is |
| | | // wrapped in strict mode code which doesn't define any globals. It's inside a |
| | | // function because try/catches deoptimize in certain engines. |
| | | |
| | | var cachedSetTimeout; |
| | | var cachedClearTimeout; |
| | | |
| | | function defaultSetTimout() { |
| | | throw new Error('setTimeout has not been defined'); |
| | | } |
| | | function defaultClearTimeout () { |
| | | throw new Error('clearTimeout has not been defined'); |
| | | } |
| | | (function () { |
| | | try { |
| | | if (typeof setTimeout === 'function') { |
| | | cachedSetTimeout = setTimeout; |
| | | } else { |
| | | cachedSetTimeout = defaultSetTimout; |
| | | } |
| | | } catch (e) { |
| | | cachedSetTimeout = defaultSetTimout; |
| | | } |
| | | try { |
| | | if (typeof clearTimeout === 'function') { |
| | | cachedClearTimeout = clearTimeout; |
| | | } else { |
| | | cachedClearTimeout = defaultClearTimeout; |
| | | } |
| | | } catch (e) { |
| | | cachedClearTimeout = defaultClearTimeout; |
| | | } |
| | | } ()) |
| | | function runTimeout(fun) { |
| | | if (cachedSetTimeout === setTimeout) { |
| | | //normal enviroments in sane situations |
| | | return setTimeout(fun, 0); |
| | | } |
| | | // if setTimeout wasn't available but was latter defined |
| | | if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { |
| | | cachedSetTimeout = setTimeout; |
| | | return setTimeout(fun, 0); |
| | | } |
| | | try { |
| | | // when when somebody has screwed with setTimeout but no I.E. maddness |
| | | return cachedSetTimeout(fun, 0); |
| | | } catch(e){ |
| | | try { |
| | | // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally |
| | | return cachedSetTimeout.call(null, fun, 0); |
| | | } catch(e){ |
| | | // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error |
| | | return cachedSetTimeout.call(this, fun, 0); |
| | | } |
| | | } |
| | | |
| | | |
| | | } |
| | | function runClearTimeout(marker) { |
| | | if (cachedClearTimeout === clearTimeout) { |
| | | //normal enviroments in sane situations |
| | | return clearTimeout(marker); |
| | | } |
| | | // if clearTimeout wasn't available but was latter defined |
| | | if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { |
| | | cachedClearTimeout = clearTimeout; |
| | | return clearTimeout(marker); |
| | | } |
| | | try { |
| | | // when when somebody has screwed with setTimeout but no I.E. maddness |
| | | return cachedClearTimeout(marker); |
| | | } catch (e){ |
| | | try { |
| | | // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally |
| | | return cachedClearTimeout.call(null, marker); |
| | | } catch (e){ |
| | | // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. |
| | | // Some versions of I.E. have different rules for clearTimeout vs setTimeout |
| | | return cachedClearTimeout.call(this, marker); |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | } |
| | | var queue = []; |
| | | var draining = false; |
| | | var currentQueue; |
| | | var queueIndex = -1; |
| | | |
| | | function cleanUpNextTick() { |
| | | if (!draining || !currentQueue) { |
| | | return; |
| | | } |
| | | draining = false; |
| | | if (currentQueue.length) { |
| | | queue = currentQueue.concat(queue); |
| | | } else { |
| | | queueIndex = -1; |
| | | } |
| | | if (queue.length) { |
| | | drainQueue(); |
| | | } |
| | | } |
| | | |
| | | function drainQueue() { |
| | | if (draining) { |
| | | return; |
| | | } |
| | | var timeout = runTimeout(cleanUpNextTick); |
| | | draining = true; |
| | | |
| | | var len = queue.length; |
| | | while(len) { |
| | | currentQueue = queue; |
| | | queue = []; |
| | | while (++queueIndex < len) { |
| | | if (currentQueue) { |
| | | currentQueue[queueIndex].run(); |
| | | } |
| | | } |
| | | queueIndex = -1; |
| | | len = queue.length; |
| | | } |
| | | currentQueue = null; |
| | | draining = false; |
| | | runClearTimeout(timeout); |
| | | } |
| | | |
| | | process.nextTick = function (fun) { |
| | | var args = new Array(arguments.length - 1); |
| | | if (arguments.length > 1) { |
| | | for (var i = 1; i < arguments.length; i++) { |
| | | args[i - 1] = arguments[i]; |
| | | } |
| | | } |
| | | queue.push(new Item(fun, args)); |
| | | if (queue.length === 1 && !draining) { |
| | | runTimeout(drainQueue); |
| | | } |
| | | }; |
| | | |
| | | // v8 likes predictible objects |
| | | function Item(fun, array) { |
| | | this.fun = fun; |
| | | this.array = array; |
| | | } |
| | | Item.prototype.run = function () { |
| | | this.fun.apply(null, this.array); |
| | | }; |
| | | process.title = 'browser'; |
| | | process.browser = true; |
| | | process.env = {}; |
| | | process.argv = []; |
| | | process.version = ''; // empty string to avoid regexp issues |
| | | process.versions = {}; |
| | | |
| | | function noop() {} |
| | | |
| | | process.on = noop; |
| | | process.addListener = noop; |
| | | process.once = noop; |
| | | process.off = noop; |
| | | process.removeListener = noop; |
| | | process.removeAllListeners = noop; |
| | | process.emit = noop; |
| | | process.prependListener = noop; |
| | | process.prependOnceListener = noop; |
| | | |
| | | process.listeners = function (name) { return [] } |
| | | |
| | | process.binding = function (name) { |
| | | throw new Error('process.binding is not supported'); |
| | | }; |
| | | |
| | | process.cwd = function () { return '/' }; |
| | | process.chdir = function (dir) { |
| | | throw new Error('process.chdir is not supported'); |
| | | }; |
| | | process.umask = function() { return 0; }; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 4 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(2), |
| | | moment = __webpack_require__(4) |
| | | ; |
| | | var emptyFunction = __webpack_require__(5); |
| | | var invariant = __webpack_require__(6); |
| | | var warning = __webpack_require__(7); |
| | | var assign = __webpack_require__(8); |
| | | |
| | | var DOM = React.DOM; |
| | | var DateTimePickerDays = React.createClass({ |
| | | var ReactPropTypesSecret = __webpack_require__(9); |
| | | var checkPropTypes = __webpack_require__(10); |
| | | |
| | | module.exports = function(isValidElement, throwOnDirectAccess) { |
| | | /* global Symbol */ |
| | | var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; |
| | | var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec. |
| | | |
| | | /** |
| | | * Returns the iterator method function contained on the iterable object. |
| | | * |
| | | * Be sure to invoke the function with the iterable as context: |
| | | * |
| | | * var iteratorFn = getIteratorFn(myIterable); |
| | | * if (iteratorFn) { |
| | | * var iterator = iteratorFn.call(myIterable); |
| | | * ... |
| | | * } |
| | | * |
| | | * @param {?object} maybeIterable |
| | | * @return {?function} |
| | | */ |
| | | function getIteratorFn(maybeIterable) { |
| | | var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); |
| | | if (typeof iteratorFn === 'function') { |
| | | return iteratorFn; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Collection of methods that allow declaration and validation of props that are |
| | | * supplied to React components. Example usage: |
| | | * |
| | | * var Props = require('ReactPropTypes'); |
| | | * var MyArticle = React.createClass({ |
| | | * propTypes: { |
| | | * // An optional string prop named "description". |
| | | * description: Props.string, |
| | | * |
| | | * // A required enum prop named "category". |
| | | * category: Props.oneOf(['News','Photos']).isRequired, |
| | | * |
| | | * // A prop named "dialog" that requires an instance of Dialog. |
| | | * dialog: Props.instanceOf(Dialog).isRequired |
| | | * }, |
| | | * render: function() { ... } |
| | | * }); |
| | | * |
| | | * A more formal specification of how these methods are used: |
| | | * |
| | | * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...) |
| | | * decl := ReactPropTypes.{type}(.isRequired)? |
| | | * |
| | | * Each and every declaration produces a function with the same signature. This |
| | | * allows the creation of custom validation functions. For example: |
| | | * |
| | | * var MyLink = React.createClass({ |
| | | * propTypes: { |
| | | * // An optional string or URI prop named "href". |
| | | * href: function(props, propName, componentName) { |
| | | * var propValue = props[propName]; |
| | | * if (propValue != null && typeof propValue !== 'string' && |
| | | * !(propValue instanceof URI)) { |
| | | * return new Error( |
| | | * 'Expected a string or an URI for ' + propName + ' in ' + |
| | | * componentName |
| | | * ); |
| | | * } |
| | | * } |
| | | * }, |
| | | * render: function() {...} |
| | | * }); |
| | | * |
| | | * @internal |
| | | */ |
| | | |
| | | var ANONYMOUS = '<<anonymous>>'; |
| | | |
| | | // Important! |
| | | // Keep this list in sync with production version in `./factoryWithThrowingShims.js`. |
| | | var ReactPropTypes = { |
| | | array: createPrimitiveTypeChecker('array'), |
| | | bool: createPrimitiveTypeChecker('boolean'), |
| | | func: createPrimitiveTypeChecker('function'), |
| | | number: createPrimitiveTypeChecker('number'), |
| | | object: createPrimitiveTypeChecker('object'), |
| | | string: createPrimitiveTypeChecker('string'), |
| | | symbol: createPrimitiveTypeChecker('symbol'), |
| | | |
| | | any: createAnyTypeChecker(), |
| | | arrayOf: createArrayOfTypeChecker, |
| | | element: createElementTypeChecker(), |
| | | instanceOf: createInstanceTypeChecker, |
| | | node: createNodeChecker(), |
| | | objectOf: createObjectOfTypeChecker, |
| | | oneOf: createEnumTypeChecker, |
| | | oneOfType: createUnionTypeChecker, |
| | | shape: createShapeTypeChecker, |
| | | exact: createStrictShapeTypeChecker, |
| | | }; |
| | | |
| | | /** |
| | | * inlined Object.is polyfill to avoid requiring consumers ship their own |
| | | * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is |
| | | */ |
| | | /*eslint-disable no-self-compare*/ |
| | | function is(x, y) { |
| | | // SameValue algorithm |
| | | if (x === y) { |
| | | // Steps 1-5, 7-10 |
| | | // Steps 6.b-6.e: +0 != -0 |
| | | return x !== 0 || 1 / x === 1 / y; |
| | | } else { |
| | | // Step 6.a: NaN == NaN |
| | | return x !== x && y !== y; |
| | | } |
| | | } |
| | | /*eslint-enable no-self-compare*/ |
| | | |
| | | /** |
| | | * We use an Error-like object for backward compatibility as people may call |
| | | * PropTypes directly and inspect their output. However, we don't use real |
| | | * Errors anymore. We don't inspect their stack anyway, and creating them |
| | | * is prohibitively expensive if they are created too often, such as what |
| | | * happens in oneOfType() for any type before the one that matched. |
| | | */ |
| | | function PropTypeError(message) { |
| | | this.message = message; |
| | | this.stack = ''; |
| | | } |
| | | // Make `instanceof Error` still work for returned errors. |
| | | PropTypeError.prototype = Error.prototype; |
| | | |
| | | function createChainableTypeChecker(validate) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | var manualPropTypeCallCache = {}; |
| | | var manualPropTypeWarningCount = 0; |
| | | } |
| | | function checkType(isRequired, props, propName, componentName, location, propFullName, secret) { |
| | | componentName = componentName || ANONYMOUS; |
| | | propFullName = propFullName || propName; |
| | | |
| | | if (secret !== ReactPropTypesSecret) { |
| | | if (throwOnDirectAccess) { |
| | | // New behavior only for users of `prop-types` package |
| | | invariant( |
| | | false, |
| | | 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + |
| | | 'Use `PropTypes.checkPropTypes()` to call them. ' + |
| | | 'Read more at http://fb.me/use-check-prop-types' |
| | | ); |
| | | } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') { |
| | | // Old behavior for people using React.PropTypes |
| | | var cacheKey = componentName + ':' + propName; |
| | | if ( |
| | | !manualPropTypeCallCache[cacheKey] && |
| | | // Avoid spamming the console because they are often not actionable except for lib authors |
| | | manualPropTypeWarningCount < 3 |
| | | ) { |
| | | warning( |
| | | false, |
| | | 'You are manually calling a React.PropTypes validation ' + |
| | | 'function for the `%s` prop on `%s`. This is deprecated ' + |
| | | 'and will throw in the standalone `prop-types` package. ' + |
| | | 'You may be seeing this warning due to a third-party PropTypes ' + |
| | | 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.', |
| | | propFullName, |
| | | componentName |
| | | ); |
| | | manualPropTypeCallCache[cacheKey] = true; |
| | | manualPropTypeWarningCount++; |
| | | } |
| | | } |
| | | } |
| | | if (props[propName] == null) { |
| | | if (isRequired) { |
| | | if (props[propName] === null) { |
| | | return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.')); |
| | | } |
| | | return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.')); |
| | | } |
| | | return null; |
| | | } else { |
| | | return validate(props, propName, componentName, location, propFullName); |
| | | } |
| | | } |
| | | |
| | | var chainedCheckType = checkType.bind(null, false); |
| | | chainedCheckType.isRequired = checkType.bind(null, true); |
| | | |
| | | return chainedCheckType; |
| | | } |
| | | |
| | | function createPrimitiveTypeChecker(expectedType) { |
| | | function validate(props, propName, componentName, location, propFullName, secret) { |
| | | var propValue = props[propName]; |
| | | var propType = getPropType(propValue); |
| | | if (propType !== expectedType) { |
| | | // `propValue` being instance of, say, date/regexp, pass the 'object' |
| | | // check, but we can offer a more precise error message here rather than |
| | | // 'of type `object`'. |
| | | var preciseType = getPreciseType(propValue); |
| | | |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.')); |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createAnyTypeChecker() { |
| | | return createChainableTypeChecker(emptyFunction.thatReturnsNull); |
| | | } |
| | | |
| | | function createArrayOfTypeChecker(typeChecker) { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | if (typeof typeChecker !== 'function') { |
| | | return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.'); |
| | | } |
| | | var propValue = props[propName]; |
| | | if (!Array.isArray(propValue)) { |
| | | var propType = getPropType(propValue); |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.')); |
| | | } |
| | | for (var i = 0; i < propValue.length; i++) { |
| | | var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret); |
| | | if (error instanceof Error) { |
| | | return error; |
| | | } |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createElementTypeChecker() { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | var propValue = props[propName]; |
| | | if (!isValidElement(propValue)) { |
| | | var propType = getPropType(propValue); |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.')); |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createInstanceTypeChecker(expectedClass) { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | if (!(props[propName] instanceof expectedClass)) { |
| | | var expectedClassName = expectedClass.name || ANONYMOUS; |
| | | var actualClassName = getClassName(props[propName]); |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.')); |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createEnumTypeChecker(expectedValues) { |
| | | if (!Array.isArray(expectedValues)) { |
| | | process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0; |
| | | return emptyFunction.thatReturnsNull; |
| | | } |
| | | |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | var propValue = props[propName]; |
| | | for (var i = 0; i < expectedValues.length; i++) { |
| | | if (is(propValue, expectedValues[i])) { |
| | | return null; |
| | | } |
| | | } |
| | | |
| | | var valuesString = JSON.stringify(expectedValues); |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.')); |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createObjectOfTypeChecker(typeChecker) { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | if (typeof typeChecker !== 'function') { |
| | | return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.'); |
| | | } |
| | | var propValue = props[propName]; |
| | | var propType = getPropType(propValue); |
| | | if (propType !== 'object') { |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.')); |
| | | } |
| | | for (var key in propValue) { |
| | | if (propValue.hasOwnProperty(key)) { |
| | | var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); |
| | | if (error instanceof Error) { |
| | | return error; |
| | | } |
| | | } |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createUnionTypeChecker(arrayOfTypeCheckers) { |
| | | if (!Array.isArray(arrayOfTypeCheckers)) { |
| | | process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0; |
| | | return emptyFunction.thatReturnsNull; |
| | | } |
| | | |
| | | for (var i = 0; i < arrayOfTypeCheckers.length; i++) { |
| | | var checker = arrayOfTypeCheckers[i]; |
| | | if (typeof checker !== 'function') { |
| | | warning( |
| | | false, |
| | | 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + |
| | | 'received %s at index %s.', |
| | | getPostfixForTypeWarning(checker), |
| | | i |
| | | ); |
| | | return emptyFunction.thatReturnsNull; |
| | | } |
| | | } |
| | | |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | for (var i = 0; i < arrayOfTypeCheckers.length; i++) { |
| | | var checker = arrayOfTypeCheckers[i]; |
| | | if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) { |
| | | return null; |
| | | } |
| | | } |
| | | |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.')); |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createNodeChecker() { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | if (!isNode(props[propName])) { |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.')); |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createShapeTypeChecker(shapeTypes) { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | var propValue = props[propName]; |
| | | var propType = getPropType(propValue); |
| | | if (propType !== 'object') { |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); |
| | | } |
| | | for (var key in shapeTypes) { |
| | | var checker = shapeTypes[key]; |
| | | if (!checker) { |
| | | continue; |
| | | } |
| | | var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); |
| | | if (error) { |
| | | return error; |
| | | } |
| | | } |
| | | return null; |
| | | } |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function createStrictShapeTypeChecker(shapeTypes) { |
| | | function validate(props, propName, componentName, location, propFullName) { |
| | | var propValue = props[propName]; |
| | | var propType = getPropType(propValue); |
| | | if (propType !== 'object') { |
| | | return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); |
| | | } |
| | | // We need to check all keys in case some are required but missing from |
| | | // props. |
| | | var allKeys = assign({}, props[propName], shapeTypes); |
| | | for (var key in allKeys) { |
| | | var checker = shapeTypes[key]; |
| | | if (!checker) { |
| | | return new PropTypeError( |
| | | 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + |
| | | '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + |
| | | '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ') |
| | | ); |
| | | } |
| | | var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); |
| | | if (error) { |
| | | return error; |
| | | } |
| | | } |
| | | return null; |
| | | } |
| | | |
| | | return createChainableTypeChecker(validate); |
| | | } |
| | | |
| | | function isNode(propValue) { |
| | | switch (typeof propValue) { |
| | | case 'number': |
| | | case 'string': |
| | | case 'undefined': |
| | | return true; |
| | | case 'boolean': |
| | | return !propValue; |
| | | case 'object': |
| | | if (Array.isArray(propValue)) { |
| | | return propValue.every(isNode); |
| | | } |
| | | if (propValue === null || isValidElement(propValue)) { |
| | | return true; |
| | | } |
| | | |
| | | var iteratorFn = getIteratorFn(propValue); |
| | | if (iteratorFn) { |
| | | var iterator = iteratorFn.call(propValue); |
| | | var step; |
| | | if (iteratorFn !== propValue.entries) { |
| | | while (!(step = iterator.next()).done) { |
| | | if (!isNode(step.value)) { |
| | | return false; |
| | | } |
| | | } |
| | | } else { |
| | | // Iterator will provide entry [k,v] tuples rather than values. |
| | | while (!(step = iterator.next()).done) { |
| | | var entry = step.value; |
| | | if (entry) { |
| | | if (!isNode(entry[1])) { |
| | | return false; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } else { |
| | | return false; |
| | | } |
| | | |
| | | return true; |
| | | default: |
| | | return false; |
| | | } |
| | | } |
| | | |
| | | function isSymbol(propType, propValue) { |
| | | // Native Symbol. |
| | | if (propType === 'symbol') { |
| | | return true; |
| | | } |
| | | |
| | | // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol' |
| | | if (propValue['@@toStringTag'] === 'Symbol') { |
| | | return true; |
| | | } |
| | | |
| | | // Fallback for non-spec compliant Symbols which are polyfilled. |
| | | if (typeof Symbol === 'function' && propValue instanceof Symbol) { |
| | | return true; |
| | | } |
| | | |
| | | return false; |
| | | } |
| | | |
| | | // Equivalent of `typeof` but with special handling for array and regexp. |
| | | function getPropType(propValue) { |
| | | var propType = typeof propValue; |
| | | if (Array.isArray(propValue)) { |
| | | return 'array'; |
| | | } |
| | | if (propValue instanceof RegExp) { |
| | | // Old webkits (at least until Android 4.0) return 'function' rather than |
| | | // 'object' for typeof a RegExp. We'll normalize this here so that /bla/ |
| | | // passes PropTypes.object. |
| | | return 'object'; |
| | | } |
| | | if (isSymbol(propType, propValue)) { |
| | | return 'symbol'; |
| | | } |
| | | return propType; |
| | | } |
| | | |
| | | // This handles more types than `getPropType`. Only used for error messages. |
| | | // See `createPrimitiveTypeChecker`. |
| | | function getPreciseType(propValue) { |
| | | if (typeof propValue === 'undefined' || propValue === null) { |
| | | return '' + propValue; |
| | | } |
| | | var propType = getPropType(propValue); |
| | | if (propType === 'object') { |
| | | if (propValue instanceof Date) { |
| | | return 'date'; |
| | | } else if (propValue instanceof RegExp) { |
| | | return 'regexp'; |
| | | } |
| | | } |
| | | return propType; |
| | | } |
| | | |
| | | // Returns a string that is postfixed to a warning about an invalid type. |
| | | // For example, "undefined" or "of type array" |
| | | function getPostfixForTypeWarning(value) { |
| | | var type = getPreciseType(value); |
| | | switch (type) { |
| | | case 'array': |
| | | case 'object': |
| | | return 'an ' + type; |
| | | case 'boolean': |
| | | case 'date': |
| | | case 'regexp': |
| | | return 'a ' + type; |
| | | default: |
| | | return type; |
| | | } |
| | | } |
| | | |
| | | // Returns class name of the object, if any. |
| | | function getClassName(propValue) { |
| | | if (!propValue.constructor || !propValue.constructor.name) { |
| | | return ANONYMOUS; |
| | | } |
| | | return propValue.constructor.name; |
| | | } |
| | | |
| | | ReactPropTypes.checkPropTypes = checkPropTypes; |
| | | ReactPropTypes.PropTypes = ReactPropTypes; |
| | | |
| | | return ReactPropTypes; |
| | | }; |
| | | |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 5 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | "use strict"; |
| | | |
| | | /** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | * |
| | | * |
| | | */ |
| | | |
| | | function makeEmptyFunction(arg) { |
| | | return function () { |
| | | return arg; |
| | | }; |
| | | } |
| | | |
| | | /** |
| | | * This function accepts and discards inputs; it has no side effects. This is |
| | | * primarily useful idiomatically for overridable function endpoints which |
| | | * always need to be callable, since JS lacks a null-call idiom ala Cocoa. |
| | | */ |
| | | var emptyFunction = function emptyFunction() {}; |
| | | |
| | | emptyFunction.thatReturns = makeEmptyFunction; |
| | | emptyFunction.thatReturnsFalse = makeEmptyFunction(false); |
| | | emptyFunction.thatReturnsTrue = makeEmptyFunction(true); |
| | | emptyFunction.thatReturnsNull = makeEmptyFunction(null); |
| | | emptyFunction.thatReturnsThis = function () { |
| | | return this; |
| | | }; |
| | | emptyFunction.thatReturnsArgument = function (arg) { |
| | | return arg; |
| | | }; |
| | | |
| | | module.exports = emptyFunction; |
| | | |
| | | /***/ }), |
| | | /* 6 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | * |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | /** |
| | | * Use invariant() to assert state which your program assumes to be true. |
| | | * |
| | | * Provide sprintf-style format (only %s is supported) and arguments |
| | | * to provide information about what broke and what you were |
| | | * expecting. |
| | | * |
| | | * The invariant message will be stripped in production, but the invariant |
| | | * will remain to ensure logic does not differ in production. |
| | | */ |
| | | |
| | | var validateFormat = function validateFormat(format) {}; |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | validateFormat = function validateFormat(format) { |
| | | if (format === undefined) { |
| | | throw new Error('invariant requires an error message argument'); |
| | | } |
| | | }; |
| | | } |
| | | |
| | | function invariant(condition, format, a, b, c, d, e, f) { |
| | | validateFormat(format); |
| | | |
| | | if (!condition) { |
| | | var error; |
| | | if (format === undefined) { |
| | | error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); |
| | | } else { |
| | | var args = [a, b, c, d, e, f]; |
| | | var argIndex = 0; |
| | | error = new Error(format.replace(/%s/g, function () { |
| | | return args[argIndex++]; |
| | | })); |
| | | error.name = 'Invariant Violation'; |
| | | } |
| | | |
| | | error.framesToPop = 1; // we don't care about invariant's own frame |
| | | throw error; |
| | | } |
| | | } |
| | | |
| | | module.exports = invariant; |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 7 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2014-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | * |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var emptyFunction = __webpack_require__(5); |
| | | |
| | | /** |
| | | * Similar to invariant but only logs a warning if the condition is not met. |
| | | * This can be used to log issues in development environments in critical |
| | | * paths. Removing the logging code for production environments will keep the |
| | | * same logic and follow the same code paths. |
| | | */ |
| | | |
| | | var warning = emptyFunction; |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | var printWarning = function printWarning(format) { |
| | | for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
| | | args[_key - 1] = arguments[_key]; |
| | | } |
| | | |
| | | var argIndex = 0; |
| | | var message = 'Warning: ' + format.replace(/%s/g, function () { |
| | | return args[argIndex++]; |
| | | }); |
| | | if (typeof console !== 'undefined') { |
| | | console.error(message); |
| | | } |
| | | try { |
| | | // --- Welcome to debugging React --- |
| | | // This error was thrown as a convenience so that you can use this stack |
| | | // to find the callsite that caused this warning to fire. |
| | | throw new Error(message); |
| | | } catch (x) {} |
| | | }; |
| | | |
| | | warning = function warning(condition, format) { |
| | | if (format === undefined) { |
| | | throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); |
| | | } |
| | | |
| | | if (format.indexOf('Failed Composite propType: ') === 0) { |
| | | return; // Ignore CompositeComponent proptype check. |
| | | } |
| | | |
| | | if (!condition) { |
| | | for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { |
| | | args[_key2 - 2] = arguments[_key2]; |
| | | } |
| | | |
| | | printWarning.apply(undefined, [format].concat(args)); |
| | | } |
| | | }; |
| | | } |
| | | |
| | | module.exports = warning; |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 8 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | /* |
| | | object-assign |
| | | (c) Sindre Sorhus |
| | | @license MIT |
| | | */ |
| | | |
| | | 'use strict'; |
| | | /* eslint-disable no-unused-vars */ |
| | | var getOwnPropertySymbols = Object.getOwnPropertySymbols; |
| | | var hasOwnProperty = Object.prototype.hasOwnProperty; |
| | | var propIsEnumerable = Object.prototype.propertyIsEnumerable; |
| | | |
| | | function toObject(val) { |
| | | if (val === null || val === undefined) { |
| | | throw new TypeError('Object.assign cannot be called with null or undefined'); |
| | | } |
| | | |
| | | return Object(val); |
| | | } |
| | | |
| | | function shouldUseNative() { |
| | | try { |
| | | if (!Object.assign) { |
| | | return false; |
| | | } |
| | | |
| | | // Detect buggy property enumeration order in older V8 versions. |
| | | |
| | | // https://bugs.chromium.org/p/v8/issues/detail?id=4118 |
| | | var test1 = new String('abc'); // eslint-disable-line no-new-wrappers |
| | | test1[5] = 'de'; |
| | | if (Object.getOwnPropertyNames(test1)[0] === '5') { |
| | | return false; |
| | | } |
| | | |
| | | // https://bugs.chromium.org/p/v8/issues/detail?id=3056 |
| | | var test2 = {}; |
| | | for (var i = 0; i < 10; i++) { |
| | | test2['_' + String.fromCharCode(i)] = i; |
| | | } |
| | | var order2 = Object.getOwnPropertyNames(test2).map(function (n) { |
| | | return test2[n]; |
| | | }); |
| | | if (order2.join('') !== '0123456789') { |
| | | return false; |
| | | } |
| | | |
| | | // https://bugs.chromium.org/p/v8/issues/detail?id=3056 |
| | | var test3 = {}; |
| | | 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { |
| | | test3[letter] = letter; |
| | | }); |
| | | if (Object.keys(Object.assign({}, test3)).join('') !== |
| | | 'abcdefghijklmnopqrst') { |
| | | return false; |
| | | } |
| | | |
| | | return true; |
| | | } catch (err) { |
| | | // We don't expect any of the above to throw, but better to be safe. |
| | | return false; |
| | | } |
| | | } |
| | | |
| | | module.exports = shouldUseNative() ? Object.assign : function (target, source) { |
| | | var from; |
| | | var to = toObject(target); |
| | | var symbols; |
| | | |
| | | for (var s = 1; s < arguments.length; s++) { |
| | | from = Object(arguments[s]); |
| | | |
| | | for (var key in from) { |
| | | if (hasOwnProperty.call(from, key)) { |
| | | to[key] = from[key]; |
| | | } |
| | | } |
| | | |
| | | if (getOwnPropertySymbols) { |
| | | symbols = getOwnPropertySymbols(from); |
| | | for (var i = 0; i < symbols.length; i++) { |
| | | if (propIsEnumerable.call(from, symbols[i])) { |
| | | to[symbols[i]] = from[symbols[i]]; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | return to; |
| | | }; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 9 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | /** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; |
| | | |
| | | module.exports = ReactPropTypesSecret; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 10 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | var invariant = __webpack_require__(6); |
| | | var warning = __webpack_require__(7); |
| | | var ReactPropTypesSecret = __webpack_require__(9); |
| | | var loggedTypeFailures = {}; |
| | | } |
| | | |
| | | /** |
| | | * Assert that the values match with the type specs. |
| | | * Error messages are memorized and will only be shown once. |
| | | * |
| | | * @param {object} typeSpecs Map of name to a ReactPropType |
| | | * @param {object} values Runtime values that need to be type-checked |
| | | * @param {string} location e.g. "prop", "context", "child context" |
| | | * @param {string} componentName Name of the component for error messages. |
| | | * @param {?Function} getStack Returns the component stack. |
| | | * @private |
| | | */ |
| | | function checkPropTypes(typeSpecs, values, location, componentName, getStack) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | for (var typeSpecName in typeSpecs) { |
| | | if (typeSpecs.hasOwnProperty(typeSpecName)) { |
| | | var error; |
| | | // Prop type validation may throw. In case they do, we don't want to |
| | | // fail the render phase where it didn't fail before. So we log it. |
| | | // After these have been cleaned up, we'll let them throw. |
| | | try { |
| | | // This is intentionally an invariant that gets caught. It's the same |
| | | // behavior as without this statement except with a better message. |
| | | invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]); |
| | | error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); |
| | | } catch (ex) { |
| | | error = ex; |
| | | } |
| | | warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error); |
| | | if (error instanceof Error && !(error.message in loggedTypeFailures)) { |
| | | // Only monitor this failure once because there tends to be a lot of the |
| | | // same error. |
| | | loggedTypeFailures[error.message] = true; |
| | | |
| | | var stack = getStack ? getStack() : ''; |
| | | |
| | | warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : ''); |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | module.exports = checkPropTypes; |
| | | |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 11 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var emptyFunction = __webpack_require__(5); |
| | | var invariant = __webpack_require__(6); |
| | | var ReactPropTypesSecret = __webpack_require__(9); |
| | | |
| | | module.exports = function() { |
| | | function shim(props, propName, componentName, location, propFullName, secret) { |
| | | if (secret === ReactPropTypesSecret) { |
| | | // It is still safe when called from React. |
| | | return; |
| | | } |
| | | invariant( |
| | | false, |
| | | 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + |
| | | 'Use PropTypes.checkPropTypes() to call them. ' + |
| | | 'Read more at http://fb.me/use-check-prop-types' |
| | | ); |
| | | }; |
| | | shim.isRequired = shim; |
| | | function getShim() { |
| | | return shim; |
| | | }; |
| | | // Important! |
| | | // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. |
| | | var ReactPropTypes = { |
| | | array: shim, |
| | | bool: shim, |
| | | func: shim, |
| | | number: shim, |
| | | object: shim, |
| | | string: shim, |
| | | symbol: shim, |
| | | |
| | | any: shim, |
| | | arrayOf: getShim, |
| | | element: shim, |
| | | instanceOf: getShim, |
| | | node: shim, |
| | | objectOf: getShim, |
| | | oneOf: getShim, |
| | | oneOfType: getShim, |
| | | shape: getShim, |
| | | exact: getShim |
| | | }; |
| | | |
| | | ReactPropTypes.checkPropTypes = emptyFunction; |
| | | ReactPropTypes.PropTypes = ReactPropTypes; |
| | | |
| | | return ReactPropTypes; |
| | | }; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 12 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | * |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(13); |
| | | var factory = __webpack_require__(14); |
| | | |
| | | if (typeof React === 'undefined') { |
| | | throw Error( |
| | | 'create-react-class could not find the React object. If you are using script tags, ' + |
| | | 'make sure that React is being loaded before create-react-class.' |
| | | ); |
| | | } |
| | | |
| | | // Hack to grab NoopUpdateQueue from isomorphic React |
| | | var ReactNoopUpdateQueue = new React.Component().updater; |
| | | |
| | | module.exports = factory( |
| | | React.Component, |
| | | React.isValidElement, |
| | | ReactNoopUpdateQueue |
| | | ); |
| | | |
| | | |
| | | /***/ }), |
| | | /* 13 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | module.exports = __WEBPACK_EXTERNAL_MODULE_13__; |
| | | |
| | | /***/ }), |
| | | /* 14 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | * |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var _assign = __webpack_require__(15); |
| | | |
| | | var emptyObject = __webpack_require__(16); |
| | | var _invariant = __webpack_require__(6); |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | var warning = __webpack_require__(7); |
| | | } |
| | | |
| | | var MIXINS_KEY = 'mixins'; |
| | | |
| | | // Helper function to allow the creation of anonymous functions which do not |
| | | // have .name set to the name of the variable being assigned to. |
| | | function identity(fn) { |
| | | return fn; |
| | | } |
| | | |
| | | var ReactPropTypeLocationNames; |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | ReactPropTypeLocationNames = { |
| | | prop: 'prop', |
| | | context: 'context', |
| | | childContext: 'child context' |
| | | }; |
| | | } else { |
| | | ReactPropTypeLocationNames = {}; |
| | | } |
| | | |
| | | function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) { |
| | | /** |
| | | * Policies that describe methods in `ReactClassInterface`. |
| | | */ |
| | | |
| | | var injectedMixins = []; |
| | | |
| | | /** |
| | | * Composite components are higher-level components that compose other composite |
| | | * or host components. |
| | | * |
| | | * To create a new type of `ReactClass`, pass a specification of |
| | | * your new class to `React.createClass`. The only requirement of your class |
| | | * specification is that you implement a `render` method. |
| | | * |
| | | * var MyComponent = React.createClass({ |
| | | * render: function() { |
| | | * return <div>Hello World</div>; |
| | | * } |
| | | * }); |
| | | * |
| | | * The class specification supports a specific protocol of methods that have |
| | | * special meaning (e.g. `render`). See `ReactClassInterface` for |
| | | * more the comprehensive protocol. Any other properties and methods in the |
| | | * class specification will be available on the prototype. |
| | | * |
| | | * @interface ReactClassInterface |
| | | * @internal |
| | | */ |
| | | var ReactClassInterface = { |
| | | /** |
| | | * An array of Mixin objects to include when defining your component. |
| | | * |
| | | * @type {array} |
| | | * @optional |
| | | */ |
| | | mixins: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * An object containing properties and methods that should be defined on |
| | | * the component's constructor instead of its prototype (static methods). |
| | | * |
| | | * @type {object} |
| | | * @optional |
| | | */ |
| | | statics: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Definition of prop types for this component. |
| | | * |
| | | * @type {object} |
| | | * @optional |
| | | */ |
| | | propTypes: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Definition of context types for this component. |
| | | * |
| | | * @type {object} |
| | | * @optional |
| | | */ |
| | | contextTypes: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Definition of context types this component sets for its children. |
| | | * |
| | | * @type {object} |
| | | * @optional |
| | | */ |
| | | childContextTypes: 'DEFINE_MANY', |
| | | |
| | | // ==== Definition methods ==== |
| | | |
| | | /** |
| | | * Invoked when the component is mounted. Values in the mapping will be set on |
| | | * `this.props` if that prop is not specified (i.e. using an `in` check). |
| | | * |
| | | * This method is invoked before `getInitialState` and therefore cannot rely |
| | | * on `this.state` or use `this.setState`. |
| | | * |
| | | * @return {object} |
| | | * @optional |
| | | */ |
| | | getDefaultProps: 'DEFINE_MANY_MERGED', |
| | | |
| | | /** |
| | | * Invoked once before the component is mounted. The return value will be used |
| | | * as the initial value of `this.state`. |
| | | * |
| | | * getInitialState: function() { |
| | | * return { |
| | | * isOn: false, |
| | | * fooBaz: new BazFoo() |
| | | * } |
| | | * } |
| | | * |
| | | * @return {object} |
| | | * @optional |
| | | */ |
| | | getInitialState: 'DEFINE_MANY_MERGED', |
| | | |
| | | /** |
| | | * @return {object} |
| | | * @optional |
| | | */ |
| | | getChildContext: 'DEFINE_MANY_MERGED', |
| | | |
| | | /** |
| | | * Uses props from `this.props` and state from `this.state` to render the |
| | | * structure of the component. |
| | | * |
| | | * No guarantees are made about when or how often this method is invoked, so |
| | | * it must not have side effects. |
| | | * |
| | | * render: function() { |
| | | * var name = this.props.name; |
| | | * return <div>Hello, {name}!</div>; |
| | | * } |
| | | * |
| | | * @return {ReactComponent} |
| | | * @required |
| | | */ |
| | | render: 'DEFINE_ONCE', |
| | | |
| | | // ==== Delegate methods ==== |
| | | |
| | | /** |
| | | * Invoked when the component is initially created and about to be mounted. |
| | | * This may have side effects, but any external subscriptions or data created |
| | | * by this method must be cleaned up in `componentWillUnmount`. |
| | | * |
| | | * @optional |
| | | */ |
| | | componentWillMount: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Invoked when the component has been mounted and has a DOM representation. |
| | | * However, there is no guarantee that the DOM node is in the document. |
| | | * |
| | | * Use this as an opportunity to operate on the DOM when the component has |
| | | * been mounted (initialized and rendered) for the first time. |
| | | * |
| | | * @param {DOMElement} rootNode DOM element representing the component. |
| | | * @optional |
| | | */ |
| | | componentDidMount: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Invoked before the component receives new props. |
| | | * |
| | | * Use this as an opportunity to react to a prop transition by updating the |
| | | * state using `this.setState`. Current props are accessed via `this.props`. |
| | | * |
| | | * componentWillReceiveProps: function(nextProps, nextContext) { |
| | | * this.setState({ |
| | | * likesIncreasing: nextProps.likeCount > this.props.likeCount |
| | | * }); |
| | | * } |
| | | * |
| | | * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop |
| | | * transition may cause a state change, but the opposite is not true. If you |
| | | * need it, you are probably looking for `componentWillUpdate`. |
| | | * |
| | | * @param {object} nextProps |
| | | * @optional |
| | | */ |
| | | componentWillReceiveProps: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Invoked while deciding if the component should be updated as a result of |
| | | * receiving new props, state and/or context. |
| | | * |
| | | * Use this as an opportunity to `return false` when you're certain that the |
| | | * transition to the new props/state/context will not require a component |
| | | * update. |
| | | * |
| | | * shouldComponentUpdate: function(nextProps, nextState, nextContext) { |
| | | * return !equal(nextProps, this.props) || |
| | | * !equal(nextState, this.state) || |
| | | * !equal(nextContext, this.context); |
| | | * } |
| | | * |
| | | * @param {object} nextProps |
| | | * @param {?object} nextState |
| | | * @param {?object} nextContext |
| | | * @return {boolean} True if the component should update. |
| | | * @optional |
| | | */ |
| | | shouldComponentUpdate: 'DEFINE_ONCE', |
| | | |
| | | /** |
| | | * Invoked when the component is about to update due to a transition from |
| | | * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState` |
| | | * and `nextContext`. |
| | | * |
| | | * Use this as an opportunity to perform preparation before an update occurs. |
| | | * |
| | | * NOTE: You **cannot** use `this.setState()` in this method. |
| | | * |
| | | * @param {object} nextProps |
| | | * @param {?object} nextState |
| | | * @param {?object} nextContext |
| | | * @param {ReactReconcileTransaction} transaction |
| | | * @optional |
| | | */ |
| | | componentWillUpdate: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Invoked when the component's DOM representation has been updated. |
| | | * |
| | | * Use this as an opportunity to operate on the DOM when the component has |
| | | * been updated. |
| | | * |
| | | * @param {object} prevProps |
| | | * @param {?object} prevState |
| | | * @param {?object} prevContext |
| | | * @param {DOMElement} rootNode DOM element representing the component. |
| | | * @optional |
| | | */ |
| | | componentDidUpdate: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Invoked when the component is about to be removed from its parent and have |
| | | * its DOM representation destroyed. |
| | | * |
| | | * Use this as an opportunity to deallocate any external resources. |
| | | * |
| | | * NOTE: There is no `componentDidUnmount` since your component will have been |
| | | * destroyed by that point. |
| | | * |
| | | * @optional |
| | | */ |
| | | componentWillUnmount: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Replacement for (deprecated) `componentWillMount`. |
| | | * |
| | | * @optional |
| | | */ |
| | | UNSAFE_componentWillMount: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Replacement for (deprecated) `componentWillReceiveProps`. |
| | | * |
| | | * @optional |
| | | */ |
| | | UNSAFE_componentWillReceiveProps: 'DEFINE_MANY', |
| | | |
| | | /** |
| | | * Replacement for (deprecated) `componentWillUpdate`. |
| | | * |
| | | * @optional |
| | | */ |
| | | UNSAFE_componentWillUpdate: 'DEFINE_MANY', |
| | | |
| | | // ==== Advanced methods ==== |
| | | |
| | | /** |
| | | * Updates the component's currently mounted DOM representation. |
| | | * |
| | | * By default, this implements React's rendering and reconciliation algorithm. |
| | | * Sophisticated clients may wish to override this. |
| | | * |
| | | * @param {ReactReconcileTransaction} transaction |
| | | * @internal |
| | | * @overridable |
| | | */ |
| | | updateComponent: 'OVERRIDE_BASE' |
| | | }; |
| | | |
| | | /** |
| | | * Similar to ReactClassInterface but for static methods. |
| | | */ |
| | | var ReactClassStaticInterface = { |
| | | /** |
| | | * This method is invoked after a component is instantiated and when it |
| | | * receives new props. Return an object to update state in response to |
| | | * prop changes. Return null to indicate no change to state. |
| | | * |
| | | * If an object is returned, its keys will be merged into the existing state. |
| | | * |
| | | * @return {object || null} |
| | | * @optional |
| | | */ |
| | | getDerivedStateFromProps: 'DEFINE_MANY_MERGED' |
| | | }; |
| | | |
| | | /** |
| | | * Mapping from class specification keys to special processing functions. |
| | | * |
| | | * Although these are declared like instance properties in the specification |
| | | * when defining classes using `React.createClass`, they are actually static |
| | | * and are accessible on the constructor instead of the prototype. Despite |
| | | * being static, they must be defined outside of the "statics" key under |
| | | * which all other static methods are defined. |
| | | */ |
| | | var RESERVED_SPEC_KEYS = { |
| | | displayName: function(Constructor, displayName) { |
| | | Constructor.displayName = displayName; |
| | | }, |
| | | mixins: function(Constructor, mixins) { |
| | | if (mixins) { |
| | | for (var i = 0; i < mixins.length; i++) { |
| | | mixSpecIntoComponent(Constructor, mixins[i]); |
| | | } |
| | | } |
| | | }, |
| | | childContextTypes: function(Constructor, childContextTypes) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | validateTypeDef(Constructor, childContextTypes, 'childContext'); |
| | | } |
| | | Constructor.childContextTypes = _assign( |
| | | {}, |
| | | Constructor.childContextTypes, |
| | | childContextTypes |
| | | ); |
| | | }, |
| | | contextTypes: function(Constructor, contextTypes) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | validateTypeDef(Constructor, contextTypes, 'context'); |
| | | } |
| | | Constructor.contextTypes = _assign( |
| | | {}, |
| | | Constructor.contextTypes, |
| | | contextTypes |
| | | ); |
| | | }, |
| | | /** |
| | | * Special case getDefaultProps which should move into statics but requires |
| | | * automatic merging. |
| | | */ |
| | | getDefaultProps: function(Constructor, getDefaultProps) { |
| | | if (Constructor.getDefaultProps) { |
| | | Constructor.getDefaultProps = createMergedResultFunction( |
| | | Constructor.getDefaultProps, |
| | | getDefaultProps |
| | | ); |
| | | } else { |
| | | Constructor.getDefaultProps = getDefaultProps; |
| | | } |
| | | }, |
| | | propTypes: function(Constructor, propTypes) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | validateTypeDef(Constructor, propTypes, 'prop'); |
| | | } |
| | | Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes); |
| | | }, |
| | | statics: function(Constructor, statics) { |
| | | mixStaticSpecIntoComponent(Constructor, statics); |
| | | }, |
| | | autobind: function() {} |
| | | }; |
| | | |
| | | function validateTypeDef(Constructor, typeDef, location) { |
| | | for (var propName in typeDef) { |
| | | if (typeDef.hasOwnProperty(propName)) { |
| | | // use a warning instead of an _invariant so components |
| | | // don't show up in prod but only in __DEV__ |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | typeof typeDef[propName] === 'function', |
| | | '%s: %s type `%s` is invalid; it must be a function, usually from ' + |
| | | 'React.PropTypes.', |
| | | Constructor.displayName || 'ReactClass', |
| | | ReactPropTypeLocationNames[location], |
| | | propName |
| | | ); |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | function validateMethodOverride(isAlreadyDefined, name) { |
| | | var specPolicy = ReactClassInterface.hasOwnProperty(name) |
| | | ? ReactClassInterface[name] |
| | | : null; |
| | | |
| | | // Disallow overriding of base class methods unless explicitly allowed. |
| | | if (ReactClassMixin.hasOwnProperty(name)) { |
| | | _invariant( |
| | | specPolicy === 'OVERRIDE_BASE', |
| | | 'ReactClassInterface: You are attempting to override ' + |
| | | '`%s` from your class specification. Ensure that your method names ' + |
| | | 'do not overlap with React methods.', |
| | | name |
| | | ); |
| | | } |
| | | |
| | | // Disallow defining methods more than once unless explicitly allowed. |
| | | if (isAlreadyDefined) { |
| | | _invariant( |
| | | specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED', |
| | | 'ReactClassInterface: You are attempting to define ' + |
| | | '`%s` on your component more than once. This conflict may be due ' + |
| | | 'to a mixin.', |
| | | name |
| | | ); |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Mixin helper which handles policy validation and reserved |
| | | * specification keys when building React classes. |
| | | */ |
| | | function mixSpecIntoComponent(Constructor, spec) { |
| | | if (!spec) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | var typeofSpec = typeof spec; |
| | | var isMixinValid = typeofSpec === 'object' && spec !== null; |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | isMixinValid, |
| | | "%s: You're attempting to include a mixin that is either null " + |
| | | 'or not an object. Check the mixins included by the component, ' + |
| | | 'as well as any mixins they include themselves. ' + |
| | | 'Expected object but got %s.', |
| | | Constructor.displayName || 'ReactClass', |
| | | spec === null ? null : typeofSpec |
| | | ); |
| | | } |
| | | } |
| | | |
| | | return; |
| | | } |
| | | |
| | | _invariant( |
| | | typeof spec !== 'function', |
| | | "ReactClass: You're attempting to " + |
| | | 'use a component class or function as a mixin. Instead, just use a ' + |
| | | 'regular object.' |
| | | ); |
| | | _invariant( |
| | | !isValidElement(spec), |
| | | "ReactClass: You're attempting to " + |
| | | 'use a component as a mixin. Instead, just use a regular object.' |
| | | ); |
| | | |
| | | var proto = Constructor.prototype; |
| | | var autoBindPairs = proto.__reactAutoBindPairs; |
| | | |
| | | // By handling mixins before any other properties, we ensure the same |
| | | // chaining order is applied to methods with DEFINE_MANY policy, whether |
| | | // mixins are listed before or after these methods in the spec. |
| | | if (spec.hasOwnProperty(MIXINS_KEY)) { |
| | | RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins); |
| | | } |
| | | |
| | | for (var name in spec) { |
| | | if (!spec.hasOwnProperty(name)) { |
| | | continue; |
| | | } |
| | | |
| | | if (name === MIXINS_KEY) { |
| | | // We have already handled mixins in a special case above. |
| | | continue; |
| | | } |
| | | |
| | | var property = spec[name]; |
| | | var isAlreadyDefined = proto.hasOwnProperty(name); |
| | | validateMethodOverride(isAlreadyDefined, name); |
| | | |
| | | if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) { |
| | | RESERVED_SPEC_KEYS[name](Constructor, property); |
| | | } else { |
| | | // Setup methods on prototype: |
| | | // The following member methods should not be automatically bound: |
| | | // 1. Expected ReactClass methods (in the "interface"). |
| | | // 2. Overridden methods (that were mixed in). |
| | | var isReactClassMethod = ReactClassInterface.hasOwnProperty(name); |
| | | var isFunction = typeof property === 'function'; |
| | | var shouldAutoBind = |
| | | isFunction && |
| | | !isReactClassMethod && |
| | | !isAlreadyDefined && |
| | | spec.autobind !== false; |
| | | |
| | | if (shouldAutoBind) { |
| | | autoBindPairs.push(name, property); |
| | | proto[name] = property; |
| | | } else { |
| | | if (isAlreadyDefined) { |
| | | var specPolicy = ReactClassInterface[name]; |
| | | |
| | | // These cases should already be caught by validateMethodOverride. |
| | | _invariant( |
| | | isReactClassMethod && |
| | | (specPolicy === 'DEFINE_MANY_MERGED' || |
| | | specPolicy === 'DEFINE_MANY'), |
| | | 'ReactClass: Unexpected spec policy %s for key %s ' + |
| | | 'when mixing in component specs.', |
| | | specPolicy, |
| | | name |
| | | ); |
| | | |
| | | // For methods which are defined more than once, call the existing |
| | | // methods before calling the new property, merging if appropriate. |
| | | if (specPolicy === 'DEFINE_MANY_MERGED') { |
| | | proto[name] = createMergedResultFunction(proto[name], property); |
| | | } else if (specPolicy === 'DEFINE_MANY') { |
| | | proto[name] = createChainedFunction(proto[name], property); |
| | | } |
| | | } else { |
| | | proto[name] = property; |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | // Add verbose displayName to the function, which helps when looking |
| | | // at profiling tools. |
| | | if (typeof property === 'function' && spec.displayName) { |
| | | proto[name].displayName = spec.displayName + '_' + name; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | function mixStaticSpecIntoComponent(Constructor, statics) { |
| | | if (!statics) { |
| | | return; |
| | | } |
| | | |
| | | for (var name in statics) { |
| | | var property = statics[name]; |
| | | if (!statics.hasOwnProperty(name)) { |
| | | continue; |
| | | } |
| | | |
| | | var isReserved = name in RESERVED_SPEC_KEYS; |
| | | _invariant( |
| | | !isReserved, |
| | | 'ReactClass: You are attempting to define a reserved ' + |
| | | 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + |
| | | 'as an instance property instead; it will still be accessible on the ' + |
| | | 'constructor.', |
| | | name |
| | | ); |
| | | |
| | | var isAlreadyDefined = name in Constructor; |
| | | if (isAlreadyDefined) { |
| | | var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) |
| | | ? ReactClassStaticInterface[name] |
| | | : null; |
| | | |
| | | _invariant( |
| | | specPolicy === 'DEFINE_MANY_MERGED', |
| | | 'ReactClass: You are attempting to define ' + |
| | | '`%s` on your component more than once. This conflict may be ' + |
| | | 'due to a mixin.', |
| | | name |
| | | ); |
| | | |
| | | Constructor[name] = createMergedResultFunction(Constructor[name], property); |
| | | |
| | | return; |
| | | } |
| | | |
| | | Constructor[name] = property; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Merge two objects, but throw if both contain the same key. |
| | | * |
| | | * @param {object} one The first object, which is mutated. |
| | | * @param {object} two The second object |
| | | * @return {object} one after it has been mutated to contain everything in two. |
| | | */ |
| | | function mergeIntoWithNoDuplicateKeys(one, two) { |
| | | _invariant( |
| | | one && two && typeof one === 'object' && typeof two === 'object', |
| | | 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.' |
| | | ); |
| | | |
| | | for (var key in two) { |
| | | if (two.hasOwnProperty(key)) { |
| | | _invariant( |
| | | one[key] === undefined, |
| | | 'mergeIntoWithNoDuplicateKeys(): ' + |
| | | 'Tried to merge two objects with the same key: `%s`. This conflict ' + |
| | | 'may be due to a mixin; in particular, this may be caused by two ' + |
| | | 'getInitialState() or getDefaultProps() methods returning objects ' + |
| | | 'with clashing keys.', |
| | | key |
| | | ); |
| | | one[key] = two[key]; |
| | | } |
| | | } |
| | | return one; |
| | | } |
| | | |
| | | /** |
| | | * Creates a function that invokes two functions and merges their return values. |
| | | * |
| | | * @param {function} one Function to invoke first. |
| | | * @param {function} two Function to invoke second. |
| | | * @return {function} Function that invokes the two argument functions. |
| | | * @private |
| | | */ |
| | | function createMergedResultFunction(one, two) { |
| | | return function mergedResult() { |
| | | var a = one.apply(this, arguments); |
| | | var b = two.apply(this, arguments); |
| | | if (a == null) { |
| | | return b; |
| | | } else if (b == null) { |
| | | return a; |
| | | } |
| | | var c = {}; |
| | | mergeIntoWithNoDuplicateKeys(c, a); |
| | | mergeIntoWithNoDuplicateKeys(c, b); |
| | | return c; |
| | | }; |
| | | } |
| | | |
| | | /** |
| | | * Creates a function that invokes two functions and ignores their return vales. |
| | | * |
| | | * @param {function} one Function to invoke first. |
| | | * @param {function} two Function to invoke second. |
| | | * @return {function} Function that invokes the two argument functions. |
| | | * @private |
| | | */ |
| | | function createChainedFunction(one, two) { |
| | | return function chainedFunction() { |
| | | one.apply(this, arguments); |
| | | two.apply(this, arguments); |
| | | }; |
| | | } |
| | | |
| | | /** |
| | | * Binds a method to the component. |
| | | * |
| | | * @param {object} component Component whose method is going to be bound. |
| | | * @param {function} method Method to be bound. |
| | | * @return {function} The bound method. |
| | | */ |
| | | function bindAutoBindMethod(component, method) { |
| | | var boundMethod = method.bind(component); |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | boundMethod.__reactBoundContext = component; |
| | | boundMethod.__reactBoundMethod = method; |
| | | boundMethod.__reactBoundArguments = null; |
| | | var componentName = component.constructor.displayName; |
| | | var _bind = boundMethod.bind; |
| | | boundMethod.bind = function(newThis) { |
| | | for ( |
| | | var _len = arguments.length, |
| | | args = Array(_len > 1 ? _len - 1 : 0), |
| | | _key = 1; |
| | | _key < _len; |
| | | _key++ |
| | | ) { |
| | | args[_key - 1] = arguments[_key]; |
| | | } |
| | | |
| | | // User is trying to bind() an autobound method; we effectively will |
| | | // ignore the value of "this" that the user is trying to use, so |
| | | // let's warn. |
| | | if (newThis !== component && newThis !== null) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | false, |
| | | 'bind(): React component methods may only be bound to the ' + |
| | | 'component instance. See %s', |
| | | componentName |
| | | ); |
| | | } |
| | | } else if (!args.length) { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | false, |
| | | 'bind(): You are binding a component method to the component. ' + |
| | | 'React does this for you automatically in a high-performance ' + |
| | | 'way, so you can safely remove this call. See %s', |
| | | componentName |
| | | ); |
| | | } |
| | | return boundMethod; |
| | | } |
| | | var reboundMethod = _bind.apply(boundMethod, arguments); |
| | | reboundMethod.__reactBoundContext = component; |
| | | reboundMethod.__reactBoundMethod = method; |
| | | reboundMethod.__reactBoundArguments = args; |
| | | return reboundMethod; |
| | | }; |
| | | } |
| | | return boundMethod; |
| | | } |
| | | |
| | | /** |
| | | * Binds all auto-bound methods in a component. |
| | | * |
| | | * @param {object} component Component whose method is going to be bound. |
| | | */ |
| | | function bindAutoBindMethods(component) { |
| | | var pairs = component.__reactAutoBindPairs; |
| | | for (var i = 0; i < pairs.length; i += 2) { |
| | | var autoBindKey = pairs[i]; |
| | | var method = pairs[i + 1]; |
| | | component[autoBindKey] = bindAutoBindMethod(component, method); |
| | | } |
| | | } |
| | | |
| | | var IsMountedPreMixin = { |
| | | componentDidMount: function() { |
| | | this.__isMounted = true; |
| | | } |
| | | }; |
| | | |
| | | var IsMountedPostMixin = { |
| | | componentWillUnmount: function() { |
| | | this.__isMounted = false; |
| | | } |
| | | }; |
| | | |
| | | /** |
| | | * Add more to the ReactClass base class. These are all legacy features and |
| | | * therefore not already part of the modern ReactComponent. |
| | | */ |
| | | var ReactClassMixin = { |
| | | /** |
| | | * TODO: This will be deprecated because state should always keep a consistent |
| | | * type signature and the only use case for this, is to avoid that. |
| | | */ |
| | | replaceState: function(newState, callback) { |
| | | this.updater.enqueueReplaceState(this, newState, callback); |
| | | }, |
| | | |
| | | /** |
| | | * Checks whether or not this composite component is mounted. |
| | | * @return {boolean} True if mounted, false otherwise. |
| | | * @protected |
| | | * @final |
| | | */ |
| | | isMounted: function() { |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | this.__didWarnIsMounted, |
| | | '%s: isMounted is deprecated. Instead, make sure to clean up ' + |
| | | 'subscriptions and pending requests in componentWillUnmount to ' + |
| | | 'prevent memory leaks.', |
| | | (this.constructor && this.constructor.displayName) || |
| | | this.name || |
| | | 'Component' |
| | | ); |
| | | this.__didWarnIsMounted = true; |
| | | } |
| | | return !!this.__isMounted; |
| | | } |
| | | }; |
| | | |
| | | var ReactClassComponent = function() {}; |
| | | _assign( |
| | | ReactClassComponent.prototype, |
| | | ReactComponent.prototype, |
| | | ReactClassMixin |
| | | ); |
| | | |
| | | /** |
| | | * Creates a composite component class given a class specification. |
| | | * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass |
| | | * |
| | | * @param {object} spec Class specification (which must define `render`). |
| | | * @return {function} Component constructor function. |
| | | * @public |
| | | */ |
| | | function createClass(spec) { |
| | | // To keep our warnings more understandable, we'll use a little hack here to |
| | | // ensure that Constructor.name !== 'Constructor'. This makes sure we don't |
| | | // unnecessarily identify a class without displayName as 'Constructor'. |
| | | var Constructor = identity(function(props, context, updater) { |
| | | // This constructor gets overridden by mocks. The argument is used |
| | | // by mocks to assert on what gets mounted. |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | this instanceof Constructor, |
| | | 'Something is calling a React component directly. Use a factory or ' + |
| | | 'JSX instead. See: https://fb.me/react-legacyfactory' |
| | | ); |
| | | } |
| | | |
| | | // Wire up auto-binding |
| | | if (this.__reactAutoBindPairs.length) { |
| | | bindAutoBindMethods(this); |
| | | } |
| | | |
| | | this.props = props; |
| | | this.context = context; |
| | | this.refs = emptyObject; |
| | | this.updater = updater || ReactNoopUpdateQueue; |
| | | |
| | | this.state = null; |
| | | |
| | | // ReactClasses doesn't have constructors. Instead, they use the |
| | | // getInitialState and componentWillMount methods for initialization. |
| | | |
| | | var initialState = this.getInitialState ? this.getInitialState() : null; |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | // We allow auto-mocks to proceed as if they're returning null. |
| | | if ( |
| | | initialState === undefined && |
| | | this.getInitialState._isMockFunction |
| | | ) { |
| | | // This is probably bad practice. Consider warning here and |
| | | // deprecating this convenience. |
| | | initialState = null; |
| | | } |
| | | } |
| | | _invariant( |
| | | typeof initialState === 'object' && !Array.isArray(initialState), |
| | | '%s.getInitialState(): must return an object or null', |
| | | Constructor.displayName || 'ReactCompositeComponent' |
| | | ); |
| | | |
| | | this.state = initialState; |
| | | }); |
| | | Constructor.prototype = new ReactClassComponent(); |
| | | Constructor.prototype.constructor = Constructor; |
| | | Constructor.prototype.__reactAutoBindPairs = []; |
| | | |
| | | injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor)); |
| | | |
| | | mixSpecIntoComponent(Constructor, IsMountedPreMixin); |
| | | mixSpecIntoComponent(Constructor, spec); |
| | | mixSpecIntoComponent(Constructor, IsMountedPostMixin); |
| | | |
| | | // Initialize the defaultProps property after all mixins have been merged. |
| | | if (Constructor.getDefaultProps) { |
| | | Constructor.defaultProps = Constructor.getDefaultProps(); |
| | | } |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | // This is a tag to indicate that the use of these method names is ok, |
| | | // since it's used with createClass. If it's not, then it's likely a |
| | | // mistake so we'll warn you to use the static property, property |
| | | // initializer or constructor respectively. |
| | | if (Constructor.getDefaultProps) { |
| | | Constructor.getDefaultProps.isReactClassApproved = {}; |
| | | } |
| | | if (Constructor.prototype.getInitialState) { |
| | | Constructor.prototype.getInitialState.isReactClassApproved = {}; |
| | | } |
| | | } |
| | | |
| | | _invariant( |
| | | Constructor.prototype.render, |
| | | 'createClass(...): Class specification must implement a `render` method.' |
| | | ); |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | warning( |
| | | !Constructor.prototype.componentShouldUpdate, |
| | | '%s has a method called ' + |
| | | 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + |
| | | 'The name is phrased as a question because the function is ' + |
| | | 'expected to return a value.', |
| | | spec.displayName || 'A component' |
| | | ); |
| | | warning( |
| | | !Constructor.prototype.componentWillRecieveProps, |
| | | '%s has a method called ' + |
| | | 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', |
| | | spec.displayName || 'A component' |
| | | ); |
| | | warning( |
| | | !Constructor.prototype.UNSAFE_componentWillRecieveProps, |
| | | '%s has a method called UNSAFE_componentWillRecieveProps(). ' + |
| | | 'Did you mean UNSAFE_componentWillReceiveProps()?', |
| | | spec.displayName || 'A component' |
| | | ); |
| | | } |
| | | |
| | | // Reduce time spent doing lookups by setting these on the prototype. |
| | | for (var methodName in ReactClassInterface) { |
| | | if (!Constructor.prototype[methodName]) { |
| | | Constructor.prototype[methodName] = null; |
| | | } |
| | | } |
| | | |
| | | return Constructor; |
| | | } |
| | | |
| | | return createClass; |
| | | } |
| | | |
| | | module.exports = factory; |
| | | |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 15 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | /* |
| | | object-assign |
| | | (c) Sindre Sorhus |
| | | @license MIT |
| | | */ |
| | | |
| | | 'use strict'; |
| | | /* eslint-disable no-unused-vars */ |
| | | var getOwnPropertySymbols = Object.getOwnPropertySymbols; |
| | | var hasOwnProperty = Object.prototype.hasOwnProperty; |
| | | var propIsEnumerable = Object.prototype.propertyIsEnumerable; |
| | | |
| | | function toObject(val) { |
| | | if (val === null || val === undefined) { |
| | | throw new TypeError('Object.assign cannot be called with null or undefined'); |
| | | } |
| | | |
| | | return Object(val); |
| | | } |
| | | |
| | | function shouldUseNative() { |
| | | try { |
| | | if (!Object.assign) { |
| | | return false; |
| | | } |
| | | |
| | | // Detect buggy property enumeration order in older V8 versions. |
| | | |
| | | // https://bugs.chromium.org/p/v8/issues/detail?id=4118 |
| | | var test1 = new String('abc'); // eslint-disable-line no-new-wrappers |
| | | test1[5] = 'de'; |
| | | if (Object.getOwnPropertyNames(test1)[0] === '5') { |
| | | return false; |
| | | } |
| | | |
| | | // https://bugs.chromium.org/p/v8/issues/detail?id=3056 |
| | | var test2 = {}; |
| | | for (var i = 0; i < 10; i++) { |
| | | test2['_' + String.fromCharCode(i)] = i; |
| | | } |
| | | var order2 = Object.getOwnPropertyNames(test2).map(function (n) { |
| | | return test2[n]; |
| | | }); |
| | | if (order2.join('') !== '0123456789') { |
| | | return false; |
| | | } |
| | | |
| | | // https://bugs.chromium.org/p/v8/issues/detail?id=3056 |
| | | var test3 = {}; |
| | | 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { |
| | | test3[letter] = letter; |
| | | }); |
| | | if (Object.keys(Object.assign({}, test3)).join('') !== |
| | | 'abcdefghijklmnopqrst') { |
| | | return false; |
| | | } |
| | | |
| | | return true; |
| | | } catch (err) { |
| | | // We don't expect any of the above to throw, but better to be safe. |
| | | return false; |
| | | } |
| | | } |
| | | |
| | | module.exports = shouldUseNative() ? Object.assign : function (target, source) { |
| | | var from; |
| | | var to = toObject(target); |
| | | var symbols; |
| | | |
| | | for (var s = 1; s < arguments.length; s++) { |
| | | from = Object(arguments[s]); |
| | | |
| | | for (var key in from) { |
| | | if (hasOwnProperty.call(from, key)) { |
| | | to[key] = from[key]; |
| | | } |
| | | } |
| | | |
| | | if (getOwnPropertySymbols) { |
| | | symbols = getOwnPropertySymbols(from); |
| | | for (var i = 0; i < symbols.length; i++) { |
| | | if (propIsEnumerable.call(from, symbols[i])) { |
| | | to[symbols[i]] = from[symbols[i]]; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | return to; |
| | | }; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 16 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | /* WEBPACK VAR INJECTION */(function(process) {/** |
| | | * Copyright (c) 2013-present, Facebook, Inc. |
| | | * |
| | | * This source code is licensed under the MIT license found in the |
| | | * LICENSE file in the root directory of this source tree. |
| | | * |
| | | */ |
| | | |
| | | 'use strict'; |
| | | |
| | | var emptyObject = {}; |
| | | |
| | | if (process.env.NODE_ENV !== 'production') { |
| | | Object.freeze(emptyObject); |
| | | } |
| | | |
| | | module.exports = emptyObject; |
| | | /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3))) |
| | | |
| | | /***/ }), |
| | | /* 17 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | module.exports = __WEBPACK_EXTERNAL_MODULE_17__; |
| | | |
| | | /***/ }), |
| | | /* 18 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(13), |
| | | createClass = __webpack_require__(12), |
| | | DaysView = __webpack_require__(19), |
| | | MonthsView = __webpack_require__(22), |
| | | YearsView = __webpack_require__(23), |
| | | TimeView = __webpack_require__(24) |
| | | ; |
| | | |
| | | var CalendarContainer = createClass({ |
| | | viewComponents: { |
| | | days: DaysView, |
| | | months: MonthsView, |
| | | years: YearsView, |
| | | time: TimeView |
| | | }, |
| | | |
| | | render: function() { |
| | | return React.createElement( this.viewComponents[ this.props.view ], this.props.viewProps ); |
| | | } |
| | | }); |
| | | |
| | | module.exports = CalendarContainer; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 19 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(13), |
| | | createClass = __webpack_require__(12), |
| | | moment = __webpack_require__(17), |
| | | onClickOutside = __webpack_require__(20).default |
| | | ; |
| | | |
| | | var DateTimePickerDays = onClickOutside( 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')}, '›')) |
| | | React.createElement('thead', { key: 'th' }, [ |
| | | React.createElement('tr', { key: 'h' }, [ |
| | | React.createElement('th', { key: 'p', className: 'rdtPrev', onClick: this.props.subtractTime( 1, 'months' )}, React.createElement('span', {}, '‹' )), |
| | | React.createElement('th', { key: 's', className: 'rdtSwitch', onClick: this.props.showView( 'months' ), colSpan: 5, 'data-value': this.props.viewDate.month() }, locale.months( date ) + ' ' + date.year() ), |
| | | React.createElement('th', { key: 'n', className: 'rdtNext', onClick: this.props.addTime( 1, 'months' )}, React.createElement('span', {}, '›' )) |
| | | ]), |
| | | DOM.tr({ key: 'd'}, this.getDaysOfWeek( locale ).map( function( day, index ){ return DOM.th({ key: day + index, className: 'dow'}, day ); }) ) |
| | | React.createElement('tr', { key: 'd'}, this.getDaysOfWeek( locale ).map( function( day, index ) { return React.createElement('th', { key: day + index, className: 'dow'}, day ); }) ) |
| | | ]), |
| | | DOM.tbody({key: 'tb'}, this.renderDays()) |
| | | React.createElement('tbody', { key: 'tb' }, this.renderDays()) |
| | | ]; |
| | | |
| | | if ( footer ) |
| | | tableChildren.push( footer ); |
| | | |
| | | return DOM.div({ className: 'rdtDays' }, |
| | | DOM.table({}, tableChildren ) |
| | | return React.createElement('div', { className: 'rdtDays' }, |
| | | React.createElement('table', {}, tableChildren ) |
| | | ); |
| | | }, |
| | | |
| | |
| | | * depending on the current locale |
| | | * @return {array} A list with the shortname of the days |
| | | */ |
| | | getDaysOfWeek: function( locale ){ |
| | | getDaysOfWeek: function( locale ) { |
| | | var days = locale._weekdaysMin, |
| | | first = locale.firstDayOfWeek(), |
| | | dow = [], |
| | | i = 0 |
| | | ; |
| | | ; |
| | | |
| | | days.forEach( function( day ){ |
| | | dow[ (7 + (i++) - first) % 7 ] = day; |
| | | days.forEach( function( day ) { |
| | | dow[ (7 + ( i++ ) - first) % 7 ] = day; |
| | | }); |
| | | |
| | | return dow; |
| | |
| | | weeks = [], |
| | | days = [], |
| | | renderer = this.props.renderDay || this.renderDay, |
| | | isValid = this.props.isValidDate || this.isValidDate, |
| | | classes, disabled, dayProps, currentDate |
| | | ; |
| | | isValid = this.props.isValidDate || this.alwaysValidDate, |
| | | classes, isDisabled, dayProps, currentDate |
| | | ; |
| | | |
| | | // Go to the last week of the previous month |
| | | prevMonth.date( prevMonth.daysInMonth() ).startOf('week'); |
| | | var lastDay = prevMonth.clone().add(42, 'd'); |
| | | prevMonth.date( prevMonth.daysInMonth() ).startOf( 'week' ); |
| | | var lastDay = prevMonth.clone().add( 42, 'd' ); |
| | | |
| | | while ( prevMonth.isBefore( lastDay ) ){ |
| | | while ( prevMonth.isBefore( lastDay ) ) { |
| | | classes = 'rdtDay'; |
| | | currentDate = prevMonth.clone(); |
| | | |
| | |
| | | else if ( ( prevMonth.year() === currentYear && prevMonth.month() > currentMonth ) || ( prevMonth.year() > currentYear ) ) |
| | | classes += ' rdtNew'; |
| | | |
| | | if ( selected && prevMonth.isSame(selected, 'day') ) |
| | | if ( selected && prevMonth.isSame( selected, 'day' ) ) |
| | | classes += ' rdtActive'; |
| | | |
| | | if (prevMonth.isSame(moment(), 'day') ) |
| | | if ( prevMonth.isSame( moment(), 'day' ) ) |
| | | classes += ' rdtToday'; |
| | | |
| | | disabled = !isValid( currentDate, selected ); |
| | | if ( disabled ) |
| | | isDisabled = !isValid( currentDate, selected ); |
| | | if ( isDisabled ) |
| | | classes += ' rdtDisabled'; |
| | | |
| | | dayProps = { |
| | | key: prevMonth.format('M_D'), |
| | | key: prevMonth.format( 'M_D' ), |
| | | 'data-value': prevMonth.date(), |
| | | className: classes |
| | | }; |
| | | if ( !disabled ) |
| | | |
| | | if ( !isDisabled ) |
| | | dayProps.onClick = this.updateSelectedDate; |
| | | |
| | | days.push( renderer( dayProps, currentDate, selected ) ); |
| | | |
| | | if ( days.length === 7 ){ |
| | | weeks.push( DOM.tr( {key: prevMonth.format('M_D')}, days ) ); |
| | | if ( days.length === 7 ) { |
| | | weeks.push( React.createElement('tr', { key: prevMonth.format( 'M_D' )}, days ) ); |
| | | days = []; |
| | | } |
| | | |
| | |
| | | }, |
| | | |
| | | updateSelectedDate: function( event ) { |
| | | this.props.updateSelectedDate(event, true); |
| | | this.props.updateSelectedDate( event, true ); |
| | | }, |
| | | |
| | | renderDay: function( props, currentDate ){ |
| | | return DOM.td( props, currentDate.date() ); |
| | | renderDay: function( props, currentDate ) { |
| | | return React.createElement('td', props, currentDate.date() ); |
| | | }, |
| | | |
| | | renderFooter: function(){ |
| | | 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 )) |
| | | return React.createElement('tfoot', { key: 'tf'}, |
| | | React.createElement('tr', {}, |
| | | React.createElement('td', { onClick: this.props.showView( 'time' ), colSpan: 7, className: 'rdtTimeToggle' }, date.format( this.props.timeFormat )) |
| | | ) |
| | | ); |
| | | }, |
| | | isValidDate: function(){ return 1; } |
| | | }); |
| | | |
| | | alwaysValidDate: function() { |
| | | return 1; |
| | | }, |
| | | |
| | | handleClickOutside: function() { |
| | | this.props.handleClickOutside(); |
| | | } |
| | | })); |
| | | |
| | | module.exports = DateTimePickerDays; |
| | | |
| | | |
| | | /***/ }, |
| | | /* 4 */ |
| | | /***/ function(module, exports) { |
| | | |
| | | module.exports = __WEBPACK_EXTERNAL_MODULE_4__; |
| | | |
| | | /***/ }, |
| | | /* 5 */ |
| | | /***/ function(module, exports, __webpack_require__) { |
| | | /***/ }), |
| | | /* 20 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(2); |
| | | Object.defineProperty(exports, '__esModule', { value: true }); |
| | | |
| | | var DOM = React.DOM; |
| | | var DateTimePickerMonths = React.createClass({ |
| | | var react = __webpack_require__(13); |
| | | var reactDom = __webpack_require__(21); |
| | | |
| | | function _inheritsLoose(subClass, superClass) { |
| | | subClass.prototype = Object.create(superClass.prototype); |
| | | subClass.prototype.constructor = subClass; |
| | | subClass.__proto__ = superClass; |
| | | } |
| | | |
| | | function _objectWithoutProperties(source, excluded) { |
| | | if (source == null) return {}; |
| | | var target = {}; |
| | | var sourceKeys = Object.keys(source); |
| | | var key, i; |
| | | |
| | | for (i = 0; i < sourceKeys.length; i++) { |
| | | key = sourceKeys[i]; |
| | | if (excluded.indexOf(key) >= 0) continue; |
| | | target[key] = source[key]; |
| | | } |
| | | |
| | | if (Object.getOwnPropertySymbols) { |
| | | var sourceSymbolKeys = Object.getOwnPropertySymbols(source); |
| | | |
| | | for (i = 0; i < sourceSymbolKeys.length; i++) { |
| | | key = sourceSymbolKeys[i]; |
| | | if (excluded.indexOf(key) >= 0) continue; |
| | | if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; |
| | | target[key] = source[key]; |
| | | } |
| | | } |
| | | |
| | | return target; |
| | | } |
| | | |
| | | /** |
| | | * Check whether some DOM node is our Component's node. |
| | | */ |
| | | function isNodeFound(current, componentNode, ignoreClass) { |
| | | if (current === componentNode) { |
| | | 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 (current.correspondingElement) { |
| | | return current.correspondingElement.classList.contains(ignoreClass); |
| | | } |
| | | |
| | | return current.classList.contains(ignoreClass); |
| | | } |
| | | /** |
| | | * Try to find our node in a hierarchy of nodes, returning the document |
| | | * node as highest node if our node is not found in the path up. |
| | | */ |
| | | |
| | | function findHighest(current, componentNode, ignoreClass) { |
| | | if (current === componentNode) { |
| | | return true; |
| | | } // 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 (current.parentNode) { |
| | | if (isNodeFound(current, componentNode, ignoreClass)) { |
| | | return true; |
| | | } |
| | | |
| | | current = current.parentNode; |
| | | } |
| | | |
| | | return current; |
| | | } |
| | | /** |
| | | * Check if the browser scrollbar was clicked |
| | | */ |
| | | |
| | | function clickedScrollbar(evt) { |
| | | return document.documentElement.clientWidth <= evt.clientX || document.documentElement.clientHeight <= evt.clientY; |
| | | } |
| | | |
| | | // ideally will get replaced with external dep |
| | | // when rafrex/detect-passive-events#4 and rafrex/detect-passive-events#5 get merged in |
| | | var testPassiveEventSupport = function testPassiveEventSupport() { |
| | | if (typeof window === 'undefined' || typeof window.addEventListener !== 'function') { |
| | | return; |
| | | } |
| | | |
| | | var passive = false; |
| | | var options = Object.defineProperty({}, 'passive', { |
| | | get: function get() { |
| | | passive = true; |
| | | } |
| | | }); |
| | | |
| | | var noop = function noop() {}; |
| | | |
| | | window.addEventListener('testPassiveEventSupport', noop, options); |
| | | window.removeEventListener('testPassiveEventSupport', noop, options); |
| | | return passive; |
| | | }; |
| | | |
| | | function autoInc(seed) { |
| | | if (seed === void 0) { |
| | | seed = 0; |
| | | } |
| | | |
| | | return function () { |
| | | return ++seed; |
| | | }; |
| | | } |
| | | |
| | | var uid = autoInc(); |
| | | |
| | | var passiveEventSupport; |
| | | var handlersMap = {}; |
| | | var enabledInstances = {}; |
| | | var touchEvents = ['touchstart', 'touchmove']; |
| | | var IGNORE_CLASS_NAME = 'ignore-react-onclickoutside'; |
| | | /** |
| | | * Options for addEventHandler and removeEventHandler |
| | | */ |
| | | |
| | | function getEventHandlerOptions(instance, eventName) { |
| | | var handlerOptions = null; |
| | | var isTouchEvent = touchEvents.indexOf(eventName) !== -1; |
| | | |
| | | if (isTouchEvent && passiveEventSupport) { |
| | | handlerOptions = { |
| | | passive: !instance.props.preventDefault |
| | | }; |
| | | } |
| | | |
| | | return handlerOptions; |
| | | } |
| | | /** |
| | | * This function generates the HOC function that you'll use |
| | | * in order to impart onOutsideClick listening to an |
| | | * arbitrary component. It gets called at the end of the |
| | | * bootstrapping code to yield an instance of the |
| | | * onClickOutsideHOC function defined inside setupHOC(). |
| | | */ |
| | | |
| | | |
| | | function onClickOutsideHOC(WrappedComponent, config) { |
| | | var _class, _temp; |
| | | |
| | | return _temp = _class = |
| | | /*#__PURE__*/ |
| | | function (_Component) { |
| | | _inheritsLoose(onClickOutside, _Component); |
| | | |
| | | function onClickOutside(props) { |
| | | var _this; |
| | | |
| | | _this = _Component.call(this, props) || this; |
| | | |
| | | _this.__outsideClickHandler = function (event) { |
| | | if (typeof _this.__clickOutsideHandlerProp === 'function') { |
| | | _this.__clickOutsideHandlerProp(event); |
| | | |
| | | return; |
| | | } |
| | | |
| | | var instance = _this.getInstance(); |
| | | |
| | | if (typeof instance.props.handleClickOutside === 'function') { |
| | | instance.props.handleClickOutside(event); |
| | | return; |
| | | } |
| | | |
| | | if (typeof instance.handleClickOutside === 'function') { |
| | | instance.handleClickOutside(event); |
| | | return; |
| | | } |
| | | |
| | | throw new Error('WrappedComponent lacks a handleClickOutside(event) function for processing outside click events.'); |
| | | }; |
| | | |
| | | _this.enableOnClickOutside = function () { |
| | | if (typeof document === 'undefined' || enabledInstances[_this._uid]) { |
| | | return; |
| | | } |
| | | |
| | | if (typeof passiveEventSupport === 'undefined') { |
| | | passiveEventSupport = testPassiveEventSupport(); |
| | | } |
| | | |
| | | enabledInstances[_this._uid] = true; |
| | | var events = _this.props.eventTypes; |
| | | |
| | | if (!events.forEach) { |
| | | events = [events]; |
| | | } |
| | | |
| | | handlersMap[_this._uid] = function (event) { |
| | | if (_this.props.disableOnClickOutside) return; |
| | | if (_this.componentNode === null) return; |
| | | |
| | | if (_this.props.preventDefault) { |
| | | event.preventDefault(); |
| | | } |
| | | |
| | | if (_this.props.stopPropagation) { |
| | | event.stopPropagation(); |
| | | } |
| | | |
| | | if (_this.props.excludeScrollbar && clickedScrollbar(event)) return; |
| | | var current = event.target; |
| | | |
| | | if (findHighest(current, _this.componentNode, _this.props.outsideClickIgnoreClass) !== document) { |
| | | return; |
| | | } |
| | | |
| | | _this.__outsideClickHandler(event); |
| | | }; |
| | | |
| | | events.forEach(function (eventName) { |
| | | document.addEventListener(eventName, handlersMap[_this._uid], getEventHandlerOptions(_this, eventName)); |
| | | }); |
| | | }; |
| | | |
| | | _this.disableOnClickOutside = function () { |
| | | delete enabledInstances[_this._uid]; |
| | | var fn = handlersMap[_this._uid]; |
| | | |
| | | if (fn && typeof document !== 'undefined') { |
| | | var events = _this.props.eventTypes; |
| | | |
| | | if (!events.forEach) { |
| | | events = [events]; |
| | | } |
| | | |
| | | events.forEach(function (eventName) { |
| | | return document.removeEventListener(eventName, fn, getEventHandlerOptions(_this, eventName)); |
| | | }); |
| | | delete handlersMap[_this._uid]; |
| | | } |
| | | }; |
| | | |
| | | _this.getRef = function (ref) { |
| | | return _this.instanceRef = ref; |
| | | }; |
| | | |
| | | _this._uid = uid(); |
| | | return _this; |
| | | } |
| | | /** |
| | | * Access the WrappedComponent's instance. |
| | | */ |
| | | |
| | | |
| | | var _proto = onClickOutside.prototype; |
| | | |
| | | _proto.getInstance = function getInstance() { |
| | | if (!WrappedComponent.prototype.isReactComponent) { |
| | | return this; |
| | | } |
| | | |
| | | var ref = this.instanceRef; |
| | | return ref.getInstance ? ref.getInstance() : ref; |
| | | }; |
| | | |
| | | /** |
| | | * Add click listeners to the current document, |
| | | * linked to this component's state. |
| | | */ |
| | | _proto.componentDidMount = function componentDidMount() { |
| | | // If we are in an environment without a DOM such |
| | | // as shallow rendering or snapshots then we exit |
| | | // early to prevent any unhandled errors being thrown. |
| | | if (typeof document === 'undefined' || !document.createElement) { |
| | | return; |
| | | } |
| | | |
| | | var instance = this.getInstance(); |
| | | |
| | | if (config && typeof config.handleClickOutside === 'function') { |
| | | this.__clickOutsideHandlerProp = config.handleClickOutside(instance); |
| | | |
| | | if (typeof this.__clickOutsideHandlerProp !== 'function') { |
| | | throw new Error('WrappedComponent lacks a function for processing outside click events specified by the handleClickOutside config option.'); |
| | | } |
| | | } |
| | | |
| | | this.componentNode = reactDom.findDOMNode(this.getInstance()); |
| | | this.enableOnClickOutside(); |
| | | }; |
| | | |
| | | _proto.componentDidUpdate = function componentDidUpdate() { |
| | | this.componentNode = reactDom.findDOMNode(this.getInstance()); |
| | | }; |
| | | /** |
| | | * Remove all document's event listeners for this component |
| | | */ |
| | | |
| | | |
| | | _proto.componentWillUnmount = function componentWillUnmount() { |
| | | this.disableOnClickOutside(); |
| | | }; |
| | | /** |
| | | * Can be called to explicitly enable event listening |
| | | * for clicks and touches outside of this element. |
| | | */ |
| | | |
| | | |
| | | /** |
| | | * Pass-through render |
| | | */ |
| | | _proto.render = function render() { |
| | | // eslint-disable-next-line no-unused-vars |
| | | var _props = this.props, |
| | | excludeScrollbar = _props.excludeScrollbar, |
| | | props = _objectWithoutProperties(_props, ["excludeScrollbar"]); |
| | | |
| | | if (WrappedComponent.prototype.isReactComponent) { |
| | | props.ref = this.getRef; |
| | | } else { |
| | | props.wrappedRef = this.getRef; |
| | | } |
| | | |
| | | props.disableOnClickOutside = this.disableOnClickOutside; |
| | | props.enableOnClickOutside = this.enableOnClickOutside; |
| | | return react.createElement(WrappedComponent, props); |
| | | }; |
| | | |
| | | return onClickOutside; |
| | | }(react.Component), _class.displayName = "OnClickOutside(" + (WrappedComponent.displayName || WrappedComponent.name || 'Component') + ")", _class.defaultProps = { |
| | | eventTypes: ['mousedown', 'touchstart'], |
| | | excludeScrollbar: config && config.excludeScrollbar || false, |
| | | outsideClickIgnoreClass: IGNORE_CLASS_NAME, |
| | | preventDefault: false, |
| | | stopPropagation: false |
| | | }, _class.getClass = function () { |
| | | return WrappedComponent.getClass ? WrappedComponent.getClass() : WrappedComponent; |
| | | }, _temp; |
| | | } |
| | | |
| | | exports.IGNORE_CLASS_NAME = IGNORE_CLASS_NAME; |
| | | exports['default'] = onClickOutsideHOC; |
| | | |
| | | |
| | | /***/ }), |
| | | /* 21 */ |
| | | /***/ (function(module, exports) { |
| | | |
| | | module.exports = __WEBPACK_EXTERNAL_MODULE_21__; |
| | | |
| | | /***/ }), |
| | | /* 22 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(13), |
| | | createClass = __webpack_require__(12), |
| | | onClickOutside = __webpack_require__(20).default |
| | | ; |
| | | |
| | | var DateTimePickerMonths = onClickOutside( 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')}, '›')) |
| | | return React.createElement('div', { className: 'rdtMonths' }, [ |
| | | React.createElement('table', { key: 'a' }, React.createElement('thead', {}, React.createElement('tr', {}, [ |
| | | React.createElement('th', { key: 'prev', className: 'rdtPrev', onClick: this.props.subtractTime( 1, 'years' )}, React.createElement('span', {}, '‹' )), |
| | | React.createElement('th', { key: 'year', className: 'rdtSwitch', onClick: this.props.showView( 'years' ), colSpan: 2, 'data-value': this.props.viewDate.year() }, this.props.viewDate.year() ), |
| | | React.createElement('th', { key: 'next', className: 'rdtNext', onClick: this.props.addTime( 1, 'years' )}, React.createElement('span', {}, '›' )) |
| | | ]))), |
| | | DOM.table({ key: 'months'}, DOM.tbody({ key: 'b'}, this.renderMonths())) |
| | | React.createElement('table', { key: 'months' }, React.createElement('tbody', { key: 'b' }, this.renderMonths())) |
| | | ]); |
| | | }, |
| | | |
| | |
| | | i = 0, |
| | | months = [], |
| | | renderer = this.props.renderMonth || this.renderMonth, |
| | | classes, props |
| | | ; |
| | | isValid = this.props.isValidDate || this.alwaysValidDate, |
| | | classes, props, currentMonth, isDisabled, noOfDaysInMonth, daysInMonth, validDay, |
| | | // Date is irrelevant because we're only interested in month |
| | | irrelevantDate = 1 |
| | | ; |
| | | |
| | | while (i < 12) { |
| | | classes = 'rdtMonth'; |
| | | if ( date && i === month && year === date.year() ) |
| | | currentMonth = |
| | | this.props.viewDate.clone().set({ year: year, month: i, date: irrelevantDate }); |
| | | |
| | | noOfDaysInMonth = currentMonth.endOf( 'month' ).format( 'D' ); |
| | | daysInMonth = Array.from({ length: noOfDaysInMonth }, function( e, i ) { |
| | | return i + 1; |
| | | }); |
| | | |
| | | validDay = daysInMonth.find(function( d ) { |
| | | var day = currentMonth.clone().set( 'date', d ); |
| | | return isValid( day ); |
| | | }); |
| | | |
| | | isDisabled = ( validDay === undefined ); |
| | | |
| | | if ( isDisabled ) |
| | | classes += ' rdtDisabled'; |
| | | |
| | | if ( date && i === date.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') |
| | | className: classes |
| | | }; |
| | | |
| | | months.push( renderer( props, i, year, date && date.clone() )); |
| | | if ( !isDisabled ) |
| | | props.onClick = ( this.props.updateOn === 'months' ? |
| | | this.updateSelectedMonth : this.props.setDate( 'month' ) ); |
| | | |
| | | if ( months.length === 4 ){ |
| | | rows.push( DOM.tr({ key: month + '_' + rows.length }, months) ); |
| | | months.push( renderer( props, i, year, date && date.clone() ) ); |
| | | |
| | | if ( months.length === 4 ) { |
| | | rows.push( React.createElement('tr', { key: month + '_' + rows.length }, months ) ); |
| | | months = []; |
| | | } |
| | | |
| | |
| | | }, |
| | | |
| | | updateSelectedMonth: function( event ) { |
| | | this.props.updateSelectedDate(event, true); |
| | | this.props.updateSelectedDate( event ); |
| | | }, |
| | | |
| | | renderMonth: function( props, month ) { |
| | | var monthsShort = this.props.viewDate.localeData()._monthsShort; |
| | | return DOM.td( props, monthsShort.standalone |
| | | ? capitalize( monthsShort.standalone[ month ] ) |
| | | : monthsShort[ month ] |
| | | ); |
| | | } |
| | | }); |
| | | var localMoment = this.props.viewDate; |
| | | var monthStr = localMoment.localeData().monthsShort( localMoment.month( month ) ); |
| | | var strLength = 3; |
| | | // Because some months are up to 5 characters long, we want to |
| | | // use a fixed string length for consistency |
| | | var monthStrFixedLength = monthStr.substring( 0, strLength ); |
| | | return React.createElement('td', props, capitalize( monthStrFixedLength ) ); |
| | | }, |
| | | |
| | | function capitalize(str) { |
| | | return str.charAt(0).toUpperCase() + str.slice(1); |
| | | alwaysValidDate: function() { |
| | | return 1; |
| | | }, |
| | | |
| | | handleClickOutside: function() { |
| | | this.props.handleClickOutside(); |
| | | } |
| | | })); |
| | | |
| | | function capitalize( str ) { |
| | | return str.charAt( 0 ).toUpperCase() + str.slice( 1 ); |
| | | } |
| | | |
| | | module.exports = DateTimePickerMonths; |
| | | |
| | | |
| | | /***/ }, |
| | | /* 6 */ |
| | | /***/ function(module, exports, __webpack_require__) { |
| | | /***/ }), |
| | | /* 23 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(2); |
| | | var React = __webpack_require__(13), |
| | | createClass = __webpack_require__(12), |
| | | onClickOutside = __webpack_require__(20).default |
| | | ; |
| | | |
| | | var DOM = React.DOM; |
| | | var DateTimePickerYears = React.createClass({ |
| | | var DateTimePickerYears = onClickOutside( createClass({ |
| | | render: function() { |
| | | var year = parseInt(this.props.viewDate.year() / 10, 10) * 10; |
| | | 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 ))) |
| | | return React.createElement('div', { className: 'rdtYears' }, [ |
| | | React.createElement('table', { key: 'a' }, React.createElement('thead', {}, React.createElement('tr', {}, [ |
| | | React.createElement('th', { key: 'prev', className: 'rdtPrev', onClick: this.props.subtractTime( 10, 'years' )}, React.createElement('span', {}, '‹' )), |
| | | React.createElement('th', { key: 'year', className: 'rdtSwitch', onClick: this.props.showView( 'years' ), colSpan: 2 }, year + '-' + ( year + 9 ) ), |
| | | React.createElement('th', { key: 'next', className: 'rdtNext', onClick: this.props.addTime( 10, 'years' )}, React.createElement('span', {}, '›' )) |
| | | ]))), |
| | | React.createElement('table', { key: 'years' }, React.createElement('tbody', {}, this.renderYears( year ))) |
| | | ]); |
| | | }, |
| | | |
| | |
| | | rows = [], |
| | | renderer = this.props.renderYear || this.renderYear, |
| | | selectedDate = this.props.selectedDate, |
| | | classes, props |
| | | ; |
| | | isValid = this.props.isValidDate || this.alwaysValidDate, |
| | | classes, props, currentYear, isDisabled, noOfDaysInYear, daysInYear, validDay, |
| | | // Month and date are irrelevant here because |
| | | // we're only interested in the year |
| | | irrelevantMonth = 0, |
| | | irrelevantDate = 1 |
| | | ; |
| | | |
| | | year--; |
| | | while (i < 11) { |
| | | classes = 'rdtYear'; |
| | | if ( i === -1 | i === 10 ) |
| | | classes += ' rdtOld'; |
| | | currentYear = this.props.viewDate.clone().set( |
| | | { year: year, month: irrelevantMonth, date: irrelevantDate } ); |
| | | |
| | | // Not sure what 'rdtOld' is for, commenting out for now as it's not working properly |
| | | // if ( i === -1 | i === 10 ) |
| | | // classes += ' rdtOld'; |
| | | |
| | | noOfDaysInYear = currentYear.endOf( 'year' ).format( 'DDD' ); |
| | | daysInYear = Array.from({ length: noOfDaysInYear }, function( e, i ) { |
| | | return i + 1; |
| | | }); |
| | | |
| | | validDay = daysInYear.find(function( d ) { |
| | | var day = currentYear.clone().dayOfYear( d ); |
| | | return isValid( day ); |
| | | }); |
| | | |
| | | isDisabled = ( validDay === undefined ); |
| | | |
| | | if ( isDisabled ) |
| | | classes += ' rdtDisabled'; |
| | | |
| | | 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') |
| | | className: classes |
| | | }; |
| | | |
| | | if ( !isDisabled ) |
| | | props.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 ) ); |
| | | if ( years.length === 4 ) { |
| | | rows.push( React.createElement('tr', { key: i }, years ) ); |
| | | years = []; |
| | | } |
| | | |
| | |
| | | }, |
| | | |
| | | updateSelectedYear: function( event ) { |
| | | this.props.updateSelectedDate(event, true); |
| | | this.props.updateSelectedDate( event ); |
| | | }, |
| | | |
| | | renderYear: function( props, year ){ |
| | | return DOM.td( props, year ); |
| | | renderYear: function( props, year ) { |
| | | return React.createElement('td', props, year ); |
| | | }, |
| | | |
| | | alwaysValidDate: function() { |
| | | return 1; |
| | | }, |
| | | |
| | | handleClickOutside: function() { |
| | | this.props.handleClickOutside(); |
| | | } |
| | | }); |
| | | })); |
| | | |
| | | module.exports = DateTimePickerYears; |
| | | |
| | | |
| | | /***/ }, |
| | | /* 7 */ |
| | | /***/ function(module, exports, __webpack_require__) { |
| | | /***/ }), |
| | | /* 24 */ |
| | | /***/ (function(module, exports, __webpack_require__) { |
| | | |
| | | 'use strict'; |
| | | |
| | | var React = __webpack_require__(2), |
| | | assign = __webpack_require__(1); |
| | | var React = __webpack_require__(13), |
| | | createClass = __webpack_require__(12), |
| | | assign = __webpack_require__(1), |
| | | onClickOutside = __webpack_require__(20).default |
| | | ; |
| | | |
| | | var DOM = React.DOM; |
| | | var DateTimePickerTime = React.createClass({ |
| | | getInitialState: function(){ |
| | | var DateTimePickerTime = onClickOutside( createClass({ |
| | | getInitialState: function() { |
| | | return this.calculateState( this.props ); |
| | | }, |
| | | calculateState: function( props ){ |
| | | |
| | | calculateState: function( props ) { |
| | | var date = props.selectedDate || props.viewDate, |
| | | format = props.timeFormat, |
| | | counters = [] |
| | | ; |
| | | ; |
| | | |
| | | if ( format.indexOf('H') !== -1 || format.indexOf('h') !== -1 ){ |
| | | if ( format.toLowerCase().indexOf('h') !== -1 ) { |
| | | counters.push('hours'); |
| | | if ( format.indexOf('m') !== -1 ){ |
| | | if ( format.indexOf('m') !== -1 ) { |
| | | counters.push('minutes'); |
| | | if ( format.indexOf('s') !== -1 ){ |
| | | if ( format.indexOf('s') !== -1 ) { |
| | | counters.push('seconds'); |
| | | } |
| | | } |
| | | } |
| | | |
| | | var hours = date.format( 'H' ); |
| | | |
| | | var daypart = false; |
| | | if ( this.props.timeFormat.indexOf(' A') !== -1 && this.state !== null ){ |
| | | daypart = ( this.state.hours >= 12 ) ? 'PM' : 'AM'; |
| | | if ( this.state !== null && this.props.timeFormat.toLowerCase().indexOf( ' a' ) !== -1 ) { |
| | | if ( this.props.timeFormat.indexOf( ' A' ) !== -1 ) { |
| | | daypart = ( hours >= 12 ) ? 'PM' : 'AM'; |
| | | } else { |
| | | daypart = ( hours >= 12 ) ? 'pm' : 'am'; |
| | | } |
| | | } |
| | | |
| | | return { |
| | | hours: date.format('H'), |
| | | minutes: date.format('mm'), |
| | | seconds: date.format('ss'), |
| | | milliseconds: date.format('SSS'), |
| | | hours: hours, |
| | | 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) { |
| | | renderCounter: function( type ) { |
| | | if ( type !== 'daypart' ) { |
| | | var value = this.state[ type ]; |
| | | if ( type === 'hours' && this.props.timeFormat.toLowerCase().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 React.createElement('div', { key: type, className: 'rdtCounter' }, [ |
| | | React.createElement('span', { key: 'up', className: 'rdtBtn', onTouchStart: this.onStartClicking('increase', type), onMouseDown: this.onStartClicking( 'increase', type ), onContextMenu: this.disableContextMenu }, 'â–²' ), |
| | | React.createElement('div', { key: 'c', className: 'rdtCount' }, value ), |
| | | React.createElement('span', { key: 'do', className: 'rdtBtn', onTouchStart: this.onStartClicking('decrease', type), onMouseDown: this.onStartClicking( 'decrease', type ), onContextMenu: this.disableContextMenu }, 'â–¼' ) |
| | | ]); |
| | | } |
| | | 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') }, 'â–¼' ) |
| | | return React.createElement('div', { key: 'dayPart', className: 'rdtCounter' }, [ |
| | | React.createElement('span', { key: 'up', className: 'rdtBtn', onTouchStart: this.onStartClicking('toggleDayPart', 'hours'), onMouseDown: this.onStartClicking( 'toggleDayPart', 'hours'), onContextMenu: this.disableContextMenu }, 'â–²' ), |
| | | React.createElement('div', { key: this.state.daypart, className: 'rdtCount' }, this.state.daypart ), |
| | | React.createElement('span', { key: 'do', className: 'rdtBtn', onTouchStart: this.onStartClicking('toggleDayPart', 'hours'), onMouseDown: this.onStartClicking( 'toggleDayPart', 'hours'), onContextMenu: this.disableContextMenu }, 'â–¼' ) |
| | | ]); |
| | | }, |
| | | |
| | | render: function() { |
| | | var me = this, |
| | | counters = [] |
| | | ; |
| | | |
| | | this.state.counters.forEach( function(c){ |
| | | this.state.counters.forEach( function( c ) { |
| | | if ( counters.length ) |
| | | counters.push( DOM.div( {key: 'sep' + counters.length, className: 'rdtCounterSeparator' }, ':' )); |
| | | counters.push( React.createElement('div', { key: 'sep' + counters.length, className: 'rdtCounterSeparator' }, ':' ) ); |
| | | counters.push( me.renderCounter( c ) ); |
| | | }); |
| | | |
| | | if (this.state.daypart !== false) { |
| | | 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' }, ':' )); |
| | | if ( this.state.counters.length === 3 && this.props.timeFormat.indexOf( 'S' ) !== -1 ) { |
| | | counters.push( React.createElement('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 }) |
| | | React.createElement('div', { className: 'rdtCounter rdtMilli', key: 'm' }, |
| | | React.createElement('input', { value: this.state.milliseconds, type: 'text', onChange: this.updateMilli } ) |
| | | ) |
| | | ); |
| | | } |
| | | |
| | | return DOM.div( {className: 'rdtTime'}, |
| | | DOM.table( {}, [ |
| | | return React.createElement('div', { className: 'rdtTime' }, |
| | | React.createElement('table', {}, [ |
| | | this.renderHeader(), |
| | | DOM.tbody({key: 'b'}, DOM.tr({}, DOM.td({}, |
| | | DOM.div({ className: 'rdtCounters' }, counters ) |
| | | React.createElement('tbody', { key: 'b'}, React.createElement('tr', {}, React.createElement('td', {}, |
| | | React.createElement('div', { className: 'rdtCounters' }, counters ) |
| | | ))) |
| | | ]) |
| | | ); |
| | | }, |
| | | |
| | | componentWillMount: function() { |
| | | var me = this; |
| | | me.timeConstraints = { |
| | |
| | | seconds: { |
| | | min: 0, |
| | | max: 59, |
| | | step: 1, |
| | | step: 1 |
| | | }, |
| | | milliseconds: { |
| | | min: 0, |
| | |
| | | step: 1 |
| | | } |
| | | }; |
| | | ['hours', 'minutes', 'seconds', 'milliseconds'].forEach(function(type) { |
| | | assign(me.timeConstraints[type], me.props.timeConstraints[type]); |
| | | ['hours', 'minutes', 'seconds', 'milliseconds'].forEach( function( type ) { |
| | | assign(me.timeConstraints[ type ], me.props.timeConstraints[ type ]); |
| | | }); |
| | | this.setState( this.calculateState( this.props ) ); |
| | | }, |
| | | componentWillReceiveProps: function( nextProps ){ |
| | | |
| | | componentWillReceiveProps: function( nextProps ) { |
| | | this.setState( this.calculateState( nextProps ) ); |
| | | }, |
| | | updateMilli: function( e ){ |
| | | |
| | | updateMilli: function( e ) { |
| | | var milli = parseInt( e.target.value, 10 ); |
| | | if ( milli === e.target.value && milli >= 0 && milli < 1000 ){ |
| | | if ( milli === e.target.value && milli >= 0 && milli < 1000 ) { |
| | | this.props.setTime( 'milliseconds', milli ); |
| | | this.setState({ milliseconds: milli }); |
| | | this.setState( { milliseconds: milli } ); |
| | | } |
| | | }, |
| | | renderHeader: function(){ |
| | | |
| | | 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 ) ) |
| | | return React.createElement('thead', { key: 'h' }, React.createElement('tr', {}, |
| | | React.createElement('th', { className: 'rdtSwitch', colSpan: 4, onClick: this.props.showView( 'days' ) }, date.format( this.props.dateFormat ) ) |
| | | )); |
| | | }, |
| | | onStartClicking: function( action, type ){ |
| | | |
| | | onStartClicking: function( action, type ) { |
| | | var me = this; |
| | | |
| | | return function(){ |
| | | return function() { |
| | | var update = {}; |
| | | update[ type ] = me[ action ]( type ); |
| | | me.setState( update ); |
| | | |
| | | me.timer = setTimeout( function(){ |
| | | me.increaseTimer = setInterval( function(){ |
| | | me.timer = setTimeout( function() { |
| | | me.increaseTimer = setInterval( function() { |
| | | update[ type ] = me[ action ]( type ); |
| | | me.setState( update ); |
| | | }, 70); |
| | | }, 500); |
| | | |
| | | me.mouseUpListener = function(){ |
| | | me.mouseUpListener = function() { |
| | | clearTimeout( me.timer ); |
| | | clearInterval( me.increaseTimer ); |
| | | me.props.setTime( type, me.state[ type ] ); |
| | | document.body.removeEventListener('mouseup', me.mouseUpListener); |
| | | document.body.removeEventListener( 'mouseup', me.mouseUpListener ); |
| | | document.body.removeEventListener( 'touchend', me.mouseUpListener ); |
| | | }; |
| | | |
| | | document.body.addEventListener('mouseup', me.mouseUpListener); |
| | | document.body.addEventListener( 'mouseup', me.mouseUpListener ); |
| | | document.body.addEventListener( 'touchend', me.mouseUpListener ); |
| | | }; |
| | | }, |
| | | |
| | | disableContextMenu: function( event ) { |
| | | event.preventDefault(); |
| | | return false; |
| | | }, |
| | | |
| | | padValues: { |
| | | hours: 1, |
| | | minutes: 2, |
| | | seconds: 2, |
| | | milliseconds: 3 |
| | | }, |
| | | toggleDayPart: function( type ){ // type is always 'hours' |
| | | var value = parseInt(this.state[ type ], 10) + 12; |
| | | |
| | | 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)); |
| | | 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; |
| | | |
| | | 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) ); |
| | | 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; |
| | | |
| | | 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 ){ |
| | | |
| | | pad: function( type, value ) { |
| | | var str = value + ''; |
| | | while ( str.length < this.padValues[ type ] ) |
| | | str = '0' + str; |
| | | return str; |
| | | }, |
| | | |
| | | handleClickOutside: function() { |
| | | this.props.handleClickOutside(); |
| | | } |
| | | }); |
| | | })); |
| | | |
| | | 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"} |