it('should be compatible with React.PropTypes.oneOfType', function() {
typeCheckPass(
React.PropTypes.oneOfType([LinkPropTypes.link(React.PropTypes.number)]),
{value: 123, requestChange: emptyFunction}
);
typeCheckFail(
React.PropTypes.oneOfType([LinkPropTypes.link(React.PropTypes.number)]),
123,
invalidMessage
);
typeCheckPass(
LinkPropTypes.link(React.PropTypes.oneOfType([React.PropTypes.number])),
{value: 123, requestChange: emptyFunction}
);
typeCheckFail(
LinkPropTypes.link(React.PropTypes.oneOfType([React.PropTypes.number])),
{value: 'imastring', requestChange: emptyFunction},
'Invalid prop `testProp.value` supplied to `testComponent`.'
);
});
);
}
}]);
return DeviceOrientation;
}(_react.Component);
// https://developer.mozilla.org/en-US/docs/Web/API/screen/lockOrientation
exports.default = DeviceOrientation;
var LOCK_ORIENTATIONS = ['portrait-primary', 'portrait-secondary', 'landscape-primary', 'landscape-secondary', 'portrait', 'landscape', 'default'];
var isOrientation = function isOrientation(props, propName, componentName, location, propFullName) {
var propValue = props[propName];
if (propValue.type !== Orientation) {
return new Error('Invalid ' + location + ' \'' + propFullName + '\' supplied to \'' + componentName + '\', expected \'Orientation\' component.');
}
};
DeviceOrientation.propTypes = {
children: _react.PropTypes.oneOfType([isOrientation, _react.PropTypes.arrayOf(isOrientation)]).isRequired,
className: _react.PropTypes.string,
lockOrientation: _react.PropTypes.oneOfType([_react.PropTypes.oneOf(LOCK_ORIENTATIONS), _react.PropTypes.arrayOf(_react.PropTypes.oneOf(LOCK_ORIENTATIONS))]),
onLockOrientation: _react.PropTypes.func,
onOrientationChange: _react.PropTypes.func
};
DeviceOrientation.defaultProps = {
className: ''
};
var LayoutPropTypes = {
/** `display` sets the display type of this component.
*
* It works similarly to `display` in CSS, but only support 'flex' and 'none'.
* 'flex' is the default.
*/
display: ReactPropTypes.string,
/** `width` sets the width of this component.
*
* It works similarly to `width` in CSS, but in React Native you
* must use points or percentages. Ems and other units are not supported.
* See https://developer.mozilla.org/en-US/docs/Web/CSS/width for more details.
*/
width: ReactPropTypes.oneOfType([
ReactPropTypes.number,
ReactPropTypes.string,
]),
/** `height` sets the height of this component.
*
* It works similarly to `height` in CSS, but in React Native you
* must use points or percentages. Ems and other units are not supported.
* See https://developer.mozilla.org/en-US/docs/Web/CSS/height for more details.
*/
height: ReactPropTypes.oneOfType([
ReactPropTypes.number,
ReactPropTypes.string,
]),
/** `top` is the number of logical pixels to offset the top edge of
* this component.
routes: ?Array<RouteDef>,
render: Function,
createElement: ?Function,
onError?: () => void,
onUpdate?: () => void,
matchContext: Object,
};
const { TABS_ROUTE } = RouteTypes;
const {
POP: HISTORY_POP,
REPLACE: HISTORY_REPLACE,
} = Actions;
const route = PropTypes.oneOfType([PropTypes.object, PropTypes.element]);
let backwardHistory: Array<Snapshot> = [];
let forwardHistory: Array<Snapshot> = [];
class NativeRouter extends Component<any, any, any> {
static propTypes = {
history: PropTypes.object.isRequired,
children: PropTypes.oneOfType([route, PropTypes.arrayOf(route)]),
routes: PropTypes.oneOfType([route, PropTypes.arrayOf(route)]),
render: PropTypes.func.isRequired,
createElement: PropTypes.func,
onError: PropTypes.func,
onUpdate: PropTypes.func,
matchContext: PropTypes.object.isRequired,
'active': isSelected,
'col-xs-5': true
})}
style={{
cursor: 'default'
}}>
<a
onClick={this.handlesOnClick}
style={{textAlign: 'center'}}>
{itemText}
</a>
</li>
);
}
handlesOnClick(event) {
event.preventDefault();
const { onClick, itemId } = this.props;
onClick(itemId);
}
}
NavItem.propTypes = {
itemId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
itemText: PropTypes.string.isRequired,
isSelected: PropTypes.bool.isRequired,
onClick: PropTypes.func.isRequired
};
export default NavItem;
onPress={() => onPress(roomId, exists)}
rippleColor="#ECECEC">
<Avatar
src={src}
size={50} />
<View style={s.infoContainer}>
<Text style={s.name}>{name}</Text>
<Text style={s.userCount}>{userCount} people</Text>
</View>
</Button>
)
}
SearchRoomItem.defaultProps = {
exists: true
}
SearchRoomItem.propTypes = {
name: PropTypes.string.isRequired,
userCount: PropTypes.number.isRequired,
id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
user: PropTypes.object,
onPress: PropTypes.func,
exists: PropTypes.bool,
room: PropTypes.object
}
export default SearchRoomItem
}
}
Legend.defaultProps = {
announce: false
};
Legend.propTypes = {
activeIndex: PropTypes.number,
announce: PropTypes.bool,
onActive: PropTypes.func,
series: PropTypes.arrayOf(PropTypes.shape({
label: PropTypes.string,
value: PropTypes.oneOfType([
PropTypes.number,
PropTypes.node
]),
units: PropTypes.oneOfType([
PropTypes.string,
PropTypes.shape({
prefix: PropTypes.string,
suffix: PropTypes.string
})
]),
colorIndex: PropTypes.oneOfType([
PropTypes.number, // 1-6
PropTypes.string // status
]),
onClick: PropTypes.func
})).isRequired,
size: PropTypes.oneOf(['medium', 'large']),
* Renders bars for your bar chart.
*
* @example ../docs/examples/Bars.md
*/
const Bars = React.createClass({
displayName: 'Bars',
propTypes: {
className: React.PropTypes.string,
/**
* Colors
*/
colors: React.PropTypes.oneOfType([
React.PropTypes.oneOf(['category10', 'category20', 'category20b', 'category20c']),
React.PropTypes.arrayOf(React.PropTypes.string),
React.PropTypes.func
]),
opacity: React.PropTypes.number,
style: React.PropTypes.object,
combined: React.PropTypes.bool,
groupPadding: React.PropTypes.oneOfType([React.PropTypes.number, React.PropTypes.string, React.PropTypes.func]),
innerPadding: React.PropTypes.oneOfType([React.PropTypes.number, React.PropTypes.string, React.PropTypes.func]),
seriesVisible: React.PropTypes.oneOfType([React.PropTypes.bool, React.PropTypes.func]),
seriesAttributes: React.PropTypes.oneOfType([React.PropTypes.object, React.PropTypes.func]),
seriesStyle: React.PropTypes.oneOfType([React.PropTypes.object, React.PropTypes.func]),
groupStyle: React.PropTypes.oneOfType([React.PropTypes.object, React.PropTypes.func]),
import React, { PropTypes } from 'react';
import MenuMixin from './MenuMixin';
import assign from 'object-assign';
import { getKeyFromChildrenIndex } from './util';
import Animate from 'rc-animate';
const SubPopupMenu = React.createClass({
propTypes: {
onSelect: PropTypes.func,
onClick: PropTypes.func,
onDeselect: PropTypes.func,
onOpenChange: PropTypes.func,
onDestroy: PropTypes.func,
openTransitionName: PropTypes.string,
openAnimation: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
openKeys: PropTypes.arrayOf(PropTypes.string),
closeSubMenuOnMouseLeave: PropTypes.bool,
visible: PropTypes.bool,
children: PropTypes.any,
},
mixins: [MenuMixin],
onDeselect(selectInfo) {
this.props.onDeselect(selectInfo);
},
onSelect(selectInfo) {
this.props.onSelect(selectInfo);
},
<LineComponent index={numberOfList} {...lineWrapperProps} />
</LineWrapper>
</div>
);
})}
</ListWrapper>
</div>
);
};
};
ListComponentWithToolBar.displayName ='ListComponentWithToolBar';
ListComponentWithToolBar.propTypes = {
GlobalGroupActionsComponent: PropTypes.func,
isGroup: PropTypes.bool,
lineProps: PropTypes.object,
lineIdentifierProperty: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
LineWrapper: PropTypes.func,
ListWrapper: PropTypes.func,
numberOfList: PropTypes.number,
numberOfSelectedElement: PropTypes.number,
scope: PropTypes.string,
selectedElements: PropTypes.arrayOf(PropTypes.object),
stateOfTheSelectionList: PropTypes.bool,
toggleAllLine: PropTypes.func,
toggleLineSelection: PropTypes.func,
unitSearchDispatch: PropTypes.object.isRequired,
valuesForResult: PropTypes.object.isRequired
};
ListComponentWithToolBar.defaultProps = {
isGroup: false,
lineProps: {},
var React = require('react');
var classNames = require('classnames');
var Toggle = React.createClass({
propTypes: {
isToggled: React.PropTypes.bool,
onToggle: React.PropTypes.func,
options: React.PropTypes.arrayOf(React.PropTypes.shape({
label: React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.number
]),
value: React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.number
])
}))
},
_onToggle: function() {
this.props.onToggle(!this.props.isToggled);
},
render: function() {
var toggleClassName = classNames('pol-toggle', {
'pol-toggled': this.props.isToggled
});
return (
<div className={toggleClassName} onClick={this._onToggle}>
<div className="pol-toggle-options">
}
return (getJsonFromUrl().i13n_debug === '1') ? true : false;
}
/**
* React.js I13n Mixin
* Append the functions needed to create an i13n node
* @class I13nMixin
*/
var I13nMixin = {
mixins: [I13nUtils, ViewportMixin],
propTypes: {
component: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.func]),
model: React.PropTypes.oneOfType([React.PropTypes.object, React.PropTypes.func]),
i13nModel: React.PropTypes.oneOfType([React.PropTypes.object, React.PropTypes.func]),
isLeafNode: React.PropTypes.bool,
bindClickEvent: React.PropTypes.bool,
follow: React.PropTypes.bool,
scanLinks: React.PropTypes.shape({
enable: React.PropTypes.bool,
tags: React.PropTypes.array
})
},
/**
* componentWillUpdate
* @method componentWillUpdate
*/
import React from 'react';
import Input from './Input';
/**
* VerticalInput
*/
class HorinzontalInput extends Input {
renderComponent() {
return React.createElement('div', {className: 'form-group'+this.state.validationState},
React.createElement('label', {}, this.props.labelValue),
Input.prototype.renderComponent.call(this));
}
}
HorinzontalInput.propTypes = {
type: React.PropTypes.string,
name: React.PropTypes.string.isRequired,
defaultValue: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.number]),
model: React.PropTypes.object.isRequired,
bsSize: React.PropTypes.oneOf(['xs','sm', 'md', 'lg']),
labelValue:React.PropTypes.string
};
export default HorinzontalInput;
/** Primary content. */
children: PropTypes.node,
/** Additional classes. */
className: PropTypes.string,
/** Shorthand for primary content. */
content: customPropTypes.contentShorthand,
/** A loader can be disabled or hidden. */
disabled: PropTypes.bool,
/** A loader can show it's unsure of how long a task will take. */
indeterminate: PropTypes.bool,
/** Loaders can appear inline with content. */
inline: PropTypes.oneOfType([
PropTypes.bool,
PropTypes.oneOf(Loader._meta.props.inline),
]),
/** Loaders can have their colors inverted. */
inverted: PropTypes.bool,
/** Loaders can have different sizes. */
size: PropTypes.oneOf(Loader._meta.props.size),
}
export default Loader
shouldComponentUpdate(nextProps, nextState) {
return shallowCompare(this, nextProps, nextState);
}
render() {
const { selectedValue } = this.props;
return (
<RadioGroup
name="typeFicheContact"
selectedValue={selectedValue}
onChange={this.handlesOnChange}>
<Radio value="information" />Information
<Radio value="reclamation" />Réclamation
</RadioGroup>
);
}
handlesOnChange(value) {
event.preventDefault();
const { onChange } = this.props;
onChange(value);
}
}
TypeFicheContactRadio.propTypes = {
onChange: PropTypes.func.isRequired,
selectedValue: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
};
export default TypeFicheContactRadio;
</ElementType>
)
}
Header._meta = {
name: 'Header',
type: META.TYPES.ELEMENT,
}
Header.propTypes = {
/** An element type to render as (string or function). */
as: customPropTypes.as,
/** Attach header to other content, like a segment. */
attached: PropTypes.oneOfType([
PropTypes.bool,
PropTypes.oneOf(['top', 'bottom']),
]),
/** Format header to appear inside a content block. */
block: PropTypes.bool,
/** Primary content. */
children: PropTypes.node,
/** Additional classes. */
className: PropTypes.string,
/** Color of the header. */
color: PropTypes.oneOf(SUI.COLORS),
/** Shorthand for primary content. */
const createConnectedFields = ({ deepEqual, getIn, toJS }) => {
const getSyncError = (syncErrors, name) => {
const error = plain.getIn(syncErrors, name)
// Because the error for this field might not be at a level in the error structure where
// it can be set directly, it might need to be unwrapped from the _error property
return error && error._error ? error._error : error
}
const getSyncWarning = (syncWarnings, name) => {
const warning = plain.getIn(syncWarnings, name)
// Because the warning for this field might not be at a level in the warning structure where
// it can be set directly, it might need to be unwrapped from the _warning property
return warning && warning._warning ? warning._warning : warning
}
class ConnectedFields extends Component {
constructor(props) {
super(props)
this.handleChange = this.handleChange.bind(this)
this.handleFocus = this.handleFocus.bind(this)
this.handleBlur = this.handleBlur.bind(this)
this.onChangeFns = Object.keys(props._fields).reduce((acc, name) => ({
...acc, [name]: event => this.handleChange(name, event)
}), {})
this.onFocusFns = Object.keys(props._fields).reduce((acc, name) => ({
...acc, [name]: () => this.handleFocus(name)
}), {})
this.onBlurFns = Object.keys(props._fields).reduce((acc, name) => ({
...acc, [name]: event => this.handleBlur(name, event)
}), {})
}
shouldComponentUpdate(nextProps) {
const nextPropsKeys = Object.keys(nextProps)
const thisPropsKeys = Object.keys(this.props)
return nextPropsKeys.length !== thisPropsKeys.length || nextPropsKeys.some(prop => {
return !~propsToNotUpdateFor.indexOf(prop) && !deepEqual(this.props[ prop ], nextProps[ prop ])
})
}
isDirty() {
const { _fields } = this.props
return Object.keys(_fields).some(name => _fields[ name ].dirty)
}
getValues() {
const { _fields } = this.props
return Object.keys(_fields).reduce((accumulator, name) =>
plain.setIn(accumulator, name, _fields[ name ].value), {})
}
getRenderedComponent() {
return this.refs.renderedComponent
}
handleChange(name, event) {
const { dispatch, parse, normalize, _reduxForm } = this.props
const value = onChangeValue(event, { name, parse, normalize })
dispatch(_reduxForm.change(name, value))
}
handleFocus(name) {
const { dispatch, _reduxForm } = this.props
dispatch(_reduxForm.focus(name))
}
handleBlur(name, event) {
const { dispatch, parse, normalize, _reduxForm } = this.props
const value = onChangeValue(event, { name, parse, normalize })
// dispatch blur action
dispatch(_reduxForm.blur(name, value))
// call post-blur callback
if (_reduxForm.asyncValidate) {
_reduxForm.asyncValidate(name, value)
}
}
render() {
const { component, withRef, _fields, _reduxForm, ...rest } = this.props
const { sectionPrefix } = _reduxForm
const { custom, ...props } = Object.keys(_fields).reduce((accumulator, name) => {
const connectedProps = _fields[ name ]
const { custom, ...fieldProps } = createFieldProps({ getIn, toJS },
name,
{
...connectedProps,
...rest,
onBlur: this.onBlurFns[name],
onChange: this.onChangeFns[name],
onFocus: this.onFocusFns[name]
}
)
accumulator.custom = custom
const fieldName = sectionPrefix ? name.replace(`${sectionPrefix}.`, '') : name
return plain.setIn(accumulator, fieldName, fieldProps)
}, {})
if (withRef) {
props.ref = 'renderedComponent'
}
return createElement(component, { ...props, ...custom })
}
}
ConnectedFields.propTypes = {
component: PropTypes.oneOfType([ PropTypes.func, PropTypes.string ]).isRequired,
_fields: PropTypes.object.isRequired,
props: PropTypes.object
}
const connector = connect(
(state, ownProps) => {
const { names, _reduxForm: { initialValues, getFormState } } = ownProps
const formState = getFormState(state)
return {
_fields: names.reduce((accumulator, name) => {
const initialState = getIn(formState, `initial.${name}`)
const initial = initialState !== undefined ? initialState : (initialValues && getIn(initialValues, name))
const value = getIn(formState, `values.${name}`)
const syncError = getSyncError(getIn(formState, 'syncErrors'), name)
const syncWarning = getSyncWarning(getIn(formState, 'syncWarnings'), name)
const submitting = getIn(formState, 'submitting')
const pristine = value === initial
accumulator[ name ] = {
asyncError: getIn(formState, `asyncErrors.${name}`),
asyncValidating: getIn(formState, 'asyncValidating') === name,
dirty: !pristine,
pristine,
state: getIn(formState, `fields.${name}`),
submitError: getIn(formState, `submitErrors.${name}`),
submitFailed: getIn(formState, 'submitFailed'),
submitting,
syncError,
syncWarning,
value,
_value: ownProps.value // save value passed in (for checkboxes)
}
return accumulator
}, {})
}
},
undefined,
undefined,
{ withRef: true }
)
return connector(ConnectedFields)
}
import React, { PropTypes } from 'react';
const FormInput = ({ inputType, inputID, labelText, initialValue, handleChangeFn }) => {
return (
<div>
<label htmlFor={inputID}>{labelText}</label>
<div className='inputArea'>
<input type={inputType} id={inputID} value={initialValue} onChange={handleChangeFn} />
</div>
</div>
);
};
FormInput.propTypes = {
inputType: PropTypes.string.isRequired,
inputID: PropTypes.string.isRequired,
handleChangeFn: PropTypes.func.isRequired,
labelText: PropTypes.string,
initialValue: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
};
export default FormInput;
import React from 'react';
import SelectField from 'material-ui/lib/select-field';
import MenuItem from 'material-ui/lib/menus/menu-item';
import MuiThemeMixin from '../mui-theme.mixin';
export default React.createClass({
propTypes: {
defaultValue: React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.number,
React.PropTypes.bool,
]),
value: React.PropTypes.string.isRequired,
onFocus: React.PropTypes.func,
onBlur: React.PropTypes.func,
onChange: React.PropTypes.func,
menuItems: React.PropTypes.oneOfType([
React.PropTypes.array,
React.PropTypes.object,
]),
includeEmpty: React.PropTypes.bool,
emptyLabel: React.PropTypes.string,
},
mixins: [MuiThemeMixin],
getDefaultProps() {
return {
includeEmpty: false,
emptyLabel: '',
</label>
);
if (!matchInputHeight) {
return label;
}
return (
<div className="form-control-input-height">
{label}
</div>
);
};
FieldLabel.propTypes = {
children: React.PropTypes.node,
// Vertically center the element based on the height of input fields
matchInputHeight: React.PropTypes.bool,
// Optional boolean to show a required indicator
required: React.PropTypes.bool,
// Classes
className: React.PropTypes.oneOfType([
React.PropTypes.array,
React.PropTypes.object,
React.PropTypes.string
])
};
module.exports = FieldLabel;
{children}
{isError ? <ErrorList errors={errors} /> : <div/>}
{help ? <p className="help-block">{help}</p> : null}
</div>
);
}
if (process.env.NODE_ENV !== "production") {
Wrapper.propTypes = {
type: PropTypes.string.isRequired,
id: PropTypes.string,
classNames: React.PropTypes.string,
label: PropTypes.string,
hidden: PropTypes.bool,
help: PropTypes.oneOfType([
PropTypes.string,
PropTypes.element,
]),
required: PropTypes.bool,
displayLabel: PropTypes.bool,
children: React.PropTypes.node.isRequired,
};
}
Wrapper.defaultProps = {
classNames: "",
errorSchema: {errors: []},
hidden: false,
required: false,
displayLabel: true,
};
* Called when a new mention is added in the input
*
* Example:
*
* ```js
* function(id, display) {
* console.log("user " + display + " was mentioned!");
* }
* ```
*/
onAdd: _react.PropTypes.func,
onRemove: _react.PropTypes.func,
renderSuggestion: _react.PropTypes.func,
trigger: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.instanceOf(RegExp)]),
isLoading: _react.PropTypes.bool,
className: _react.PropTypes.string,
style: _react.PropTypes.object
};
Mention.defaultProps = {
trigger: "@",
onAdd: function onAdd() {
return null;
},
onRemove: function onRemove() {
return null;
},
if (this.state.time) {
time = <span className={`${CLASS_ROOT}__time`}>{this.state.time}</span>;
}
return (
<span className={classes.join(' ')}>
{date} {time}
</span>
);
}
}
const FIELD_TYPES = PropTypes.oneOf(['date', 'time']);
Timestamp.propTypes = {
align: PropTypes.oneOf(['left', 'right']),
fields: PropTypes.oneOfType([
PropTypes.arrayOf(FIELD_TYPES),
FIELD_TYPES
]),
value: PropTypes.oneOfType([
PropTypes.string, // ISO-8601 string
PropTypes.object // Date object
]).isRequired
};
Timestamp.defaultProps = {
align: 'left'
};
View,
} from 'react-native';
import {
carbonStyles,
} from '../styles';
import {
Container,
} from '../container';
const cs = StyleSheet.create(carbonStyles);
const propTypes = {
children: PropTypes.oneOfType([
PropTypes.arrayOf(PropTypes.node),
PropTypes.node,
]),
color: PropTypes.number,
footer: PropTypes.bool,
header: PropTypes.bool,
style: PropTypes.any,
};
const defaultProps = {};
export default function ToolbarRight(props) {
return (
<View style={[cs.container, props.padding && cs.padding, props.style]}>
<View
{...props}
style={[
onChange: React.PropTypes.func,
//------------------------------------
min: React.PropTypes.number,
max: React.PropTypes.number,
step: React.PropTypes.number,
culture: React.PropTypes.string,
format: CustomPropTypes.numberFormat,
name: React.PropTypes.string,
parse: React.PropTypes.func,
disabled: React.PropTypes.oneOfType([React.PropTypes.bool, React.PropTypes.oneOf(['disabled'])]),
readOnly: React.PropTypes.oneOfType([React.PropTypes.bool, React.PropTypes.oneOf(['readOnly'])]),
messages: React.PropTypes.shape({
increment: React.PropTypes.string,
decrement: React.PropTypes.string
})
};
var NumberPicker = React.createClass({
displayName: 'NumberPicker',
mixins: [require('./mixins/WidgetMixin'), require('./mixins/TimeoutMixin'), require('./mixins/PureRenderMixin'), require('./mixins/RtlParentContextMixin')],
StepLabel.propTypes = {
/**
* Sets active styling. Overrides disabled coloring.
*/
active: _react.PropTypes.bool,
/**
* The label text node
*/
children: _react.PropTypes.node,
/**
* Sets completed styling. Overrides disabled coloring.
*/
completed: _react.PropTypes.bool,
/**
* Sets disabled styling.
*/
disabled: _react.PropTypes.bool,
/**
* The icon displayed by the step label.
*/
icon: _react.PropTypes.oneOfType([_react.PropTypes.element, _react.PropTypes.string, _react.PropTypes.number]),
/**
* Override the inline-style of the root element.
*/
style: _react.PropTypes.object
};
StepLabel.contextTypes = {
muiTheme: _react.PropTypes.object.isRequired,
stepper: _react.PropTypes.object
};
exports.default = StepLabel;
}
};
}
var ReactCSSTransitionGroup = React.createClass({
displayName: 'ReactCSSTransitionGroup',
propTypes: {
transitionName: React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.shape({
enter: React.PropTypes.string,
leave: React.PropTypes.string,
active: React.PropTypes.string,
}),
React.PropTypes.shape({
enter: React.PropTypes.string,
enterActive: React.PropTypes.string,
leave: React.PropTypes.string,
leaveActive: React.PropTypes.string,
appear: React.PropTypes.string,
appearActive: React.PropTypes.string,
}),
]).isRequired,
transitionAppear: React.PropTypes.bool,
transitionEnter: React.PropTypes.bool,
transitionLeave: React.PropTypes.bool,
transitionAppearTimeout: createTransitionTimeoutPropValidator('Appear'),
transitionEnterTimeout: createTransitionTimeoutPropValidator('Enter'),
transitionLeaveTimeout: createTransitionTimeoutPropValidator('Leave'),
},
height: '100%',
};
const ResponsiveContainer = props => (
<div className="recharts-responsive-container" style={style}>
<ContainerDimensions>
{
container =>
render({
container,
...props,
})
}
</ContainerDimensions>
</div>
);
ResponsiveContainer.displayName = 'ResponsiveContainer';
ResponsiveContainer.propTypes = {
width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
children: PropTypes.node,
};
ResponsiveContainer.defaultProps = {
width: '100%',
height: '100%',
};
export default ResponsiveContainer;
var View = require('View');
var ensurePositiveDelayProps = require('ensurePositiveDelayProps');
var warning = require('fbjs/lib/warning');
var PRESS_RETENTION_OFFSET = { top: 20, left: 20, right: 20, bottom: 30 };
var TouchableWithoutFeedback = React.createClass({
displayName: 'TouchableWithoutFeedback',
mixins: [TimerMixin, Touchable.Mixin],
propTypes: {
accessible: React.PropTypes.bool,
accessibilityComponentType: React.PropTypes.oneOf(View.AccessibilityComponentType),
accessibilityTraits: React.PropTypes.oneOfType([React.PropTypes.oneOf(View.AccessibilityTraits), React.PropTypes.arrayOf(React.PropTypes.oneOf(View.AccessibilityTraits))]),
disabled: React.PropTypes.bool,
onPress: React.PropTypes.func,
onPressIn: React.PropTypes.func,
onPressOut: React.PropTypes.func,
onLayout: React.PropTypes.func,
onLongPress: React.PropTypes.func,
delayPressIn: React.PropTypes.number,
delayPressOut: React.PropTypes.number,
import React from 'react';
import debounce from 'lodash.debounce';
import {shouldComponentUpdate} from 'react/lib/ReactComponentWithPureRenderMixin';
export const DebounceInput = React.createClass({
propTypes: {
element: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.func]),
type: React.PropTypes.string,
onChange: React.PropTypes.func.isRequired,
onKeyDown: React.PropTypes.func,
onBlur: React.PropTypes.func,
value: React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.number
]),
minLength: React.PropTypes.number,
debounceTimeout: React.PropTypes.number,
forceNotifyByEnter: React.PropTypes.bool,
forceNotifyOnBlur: React.PropTypes.bool
},
getDefaultProps() {
return {
element: 'input',
type: 'text',
minLength: 0,
debounceTimeout: 100,
forceNotifyByEnter: true,
forceNotifyOnBlur: true