path
stringlengths 5
296
| repo_name
stringlengths 5
85
| content
stringlengths 25
1.05M
|
|---|---|---|
es6/RoutingContext.js
|
fis-components/react-router
|
'use strict';
import React from 'react';
import RouterContext from './RouterContext';
import warning from './routerWarning';
var RoutingContext = React.createClass({
displayName: 'RoutingContext',
componentWillMount: function componentWillMount() {
process.env.NODE_ENV !== 'production' ? warning(false, '`RoutingContext` has been renamed to `RouterContext`. Please use `import { RouterContext } from \'react-router\'`. http://tiny.cc/router-routercontext') : undefined;
},
render: function render() {
return React.createElement(RouterContext, this.props);
}
});
export default RoutingContext;
|
src/svg-icons/device/signal-cellular-4-bar.js
|
hai-cea/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let DeviceSignalCellular4Bar = (props) => (
<SvgIcon {...props}>
<path d="M2 22h20V2z"/>
</SvgIcon>
);
DeviceSignalCellular4Bar = pure(DeviceSignalCellular4Bar);
DeviceSignalCellular4Bar.displayName = 'DeviceSignalCellular4Bar';
DeviceSignalCellular4Bar.muiName = 'SvgIcon';
export default DeviceSignalCellular4Bar;
|
src/components/BigDrink/BigDrink.js
|
hrnik/roofbar
|
import React from 'react'
import PropTypes from 'prop-types'
import Delay from 'react-delay'
import Button from 'components/Button'
import { DRINK_STATUS_AVAILABLE } from 'store/bar'
import Loader from 'components/Loader'
import classNames from 'classnames'
import './BigDrink.scss'
const BigDrink = ({
name,
drinkId,
description,
img,
processing,
makeOrder,
status,
disable,
disableDrink,
enableDrink,
disableMode = false
}) => {
const isDisableDrink = disable || status !== DRINK_STATUS_AVAILABLE
const editBtns = !isDisableDrink
? <Button
disable={processing}
black
onClick={() => disableDrink(drinkId)}
fullWidth
>
Decline
</Button>
: <Button
disable={processing}
onClick={() => enableDrink(drinkId)}
fullWidth
>
Enable
</Button>
return (
<div
className={classNames('drink__wraper', {
'drink__wraper--processing': processing
})}
>
<div
className={classNames('drink', { 'drink--disable': isDisableDrink })}
>
<img className='drink__image' src={img} alt={name} />
<div className='drink__text'>
<div className='drink__name'>{name}</div>
<div className='drink__description'>{description}</div>
</div>
</div>
<div className='btn-order-wraper'>
{!disableMode
? <Button
disable={isDisableDrink || processing}
onClick={() => makeOrder(drinkId)}
fullWidth
>
Make order
</Button>
: editBtns}
</div>
{processing && <Delay wait={300}><Loader className='drink__loader' absoluteCenter /></Delay> }
</div>
)
}
BigDrink.propTypes = {
name: PropTypes.string,
img: PropTypes.string,
description: PropTypes.string
}
export default BigDrink
|
src/mui/input/ReferenceInput.spec.js
|
matteolc/admin-on-rest
|
import React from 'react';
import assert from 'assert';
import { shallow } from 'enzyme';
import sinon from 'sinon';
import { ReferenceInput } from './ReferenceInput';
describe('<ReferenceInput />', () => {
const defaultProps = {
crudGetMatching: () => true,
crudGetOne: () => true,
input: {},
reference: 'posts',
resource: 'comments',
source: 'post_id',
};
const MyComponent = () => <span id="mycomponent" />;
it('should not render anything if there is no referenceRecord and allowEmpty is false', () => {
const wrapper = shallow((
<ReferenceInput {...defaultProps}>
<MyComponent />
</ReferenceInput>
));
const MyComponentElement = wrapper.find('MyComponent');
assert.equal(MyComponentElement.length, 0);
});
it('should not render enclosed component if allowEmpty is true', () => {
const wrapper = shallow((
<ReferenceInput {...defaultProps} allowEmpty>
<MyComponent />
</ReferenceInput>
));
const MyComponentElement = wrapper.find('MyComponent');
assert.equal(MyComponentElement.length, 1);
});
it('should call crudGetMatching on mount with default fetch values', () => {
const crudGetMatching = sinon.spy();
shallow((
<ReferenceInput {...defaultProps} allowEmpty crudGetMatching={crudGetMatching}>
<MyComponent />
</ReferenceInput>
), { lifecycleExperimental: true });
assert.deepEqual(crudGetMatching.args[0], [
'posts',
'comments@post_id',
{
page: 1,
perPage: 25,
},
{
field: 'id',
order: 'DESC',
},
{},
]);
});
it('should allow to customize crudGetMatching arguments with perPage, sort, and filter props', () => {
const crudGetMatching = sinon.spy();
shallow((
<ReferenceInput
{...defaultProps}
allowEmpty
crudGetMatching={crudGetMatching}
sort={{ field: 'foo', order: 'ASC' }}
perPage={5}
filter={{ q: 'foo' }}
>
<MyComponent />
</ReferenceInput>
), { lifecycleExperimental: true });
assert.deepEqual(crudGetMatching.args[0], [
'posts',
'comments@post_id',
{
page: 1,
perPage: 5,
},
{
field: 'foo',
order: 'ASC',
},
{
q: 'foo',
},
]);
});
it('should call crudGetMatching when setFilter is called', () => {
const crudGetMatching = sinon.spy();
const wrapper = shallow((
<ReferenceInput
{...defaultProps}
allowEmpty
crudGetMatching={crudGetMatching}
>
<MyComponent />
</ReferenceInput>
), { lifecycleExperimental: true });
wrapper.instance().setFilter('bar');
assert.deepEqual(crudGetMatching.args[1], [
'posts',
'comments@post_id',
{
page: 1,
perPage: 25,
},
{
field: 'id',
order: 'DESC',
},
{
q: 'bar',
},
]);
});
it('should use custom filterToQuery function prop', () => {
const crudGetMatching = sinon.spy();
const wrapper = shallow((
<ReferenceInput
{...defaultProps}
allowEmpty
crudGetMatching={crudGetMatching}
filterToQuery={searchText => ({ foo: searchText })}
>
<MyComponent />
</ReferenceInput>
), { lifecycleExperimental: true });
wrapper.instance().setFilter('bar');
assert.deepEqual(crudGetMatching.args[1], [
'posts',
'comments@post_id',
{
page: 1,
perPage: 25,
},
{
field: 'id',
order: 'DESC',
},
{
foo: 'bar',
},
]);
});
it('should call crudGetOne on mount if value is set', () => {
const crudGetOne = sinon.spy();
shallow((
<ReferenceInput
{...defaultProps}
allowEmpty
crudGetOne={crudGetOne}
input={{ value: 5 }}
>
<MyComponent />
</ReferenceInput>
), { lifecycleExperimental: true });
assert.deepEqual(crudGetOne.args[0], [
'posts',
5,
null,
false,
]);
});
it('should pass onChange down to child component', () => {
const onChange = sinon.spy();
const wrapper = shallow((
<ReferenceInput
{...defaultProps}
allowEmpty
onChange={onChange}
>
<MyComponent />
</ReferenceInput>
));
wrapper.find('MyComponent').simulate('change', 'foo');
assert.deepEqual(onChange.args[0], [
'foo',
]);
});
it('should pass meta down to child component', () => {
const wrapper = shallow(
<ReferenceInput
{...defaultProps}
allowEmpty
meta={{ touched: false }}
>
<MyComponent />
</ReferenceInput>,
);
const myComponent = wrapper.find('MyComponent');
assert.notEqual(myComponent.prop('meta', undefined));
});
});
|
wegas-app/src/main/node/wegas-react-form/src/Script/modules/Condition.js
|
Heigvd/Wegas
|
import PropTypes from 'prop-types';
import React from 'react';
import { types } from 'recast';
import Impact, { ErrorCatcher } from './Impact';
import { methodDescriptor, extractMethod } from './method';
import { methodDescriptor as globalMethodDescriptor } from './globalMethod';
import ConditionOperator from './ConditionOperator';
import { renderForm, valueToAST, getReadOnlySchema } from './args';
import { containerStyle } from '../Views/conditionImpactStyle';
const b = types.builders;
const nT = types.namedTypes;
/**
* return a default value for the given type
* @param {string} type the type for which a default value is required
* @returns {string|undefined|boolean} the default value
*/
function defaultValue(type) {
switch (type) {
case 'string':
return '';
case 'number':
return undefined;
case 'boolean':
return true;
default:
throw new Error(
`Default value for 'returns' property '${type}' is not implemented`
);
}
}
/**
* Find method's schema. Delegate to different method if it's a global method or a variable method.
* @param {Object} node ast left node
* @returns {Object} schema for given ast node
*/
function getMethodDescriptor(node) {
const { global, method, variable, member } = extractMethod(
nT.CallExpression.check(node) ? node : node.left
);
return global
? globalMethodDescriptor(member, method)
: methodDescriptor(variable, method);
}
function isBoolCallFn(node) {
const descr = getMethodDescriptor(node);
return nT.CallExpression.check(node) && descr && descr.returns === 'boolean';
}
class Condition extends React.Component {
constructor(props) {
super(props);
const { node } = props;
const descr = getMethodDescriptor(node);
if (nT.CallExpression.check(node)) {
if (isBoolCallFn(node)) {
this.state = { node: { left: node } };
} else {
this.state = { node: { left: node, operator: '===' } };
}
} else {
this.state = {
node: {
left: node.left,
right: node.right,
operator: node.operator || '===',
},
};
}
this.returns = descr && descr.returns; // store current method's returns
this.sendUpdate = this.sendUpdate.bind(this);
}
componentWillReceiveProps(nextProps) {
const { node } = nextProps;
const descr = getMethodDescriptor(node);
if (nT.CallExpression.check(node)) {
if (isBoolCallFn(node)) {
this.setState({ node: { left: node } });
} else {
this.setState({ node: { left: node, operator: '===' } });
}
} else {
this.setState({
node: {
left: node.left,
right: node.right,
operator: node.operator || '===',
},
});
}
this.returns = descr && descr.returns;
}
sendUpdate() {
const { node } = this.state;
const descr = getMethodDescriptor(node);
if (!descr && node.left) {
this.props.onChange(node.left);
} else if (
descr &&
descr.returns === 'boolean' &&
(node.right === undefined ||
(node.right &&
node.right.value === true &&
node.operator === '==='))
) {
this.props.onChange(node.left);
} else if (node.operator && node.left) {
const n = b.binaryExpression(
node.operator,
node.left,
node.right ||
valueToAST(defaultValue(descr.returns), {
type: descr.returns,
})
);
this.props.onChange(n);
}
}
check() {
const { node } = this.state;
const descr = getMethodDescriptor(node);
if (!descr) {
this.setState(({ node: n }) => ({
node: { ...n, right: undefined },
}));
} else if (this.returns !== descr.returns) {
this.setState(
({ node: n }) => ({
node: {
...n,
operator: '===',
right: valueToAST(defaultValue(descr.returns), {
type: descr.returns,
}),
},
}),
this.sendUpdate
);
this.returns = descr.returns;
} else {
this.sendUpdate();
}
}
render() {
const { node } = this.state;
const descr = getMethodDescriptor(node);
let container;
if (descr && typeof descr.returns !== 'string') {
const { method } = extractMethod(
nT.CallExpression.check(node) ? node : node.left
);
throw Error(
`Method '${method}' is not comparable. Missing 'returns' description`
);
}
if (node.right) {
if (!descr) {
const { method } = extractMethod(
nT.CallExpression.check(node) ? node : node.left
);
throw Error(`Method '${method}' not found`);
}
const schema = {
type: descr.returns,
value: defaultValue(descr.returns),
required: true,
view: {
layout: 'extraShortInline',
},
};
let argsForm = renderForm(
node.right,
schema,
v =>
this.setState(
({ node: n }) => ({ node: { ...n, right: v } }),
this.check
),
undefined,
'right'
);
if (this.props.view.readOnly) {
argsForm = getReadOnlySchema(argsForm);
}
container = [
<div key="operator" className={containerStyle}>
<ConditionOperator
operator={node.operator}
onChange={v =>
this.setState(
({ node: n }) => ({
node: { ...n, operator: v },
}),
this.check
)
}
type={descr.returns}
readOnly={this.props.view.readOnly}
/>
</div>,
argsForm,
];
}
const isBoolCall =
nT.CallExpression.check(node) && descr.returns === 'boolean';
return (
<div>
<Impact
{...this.props}
node={isBoolCall ? node : node.left}
onChange={v => {
if (nT.CallExpression.check(v)) {
this.setState(({ node: n }) => {
const des = getMethodDescriptor(v);
if (des && des.returns === 'boolean') {
return { node: { left: v } };
}
return { node: { ...n, left: v } };
}, this.check);
} else if (nT.ExpressionStatement.check(v)) {
this.props.onChange(v.expression);
} else {
this.props.onChange(v);
}
}}
/>
{container}
</div>
);
}
}
Condition.propTypes = {
onChange: PropTypes.func.isRequired,
node: PropTypes.object.isRequired,
};
export default function SecuredCondition(props) {
return (
<ErrorCatcher
node={props.node}
onChange={v => props.onChange(v.expression)}
>
<Condition {...props} />
</ErrorCatcher>
);
}
SecuredCondition.propTypes = {
node: PropTypes.object,
onChange: PropTypes.func.isRequired,
};
|
src/containers/EventsPage/EventsPage.js
|
ReactPoland/react-community
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import Helmet from 'react-helmet';
import _partition from 'lodash/partition';
import { loadEvents, addEvent, editEvent, removeEvent } from 'redux/modules/eventsModule';
// COMPONENTS
import { Map } from 'components';
import AddEventDialog from './AddEventDialog';
import EditEventDialog from './EditEventDialog';
import ViewEventDialog from './ViewEventDialog';
import EventsList from './EventsList';
// LAYOUT
import Grid from 'react-bootstrap/lib/Grid';
import Paper from 'material-ui/Paper';
import FloatingActionButton from 'material-ui/FloatingActionButton';
import ContentAdd from 'material-ui/svg-icons/content/add';
import { EventsCalendar, LoadingScreen } from 'components';
import { Div } from 'components/styled';
import permission from 'utils/privileges';
import { showError } from 'redux/modules/errorsModule';
const mappedState = ({ events, auth }) => ({
events: events.all,
// Loading events
loadingEvents: events.loadingEvents,
eventsLoaded: events.eventsLoaded,
// Authorization
loggedIn: auth.loggedIn,
user: auth.user,
permission: permission(auth.user)
});
const mappedActions = {
loadEvents,
addEvent,
editEvent,
removeEvent,
showError
};
@connect(mappedState, mappedActions)
export default class EventsPage extends Component {
static propTypes = {
events: PropTypes.array.isRequired,
// Loading events
loadingEvents: PropTypes.bool.isRequired,
eventsLoaded: PropTypes.bool.isRequired,
loadEvents: PropTypes.func.isRequired,
// Adding a new event
addEvent: PropTypes.func.isRequired,
// Editing an event
editEvent: PropTypes.func.isRequired,
// Removing an event
removeEvent: PropTypes.func.isRequired,
// Authorization
loggedIn: PropTypes.bool.isRequired,
user: PropTypes.object,
permission: PropTypes.object,
showError: PropTypes.func.isRequired
}
state = {
showAddEventDialog: false,
showEditEventDialog: false,
eventDetailDialog: null,
eventToEditId: null,
rangeToFilterEvents: null
}
componentWillMount() {
// Load events, if they're not ready
if (!this.props.eventsLoaded && !this.props.loadingEvents) this.props.loadEvents();
// Initializes Google Maps code
const { google } = window;
this.geocoder = new google.maps.Geocoder;
}
onSelectDays = (range) => {
this.setState({ rangeToFilterEvents: range });
}
onSelectEvent = (id) => () => {
const event = this.props.events.find(currentEvent => currentEvent.id === id);
this.getLocation(event.googleLocationId).then(location => {
this.setState({
eventDetailDialog: {
...event,
location
}
});
});
}
getLocation = async (googleLocationId) => {
if (!googleLocationId) return undefined;
return new Promise(resolve => {
this.geocoder.geocode({ placeId: googleLocationId }, results => {
resolve(results[0]);
});
});
}
closeEventDetail = () => this.setState({ eventDetailDialog: null })
prepareEvent = (eventData) => {
return {
id: eventData.id,
title: eventData.title,
organizedById: this.props.user.id,
price: eventData.price,
link: eventData.link,
description: eventData.description,
date: eventData.date,
lat: eventData.location.geometry.location.lat(),
lng: eventData.location.geometry.location.lng(),
googleLocationId: eventData.location.place_id
};
}
// DIALOG WINDOW (MODAL) HANDLING
openAddEventDialog = () => {
if (this.props.permission.isAuth) this.setState({ showAddEventDialog: true });
else this.props.showError({ requestName: 'Add new event', error: new Error('Please authorize') });
}
closeAddEventDialog = () => {
this.setState({ showAddEventDialog: false });
}
openEditEventDialog = (eventId) => {
this.setState({
showEditEventDialog: true,
eventToEditId: eventId
});
}
closeEditEventDialog = () => {
this.setState({
showEditEventDialog: false,
eventToEditId: null
});
}
// REDUX/API CALLS
addEvent = (eventData) => {
this.props.addEvent(this.prepareEvent(eventData));
}
editEvent = (eventData) => {
this.props.editEvent(this.prepareEvent(eventData));
}
deleteEvent = (eventId) => {
this.props.removeEvent(eventId);
}
// RENDER
render() {
// Prepare events' lists
const allEvents = this.props.events;
const firstEvent = allEvents[0];
let userEvents = [];
let otherEvents = [];
if (this.props.user) {
[userEvents, otherEvents] = _partition(allEvents, event => {
return event.organizedById === this.props.user.id || event.organizedBy.id === this.props.user.id;
});
}
const userHasEvents = userEvents.length > 0;
const thereAreOtherEvents = otherEvents.length > 0;
// Events lists components
const userEventsList = (
<EventsList
title="Your events"
events={userEvents}
range={this.state.rangeToFilterEvents}
onEdit={this.openEditEventDialog}
onSelectEvent={this.onSelectEvent}
onDelete={this.deleteEvent}
/>
);
const otherEventsList = (
<EventsList
title="Other events"
range={this.state.rangeToFilterEvents}
onSelectEvent={this.onSelectEvent}
events={otherEvents} />
);
const allEventsList = (
<EventsList
title="All events"
onSelectEvent={this.onSelectEvent}
range={this.state.rangeToFilterEvents}
events={allEvents} />
);
// Other components
const centerCoords = firstEvent && [firstEvent.lat, firstEvent.lng];
const mapAndCalendar = (
<Paper style={{ overflow: 'hidden', marginBottom: 24 }}>
<Div flex wrap>
<Div flexVal={1} style={{ height: 200, minWidth: 200 }}>
<Map
type="events"
style={{ height: '100%' }}
centerCoords={centerCoords}
markers={this.props.events}
/>
</Div>
<EventsCalendar
onDayClick={this.onSelectDays}
/>
</Div>
</Paper>
);
return (
<LoadingScreen loading={this.props.loadingEvents}>
<Grid style={{ paddingTop: 24 }}>
<FloatingActionButton
style={{
position: 'fixed',
right: 40,
bottom: 40,
zIndex: 1000
}}
onClick={this.openAddEventDialog} >
<ContentAdd />
</FloatingActionButton>
<Helmet title="Events" />
<h1 style={{ margin: '0 0 20px 0' }}>React Events</h1>
{mapAndCalendar}
{/* Events lists */}
{userHasEvents && userEventsList}
{userHasEvents && thereAreOtherEvents && otherEventsList}
{!userHasEvents && allEventsList}
{/* Event modals with forms */}
<AddEventDialog
popupVisible={this.state.showAddEventDialog}
closePopup={this.closeAddEventDialog}
addEvent={this.addEvent}
/>
<EditEventDialog
eventId={this.state.eventToEditId}
popupVisible={this.state.showEditEventDialog}
closePopup={this.closeEditEventDialog}
editEvent={this.editEvent}
/>
<ViewEventDialog
open={!!this.state.eventDetailDialog}
closePopup={this.closeEventDetail}
event={this.state.eventDetailDialog} />
</Grid>
</LoadingScreen>
);
}
}
|
app/containers/Store/index.js
|
monkeyzealer/Webstore-FrontEnd
|
/*
*
* Store
*
*/
import React from 'react';
import Helmet from 'react-helmet';
import {Link} from 'react-router';
import Avatar from 'material-ui/Avatar';
import FileFolder from 'material-ui/svg-icons/file/folder';
import FontIcon from 'material-ui/FontIcon';
import List from 'material-ui/List/List';
import ListItem from 'material-ui/List/ListItem';
import Footer from 'components/Footer';
import NavBar from 'components/NavBar';
import Header from 'components/Header'
import Responsive from 'react-responsive';
import TextField from 'material-ui/TextField';
import {orange500, blue500, brown500, brown900, brown700,} from 'material-ui/styles/colors';
import SelectField from 'material-ui/SelectField';
import MenuItem from 'material-ui/MenuItem';
/**
* A simple example of a scrollable `GridList` containing a [Subheader](/#/components/subheader).
*/
export default class Store extends React.PureComponent {
constructor(props){
super(props);
this.state={
filterProducts:[],
products:[],
categories:[],
user:JSON.parse(sessionStorage.getItem("user")),
categoryID:0,
}
}
componentWillMount(){
fetch("http://sumorobot.codemonkeytestsites.com/api/getProducts")
.then(function(res){
return res.json()
})
.then(function(json){
this.setState({
products:json,
filterProducts:json
})
}.bind(this))
fetch("http://sumorobot.codemonkeytestsites.com/api/getCategories?token="+this.state.token)
.then(function(res){
return res.json()
})
.then(function(json){
this.setState({
categories:json
})
}.bind(this))
}
handleCategory = (event, index, value) => {
var products = this.state.products;
var newProducts = [];
this.setState({categoryID:value});
if(value === null) {
this.setState({
filterProducts: products
})
}
else {
for(var i = 0; i < products.length; i++)
{
if(products[i].categoryID === value){
newProducts.push(products[i]);
}
}
this.setState({
filterProducts:newProducts
})
}
}
showMenu = () => {
const AdminBarLink ={
marginBottom: "25px"
};
const styles = {
customWidth: {
width: 200,
},
underlineStyle: {
borderColor: brown700,
},
underlineFocusStyle: {
borderColor: brown900,
},
hintStyle: {
width: "100%",
height: "30px",
color: "white",
},
inputStyle: {
background: "rgba(0, 0, 0, 0.3)",
width: "100%",
height: "30px",
color: "white",
paddingLeft: "10px",
paddingRight: "10px",
},
textareaStyle: {
background: "rgba(0, 0, 0, 0.3)",
marginTop: "0",
paddingLeft: "10px",
paddingRight: "10px",
height: "258px",
paddingTop: "5px",
paddingBottom: "5px",
marginBottom: "0"
},
uploadButton: {
verticalAlign: 'middle',
color: "red !important",
},
uploadInput: {
cursor: 'pointer',
position: 'absolute',
top: 0,
bottom: 0,
right: 0,
left: 0,
width: '100%',
opacity: 0,
},
button: {
backgroundColor: brown700,
color: "red !important",
},
button2: {
margin: 12,
backgroundColor: brown900,
},
label1: {
color: "red"
},
floatlabel1: {
color: "red !important",
border: "1px solid black important",
},
};
var createProductLink = <Link style={{marginBottom: '10px', color:'red', textDecoration:'none', padding:'10px', border:'1px solid gray', background:'black', fontSize:'18px'}} to="/create-product">Create Product</Link>;
var createCategoryLink = <Link to="/create-category" style={{color:'red', textDecoration:'none', fontSize:'18px', border:'1px solid gray', padding:'10px', background:'black'}}>Create Category</Link>;
var deleteCategoryLink = <Link style={{color:'red', textDecoration:'none', padding:'10px', border:'1px solid gray', background:'black', fontSize:'18px'}} to="/delete-category">Delete Category</Link>;
var OrdersLink = <Link style={{color:'red', textDecoration:'none', padding:'10px', border:'1px solid gray', background:'black', fontSize:'18px'}} to="/orders">View Orders</Link>
var _this = this
if(this.state.user === null)
{
OrdersLink = "";
createProductLink = "";
createCategoryLink = "";
deleteCategoryLink = "";
}
else {
if(this.state.user.roleID !== 1) {
OrdersLink = "";
createProductLink = "";
createCategoryLink = "";
deleteCategoryLink = "";
}
}
return(
<div>
<Responsive minDeviceWidth={1024}>
{createProductLink} {createCategoryLink} {deleteCategoryLink} {OrdersLink} <Link style={{color:'red', textDecoration:'none', padding:'10px', border:'1px solid gray', background:'black', fontSize:'18px'}} to="/user-orders">My Orders</Link>
</Responsive>
<Responsive maxDeviceWidth={1023}>
<p style={AdminBarLink}>{createProductLink}</p> <p style={AdminBarLink}>{createCategoryLink}</p> <p style={AdminBarLink}> {deleteCategoryLink} </p> <p style={AdminBarLink}> {OrdersLink} </p> <p> <Link style={{color:'red', textDecoration:'none', padding:'10px', border:'1px solid gray', background:'black', fontSize:'18px'}} to="/user-orders">My Orders</Link></p>
</Responsive>
</div>
)
}
render() {
const Container={
display: "flex",
flexDirection: "column",
justifyContent: "space-between",
minHeight: "100vh",
background: "white",
};
const mainContainer={
display: "flex",
flexDirection: "row",
flexWrap: "wrap",
flexGrow: "1"
};
const main={
width: "100%",
height: "auto",
background: "white",
display: "flex",
flexWrap: "wrap",
flexDirection: "column",
paddingBottom: "20px",
paddingTop: "60px",
};
const footerStyle ={
alignSelf: "flex-end",
};
const AdminBarLink ={
marginBottom: "5px"
};
const productImage={
width: "80%",
height: "250px",
maxWidth:"300px",
background: "rgba(255, 255, 255, 0.3)",
position: "relative",
padding: "0",
borderRadius: "0",
border: "1px solid lightgray",
}
const flexGrid ={
margin: "0 auto",
padding: "0",
display: "-webkit-flex",
display: "flex",
flexWrap: "wrap",
width: "95%",
marginBottom: "20px"
};
const flexGridLi ={
position: "relative",
listStyle: "none",
display: "-webkit-flex",
display: "flex",
margin: "0",
flex: "auto",
width: "20%", /* <-- more control */
};
const productContent={
width: "100%",
height: "auto",
overflow: "hidden",
padding: "0.5em"
};
const productTitle={
marginBottom: "0",
textAlign: "center",
marginTop: "10px"
};
const price={
textAlign: "center",
};
const Product={
border: "0",
height: "auto",
maxWidth: "100%",
textAlign: "center",
paddingTop: "25px",
paddingBottom: "25px",
borderBottom: "1px solid black",
background: "rgb(98, 98, 98)"
};
const Productbox={
backgroundColor: "#BdBEC0",
width: "24%",
margin: "0.5em",
textDecoration: "none",
color: "black",
border: "1px solid black"
};
const AdminBar = {
width: "100%",
color: "red !important",
margin: "0 auto",
textAlign: "left",
padding: "12px",
paddingLeft: "2.8%"
}
const AdminLink = {
color: "red !important",
textDecoration: "none"
}
const ProductboxMobile={
backgroundColor: "#BdBEC0",
width: "100%",
margin: "0.5em",
textDecoration: "none",
color: "black",
border: "1px solid black"
};
const search={
marginBottom: "0",
border: "1px solid black",
paddingLeft: "15px",
paddingRight: "15px",
width: "250px",
marginTop:"15px"
}
const searchTitle={
marginBottom: "0",
marginTop: "15px"
}
const styles = {
customWidth: {
width: 200,
},
underlineStyle: {
borderColor: brown700,
},
underlineFocusStyle: {
borderColor: brown900,
},
hintStyle: {
width: "100%",
height: "30px",
color: "white",
},
inputStyle: {
background: "rgba(0, 0, 0, 0.3)",
width: "100%",
height: "30px",
color: "white",
paddingLeft: "10px",
paddingRight: "10px",
},
textareaStyle: {
background: "rgba(0, 0, 0, 0.3)",
marginTop: "0",
paddingLeft: "10px",
paddingRight: "10px",
height: "258px",
paddingTop: "5px",
paddingBottom: "5px",
marginBottom: "0"
},
uploadButton: {
verticalAlign: 'middle',
color: "red !important",
},
uploadInput: {
cursor: 'pointer',
position: 'absolute',
top: 0,
bottom: 0,
right: 0,
left: 0,
width: '100%',
opacity: 0,
},
button: {
backgroundColor: brown700,
color: "red !important",
},
button2: {
margin: 12,
backgroundColor: brown900,
},
label1: {
color: "red",
},
floatlabel1: {
color: "red !important",
border: "1px solid black important",
},
};
return (
<div style={Container}>
<Helmet title="Store" meta={[ { name: 'description', content: 'Description of Store' }]}/>
<Header />
<Responsive minDeviceWidth={1024}>
<main style={mainContainer}>
<div style={main}>
<div style={AdminBar}>
{this.showMenu()}
<div style={search}>
<h2 style={searchTitle}>search by:</h2>
<SelectField
labelStyle={styles.label1}
value={this.state.categoryID}
onChange={this.handleCategory}
className="Categories"
style={styles.customWidth}
>
<MenuItem value={null} primaryText="All" />
{this.state.categories.map((category, i) => (
<MenuItem value={category.id} primaryText={category.category} key={i}/>
))}
</SelectField>
</div>
</div>
<div style={flexGrid}>
{this.state.filterProducts.map((product,i) => (
<Link to={`/product/${product.id}`} style={Productbox}>
<div style={Product}>
<img
src={product.image}
style={productImage}
className="Product"
/>
</div>
<div style={productContent}>
<h3 style={productTitle}> {product.product} </h3>
<div style={price}>Price: ${product.price}</div>
</div>
</Link>
))}
</div>
</div>
</main>
</Responsive>
<Responsive maxDeviceWidth={1023}>
<main style={mainContainer}>
<div style={main}>
<div style={AdminBar}>
{this.showMenu()}
<div style={search}>
<h2 style={searchTitle}>search by:</h2>
<SelectField
labelStyle={styles.label1}
value={this.state.categoryID}
onChange={this.handleCategory}
className="Categories"
style={styles.customWidth}
>
{this.state.categories.map((category, i) => (
<MenuItem value={category.id} primaryText={category.category} key={i}/>
))}
</SelectField>
</div>
</div>
<div style={flexGrid}>
{this.state.filterProducts.map((product,i) => (
<Link to={`/product/${product.id}`} style={ProductboxMobile}>
<div style={Product}>
<img
src={product.image}
style={productImage}
className="Product"
/>
</div>
<div style={productContent}>
<h3 style={productTitle}> {product.product} </h3>
<div style={price}>Price: ${product.price}</div>
</div>
</Link>
))}
</div>
</div>
</main>
</Responsive>
<Footer style={footerStyle} />
</div>
);
}
}
|
test/helperFunctions-test.js
|
mlimberg/Digidex
|
import React from 'react';
import { shallow, mount, render } from 'enzyme';
import sinon from 'sinon';
import { expect } from 'chai'
import combineArrays from '../lib/components/Helpers/combineArrays'
describe('combineArrays()', () => {
it('should return a single array', () => {
let array1 = [{ firstName: 'Wayne', lastName: 'Gretzky', firebaseId: 123 }, { firstName: 'Tim', lastName: 'Taylor', firebaseId: 938 }]
let array2 = [{ firstName: 'Tina', lastName: 'Turner', firebaseId: 763 }, { firstName: 'Wayne', lastName: 'Gretzky', firebaseId: 123 }]
expect(combineArrays(array1, array2)).to.have.length(3)
})
})
|
example/examples/LoadingMap.js
|
ksincennes/react-native-maps
|
import React from 'react';
import {
Text,
View,
Dimensions,
StyleSheet,
} from 'react-native';
import MapView from 'react-native-maps';
import flagImg from './assets/flag-blue.png';
const { width, height } = Dimensions.get('window');
const ASPECT_RATIO = width / height;
const LATITUDE = 37.78825;
const LONGITUDE = -122.4324;
const LATITUDE_DELTA = 0.0922;
const LONGITUDE_DELTA = LATITUDE_DELTA * ASPECT_RATIO;
const SPACE = 0.01;
class LoadingMap extends React.Component {
constructor(props) {
super(props);
this.state = {
region: {
latitude: LATITUDE,
longitude: LONGITUDE,
latitudeDelta: LATITUDE_DELTA,
longitudeDelta: LONGITUDE_DELTA,
},
};
}
render() {
return (
<View style={styles.container}>
<MapView
provider={this.props.provider}
style={styles.map}
initialRegion={this.state.region}
onPress={this.onMapPress}
loadingEnabled
loadingIndicatorColor="#666666"
loadingBackgroundColor="#eeeeee"
>
<MapView.Marker
coordinate={{
latitude: LATITUDE + SPACE,
longitude: LONGITUDE + SPACE,
}}
centerOffset={{ x: -18, y: -60 }}
anchor={{ x: 0.69, y: 1 }}
image={flagImg}
/>
<MapView.Marker
coordinate={{
latitude: LATITUDE - SPACE,
longitude: LONGITUDE - SPACE,
}}
centerOffset={{ x: -42, y: -60 }}
anchor={{ x: 0.84, y: 1 }}
>
<MapView.Callout>
<View>
<Text>This is a plain view</Text>
</View>
</MapView.Callout>
</MapView.Marker>
</MapView>
<View style={styles.buttonContainer}>
<View style={styles.bubble}>
<Text>Map with Loading</Text>
</View>
</View>
</View>
);
}
}
LoadingMap.propTypes = {
provider: MapView.ProviderPropType,
};
const styles = StyleSheet.create({
container: {
...StyleSheet.absoluteFillObject,
justifyContent: 'flex-end',
alignItems: 'center',
},
map: {
...StyleSheet.absoluteFillObject,
},
bubble: {
backgroundColor: 'rgba(255,255,255,0.7)',
paddingHorizontal: 18,
paddingVertical: 12,
borderRadius: 20,
},
buttonContainer: {
flexDirection: 'row',
marginVertical: 20,
backgroundColor: 'transparent',
},
});
module.exports = LoadingMap;
|
app/App.js
|
pro-react/react-app-boilerplate
|
import React, { Component } from 'react';
import {render} from 'react-dom';
class App extends Component {
render(){
return (
<h1>Hello World</h1>
);
}
}
render(<App />, document.getElementById('root'));
|
client/app/Core/MultiSelectDropDown/index.js
|
puja1234/DTA
|
/**
* Created by saubhagya on 1/8/17.
*/
import React, { Component } from 'react';
import TtnButton from 'core/Button/btn';
class MultiSelectDropdown extends Component{
constructor(){
super();
}
render(){
return(
<div>
{this.props.newCollab.map((item, index) => {
return (
<div key={index}>
{item}
<TtnButton iconButton
level = "primary"
rounded icon = "glyphicon glyphicon-remove"
onClick={(event) => this.props.onDeleteCollab(item)}/>
</div>
)
})}
<div>
<select value={this.props.title} onChange={(event) => {this.props.onSelectedVal(event.target.value)}}>
<option>Select</option>
{this.props.collabArray.map((item, index) => {
return (<option value={item} key={index}>{item}</option>)
})}
</select>
</div>
</div>
);
}
}
export default MultiSelectDropdown;
//Earlier in place of <TtnButton/> we had the following code... :-
/*<button key={index} value={item} onClick={(event) => this.props.onDeleteCollab(item)}>{item}
<span className="glyphicon glyphicon-remove"></span>
</button>*/
|
server/sonar-web/src/main/js/apps/web-api/components/__tests__/Params-test.js
|
lbndev/sonarqube
|
/*
* SonarQube
* Copyright (C) 2009-2017 SonarSource SA
* mailto:info AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
import React from 'react';
import { shallow } from 'enzyme';
import Params from '../Params';
it('should render deprecated parameters', () => {
const params = [
{
key: 'foo',
deprecatedSince: '5.0'
}
];
expect(shallow(<Params params={params} showDeprecated={true} />)).toMatchSnapshot();
});
it('should not render deprecated parameters', () => {
const params = [
{
key: 'foo',
deprecatedSince: '5.0'
}
];
expect(shallow(<Params params={params} showDeprecated={false} />)).toMatchSnapshot();
});
it('should render deprecated key', () => {
const params = [
{
key: 'foo',
deprecatedKey: 'foo-deprecated',
deprecatedKeySince: '5.0'
}
];
expect(shallow(<Params params={params} showDeprecated={true} />)).toMatchSnapshot();
});
|
web/src/components/SimpleReport.js
|
Ding-Jun/Analysis
|
import React from 'react';
import { Link } from 'react-router'
import { Card, Row, Col } from 'antd';
var RANK_LOW=0;
var RANK_MEDIUM=3;
var RANK_HIGH=5;
class SimpleReport extends React.Component{
handleClick(e){
e.preventDefault();
console.log(this.props.id)
}
render(){
var rankCls;
switch (this.props.rank){
case RANK_LOW:rankCls='red lighten-5';break;
case RANK_MEDIUM:rankCls='orange lighten-5';break;
case RANK_HIGH:rankCls='light-green lighten-5';break;
default:break;
}
var layout={
xs:24,
sm:12
}
return (
<Card key={this.props.id}
className={rankCls}
title={this.props.reportName}
bordered={true}
extra={<Link to={'/report/'+this.props.id}>更多</Link>}
>
<Row>
<Col {...layout}>
<p>良率: {this.props.passPercent}</p>
<p>测试工程师: {this.props.testMan}</p>
</Col>
<Col {...layout} >
<p>测试数量: {this.props.testCount}</p>
<p>时间: {this.props.time}</p>
</Col>
</Row>
</Card>
)
}
}
export default SimpleReport;
|
packages/react-scripts/fixtures/kitchensink/src/features/webpack/ImageInclusion.js
|
xiaohu-developer/create-react-app
|
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
import React from 'react'
import tiniestCat from './assets/tiniest-cat.jpg'
export default () => (
<img id="feature-image-inclusion" src={tiniestCat} alt="tiniest cat" />
)
|
src/pages/julia-plus.js
|
vitorbarbosa19/ziro-online
|
import React from 'react'
import BrandGallery from '../components/BrandGallery'
export default () => (
<BrandGallery brand='Julia Plus' />
)
|
app/index.js
|
atomixinteractions/material-theme-generator
|
import React from 'react'
import ReactDOM from 'react-dom'
import RedBox from 'redbox-react'
import { AppContainer } from 'react-hot-loader'
import RootComponent from './root'
import baseStyles from './styles'
const rootPoint = document.createElement('div')
document.body.insertBefore(rootPoint, document.body.firstChild)
const link = document.createElement('link')
link.rel = 'stylesheet'
link.href = 'https://fonts.googleapis.com/css?family=Noto+Sans:300,400,600,700&subset=cyrillic'
document.head.insertBefore(link, document.head.getElementsByTagName('title')[0])
baseStyles()
const render = Root => {
try {
ReactDOM.render((
<AppContainer>
<Root />
</AppContainer>
), rootPoint)
}
catch(e) {
ReactDOM.render(<RedBox error={e} />, rootPoint)
}
}
render(RootComponent)
if (module.hot) {
module.hot.accept('./root', () => {
const NewApp = require('./root').default
render(NewApp)
})
}
|
components/date_picker/DatePicker.js
|
showings/react-toolbox
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import classnames from 'classnames';
import { themr } from 'react-css-themr';
import { DATE_PICKER } from '../identifiers';
import events from '../utils/events';
import time from '../utils/time';
import InjectIconButton from '../button/IconButton';
import InjectInput from '../input/Input';
import InjectDialog from '../dialog/Dialog';
import calendarFactory from './Calendar';
import datePickerDialogFactory from './DatePickerDialog';
const factory = (Input, DatePickerDialog) => {
class DatePicker extends Component {
static propTypes = {
active: PropTypes.bool,
autoOk: PropTypes.bool,
cancelLabel: PropTypes.string,
className: PropTypes.string,
disabledDates: PropTypes.arrayOf(PropTypes.instanceOf(Date)),
enabledDates: PropTypes.arrayOf(PropTypes.instanceOf(Date)),
error: PropTypes.string,
icon: PropTypes.oneOfType([
PropTypes.string,
PropTypes.element,
]),
inputClassName: PropTypes.string,
inputFormat: PropTypes.func,
label: PropTypes.string,
locale: PropTypes.oneOfType([
PropTypes.string,
PropTypes.object,
]),
maxDate: PropTypes.instanceOf(Date),
minDate: PropTypes.instanceOf(Date),
name: PropTypes.string,
okLabel: PropTypes.string,
onChange: PropTypes.func,
onClick: PropTypes.func,
onDismiss: PropTypes.func,
onEscKeyDown: PropTypes.func,
onKeyPress: PropTypes.func,
onOverlayClick: PropTypes.func,
readonly: PropTypes.bool,
sundayFirstDayOfWeek: PropTypes.bool,
theme: PropTypes.shape({
container: PropTypes.string,
input: PropTypes.string,
}),
value: PropTypes.oneOfType([
PropTypes.instanceOf(Date),
PropTypes.string,
]),
};
static defaultProps = {
active: false,
locale: 'en',
sundayFirstDayOfWeek: false,
};
state = {
active: this.props.active,
};
componentWillReceiveProps(nextProps) {
if (nextProps.active !== this.props.active && this.state.active !== nextProps.active) {
this.setState({ active: nextProps.active });
}
}
handleDismiss = () => {
this.setState({ active: false });
if (this.props.onDismiss) {
this.props.onDismiss();
}
};
handleInputFocus = (event) => {
events.pauseEvent(event);
this.setState({ active: true });
};
handleInputBlur = (event) => {
events.pauseEvent(event);
this.setState({ active: false });
};
handleInputClick = (event) => {
events.pauseEvent(event);
this.setState({ active: true });
if (this.props.onClick) this.props.onClick(event);
};
handleInputKeyPress = (event) => {
if (event.charCode === 13) {
events.pauseEvent(event);
this.setState({ active: true });
}
if (this.props.onKeyPress) this.props.onKeyPress(event);
};
handleSelect = (value, event) => {
if (this.props.onChange) this.props.onChange(value, event);
this.setState({ active: false });
};
render() {
const { active, onDismiss,// eslint-disable-line
autoOk, cancelLabel, enabledDates, disabledDates, inputClassName, inputFormat,
locale, maxDate, minDate, okLabel, onEscKeyDown, onOverlayClick, readonly,
sundayFirstDayOfWeek, value, ...others } = this.props;
const finalInputFormat = inputFormat || time.formatDate;
const date = Object.prototype.toString.call(value) === '[object Date]' ? value : undefined;
const formattedDate = date === undefined ? '' : finalInputFormat(value, locale);
return (
<div data-react-toolbox="date-picker" className={this.props.theme.container}>
<Input
{...others}
className={classnames(this.props.theme.input, { [inputClassName]: inputClassName })}
disabled={readonly}
error={this.props.error}
icon={this.props.icon}
label={this.props.label}
name={this.props.name}
onFocus={this.handleInputFocus}
onKeyPress={this.handleInputKeyPress}
onClick={this.handleInputClick}
readOnly
type="text"
value={formattedDate}
/>
<DatePickerDialog
active={this.state.active}
autoOk={autoOk}
cancelLabel={cancelLabel}
className={this.props.className}
disabledDates={disabledDates}
enabledDates={enabledDates}
locale={locale}
maxDate={maxDate}
minDate={minDate}
name={this.props.name}
onDismiss={this.handleDismiss}
okLabel={okLabel}
onEscKeyDown={onEscKeyDown || this.handleDismiss}
onOverlayClick={onOverlayClick || this.handleDismiss}
onSelect={this.handleSelect}
sundayFirstDayOfWeek={sundayFirstDayOfWeek}
theme={this.props.theme}
value={date}
/>
</div>
);
}
}
return DatePicker;
};
const Calendar = calendarFactory(InjectIconButton);
const DatePickerDialog = datePickerDialogFactory(InjectDialog, Calendar);
const DatePicker = factory(InjectInput, DatePickerDialog);
export default themr(DATE_PICKER)(DatePicker);
export {
DatePickerDialog,
factory as datePickerFactory,
};
export { Calendar };
export { DatePicker };
|
src/app/components/EthernetConnection.js
|
UrgBenri/UrgBenriWeb
|
import React from 'react';
import Paper from 'material-ui/Paper';
import TextField from 'material-ui/TextField';
import IconButton from 'material-ui/IconButton';
import ActionLabelOutline from 'material-ui/svg-icons/action/label-outline';
import ActionLabel from 'material-ui/svg-icons/action/label';
import Subheader from 'material-ui/Subheader';
const styles = {
paper: {
margin: 5,
padding: 5,
},
container: {
display: 'flex',
flexDirection: 'row',
alignItems: 'center'
},
textField: {
flexGrow: 2
},
iconButton: {
flexGrow: 1
}
};
class EthernetConnection extends React.Component {
constructor(props) {
super(props)
this.state = {
connected: false,
};
this.handleConnect = this.handleConnect.bind(this);
this.handleDisconnect = this.handleDisconnect.bind(this);
}
handleConnect() {
this.setState({
connected: false
});
}
handleDisconnect() {
this.setState({
connected: true
});
}
handleConnected() {
}
render() {
return (
<Paper
style={styles.paper}
zDepth={2}
>
<div
style={styles.container}>
<TextField
ref={(input) => { this.textInput = input; }}
style={styles.textField}
hintText="192.168.0.10"
floatingLabelText="IP Address"
/>
<IconButton style={styles.iconButton} >
{this.state.connected ?
(<ActionLabel onClick={this.handleConnect} />) :
(<ActionLabelOutline onClick={this.handleDisconnect} />)}
</IconButton>
</div>
</Paper>
)
}
}
export default EthernetConnection;
|
client/node_modules/uu5g03/doc/main/server/public/data/source/uu5-bricks-tree.js
|
UnicornCollege/ucl.itkpd.configurator
|
import React from 'react';
import {BaseMixin, ElementaryMixin, ContentMixin} from './../common/common.js';
import List from './tree-list.js';
import Item from './tree-item.js';
import './tree.less';
export const Tree = React.createClass({
//@@viewOn:mixins
mixins: [
BaseMixin,
ElementaryMixin,
ContentMixin
],
//@@viewOff:mixins
//@@viewOn:statics
statics: {
tagName: 'UU5.Bricks.Tree',
classNames: {
main: 'uu5-bricks-tree'
},
defaults: {
childTagName: 'UU5.Bricks.Tree.Item'
}
},
//@@viewOff:statics
//@@viewOn:propTypes
propTypes: {
items: React.PropTypes.array,
glyphiconExpanded: React.PropTypes.string,
glyphiconCollapsed: React.PropTypes.string
},
//@@viewOff:propTypes
//@@viewOn:getDefaultProps
getDefaultProps: function () {
return {
items: null,
glyphiconExpanded: 'uu-glyphicon-minus',
glyphiconCollapsed: 'uu-glyphicon-plus'
};
},
//@@viewOff:getDefaultProps
//@@viewOn:standardComponentLifeCycle
//@@viewOff:standardComponentLifeCycle
//@@viewOn:interface
//@@viewOff:interface
//@@viewOn:overridingMethods
//@@viewOff:overridingMethods
//@@viewOn:componentSpecificHelpers
//@@viewOff:componentSpecificHelpers
//@@viewOn:render
render: function () {
return (
<List
{...this.getMainPropsToPass()}
items={this.props.items || this.getChildren()}
glyphiconExpanded={this.props.glyphiconExpanded}
glyphiconCollapsed={this.props.glyphiconCollapsed}
>
{this.props.children && React.Children.toArray(this.props.children)}
{this.getDisabledCover()}
</List>
);
}
//@@viewOff:render
});
Tree.List = List;
Tree.Item = Item;
export default Tree;
|
fields/types/relationship/RelationshipColumn.js
|
kwangkim/keystone
|
import React from 'react';
import ItemsTableCell from '../../../admin/src/components/ItemsTableCell';
import ItemsTableValue from '../../../admin/src/components/ItemsTableValue';
const moreIndicatorStyle = {
color: '#bbb',
fontSize: '.8rem',
fontWeight: 500,
marginLeft: 8,
};
var RelationshipColumn = React.createClass({
displayName: 'RelationshipColumn',
propTypes: {
col: React.PropTypes.object,
data: React.PropTypes.object,
},
renderMany (value) {
if (!value || !value.length) return;
let refList = this.props.col.field.refList;
let items = [];
for (let i = 0; i < 3; i++) {
if (!value[i]) break;
if (i) {
items.push(<span key={'comma' + i}>, </span>);
}
items.push(
<ItemsTableValue interior truncate={false} key={'anchor' + i} href={'/keystone/' + refList.path + '/' + value[i].id}>
{value[i].name}
</ItemsTableValue>
);
}
if (value.length > 3) {
items.push(<span key="more" style={moreIndicatorStyle}>[...{value.length - 3} more]</span>);
}
return (
<ItemsTableValue field={this.props.col.type}>
{items}
</ItemsTableValue>
);
},
renderValue (value) {
if (!value) return;
let refList = this.props.col.field.refList;
return (
<ItemsTableValue href={'/keystone/' + refList.path + '/' + value.id} padded interior field={this.props.col.type}>
{value.name}
</ItemsTableValue>
);
},
render () {
let value = this.props.data.fields[this.props.col.path];
let many = this.props.col.field.many;
return (
<ItemsTableCell>
{many ? this.renderMany(value) : this.renderValue(value)}
</ItemsTableCell>
);
}
});
module.exports = RelationshipColumn;
|
src/Modal/test/ModalTitleSpec.js
|
suitejs/suite
|
import React from 'react';
import { getDOMNode } from '@test/testUtils';
import ModalTitle from '../ModalTitle';
describe('ModalTitle', () => {
it('Should render a modal title', () => {
const title = 'Test';
const instance = getDOMNode(<ModalTitle>{title}</ModalTitle>);
assert.equal(instance.className, 'rs-modal-title');
assert.equal(instance.innerHTML, title);
});
it('Should have a custom className', () => {
const instance = getDOMNode(<ModalTitle className="custom" />);
assert.ok(instance.className.match(/\bcustom\b/));
});
it('Should have a custom style', () => {
const fontSize = '12px';
const instance = getDOMNode(<ModalTitle style={{ fontSize }} />);
assert.equal(instance.style.fontSize, fontSize);
});
it('Should have a custom className prefix', () => {
const instance = getDOMNode(<ModalTitle classPrefix="custom-prefix" />);
assert.ok(instance.className.match(/\bcustom-prefix\b/));
});
});
|
examples/js/column-filter/date-filter-programmatically.js
|
rolandsusans/react-bootstrap-table
|
/* eslint max-len: 0 */
/* eslint no-unused-vars: 0 */
import React from 'react';
import { BootstrapTable, TableHeaderColumn } from 'react-bootstrap-table';
const products = [];
function addProducts(quantity) {
const startId = products.length;
const startDate = new Date(2015, 0, 1);
const endDate = new Date();
for (let i = 0; i < quantity; i++) {
const date = new Date(startDate.getTime() + Math.random() * (endDate.getTime() - startDate.getTime()));
const id = startId + i;
products.push({
id: id,
name: 'Item name ' + id,
inStockDate: date
});
}
}
addProducts(5);
function dateFormatter(cell, row) {
return `${('0' + cell.getDate()).slice(-2)}/${('0' + (cell.getMonth() + 1)).slice(-2)}/${cell.getFullYear()}`;
}
export default class ProgrammaticallyDateFilter extends React.Component {
handleBtnClick = () => {
this.refs.nameCol.applyFilter({
date: products[2].inStockDate,
comparator: '='
});
}
render() {
return (
<div>
<button onClick={ this.handleBtnClick } className='btn btn-default'>Click to apply select filter</button>
<BootstrapTable data={ products }>
<TableHeaderColumn dataField='id' isKey={ true }>Product ID</TableHeaderColumn>
<TableHeaderColumn dataField='name'>Product Name</TableHeaderColumn>
<TableHeaderColumn ref='nameCol' dataField='inStockDate' dataFormat={ dateFormatter } filter={ { type: 'DateFilter' } }>In Stock From</TableHeaderColumn>
</BootstrapTable>
</div>
);
}
}
|
src/Tabs/Tabs.spec.js
|
kittyjumbalaya/material-components-web
|
/* eslint-env mocha */
import React from 'react';
import {shallow} from 'enzyme';
import {assert} from 'chai';
import Tabs from './Tabs';
import getMuiTheme from '../styles/getMuiTheme';
describe('<Tabs />', () => {
const muiTheme = getMuiTheme();
const shallowWithContext = (node) => shallow(node, {context: {muiTheme}});
const Tab = () => <div />;
Tab.muiName = 'Tab';
describe('uncontrolled', () => {
it('should set the right tab active', () => {
const wrapper = shallowWithContext(
<Tabs>
<Tab />
<Tab />
</Tabs>
);
assert.strictEqual(wrapper.state().selectedIndex, 0);
});
});
describe('prop: value', () => {
it('should set the right tab active', () => {
const wrapper = shallowWithContext(
<Tabs value="2">
<Tab value="1" />
<Tab value="2" />
</Tabs>
);
assert.strictEqual(wrapper.state().selectedIndex, 1);
});
it('should set the right tab active when the children change', () => {
const wrapper = shallowWithContext(
<Tabs value="2">
<Tab value="1" />
<Tab value="2" />
</Tabs>
);
wrapper.setProps({
children: [
<Tab value="2" />,
<Tab value="3" />,
],
});
assert.strictEqual(wrapper.state().selectedIndex, 0);
});
});
});
|
src/shared/universal/components/App/Posts/Post/Post.js
|
DAppx/SharpReact
|
/* */
import React from 'react';
import { connect } from 'react-redux';
import Helmet from 'react-helmet';
import * as FromState from '../../../../reducers';
function Post({ post }) {
if (!post) {
// Post hasn't been fetched yet. It would be better if we had a "status"
// reducer attached to our posts which gave us a bit more insight, such
// as whether the post is currently being fetched, or if the fetch failed.
return null;
}
const { title, body } = post;
return (
<div>
<Helmet title={`Posts - ${title}`} />
<h1>{title}</h1>
<div>
{body}
</div>
<div>
Foo
</div>
</div>
);
}
function mapStateToProps(state, { params: { id } }) {
return {
post: FromState.getPostById(state, id),
};
}
export default connect(mapStateToProps)(Post);
|
src/shared/views/plugins/Model3d/Model3d.js
|
in-depth/indepth-demo
|
import React from 'react'
import styles from './Model3d.css'
const Model3d = (props) => {
return (
<div className={styles.holder}>
<iframe width="100%" height="100%" src={props.url} frameBorder="0" allowFullScreen />
</div>
)
}
Model3d.propTypes = {
url: React.PropTypes.string.isRequired,
}
export default Model3d
|
test/containers/CounterPage.spec.js
|
MustD/a3al
|
import { expect } from 'chai';
import React from 'react';
import {
renderIntoDocument,
scryRenderedDOMComponentsWithTag,
findRenderedDOMComponentWithClass,
Simulate
} from 'react-addons-test-utils';
import { Provider } from 'react-redux';
import CounterPage from '../../app/containers/CounterPage';
import configureStore from '../../app/store/configureStore';
function setup(initialState) {
const store = configureStore(initialState);
const app = renderIntoDocument(
<Provider store={store}>
<CounterPage />
</Provider>
);
return {
app,
buttons: scryRenderedDOMComponentsWithTag(app, 'button').map(button => button),
p: findRenderedDOMComponentWithClass(app, 'counter')
};
}
describe('containers', () => {
describe('App', () => {
it('should display initial count', () => {
const { p } = setup();
expect(p.textContent).to.match(/^0$/);
});
it('should display updated count after increment button click', () => {
const { buttons, p } = setup();
Simulate.click(buttons[0]);
expect(p.textContent).to.match(/^1$/);
});
it('should display updated count after descrement button click', () => {
const { buttons, p } = setup();
Simulate.click(buttons[1]);
expect(p.textContent).to.match(/^-1$/);
});
it('shouldnt change if even and if odd button clicked', () => {
const { buttons, p } = setup();
Simulate.click(buttons[2]);
expect(p.textContent).to.match(/^0$/);
});
it('should change if odd and if odd button clicked', () => {
const { buttons, p } = setup({ counter: 1 });
Simulate.click(buttons[2]);
expect(p.textContent).to.match(/^2$/);
});
});
});
|
src/index.dev.js
|
ryanswapp/react-starter-template
|
import 'App/style/index';
import React from 'react';
import { render } from 'react-dom';
import { Router, Route, IndexRoute, browserHistory } from 'react-router';
import routes from 'config/routes.js';
import { createStore, compose, applyMiddleware, combineReducers } from 'redux';
import { Provider } from 'react-redux';
import thunkMiddleware from 'redux-thunk';
import { syncHistory, routeReducer } from 'react-router-redux';
import Actions from 'App/state/actions.js';
import Reducers from 'App/state/reducers.js';
import createSagaMiddleware from 'redux-saga';
import rootSaga from 'App/state/sagas.js';
import DevTools from 'config/DevTools.js';
import { reducer as formReducer } from 'redux-form';
const reducer = combineReducers(Object.assign({}, Reducers, {
form: formReducer,
routing: routeReducer
}));
const reduxRouterMiddleware = syncHistory(browserHistory);
const sagaMiddleware = createSagaMiddleware();
let finalCreateStore = compose(
applyMiddleware(
thunkMiddleware,
reduxRouterMiddleware,
sagaMiddleware
),
DevTools.instrument()
)(createStore);
const store = finalCreateStore(reducer);
reduxRouterMiddleware.listenForReplays(store);
sagaMiddleware.run(rootSaga);
render(
<Provider store={ store }>
<div>
<Router history={ browserHistory }>
{ routes }
</Router>
<DevTools />
</div>
</Provider>,
document.getElementById('app')
);
|
monkey/monkey_island/cc/ui/src/components/attack/techniques/T1107.js
|
guardicore/monkey
|
import React from 'react';
import ReactTable from 'react-table';
import {renderMachineFromSystemData, ScanStatus} from './Helpers'
import MitigationsComponent from './MitigationsComponent';
class T1107 extends React.Component {
constructor(props) {
super(props);
}
static renderDelete(status) {
if (status === ScanStatus.USED) {
return <span>Yes</span>
} else {
return <span>No</span>
}
}
static getDeletedFileColumns() {
return ([{
columns: [
{
Header: 'Machine',
id: 'machine',
accessor: x => renderMachineFromSystemData(x._id.machine),
style: {'whiteSpace': 'unset'}
},
{Header: 'Path', id: 'path', accessor: x => x._id.path, style: {'whiteSpace': 'unset'}},
{
Header: 'Deleted?', id: 'deleted', accessor: x => this.renderDelete(x._id.status),
style: {'whiteSpace': 'unset'}, width: 160
}]
}])
}
render() {
return (
<div>
<div>{this.props.data.message_html}</div>
<br/>
{this.props.data.deleted_files.length !== 0 ?
<ReactTable
columns={T1107.getDeletedFileColumns()}
data={this.props.data.deleted_files}
showPagination={false}
defaultPageSize={this.props.data.deleted_files.length}
/> : ''}
<MitigationsComponent mitigations={this.props.data.mitigations}/>
</div>
);
}
}
export default T1107;
|
client/components/todo-list.js
|
wbinnssmith/react-redo
|
import values from 'lodash/values';
import React from 'react';
import { connect } from 'react-redux';
import { pure } from 'recompose';
import Todo from './todo';
import { deleteTodo, toggleTodo, updateTodo } from '../modules/todos';
function stateToProps(state, props) {
return {
todos: values(state.todos).sort((a, b) => a.id - b.id),
isEditing: state.ui.isEditing
}
}
const dispatchToProps = {
deleteTodo,
toggleTodo,
updateTodo
}
export class TodoList extends React.Component {
render() {
const { deleteTodo, isEditing, todos, toggleTodo, updateTodo } = this.props;
return (
<ul className="TodoList">
{todos.map(todo =>
<Todo
todo={todo}
initialValues={todo}
isEditing={isEditing}
key={todo.id}
formKey={`${todo.id}`}
onDelete={() => deleteTodo(todo.id)}
onToggle={() => toggleTodo(todo.id)}
onSubmit={attrs => updateTodo(todo.id, attrs)}
/>
)}
</ul>
);
}
}
export default pure(connect(stateToProps, dispatchToProps)(TodoList));
|
frontend/src/Artist/Index/Overview/ArtistIndexOverviews.js
|
lidarr/Lidarr
|
import PropTypes from 'prop-types';
import React, { Component } from 'react';
import { Grid, WindowScroller } from 'react-virtualized';
import ArtistIndexItemConnector from 'Artist/Index/ArtistIndexItemConnector';
import Measure from 'Components/Measure';
import dimensions from 'Styles/Variables/dimensions';
import getIndexOfFirstCharacter from 'Utilities/Array/getIndexOfFirstCharacter';
import hasDifferentItemsOrOrder from 'Utilities/Object/hasDifferentItemsOrOrder';
import ArtistIndexOverview from './ArtistIndexOverview';
import styles from './ArtistIndexOverviews.css';
// Poster container dimensions
const columnPadding = parseInt(dimensions.artistIndexColumnPadding);
const columnPaddingSmallScreen = parseInt(dimensions.artistIndexColumnPaddingSmallScreen);
const progressBarHeight = parseInt(dimensions.progressBarSmallHeight);
const detailedProgressBarHeight = parseInt(dimensions.progressBarMediumHeight);
function calculatePosterWidth(posterSize, isSmallScreen) {
const maxiumPosterWidth = isSmallScreen ? 192 : 202;
if (posterSize === 'large') {
return maxiumPosterWidth;
}
if (posterSize === 'medium') {
return Math.floor(maxiumPosterWidth * 0.75);
}
return Math.floor(maxiumPosterWidth * 0.5);
}
function calculateRowHeight(posterHeight, sortKey, isSmallScreen, overviewOptions) {
const {
detailedProgressBar
} = overviewOptions;
const heights = [
posterHeight,
detailedProgressBar ? detailedProgressBarHeight : progressBarHeight,
isSmallScreen ? columnPaddingSmallScreen : columnPadding
];
return heights.reduce((acc, height) => acc + height, 0);
}
function calculatePosterHeight(posterWidth) {
return posterWidth;
}
class ArtistIndexOverviews extends Component {
//
// Lifecycle
constructor(props, context) {
super(props, context);
this.state = {
width: 0,
columnCount: 1,
posterWidth: 238,
posterHeight: 238,
rowHeight: calculateRowHeight(238, null, props.isSmallScreen, {})
};
this._grid = null;
}
componentDidUpdate(prevProps, prevState) {
const {
items,
sortKey,
overviewOptions,
jumpToCharacter,
scrollTop
} = this.props;
const {
width,
rowHeight
} = this.state;
if (prevProps.sortKey !== sortKey ||
prevProps.overviewOptions !== overviewOptions) {
this.calculateGrid();
}
if (this._grid &&
(prevState.width !== width ||
prevState.rowHeight !== rowHeight ||
hasDifferentItemsOrOrder(prevProps.items, items))) {
// recomputeGridSize also forces Grid to discard its cache of rendered cells
this._grid.recomputeGridSize();
}
if (jumpToCharacter != null && jumpToCharacter !== prevProps.jumpToCharacter) {
const index = getIndexOfFirstCharacter(items, jumpToCharacter);
if (this._grid && index != null) {
this._grid.scrollToCell({
rowIndex: index,
columnIndex: 0
});
}
}
if (this._grid && scrollTop !== 0) {
this._grid.scrollToPosition({ scrollTop });
}
}
//
// Control
setGridRef = (ref) => {
this._grid = ref;
}
calculateGrid = (width = this.state.width, isSmallScreen) => {
const {
sortKey,
overviewOptions
} = this.props;
const posterWidth = calculatePosterWidth(overviewOptions.size, isSmallScreen);
const posterHeight = calculatePosterHeight(posterWidth);
const rowHeight = calculateRowHeight(posterHeight, sortKey, isSmallScreen, overviewOptions);
this.setState({
width,
posterWidth,
posterHeight,
rowHeight
});
}
cellRenderer = ({ key, rowIndex, style }) => {
const {
items,
sortKey,
overviewOptions,
showRelativeDates,
shortDateFormat,
longDateFormat,
timeFormat,
isSmallScreen
} = this.props;
const {
posterWidth,
posterHeight,
rowHeight
} = this.state;
const artist = items[rowIndex];
if (!artist) {
return null;
}
return (
<div
key={key}
style={style}
>
<ArtistIndexItemConnector
key={artist.id}
component={ArtistIndexOverview}
sortKey={sortKey}
posterWidth={posterWidth}
posterHeight={posterHeight}
rowHeight={rowHeight}
overviewOptions={overviewOptions}
showRelativeDates={showRelativeDates}
shortDateFormat={shortDateFormat}
longDateFormat={longDateFormat}
timeFormat={timeFormat}
isSmallScreen={isSmallScreen}
artistId={artist.id}
qualityProfileId={artist.qualityProfileId}
metadataProfileId={artist.metadataProfileId}
/>
</div>
);
}
//
// Listeners
onMeasure = ({ width }) => {
this.calculateGrid(width, this.props.isSmallScreen);
}
//
// Render
render() {
const {
items,
isSmallScreen,
scroller
} = this.props;
const {
width,
rowHeight
} = this.state;
return (
<Measure
whitelist={['width']}
onMeasure={this.onMeasure}
>
<WindowScroller
scrollElement={isSmallScreen ? undefined : scroller}
>
{({ height, registerChild, onChildScroll, scrollTop }) => {
if (!height) {
return <div />;
}
return (
<div ref={registerChild}>
<Grid
ref={this.setGridRef}
className={styles.grid}
autoHeight={true}
height={height}
columnCount={1}
columnWidth={width}
rowCount={items.length}
rowHeight={rowHeight}
width={width}
onScroll={onChildScroll}
scrollTop={scrollTop}
overscanRowCount={2}
cellRenderer={this.cellRenderer}
onSectionRendered={this.onSectionRendered}
scrollToAlignment={'start'}
isScrollingOptOut={true}
/>
</div>
);
}
}
</WindowScroller>
</Measure>
);
}
}
ArtistIndexOverviews.propTypes = {
items: PropTypes.arrayOf(PropTypes.object).isRequired,
sortKey: PropTypes.string,
overviewOptions: PropTypes.object.isRequired,
scrollTop: PropTypes.number.isRequired,
jumpToCharacter: PropTypes.string,
scroller: PropTypes.instanceOf(Element).isRequired,
showRelativeDates: PropTypes.bool.isRequired,
shortDateFormat: PropTypes.string.isRequired,
longDateFormat: PropTypes.string.isRequired,
isSmallScreen: PropTypes.bool.isRequired,
timeFormat: PropTypes.string.isRequired
};
export default ArtistIndexOverviews;
|
packages/map-gl/src/overlays/GeoJSONLayer.expo.js
|
wq/wq.app
|
import React from 'react';
import PropTypes from 'prop-types';
import { Marker as RNMarker, Polyline as RNPolyline } from 'react-native-maps';
import { Colors } from 'react-native-paper';
import { useGeoJSON } from '@wq/map';
const COLOR_LIST = Object.values(Colors);
export default function GeoJSONLayer({ id, data }) {
data = useGeoJSON(data);
const features = (data && data.features) || [];
return (
<>
{features.map(feature => (
<Feature
key={feature.id}
feature={{
...feature,
layer: { source: id }
}}
/>
))}
</>
);
}
function makePoint([longitude, latitude]) {
return { latitude, longitude };
}
function makeLine(line) {
return line.map(makePoint);
}
function Feature({ feature }) {
if (feature.geometry.type === 'Point') {
return (
<RNMarker
pinColor={getColor(feature)}
coordinate={makePoint(feature.geometry.coordinates)}
/>
);
} else if (feature.geometry.type === 'MultiLineString') {
return (
<RNPolyline
strokeColor={getColor(feature)}
strokeWidth={8}
coordinates={makeLine(feature.geometry.coordinates[0])}
/>
);
} else if (feature.geometry.type === 'Polygon') {
return (
<RNPolyline
strokeColor={getColor(feature)}
fillColor={getColor(feature)}
strokeWidth={8}
coordinates={makeLine(feature.geometry.coordinates[0])}
/>
);
} else {
return null;
}
}
GeoJSONLayer.propTypes = {
id: PropTypes.string,
data: PropTypes.object
};
const colors = {};
function getColor(feature) {
const layerName = feature.layer.source;
if (!colors[layerName]) {
colors[layerName] =
COLOR_LIST[Math.round(COLOR_LIST.length * Math.random())];
}
return colors[layerName];
}
|
Redux-Weather/src/containers/searchBar.js
|
vivekbharatha/ModernReactWithReduxCourseUdemy
|
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';
import { fetchWeather } from './../actions/index';
class SearchBar extends Component {
constructor(props){
super(props);
this.state = { term: '' };
this.onInputChange = this.onInputChange.bind(this);
this.onSearchFormSubmit = this.onSearchFormSubmit.bind(this);
}
render() {
return (
<form className="input-group" onSubmit={this.onSearchFormSubmit}>
<input className="form-control"
placeholder="Grab 5 day forecast in any city"
value={this.state.term}
onChange={this.onInputChange}
/>
<span className="input-group-btn">
<button type="submit" className="btn btn-secondary">Submit</button>
</span>
</form>
);
}
onInputChange(event) {
this.setState({ term: event.target.value });
}
onSearchFormSubmit(event) {
event.preventDefault();
// Let's call OpenWeatherAPI here and nail it!
this.props.fetchWeather(this.state.term);
this.setState({ term: '' });
}
}
function mapDispatchToProps(dispatch) {
return bindActionCreators({ fetchWeather }, dispatch);
}
export default connect(null, mapDispatchToProps)(SearchBar);
|
app/javascript/mastodon/features/list_editor/components/search.js
|
codl/mastodon
|
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { defineMessages, injectIntl } from 'react-intl';
import { fetchListSuggestions, clearListSuggestions, changeListSuggestions } from '../../../actions/lists';
import classNames from 'classnames';
const messages = defineMessages({
search: { id: 'lists.search', defaultMessage: 'Search among people you follow' },
});
const mapStateToProps = state => ({
value: state.getIn(['listEditor', 'suggestions', 'value']),
});
const mapDispatchToProps = dispatch => ({
onSubmit: value => dispatch(fetchListSuggestions(value)),
onClear: () => dispatch(clearListSuggestions()),
onChange: value => dispatch(changeListSuggestions(value)),
});
@connect(mapStateToProps, mapDispatchToProps)
@injectIntl
export default class Search extends React.PureComponent {
static propTypes = {
intl: PropTypes.object.isRequired,
value: PropTypes.string.isRequired,
onChange: PropTypes.func.isRequired,
onSubmit: PropTypes.func.isRequired,
onClear: PropTypes.func.isRequired,
};
handleChange = e => {
this.props.onChange(e.target.value);
}
handleKeyUp = e => {
if (e.keyCode === 13) {
this.props.onSubmit(this.props.value);
}
}
handleClear = () => {
this.props.onClear();
}
render () {
const { value, intl } = this.props;
const hasValue = value.length > 0;
return (
<div className='list-editor__search search'>
<label>
<span style={{ display: 'none' }}>{intl.formatMessage(messages.search)}</span>
<input
className='search__input'
type='text'
value={value}
onChange={this.handleChange}
onKeyUp={this.handleKeyUp}
placeholder={intl.formatMessage(messages.search)}
/>
</label>
<div role='button' tabIndex='0' className='search__icon' onClick={this.handleClear}>
<i className={classNames('fa fa-search', { active: !hasValue })} />
<i aria-label={intl.formatMessage(messages.search)} className={classNames('fa fa-times-circle', { active: hasValue })} />
</div>
</div>
);
}
}
|
app/containers/Merchant/index.js
|
theterra/newsb
|
import React from 'react';
import { connect } from 'react-redux';
import AuthStyle from './AuthStyle';
import BackgrndStyle from './BackgrndStyle';
import AuthForm from '../../components/AuthForm';
import CurveStyle from './CurveStyle';
import LogoStyles from './LogoStyles';
import LoadingStyle from './LoadingStyle';
import { loginRequest } from '../AuthPage/actions';
import Logo from './logo.png';
import Loading from './loading.gif';
class MerchantPage extends React.Component { // eslint-disable-line react/prefer-stateless-function
render() {
const { formState, currentlySending, error } = this.props.data;
return (
<BackgrndStyle>
<CurveStyle>
{ !currentlySending ? <div className="ink-flex push-center">
<AuthStyle className="all-50">
<LogoStyles className="ink-flex push-center">
<img src={Logo} className="logo" alt="logo" />
</LogoStyles>
<AuthForm data={formState} onSubmit={this.props.login} stateError={error} userRole={'CUSTOMER'} />
</AuthStyle>
</div> : <LoadingStyle className="ink-flex push-center">
<img src={Loading} alt="loading" />
</LoadingStyle>}
</CurveStyle>
</BackgrndStyle>
);
}
}
function mapDispatchToProps(dispatch) {
return {
login: (username, password, userRole) => { dispatch(loginRequest({ username, password, userRole })); }
};
}
function mapStateToProps(state) {
const data = state.get('auth');
return {
data,
};
}
export default connect(mapStateToProps, mapDispatchToProps)(MerchantPage);
|
examples/src/components/Contributors.js
|
MattMcFarland/react-select
|
import React from 'react';
import Select from 'react-select';
const CONTRIBUTORS = require('../data/contributors');
const MAX_CONTRIBUTORS = 6;
const ASYNC_DELAY = 500;
const Contributors = React.createClass({
displayName: 'Contributors',
propTypes: {
label: React.PropTypes.string,
},
getInitialState () {
return {
multi: true,
value: [CONTRIBUTORS[0]],
};
},
onChange (value) {
this.setState({
value: value,
});
},
switchToMulti () {
this.setState({
multi: true,
value: [this.state.value],
});
},
switchToSingle () {
this.setState({
multi: false,
value: this.state.value[0],
});
},
getContributors (input, callback) {
input = input.toLowerCase();
var options = CONTRIBUTORS.filter(i => {
return i.github.substr(0, input.length) === input;
});
var data = {
options: options.slice(0, MAX_CONTRIBUTORS),
complete: options.length <= MAX_CONTRIBUTORS,
};
setTimeout(function() {
callback(null, data);
}, ASYNC_DELAY);
},
gotoContributor (value, event) {
window.open('https://github.com/' + value.github);
},
render () {
return (
<div className="section">
<h3 className="section-heading">{this.props.label}</h3>
<Select.Async multi={this.state.multi} value={this.state.value} onChange={this.onChange} onValueClick={this.gotoContributor} valueKey="github" labelKey="name" loadOptions={this.getContributors} />
<div className="checkbox-list">
<label className="checkbox">
<input type="radio" className="checkbox-control" checked={this.state.multi} onChange={this.switchToMulti}/>
<span className="checkbox-label">Multiselect</span>
</label>
<label className="checkbox">
<input type="radio" className="checkbox-control" checked={!this.state.multi} onChange={this.switchToSingle}/>
<span className="checkbox-label">Single Value</span>
</label>
</div>
<div className="hint">This example implements custom label and value properties, async options and opens the github profiles in a new window when values are clicked</div>
</div>
);
}
});
module.exports = Contributors;
|
src/components/GameWrapper/GameWrapper.js
|
rainbowland302/hangman
|
import React from 'react';
import { Row, Col } from 'react-flexbox-grid';
import './GameWrapper.scss';
import WordChipContainer from '../../containers/WordChipContainer';
export const GameWrapper = (props) => {
return (
<div id="gameContainer" className="game-wrapper">
<div className="row">
{
Array(props.totalWordCount)
.fill(true)
.map((m, index) => <WordChipContainer key={index} targetId={index} />)
}
</div>
</div>
);
};
GameWrapper.propTypes = {
totalWordCount: React.PropTypes.number.isRequired
};
export default GameWrapper;
|
packages/wix-style-react/src/EditableSelector/EditableRow/EditableRow.spec.js
|
wix/wix-style-react
|
import React from 'react';
import editableRowDriverFactory from './EditableRow.driver';
import {
createRendererWithDriver,
createRendererWithUniDriver,
cleanup,
} from '../../../test/utils/react';
import EditableRow from './EditableRow';
import { editableRowUniDriverFactory } from './EditableRow.uni.driver';
describe('EditableRow', () => {
describe('[sync]', () => {
runTests(createRendererWithDriver(editableRowDriverFactory));
});
describe('[async]', () => {
runTests(createRendererWithUniDriver(editableRowUniDriverFactory));
});
function runTests(render) {
afterEach(() => cleanup());
it('should focus on input when mounted', async () => {
const { driver } = render(<EditableRow />);
expect(await driver.isInputFocused()).toEqual(true);
});
it('should toggle accept button disabled state according to input presence', async () => {
const { driver } = render(<EditableRow />);
expect(await driver.isApproveDisabled()).toBe(true);
await driver.setText('new option');
expect(await driver.isApproveDisabled()).toBe(false);
});
it('should set input text from props', async () => {
const text = 'new option';
const { driver } = render(<EditableRow newOption={text} />);
expect(await driver.getText()).toEqual(text);
});
it('should trigger onApprove callback when approve button is clicked', async () => {
const onApprove = jest.fn();
const { driver } = render(<EditableRow onApprove={onApprove} />);
const text = 'new option';
await driver.setText(text);
await driver.clickApprove();
expect(onApprove).toHaveBeenCalled();
expect(onApprove.mock.calls[0][0]).toBe(text);
});
it('should trigger onApprove callback when enter key is pressed', async () => {
const onApprove = jest.fn();
const { driver } = render(<EditableRow onApprove={onApprove} />);
const text = 'new option';
await driver.setText(text);
await driver.keyDown(13); // enter
expect(onApprove).toHaveBeenCalled();
expect(onApprove.mock.calls[0][0]).toBe(text);
});
it('should trigger onCancel callback when cancel button is clicked', async () => {
const onCancel = jest.fn();
const { driver } = render(<EditableRow onCancel={onCancel} />);
await driver.clickCancel();
expect(onCancel).toHaveBeenCalled();
});
it('should trigger onCancel callback when escape key is pressed', async () => {
const onCancel = jest.fn();
const { driver } = render(<EditableRow onCancel={onCancel} />);
await driver.keyDown(27); // esc
expect(onCancel).toHaveBeenCalled();
});
}
});
|
src/index.js
|
alpjs/alp-react-redux
|
import React from 'react';
import { renderToString } from 'react-dom/server';
import Helmet from 'react-helmet';
import reactTreeWalker from 'react-tree-walker';
import Logger from 'nightingale-logger/src';
import createIsModernBrowser from 'modern-browsers';
import htmlLayout from './layout/htmlLayout';
import createAlpAppWrapper from './createAlpAppWrapper';
import createServerStore from './store/createServerStore';
import createModuleVisitor from './module/createModuleVisitor';
import type { ReduxActionType } from './types';
export { Helmet };
export { combineReducers } from 'redux/src';
export { connect } from 'react-redux/src';
export * from './types';
export {
createAction,
createReducer,
createLoader,
classNames,
createPureStatelessComponent,
identityReducer,
} from './utils/index';
export AlpModule from './module/AlpModule';
export AlpReduxModule from './module/AlpReduxModuleServer';
export Body from './layout/Body';
export AppContainer from './layout/AppContainer';
const logger = new Logger('alp:react-redux');
const renderHtml = (app, options) => {
const content = renderToString(app);
const helmet = Helmet.renderStatic();
return htmlLayout(helmet, content, options);
};
const isModernBrowser = createIsModernBrowser();
type OptionsType = {|
polyfillFeatures?: ?string,
scriptName?: ?string | false,
sharedReducers?: ?{ [string]: any },
styleName?: ?string | false,
|};
export default () => app => {
app.reduxReducers = {};
app.reduxMiddlewares = [];
return {
middleware: (ctx, next) => {
ctx.reduxInitialContext = {};
return next();
},
createApp: (App, options: ?OptionsType = {}) => async ctx => {
const version: string = ctx.config.get('version');
// TODO create alp-useragent with getter in context
const ua = ctx.req.headers['user-agent'];
const name = isModernBrowser(ua) ? 'modern-browsers' : 'es5';
const app = React.createElement(App);
const moduleVisitor = createModuleVisitor();
const preRenderStore = { getState: () => ({ ctx }) };
const PreRenderWrappedApp = createAlpAppWrapper(app, { context: ctx, store: preRenderStore });
await reactTreeWalker(React.createElement(PreRenderWrappedApp), moduleVisitor.visitor);
const store = createServerStore(ctx, moduleVisitor.getReducers(), {
sharedReducers: options.sharedReducers,
});
const WrappedApp = createAlpAppWrapper(app, { context: ctx, store });
// eslint-disable-next-line no-unused-vars
const { ctx: removeCtxFromInitialData, ...initialData } = store.getState();
ctx.body = await renderHtml(React.createElement(WrappedApp), {
version,
scriptName: options.scriptName !== undefined ? options.scriptName : name,
styleName: options.styleName !== undefined ? options.styleName : name,
polyfillFeatures: options.polyfillFeatures,
initialData,
});
},
};
};
const loggerWebsocket = logger.child('websocket');
export function emitAction(to: string, action: ReduxActionType) {
loggerWebsocket.debug('emitAction', action);
to.emit('redux:action', action);
}
|
client/routes.js
|
pandaben7890/react-panda-style-level-1
|
import React from 'react'
import { Router, Route, IndexRoute, browserHistory } from 'react-router'
import { App, Home, About } from './components'
export default () => {
return (
<Router history={browserHistory}>
<Route path='/' component={App}>
<IndexRoute component={Home} />
<Route path='about' component={About} />
</Route>
</Router>
)
}
|
src/actions/search.js
|
ello/webapp
|
import React from 'react'
import * as ACTION_TYPES from '../constants/action_types'
import * as MAPPING_TYPES from '../constants/mapping_types'
import * as api from '../networking/api'
import * as StreamRenderables from '../components/streams/StreamRenderables'
import { ZeroState } from '../components/zeros/Zeros'
export function searchForPosts(terms) {
return {
type: ACTION_TYPES.LOAD_STREAM,
payload: {
endpoint: api.searchPosts({
per_page: api.PER_PAGE,
terms: encodeURIComponent(terms),
}),
},
meta: {
mappingType: MAPPING_TYPES.POSTS,
renderStream: {
asGrid: StreamRenderables.postsAsGrid,
asList: StreamRenderables.postsAsList,
asZero: <ZeroState />,
},
resultKey: '/search/posts',
},
}
}
export function searchForUsers(terms) {
return {
type: ACTION_TYPES.LOAD_STREAM,
payload: {
endpoint: api.searchUsers({
per_page: api.PER_PAGE,
terms: encodeURIComponent(terms),
}),
},
meta: {
mappingType: MAPPING_TYPES.USERS,
renderStream: {
asGrid: StreamRenderables.usersAsGrid,
asList: StreamRenderables.usersAsGrid,
asZero: <ZeroState />,
},
resultKey: '/search/users',
},
}
}
|
actor-apps/app-web/src/app/components/activity/UserProfile.react.js
|
mxw0417/actor-platform
|
import React from 'react';
import { PureRenderMixin } from 'react/addons';
import ContactActionCreators from 'actions/ContactActionCreators';
import DialogActionCreators from 'actions/DialogActionCreators';
import PeerStore from 'stores/PeerStore';
import DialogStore from 'stores/DialogStore';
import AvatarItem from 'components/common/AvatarItem.react';
import UserProfileContactInfo from 'components/activity/UserProfileContactInfo.react';
const getStateFromStores = (userId) => {
const thisPeer = PeerStore.getUserPeer(userId);
return {
thisPeer: thisPeer,
isNotificationsEnabled: DialogStore.isNotificationsEnabled(thisPeer)
};
};
var UserProfile = React.createClass({
propTypes: {
user: React.PropTypes.object.isRequired
},
mixins: [PureRenderMixin],
getInitialState() {
return getStateFromStores(this.props.user.id);
},
componentWillMount() {
DialogStore.addNotificationsListener(this.whenNotificationChanged);
},
componentWillUnmount() {
DialogStore.removeNotificationsListener(this.whenNotificationChanged);
},
componentWillReceiveProps(newProps) {
this.setState(getStateFromStores(newProps.user.id));
},
addToContacts() {
ContactActionCreators.addContact(this.props.user.id);
},
removeFromContacts() {
ContactActionCreators.removeContact(this.props.user.id);
},
onNotificationChange(event) {
DialogActionCreators.changeNotificationsEnabled(this.state.thisPeer, event.target.checked);
},
whenNotificationChanged() {
this.setState(getStateFromStores(this.props.user.id));
},
render() {
const user = this.props.user;
const isNotificationsEnabled = this.state.isNotificationsEnabled;
let addToContacts;
if (user.isContact === false) {
addToContacts = <a className="link__blue" onClick={this.addToContacts}>Add to contacts</a>;
} else {
addToContacts = <a className="link__red" onClick={this.removeFromContacts}>Remove from contacts</a>;
}
return (
<div className="activity__body profile">
<div className="profile__name">
<AvatarItem image={user.bigAvatar}
placeholder={user.placeholder}
size="medium"
title={user.name}/>
<h3>{user.name}</h3>
</div>
<div className="notifications">
<label htmlFor="notifications">Enable Notifications</label>
<div className="switch pull-right">
<input checked={isNotificationsEnabled} id="notifications" onChange={this.onNotificationChange} type="checkbox"/>
<label htmlFor="notifications"></label>
</div>
</div>
<UserProfileContactInfo phones={user.phones}/>
<ul className="profile__list profile__list--usercontrols">
<li className="profile__list__item">
{addToContacts}
</li>
</ul>
</div>
);
}
});
export default UserProfile;
|
src/index.js
|
sPyOpenSource/personal-website
|
import React from 'react';
import ReactDOM from 'react-dom';
import { Router, Route, IndexRoute, hashHistory } from 'react-router';
import './index.css';
import Layout from './Layout';
import Home from './view/Home';
import About from './view/About';
import Media from './view/Media';
import Projects from './view/Projects';
import Game from './view/Game';
ReactDOM.render(
<Router history={hashHistory}>
<Route path="/" component={Layout}>
<IndexRoute component={Home}></IndexRoute>
<Route path="home" component={Home}></Route>
<Route path="about" component={About}></Route>
<Route path="media" component={Media}></Route>
<Route path="projects" component={Projects}></Route>
<Route path="game" component={Game}></Route>
</Route>
</Router>,
document.getElementById('root')
);
|
frontend/src/client/index.js
|
tsurupin/portfolio
|
import 'shared/styles/vendors';
import 'shared/styles/globals';
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { applyRouterMiddleware, Router, browserHistory } from 'react-router';
import useScroll from 'react-router-scroll';
import { createStore, applyMiddleware } from 'redux';
import routes from './routes';
import reducers from './reducers';
import injectTapEventPlugin from 'react-tap-event-plugin';
import thunk from 'redux-thunk';
const store = createStore(reducers, applyMiddleware(thunk));
injectTapEventPlugin();
ReactDOM.render(
<Provider store={store}>
<Router
history={browserHistory}
routes={routes}
render={applyRouterMiddleware(useScroll())}
/>
</Provider>
, document.querySelector('.container'));
|
docs/app/Examples/modules/Sidebar/SlideOut/index.js
|
Rohanhacker/Semantic-UI-React
|
import React from 'react'
import ComponentExample from 'docs/app/Components/ComponentDoc/ComponentExample'
import ExampleSection from 'docs/app/Components/ComponentDoc/ExampleSection'
const SidebarVariationsExamples = () => (
<ExampleSection title='Slide Out'>
<ComponentExample
title='Left Slide Out'
description='Sidebar attached to the left of the pushable container sliding out from the pusher.'
examplePath='modules/Sidebar/SlideOut/SidebarExampleLeftSlideOut'
/>
<ComponentExample
title='Right Slide Out'
description='Sidebar attached to the right of the pushable container sliding out from the pusher.'
examplePath='modules/Sidebar/SlideOut/SidebarExampleRightSlideOut'
/>
</ExampleSection>
)
export default SidebarVariationsExamples
|
src/app/modules/HeaderBar/components/HeaderBar.js
|
toxzilla/app
|
import React from 'react';
import {connect} from 'cerebral-view-react';
import {classNames} from 'react-dom-stylesheet';
import {User} from './../../../common/User';
import {Badge, Button, ButtonGroup, Icon, Popover, PopoverControl, Text} from './../../../common/UserInterface';
import profile from './../../../store/computed/profile';
import {Profile} from './../../Profile';
import isCropAvatarDialogOpen from './../../Dialog/computed/isCropAvatarDialogOpen';
import {Notifications} from './../../Notifications';
import unreadNotifications from './../../Notifications/computed/unreadNotifications';
import {NetworkMonitor, Proxies} from './../../Network';
import isDHTOffline from './../../Network/computed/isDHTOffline';
export default connect({
isLoggingOut: 'store.app.isLoggingOut',
isUpdatingProxies: 'store.app.isUpdatingProxies',
isDHTConnecting: 'store.app.isDHTConnecting',
connectionStatus: 'store.session.network.connectionStatus',
profile: profile(),
isCropAvatarDialogOpen: isCropAvatarDialogOpen(),
isDHTOffline: isDHTOffline(),
unreadNotifications: unreadNotifications()
}, class HeaderBar extends React.Component {
static displayName = 'HeaderBar'
static propTypes = {
signals: React.PropTypes.object.isRequired,
isLoggingOut: React.PropTypes.bool.isRequired,
isUpdatingProxies: React.PropTypes.bool.isRequired,
isDHTConnecting: React.PropTypes.bool.isRequired,
connectionStatus: React.PropTypes.number.isRequired,
profile: React.PropTypes.object.isRequired,
isCropAvatarDialogOpen: React.PropTypes.bool.isRequired,
isDHTOffline: React.PropTypes.bool.isRequired,
unreadNotifications: React.PropTypes.array.isRequired
}
state = {
isProfileOpen: false
}
render () {
const {
isLoggingOut,
isUpdatingProxies,
isDHTConnecting,
connectionStatus,
profile,
isCropAvatarDialogOpen,
isDHTOffline,
unreadNotifications
} = this.props;
const {isProfileOpen} = this.state;
const totalUnreadNotifications = unreadNotifications.length;
const hasUnreadNotifications = totalUnreadNotifications > 0;
const notificationsPopoverClasses = classNames('notifications-popover', {
unread: hasUnreadNotifications
});
const notificationsLabel = Object.assign({}, {
id: totalUnreadNotifications > 0 ? 'showUnreadNotifications' : 'showNotifications'
}, hasUnreadNotifications ? {args: {count: totalUnreadNotifications}} : null);
return (
<div className='header-bar'
role='banner'>
<Popover open={isProfileOpen}
className='profile-popover'
position='left'
skippable={!isCropAvatarDialogOpen}
onOpen={this._handleOpenProfile}
onClose={this._handleCloseProfile}>
<PopoverControl label={{id: 'showProfile', args: {nickname: profile.nickname ? profile.nickname : profile.address}}}
tabIndex={0}>
<User model={profile}
connectionStatus={connectionStatus}
showStatus={true}
showNickname={false}
showMessage={false}/>
</PopoverControl>
<Profile/>
<div className='navigation'>
<ButtonGroup>
<Button title={{id: 'logout'}}
disabled={isLoggingOut}
onMouseUp={this._handleLogout}
onKeyboardEnter={this._handleLogout}
onKeyboardPress={this._handleLogout}>
<Text l10n={{id: 'logout'}}/>
</Button>
<Button title={{id: 'settings'}}
onMouseUp={this._handleSettings}
onKeyboardEnter={this._handleSettings}
onKeyboardPress={this._handleSettings}>
<Text l10n={{id: 'settings'}}/>
</Button>
</ButtonGroup>
</div>
</Popover>
<Popover className={notificationsPopoverClasses}
onBeforeOpen={this._handleOnBeforeOpenNotifications}
onClose={this._handleCloseNotifications}>
<PopoverControl label={notificationsLabel}
tabIndex={0}>
<Icon iconName={hasUnreadNotifications ? 'notification' : 'notification_none'}/>
<Badge count={totalUnreadNotifications}/>
</PopoverControl>
<Notifications ref='notifications'
visible={true}/>
</Popover>
<Popover className='network'>
<PopoverControl label={{id: 'showNetworkMonitor', args: {status: connectionStatus }}}
tabIndex={0}>
<Icon
iconName={isDHTConnecting ? 'network_connecting' : isDHTOffline ? 'network_offline' : 'network_online'}/>
</PopoverControl>
<NetworkMonitor/>
<Proxies/>
<div className='navigation'>
<ButtonGroup>
<Button title={{id: 'addProxy'}}
disabled={isUpdatingProxies}
onMouseUp={this._handleAddProxy}
onKeyboardEnter={this._handleAddProxy}
onKeyboardPress={this._handleAddProxy}>
<Text l10n={{id: 'addProxy'}}/>
</Button>
</ButtonGroup>
</div>
</Popover>
</div>
);
}
_handleOpenProfile = () => {
this.setState({
isProfileOpen: true
});
}
_handleCloseProfile = () => {
this.setState({
isProfileOpen: false
});
this.props.signals.profile.resetProfile();
}
_handleLogout = () => {
this.setState({
isProfileOpen: false
});
this.props.signals.authenticate.logoutAccount();
}
_handleSettings = () => {
this.setState({
isProfileOpen: false
});
this.props.signals.store.changeRoute({
route: 'settings'
});
}
_handleAddProxy = () => {
this.props.signals.network.addProxy();
}
_handleOnBeforeOpenNotifications = () => {
if (this.refs.notifications.refs.scrollBar) {
this.refs.notifications.refs.scrollBar.reset();
this.refs.notifications.refs.scrollBar.resize();
}
}
_handleCloseNotifications = () => {
this.props.signals.notifications.unreadAllNotifications();
}
});
|
app/main.js
|
firewenda/testwebsite
|
import React from 'react';
import Router from 'react-router';
import ReactDOM from 'react-dom';
import createBrowserHistory from 'history/lib/createBrowserHistory';
import routes from './routes';
import Navbar from './components/Navbar';
let history = createBrowserHistory();
ReactDOM.render(<Router history={history}>{routes}</Router>, document.getElementById('app'));
|
src/RadioButton/RadioButtonGroup.js
|
rscnt/material-ui
|
import React from 'react';
import RadioButton from '../RadioButton';
import warning from 'warning';
class RadioButtonGroup extends React.Component {
static propTypes = {
/**
* Should be used to pass `RadioButton` components.
*/
children: React.PropTypes.node,
/**
* The CSS class name of the root element.
*/
className: React.PropTypes.string,
/**
* The `value` property (case-sensitive) of the radio button that will be
* selected by default. This takes precedence over the `checked` property
* of the `RadioButton` elements.
*/
defaultSelected: React.PropTypes.string,
/**
* Where the label will be placed for all child radio buttons.
* This takes precedence over the `labelPosition` property of the
* `RadioButton` elements.
*/
labelPosition: React.PropTypes.oneOf(['left', 'right']),
/**
* The name that will be applied to all child radio buttons.
*/
name: React.PropTypes.string.isRequired,
/**
* Callback function that is fired when a radio button has
* been checked.
*
* @param {object} event `change` event targeting the selected
* radio button.
* @param {string} value The `value` of the selected radio button.
*/
onChange: React.PropTypes.func,
/**
* Override the inline-styles of the root element.
*/
style: React.PropTypes.object,
/**
* The `value` of the currently selected radio button.
*/
valueSelected: React.PropTypes.string,
};
static defaultProps = {
style: {},
};
static contextTypes = {
muiTheme: React.PropTypes.object.isRequired,
};
state = {
numberCheckedRadioButtons: 0,
selected: this.props.valueSelected || this.props.defaultSelected || '',
};
componentWillMount() {
let cnt = 0;
React.Children.forEach(this.props.children, (option) => {
if (this.hasCheckAttribute(option)) cnt++;
}, this);
this.setState({numberCheckedRadioButtons: cnt});
}
componentWillReceiveProps(nextProps) {
if (nextProps.hasOwnProperty('valueSelected')) {
this.setState({
selected: nextProps.valueSelected,
});
}
}
hasCheckAttribute(radioButton) {
return radioButton.props.hasOwnProperty('checked') &&
radioButton.props.checked;
}
updateRadioButtons(newSelection) {
if (this.state.numberCheckedRadioButtons === 0) {
this.setState({selected: newSelection});
} else {
warning(false, `Cannot select a different radio button while another radio button
has the 'checked' property set to true.`);
}
}
handleChange = (event, newSelection) => {
this.updateRadioButtons(newSelection);
// Successful update
if (this.state.numberCheckedRadioButtons === 0) {
if (this.props.onChange) this.props.onChange(event, newSelection);
}
};
getSelectedValue() {
return this.state.selected;
}
setSelectedValue(newSelectionValue) {
this.updateRadioButtons(newSelectionValue);
}
clearValue() {
this.setSelectedValue('');
}
render() {
const {prepareStyles} = this.context.muiTheme;
const options = React.Children.map(this.props.children, (option) => {
const {
name, // eslint-disable-line no-unused-vars
value, // eslint-disable-line no-unused-vars
label, // eslint-disable-line no-unused-vars
onCheck, // eslint-disable-line no-unused-vars
...other,
} = option.props;
return (
<RadioButton
{...other}
ref={option.props.value}
name={this.props.name}
key={option.props.value}
value={option.props.value}
label={option.props.label}
labelPosition={this.props.labelPosition}
onCheck={this.handleChange}
checked={option.props.value === this.state.selected}
/>
);
}, this);
return (
<div
style={prepareStyles(Object.assign({}, this.props.style))}
className={this.props.className}
>
{options}
</div>
);
}
}
export default RadioButtonGroup;
|
components/GroupRow.js
|
Jack3113/edtBordeaux
|
import React from 'react';
import { Text, TouchableHighlight, View } from 'react-native';
import PropTypes from 'prop-types';
import style from '../Style';
export default class GroupRow extends React.PureComponent {
static propTypes = {
cleanName: PropTypes.string.isRequired,
color: PropTypes.string,
fontColor: PropTypes.string,
name: PropTypes.string.isRequired,
sectionStyle: PropTypes.object,
};
constructor(props) {
super(props);
this._onPress = this._onPress.bind(this);
}
_onPress(e) {
requestAnimationFrame(() => {
this.props.openGroup(this.props.name);
});
}
render() {
return (
<TouchableHighlight onPress={this._onPress} underlayColor={style.hintColors.gray}>
<View style={[style.list.view, this.props.sectionStyle, { backgroundColor: this.props.color }]}>
<Text style={{ color: this.props.fontColor }}>{this.props.cleanName}</Text>
</View>
</TouchableHighlight>
);
}
}
|
src/components/search-mapping-view/index.js
|
datea/datea-webapp-react
|
import './search-mapping-view.scss';
import React from 'react';
import {observer, inject} from 'mobx-react';
import InfiniteScroll from 'react-infinite-scroller';
import InfiniteLoaderIcon from '../infinite-loader-icon';
import Button from '@material-ui/core/Button';
import MappingColumnLayout from '../mapping-card-grid';
import DIcon from '../../icons';
import {Tr} from '../../i18n';
@inject('store')
@observer
export default class SearchMappingView extends React.Component {
constructor(props, context) {
super(props, context);
}
render() {
const {mappings, numResults, limit, loadMore} = this.props.store.searchMappingView;
return (
<div className="search-page-container mapping-column-container">
<h1><Tr id="SEARCHBOX.GLOBAL_PH" /></h1>
{!this.props.store.ui.loading &&
(numResults > 0
? <div className="num-results">
{numResults} <Tr id="CAMPAIGNS.RESULTS" />
</div>
: <div className="no-results">
<DIcon name="daterito2" />
<div className="txt">
<Tr id="SEARCH_PAGE.NO_RESULTS" />. <Tr id="ERROR.RETRY" />
</div>
</div>
)
}
{!!mappings.length &&
<div className="mappings">
<div className="mapping-group">
<InfiniteScroll
pageStart={0}
loadMore={loadMore}
hasMore={numResults > limit}
loader={<InfiniteLoaderIcon key={0} />}>
<MappingColumnLayout mappings={mappings} />
</InfiniteScroll>
</div>
</div>
}
</div>
)
}
}
|
assets/jqwidgets/demos/react/app/treegrid/xmldata/app.js
|
juannelisalde/holter
|
import React from 'react';
import ReactDOM from 'react-dom';
import JqxTreeGrid from '../../../jqwidgets-react/react_jqxtreegrid.js';
class App extends React.Component {
componentDidMount() {
this.refs.myTreeGrid.on('bindingComplete', () => {
this.refs.myTreeGrid.expandRow(2);
});
}
render() {
let source =
{
dataType: "xml",
dataFields: [
{ name: 'EmployeeID', type: 'number' },
{ name: 'ReportsTo', type: 'number' },
{ name: 'FirstName', type: 'string' },
{ name: 'LastName', type: 'string' },
{ name: 'City', type: 'string' },
{ name: 'Address', type: 'string' },
{ name: 'Title', type: 'string' },
{ name: 'HireDate', type: 'date' },
{ name: 'BirthDate', type: 'date' }
],
hierarchy:
{
keyDataField: { name: 'EmployeeID' },
parentDataField: { name: 'ReportsTo' }
},
id: 'EmployeeID',
root: 'Employees',
record: 'Employee',
url: '../sampledata/employees.xml'
};
let dataAdapter = new $.jqx.dataAdapter(source);
let columns = [
{ text: 'FirstName', dataField: 'FirstName', minWidth: 100, width: 200 },
{ text: 'LastName', dataField: 'LastName', width: 200 },
{ text: 'Title', dataField: 'Title', width: 300 },
{ text: 'Address', dataField: 'Address', width: 200 },
{ text: 'City', dataField: 'City', width: 150 },
{ text: 'Birth Date', dataField: 'BirthDate', cellsFormat: 'd', width: 120 },
{ text: 'Hire Date', dataField: 'HireDate', cellsFormat: 'd', width: 120 }
];
return (
<JqxTreeGrid ref='myTreeGrid'
width={850}
source={dataAdapter}
pageable={true}
columnsResize={true}
columns={columns}
/>
)
}
}
ReactDOM.render(<App />, document.getElementById('app'));
|
src/components/App.js
|
phuchle/recipeas
|
import React from 'react';
import Navigation from './Nav';
import Main from './Main';
import 'bootstrap/dist/css/bootstrap.css';
import '../App.css';
const App = (props) => {
return (
<div className="App">
<Navigation />
<Main />
</div>
);
};
export default App;
|
test/integration/AppBar/AppBar.spec.js
|
verdan/material-ui
|
/* eslint-env mocha */
import React from 'react';
import {mount} from 'enzyme';
import {assert} from 'chai';
import AppBar from 'src/AppBar';
import IconButton from 'src/IconButton';
import FontIcon from 'src/FontIcon';
import getMuiTheme from 'src/styles/getMuiTheme';
describe('<AppBar />', () => {
const muiTheme = getMuiTheme();
const mountWithContext = (node) => mount(node, {context: {muiTheme}});
it('renders a FontIcon inside the iconElementLeft with custom color', () => {
const wrapper = mountWithContext(
<AppBar
iconElementLeft={
<IconButton>
<FontIcon className="material-icons" color="red">home</FontIcon>
</IconButton>
}
/>
);
assert.strictEqual(wrapper.find(FontIcon).node.props.color, 'red', 'FontIcon should have color set to red');
assert.strictEqual(
wrapper.find(FontIcon).node.props.style.color,
undefined,
'FontIcon`s style object should not contain the color property'
);
});
it('renders a FontIcon inside the iconElementRight with custom color', () => {
const wrapper = mountWithContext(
<AppBar
iconElementRight={
<IconButton>
<FontIcon className="material-icons" color="red">home</FontIcon>
</IconButton>
}
/>
);
assert.strictEqual(wrapper.find(FontIcon).node.props.color, 'red', 'FontIcon should have color set to red');
assert.strictEqual(
wrapper.find(FontIcon).node.props.style.color,
undefined,
'FontIcon`s style object should not contain the color property'
);
});
});
|
client/src/javascript/components/modals/settings-modal/ConnectivityTab.js
|
stephdewit/flood
|
import {Checkbox, Form, FormRow, Textbox} from 'flood-ui-kit';
import {FormattedMessage} from 'react-intl';
import React from 'react';
import ModalFormSectionHeader from '../ModalFormSectionHeader';
import SettingsTab from './SettingsTab';
export default class ConnectivityTab extends SettingsTab {
state = {};
getDHTEnabledValue() {
if (this.state.dhtEnabled != null) {
return this.state.dhtEnabled;
}
return this.props.settings.dhtStats.dht === 'auto';
}
handleFormChange = ({event}) => {
if (event.target.name === 'dhtEnabled') {
const dhtEnabled = !this.getDHTEnabledValue();
const dhtEnabledString = dhtEnabled ? 'auto' : 'disable';
this.setState({dhtEnabled});
this.props.onCustomSettingsChange({
id: 'dht',
data: [dhtEnabledString],
overrideID: 'dhtStats',
overrideData: {dht: dhtEnabledString},
});
} else {
this.handleClientSettingFieldChange(event.target.name, event);
}
};
render() {
return (
<Form onChange={this.handleFormChange}>
<ModalFormSectionHeader>
<FormattedMessage defaultMessage="Incoming Connections" id="settings.connectivity.incoming.heading" />
</ModalFormSectionHeader>
<FormRow>
<Textbox
defaultValue={this.getFieldValue('networkPortRange')}
id="networkPortRange"
label={
<FormattedMessage id="settings.connectivity.port.range.label" defaultMessage="Listening Port Range" />
}
width="one-quarter"
/>
<Checkbox
checked={this.getFieldValue('networkPortRandom') === '1'}
grow={false}
id="networkPortRandom"
labelOffset
matchTextboxHeight>
<FormattedMessage id="settings.connectivity.port.randomize.label" defaultMessage="Randomize Port" />
</Checkbox>
<Checkbox
checked={this.getFieldValue('networkPortOpen') === '1'}
grow={false}
id="networkPortOpen"
labelOffset
matchTextboxHeight>
<FormattedMessage id="settings.connectivity.port.open.label" defaultMessage="Open Port" />
</Checkbox>
</FormRow>
<FormRow>
<Textbox
defaultValue={this.getFieldValue('networkLocalAddress')}
id="networkLocalAddress"
label={
<FormattedMessage id="settings.connectivity.ip.hostname.label" defaultMessage="Reported IP/Hostname" />
}
/>
<Textbox
defaultValue={this.getFieldValue('networkHttpMaxOpen')}
id="networkHttpMaxOpen"
label={
<FormattedMessage
id="settings.connectivity.max.http.connections"
defaultMessage="Maximum HTTP Connections"
/>
}
/>
</FormRow>
<ModalFormSectionHeader>
<FormattedMessage id="settings.connectivity.dpd.heading" defaultMessage="Decentralized Peer Discovery" />
</ModalFormSectionHeader>
<FormRow>
<Textbox
defaultValue={this.getFieldValue('dhtPort')}
id="dhtPort"
label={<FormattedMessage id="settings.connectivity.dht.port.label" defaultMessage="DHT Port" />}
width="one-quarter"
/>
<Checkbox checked={this.getDHTEnabledValue()} grow={false} id="dhtEnabled" labelOffset matchTextboxHeight>
<FormattedMessage id="settings.connectivity.dht.label" defaultMessage="Enable DHT" />
</Checkbox>
<Checkbox
checked={this.getFieldValue('protocolPex') === '1'}
grow={false}
id="protocolPex"
labelOffset
matchTextboxHeight>
<FormattedMessage id="settings.connectivity.peer.exchange.label" defaultMessage="Enable Peer Exchange" />
</Checkbox>
</FormRow>
<ModalFormSectionHeader>
<FormattedMessage id="settings.connectivity.peers.heading" defaultMessage="Peers" />
</ModalFormSectionHeader>
<FormRow>
<Textbox
defaultValue={this.getFieldValue('throttleMinPeersNormal')}
id="throttleMinPeersNormal"
label={<FormattedMessage id="settings.connectivity.peers.min.label" defaultMessage="Minimum Peers" />}
/>
<Textbox
defaultValue={this.getFieldValue('throttleMaxPeersNormal')}
id="throttleMaxPeersNormal"
label={<FormattedMessage id="settings.connectivity.peers.max.label" defaultMessage="Maxmimum Peers" />}
/>
</FormRow>
<FormRow>
<Textbox
defaultValue={this.getFieldValue('throttleMinPeersSeed')}
id="throttleMinPeersSeed"
label={
<FormattedMessage
id="settings.connectivity.peers.seeding.min.label"
defaultMessage="Minimum Peers Seeding"
/>
}
/>
<Textbox
defaultValue={this.getFieldValue('throttleMaxPeersSeed')}
id="throttleMaxPeersSeed"
label={
<FormattedMessage
id="settings.connectivity.peers.seeding.max.label"
defaultMessage="Maxmimum Peers Seeding"
/>
}
/>
</FormRow>
<FormRow>
<Textbox
defaultValue={this.getFieldValue('trackersNumWant')}
id="trackersNumWant"
label={<FormattedMessage id="settings.connectivity.peers.desired.label" defaultMessage="Peers Desired" />}
width="one-half"
/>
</FormRow>
</Form>
);
}
}
|
ajax/libs/react-select/1.0.0/react-select.es.js
|
holtkamp/cdnjs
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { findDOMNode } from 'react-dom';
import AutosizeInput from 'react-input-autosize';
import classNames from 'classnames';
function arrowRenderer(_ref) {
var onMouseDown = _ref.onMouseDown;
return React.createElement('span', {
className: 'Select-arrow',
onMouseDown: onMouseDown
});
}
arrowRenderer.propTypes = {
onMouseDown: PropTypes.func
};
var map = [{ 'base': 'A', 'letters': /[\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F]/g }, { 'base': 'AA', 'letters': /[\uA732]/g }, { 'base': 'AE', 'letters': /[\u00C6\u01FC\u01E2]/g }, { 'base': 'AO', 'letters': /[\uA734]/g }, { 'base': 'AU', 'letters': /[\uA736]/g }, { 'base': 'AV', 'letters': /[\uA738\uA73A]/g }, { 'base': 'AY', 'letters': /[\uA73C]/g }, { 'base': 'B', 'letters': /[\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181]/g }, { 'base': 'C', 'letters': /[\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E]/g }, { 'base': 'D', 'letters': /[\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779]/g }, { 'base': 'DZ', 'letters': /[\u01F1\u01C4]/g }, { 'base': 'Dz', 'letters': /[\u01F2\u01C5]/g }, { 'base': 'E', 'letters': /[\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E]/g }, { 'base': 'F', 'letters': /[\u0046\u24BB\uFF26\u1E1E\u0191\uA77B]/g }, { 'base': 'G', 'letters': /[\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E]/g }, { 'base': 'H', 'letters': /[\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D]/g }, { 'base': 'I', 'letters': /[\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197]/g }, { 'base': 'J', 'letters': /[\u004A\u24BF\uFF2A\u0134\u0248]/g }, { 'base': 'K', 'letters': /[\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2]/g }, { 'base': 'L', 'letters': /[\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780]/g }, { 'base': 'LJ', 'letters': /[\u01C7]/g }, { 'base': 'Lj', 'letters': /[\u01C8]/g }, { 'base': 'M', 'letters': /[\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C]/g }, { 'base': 'N', 'letters': /[\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4]/g }, { 'base': 'NJ', 'letters': /[\u01CA]/g }, { 'base': 'Nj', 'letters': /[\u01CB]/g }, { 'base': 'O', 'letters': /[\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C]/g }, { 'base': 'OI', 'letters': /[\u01A2]/g }, { 'base': 'OO', 'letters': /[\uA74E]/g }, { 'base': 'OU', 'letters': /[\u0222]/g }, { 'base': 'P', 'letters': /[\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754]/g }, { 'base': 'Q', 'letters': /[\u0051\u24C6\uFF31\uA756\uA758\u024A]/g }, { 'base': 'R', 'letters': /[\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782]/g }, { 'base': 'S', 'letters': /[\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784]/g }, { 'base': 'T', 'letters': /[\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786]/g }, { 'base': 'TZ', 'letters': /[\uA728]/g }, { 'base': 'U', 'letters': /[\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244]/g }, { 'base': 'V', 'letters': /[\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245]/g }, { 'base': 'VY', 'letters': /[\uA760]/g }, { 'base': 'W', 'letters': /[\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72]/g }, { 'base': 'X', 'letters': /[\u0058\u24CD\uFF38\u1E8A\u1E8C]/g }, { 'base': 'Y', 'letters': /[\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE]/g }, { 'base': 'Z', 'letters': /[\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762]/g }, { 'base': 'a', 'letters': /[\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250]/g }, { 'base': 'aa', 'letters': /[\uA733]/g }, { 'base': 'ae', 'letters': /[\u00E6\u01FD\u01E3]/g }, { 'base': 'ao', 'letters': /[\uA735]/g }, { 'base': 'au', 'letters': /[\uA737]/g }, { 'base': 'av', 'letters': /[\uA739\uA73B]/g }, { 'base': 'ay', 'letters': /[\uA73D]/g }, { 'base': 'b', 'letters': /[\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253]/g }, { 'base': 'c', 'letters': /[\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184]/g }, { 'base': 'd', 'letters': /[\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A]/g }, { 'base': 'dz', 'letters': /[\u01F3\u01C6]/g }, { 'base': 'e', 'letters': /[\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD]/g }, { 'base': 'f', 'letters': /[\u0066\u24D5\uFF46\u1E1F\u0192\uA77C]/g }, { 'base': 'g', 'letters': /[\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F]/g }, { 'base': 'h', 'letters': /[\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265]/g }, { 'base': 'hv', 'letters': /[\u0195]/g }, { 'base': 'i', 'letters': /[\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131]/g }, { 'base': 'j', 'letters': /[\u006A\u24D9\uFF4A\u0135\u01F0\u0249]/g }, { 'base': 'k', 'letters': /[\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3]/g }, { 'base': 'l', 'letters': /[\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747]/g }, { 'base': 'lj', 'letters': /[\u01C9]/g }, { 'base': 'm', 'letters': /[\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F]/g }, { 'base': 'n', 'letters': /[\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5]/g }, { 'base': 'nj', 'letters': /[\u01CC]/g }, { 'base': 'o', 'letters': /[\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275]/g }, { 'base': 'oi', 'letters': /[\u01A3]/g }, { 'base': 'ou', 'letters': /[\u0223]/g }, { 'base': 'oo', 'letters': /[\uA74F]/g }, { 'base': 'p', 'letters': /[\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755]/g }, { 'base': 'q', 'letters': /[\u0071\u24E0\uFF51\u024B\uA757\uA759]/g }, { 'base': 'r', 'letters': /[\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783]/g }, { 'base': 's', 'letters': /[\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B]/g }, { 'base': 't', 'letters': /[\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787]/g }, { 'base': 'tz', 'letters': /[\uA729]/g }, { 'base': 'u', 'letters': /[\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289]/g }, { 'base': 'v', 'letters': /[\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C]/g }, { 'base': 'vy', 'letters': /[\uA761]/g }, { 'base': 'w', 'letters': /[\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73]/g }, { 'base': 'x', 'letters': /[\u0078\u24E7\uFF58\u1E8B\u1E8D]/g }, { 'base': 'y', 'letters': /[\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF]/g }, { 'base': 'z', 'letters': /[\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763]/g }];
function stripDiacritics(str) {
for (var i = 0; i < map.length; i++) {
str = str.replace(map[i].letters, map[i].base);
}
return str;
}
function trim(str) {
return str.replace(/^\s+|\s+$/g, '');
}
function filterOptions(options, filterValue, excludeOptions, props) {
var _this = this;
if (props.ignoreAccents) {
filterValue = stripDiacritics(filterValue);
}
if (props.ignoreCase) {
filterValue = filterValue.toLowerCase();
}
if (props.trimFilter) {
filterValue = trim(filterValue);
}
if (excludeOptions) excludeOptions = excludeOptions.map(function (i) {
return i[props.valueKey];
});
return options.filter(function (option) {
if (excludeOptions && excludeOptions.indexOf(option[props.valueKey]) > -1) return false;
if (props.filterOption) return props.filterOption.call(_this, option, filterValue);
if (!filterValue) return true;
var valueTest = String(option[props.valueKey]);
var labelTest = String(option[props.labelKey]);
if (props.ignoreAccents) {
if (props.matchProp !== 'label') valueTest = stripDiacritics(valueTest);
if (props.matchProp !== 'value') labelTest = stripDiacritics(labelTest);
}
if (props.ignoreCase) {
if (props.matchProp !== 'label') valueTest = valueTest.toLowerCase();
if (props.matchProp !== 'value') labelTest = labelTest.toLowerCase();
}
return props.matchPos === 'start' ? props.matchProp !== 'label' && valueTest.substr(0, filterValue.length) === filterValue || props.matchProp !== 'value' && labelTest.substr(0, filterValue.length) === filterValue : props.matchProp !== 'label' && valueTest.indexOf(filterValue) >= 0 || props.matchProp !== 'value' && labelTest.indexOf(filterValue) >= 0;
});
}
function menuRenderer(_ref) {
var focusedOption = _ref.focusedOption,
instancePrefix = _ref.instancePrefix,
labelKey = _ref.labelKey,
onFocus = _ref.onFocus,
onSelect = _ref.onSelect,
optionClassName = _ref.optionClassName,
optionComponent = _ref.optionComponent,
optionRenderer = _ref.optionRenderer,
options = _ref.options,
valueArray = _ref.valueArray,
valueKey = _ref.valueKey,
onOptionRef = _ref.onOptionRef;
var Option = optionComponent;
return options.map(function (option, i) {
var isSelected = valueArray && valueArray.some(function (x) {
return x[valueKey] == option[valueKey];
});
var isFocused = option === focusedOption;
var optionClass = classNames(optionClassName, {
'Select-option': true,
'is-selected': isSelected,
'is-focused': isFocused,
'is-disabled': option.disabled
});
return React.createElement(
Option,
{
className: optionClass,
instancePrefix: instancePrefix,
isDisabled: option.disabled,
isFocused: isFocused,
isSelected: isSelected,
key: 'option-' + i + '-' + option[valueKey],
onFocus: onFocus,
onSelect: onSelect,
option: option,
optionIndex: i,
ref: function ref(_ref2) {
onOptionRef(_ref2, isFocused);
}
},
optionRenderer(option, i)
);
});
}
function clearRenderer() {
return React.createElement('span', {
className: 'Select-clear',
dangerouslySetInnerHTML: { __html: '×' }
});
}
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
var asyncGenerator = function () {
function AwaitValue(value) {
this.value = value;
}
function AsyncGenerator(gen) {
var front, back;
function send(key, arg) {
return new Promise(function (resolve, reject) {
var request = {
key: key,
arg: arg,
resolve: resolve,
reject: reject,
next: null
};
if (back) {
back = back.next = request;
} else {
front = back = request;
resume(key, arg);
}
});
}
function resume(key, arg) {
try {
var result = gen[key](arg);
var value = result.value;
if (value instanceof AwaitValue) {
Promise.resolve(value.value).then(function (arg) {
resume("next", arg);
}, function (arg) {
resume("throw", arg);
});
} else {
settle(result.done ? "return" : "normal", result.value);
}
} catch (err) {
settle("throw", err);
}
}
function settle(type, value) {
switch (type) {
case "return":
front.resolve({
value: value,
done: true
});
break;
case "throw":
front.reject(value);
break;
default:
front.resolve({
value: value,
done: false
});
break;
}
front = front.next;
if (front) {
resume(front.key, front.arg);
} else {
back = null;
}
}
this._invoke = send;
if (typeof gen.return !== "function") {
this.return = undefined;
}
}
if (typeof Symbol === "function" && Symbol.asyncIterator) {
AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
return this;
};
}
AsyncGenerator.prototype.next = function (arg) {
return this._invoke("next", arg);
};
AsyncGenerator.prototype.throw = function (arg) {
return this._invoke("throw", arg);
};
AsyncGenerator.prototype.return = function (arg) {
return this._invoke("return", arg);
};
return {
wrap: function (fn) {
return function () {
return new AsyncGenerator(fn.apply(this, arguments));
};
},
await: function (value) {
return new AwaitValue(value);
}
};
}();
var classCallCheck = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
var createClass = function () {
function defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
}();
var defineProperty = function (obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
};
var _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
var inherits = function (subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
enumerable: false,
writable: true,
configurable: true
}
});
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};
var objectWithoutProperties = function (obj, keys) {
var target = {};
for (var i in obj) {
if (keys.indexOf(i) >= 0) continue;
if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
target[i] = obj[i];
}
return target;
};
var possibleConstructorReturn = function (self, call) {
if (!self) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return call && (typeof call === "object" || typeof call === "function") ? call : self;
};
var Option = function (_React$Component) {
inherits(Option, _React$Component);
function Option(props) {
classCallCheck(this, Option);
var _this = possibleConstructorReturn(this, (Option.__proto__ || Object.getPrototypeOf(Option)).call(this, props));
_this.handleMouseDown = _this.handleMouseDown.bind(_this);
_this.handleMouseEnter = _this.handleMouseEnter.bind(_this);
_this.handleMouseMove = _this.handleMouseMove.bind(_this);
_this.handleTouchStart = _this.handleTouchStart.bind(_this);
_this.handleTouchEnd = _this.handleTouchEnd.bind(_this);
_this.handleTouchMove = _this.handleTouchMove.bind(_this);
_this.onFocus = _this.onFocus.bind(_this);
return _this;
}
createClass(Option, [{
key: 'blockEvent',
value: function blockEvent(event) {
event.preventDefault();
event.stopPropagation();
if (event.target.tagName !== 'A' || !('href' in event.target)) {
return;
}
if (event.target.target) {
window.open(event.target.href, event.target.target);
} else {
window.location.href = event.target.href;
}
}
}, {
key: 'handleMouseDown',
value: function handleMouseDown(event) {
event.preventDefault();
event.stopPropagation();
this.props.onSelect(this.props.option, event);
}
}, {
key: 'handleMouseEnter',
value: function handleMouseEnter(event) {
this.onFocus(event);
}
}, {
key: 'handleMouseMove',
value: function handleMouseMove(event) {
this.onFocus(event);
}
}, {
key: 'handleTouchEnd',
value: function handleTouchEnd(event) {
// Check if the view is being dragged, In this case
// we don't want to fire the click event (because the user only wants to scroll)
if (this.dragging) return;
this.handleMouseDown(event);
}
}, {
key: 'handleTouchMove',
value: function handleTouchMove(event) {
// Set a flag that the view is being dragged
this.dragging = true;
}
}, {
key: 'handleTouchStart',
value: function handleTouchStart(event) {
// Set a flag that the view is not being dragged
this.dragging = false;
}
}, {
key: 'onFocus',
value: function onFocus(event) {
if (!this.props.isFocused) {
this.props.onFocus(this.props.option, event);
}
}
}, {
key: 'render',
value: function render() {
var _props = this.props,
option = _props.option,
instancePrefix = _props.instancePrefix,
optionIndex = _props.optionIndex;
var className = classNames(this.props.className, option.className);
return option.disabled ? React.createElement(
'div',
{ className: className,
onMouseDown: this.blockEvent,
onClick: this.blockEvent },
this.props.children
) : React.createElement(
'div',
{ className: className,
style: option.style,
role: 'option',
'aria-label': option.label,
onMouseDown: this.handleMouseDown,
onMouseEnter: this.handleMouseEnter,
onMouseMove: this.handleMouseMove,
onTouchStart: this.handleTouchStart,
onTouchMove: this.handleTouchMove,
onTouchEnd: this.handleTouchEnd,
id: instancePrefix + '-option-' + optionIndex,
title: option.title },
this.props.children
);
}
}]);
return Option;
}(React.Component);
Option.propTypes = {
children: PropTypes.node,
className: PropTypes.string, // className (based on mouse position)
instancePrefix: PropTypes.string.isRequired, // unique prefix for the ids (used for aria)
isDisabled: PropTypes.bool, // the option is disabled
isFocused: PropTypes.bool, // the option is focused
isSelected: PropTypes.bool, // the option is selected
onFocus: PropTypes.func, // method to handle mouseEnter on option element
onSelect: PropTypes.func, // method to handle click on option element
onUnfocus: PropTypes.func, // method to handle mouseLeave on option element
option: PropTypes.object.isRequired, // object that is base for that option
optionIndex: PropTypes.number // index of the option, used to generate unique ids for aria
};
var Value = function (_React$Component) {
inherits(Value, _React$Component);
function Value(props) {
classCallCheck(this, Value);
var _this = possibleConstructorReturn(this, (Value.__proto__ || Object.getPrototypeOf(Value)).call(this, props));
_this.handleMouseDown = _this.handleMouseDown.bind(_this);
_this.onRemove = _this.onRemove.bind(_this);
_this.handleTouchEndRemove = _this.handleTouchEndRemove.bind(_this);
_this.handleTouchMove = _this.handleTouchMove.bind(_this);
_this.handleTouchStart = _this.handleTouchStart.bind(_this);
return _this;
}
createClass(Value, [{
key: 'handleMouseDown',
value: function handleMouseDown(event) {
if (event.type === 'mousedown' && event.button !== 0) {
return;
}
if (this.props.onClick) {
event.stopPropagation();
this.props.onClick(this.props.value, event);
return;
}
if (this.props.value.href) {
event.stopPropagation();
}
}
}, {
key: 'onRemove',
value: function onRemove(event) {
event.preventDefault();
event.stopPropagation();
this.props.onRemove(this.props.value);
}
}, {
key: 'handleTouchEndRemove',
value: function handleTouchEndRemove(event) {
// Check if the view is being dragged, In this case
// we don't want to fire the click event (because the user only wants to scroll)
if (this.dragging) return;
// Fire the mouse events
this.onRemove(event);
}
}, {
key: 'handleTouchMove',
value: function handleTouchMove(event) {
// Set a flag that the view is being dragged
this.dragging = true;
}
}, {
key: 'handleTouchStart',
value: function handleTouchStart(event) {
// Set a flag that the view is not being dragged
this.dragging = false;
}
}, {
key: 'renderRemoveIcon',
value: function renderRemoveIcon() {
if (this.props.disabled || !this.props.onRemove) return;
return React.createElement(
'span',
{ className: 'Select-value-icon',
'aria-hidden': 'true',
onMouseDown: this.onRemove,
onTouchEnd: this.handleTouchEndRemove,
onTouchStart: this.handleTouchStart,
onTouchMove: this.handleTouchMove },
'\xD7'
);
}
}, {
key: 'renderLabel',
value: function renderLabel() {
var className = 'Select-value-label';
return this.props.onClick || this.props.value.href ? React.createElement(
'a',
{ className: className, href: this.props.value.href, target: this.props.value.target, onMouseDown: this.handleMouseDown, onTouchEnd: this.handleMouseDown },
this.props.children
) : React.createElement(
'span',
{ className: className, role: 'option', 'aria-selected': 'true', id: this.props.id },
this.props.children
);
}
}, {
key: 'render',
value: function render() {
return React.createElement(
'div',
{ className: classNames('Select-value', this.props.value.className),
style: this.props.value.style,
title: this.props.value.title
},
this.renderRemoveIcon(),
this.renderLabel()
);
}
}]);
return Value;
}(React.Component);
Value.propTypes = {
children: PropTypes.node,
disabled: PropTypes.bool, // disabled prop passed to ReactSelect
id: PropTypes.string, // Unique id for the value - used for aria
onClick: PropTypes.func, // method to handle click on value label
onRemove: PropTypes.func, // method to handle removal of the value
value: PropTypes.object.isRequired // the option object for this value
};
/*!
Copyright (c) 2017 Jed Watson.
Licensed under the MIT License (MIT), see
http://jedwatson.github.io/react-select
*/
var stringifyValue = function stringifyValue(value) {
return typeof value === 'string' ? value : value !== null && JSON.stringify(value) || '';
};
var stringOrNode = PropTypes.oneOfType([PropTypes.string, PropTypes.node]);
var stringOrNumber = PropTypes.oneOfType([PropTypes.string, PropTypes.number]);
var instanceId = 1;
var Select$1 = function (_React$Component) {
inherits(Select, _React$Component);
function Select(props) {
classCallCheck(this, Select);
var _this = possibleConstructorReturn(this, (Select.__proto__ || Object.getPrototypeOf(Select)).call(this, props));
['clearValue', 'focusOption', 'handleInputBlur', 'handleInputChange', 'handleInputFocus', 'handleInputValueChange', 'handleKeyDown', 'handleMenuScroll', 'handleMouseDown', 'handleMouseDownOnArrow', 'handleMouseDownOnMenu', 'handleRequired', 'handleTouchOutside', 'handleTouchMove', 'handleTouchStart', 'handleTouchEnd', 'handleTouchEndClearValue', 'handleValueClick', 'getOptionLabel', 'onOptionRef', 'removeValue', 'selectValue'].forEach(function (fn) {
return _this[fn] = _this[fn].bind(_this);
});
_this.state = {
inputValue: '',
isFocused: false,
isOpen: false,
isPseudoFocused: false,
required: false
};
return _this;
}
createClass(Select, [{
key: 'componentWillMount',
value: function componentWillMount() {
this._instancePrefix = 'react-select-' + (this.props.instanceId || ++instanceId) + '-';
var valueArray = this.getValueArray(this.props.value);
if (this.props.required) {
this.setState({
required: this.handleRequired(valueArray[0], this.props.multi)
});
}
}
}, {
key: 'componentDidMount',
value: function componentDidMount() {
if (typeof this.props.autofocus !== 'undefined' && typeof console !== 'undefined') {
console.warn('Warning: The autofocus prop has changed to autoFocus, support will be removed after react-select@1.0');
}
if (this.props.autoFocus || this.props.autofocus) {
this.focus();
}
}
}, {
key: 'componentWillReceiveProps',
value: function componentWillReceiveProps(nextProps) {
var valueArray = this.getValueArray(nextProps.value, nextProps);
if (nextProps.required) {
this.setState({
required: this.handleRequired(valueArray[0], nextProps.multi)
});
} else if (this.props.required) {
// Used to be required but it's not any more
this.setState({ required: false });
}
}
}, {
key: 'componentDidUpdate',
value: function componentDidUpdate(prevProps, prevState) {
// focus to the selected option
if (this.menu && this.focused && this.state.isOpen && !this.hasScrolledToOption) {
var focusedOptionNode = findDOMNode(this.focused);
var menuNode = findDOMNode(this.menu);
menuNode.scrollTop = focusedOptionNode.offsetTop;
this.hasScrolledToOption = true;
} else if (!this.state.isOpen) {
this.hasScrolledToOption = false;
}
if (this._scrollToFocusedOptionOnUpdate && this.focused && this.menu) {
this._scrollToFocusedOptionOnUpdate = false;
var focusedDOM = findDOMNode(this.focused);
var menuDOM = findDOMNode(this.menu);
var focusedRect = focusedDOM.getBoundingClientRect();
var menuRect = menuDOM.getBoundingClientRect();
if (focusedRect.bottom > menuRect.bottom) {
menuDOM.scrollTop = focusedDOM.offsetTop + focusedDOM.clientHeight - menuDOM.offsetHeight;
} else if (focusedRect.top < menuRect.top) {
menuDOM.scrollTop = focusedDOM.offsetTop;
}
}
if (this.props.scrollMenuIntoView && this.menuContainer) {
var menuContainerRect = this.menuContainer.getBoundingClientRect();
if (window.innerHeight < menuContainerRect.bottom + this.props.menuBuffer) {
window.scrollBy(0, menuContainerRect.bottom + this.props.menuBuffer - window.innerHeight);
}
}
if (prevProps.disabled !== this.props.disabled) {
this.setState({ isFocused: false }); // eslint-disable-line react/no-did-update-set-state
this.closeMenu();
}
if (prevState.isOpen !== this.state.isOpen) {
this.toggleTouchOutsideEvent(this.state.isOpen);
var handler = this.state.isOpen ? this.props.onOpen : this.props.onClose;
handler && handler();
}
}
}, {
key: 'componentWillUnmount',
value: function componentWillUnmount() {
this.toggleTouchOutsideEvent(false);
}
}, {
key: 'toggleTouchOutsideEvent',
value: function toggleTouchOutsideEvent(enabled) {
if (enabled) {
if (!document.addEventListener && document.attachEvent) {
document.attachEvent('ontouchstart', this.handleTouchOutside);
} else {
document.addEventListener('touchstart', this.handleTouchOutside);
}
} else {
if (!document.removeEventListener && document.detachEvent) {
document.detachEvent('ontouchstart', this.handleTouchOutside);
} else {
document.removeEventListener('touchstart', this.handleTouchOutside);
}
}
}
}, {
key: 'handleTouchOutside',
value: function handleTouchOutside(event) {
// handle touch outside on ios to dismiss menu
if (this.wrapper && !this.wrapper.contains(event.target)) {
this.closeMenu();
}
}
}, {
key: 'focus',
value: function focus() {
if (!this.input) return;
this.input.focus();
}
}, {
key: 'blurInput',
value: function blurInput() {
if (!this.input) return;
this.input.blur();
}
}, {
key: 'handleTouchMove',
value: function handleTouchMove(event) {
// Set a flag that the view is being dragged
this.dragging = true;
}
}, {
key: 'handleTouchStart',
value: function handleTouchStart(event) {
// Set a flag that the view is not being dragged
this.dragging = false;
}
}, {
key: 'handleTouchEnd',
value: function handleTouchEnd(event) {
// Check if the view is being dragged, In this case
// we don't want to fire the click event (because the user only wants to scroll)
if (this.dragging) return;
// Fire the mouse events
this.handleMouseDown(event);
}
}, {
key: 'handleTouchEndClearValue',
value: function handleTouchEndClearValue(event) {
// Check if the view is being dragged, In this case
// we don't want to fire the click event (because the user only wants to scroll)
if (this.dragging) return;
// Clear the value
this.clearValue(event);
}
}, {
key: 'handleMouseDown',
value: function handleMouseDown(event) {
// if the event was triggered by a mousedown and not the primary
// button, or if the component is disabled, ignore it.
if (this.props.disabled || event.type === 'mousedown' && event.button !== 0) {
return;
}
if (event.target.tagName === 'INPUT') {
return;
}
// prevent default event handlers
event.stopPropagation();
event.preventDefault();
// for the non-searchable select, toggle the menu
if (!this.props.searchable) {
// TODO: This code means that if a select is searchable, onClick the options menu will not appear, only on subsequent click will it open.
this.focus();
return this.setState({
isOpen: !this.state.isOpen
});
}
if (this.state.isFocused) {
// On iOS, we can get into a state where we think the input is focused but it isn't really,
// since iOS ignores programmatic calls to input.focus() that weren't triggered by a click event.
// Call focus() again here to be safe.
this.focus();
var input = this.input;
if (typeof input.getInput === 'function') {
// Get the actual DOM input if the ref is an <AutosizeInput /> component
input = input.getInput();
}
// clears the value so that the cursor will be at the end of input when the component re-renders
input.value = '';
// if the input is focused, ensure the menu is open
this.setState({
isOpen: true,
isPseudoFocused: false
});
} else {
// otherwise, focus the input and open the menu
this._openAfterFocus = this.props.openOnClick;
this.focus();
}
}
}, {
key: 'handleMouseDownOnArrow',
value: function handleMouseDownOnArrow(event) {
// if the event was triggered by a mousedown and not the primary
// button, or if the component is disabled, ignore it.
if (this.props.disabled || event.type === 'mousedown' && event.button !== 0) {
return;
}
// If the menu isn't open, let the event bubble to the main handleMouseDown
if (!this.state.isOpen) {
return;
}
// prevent default event handlers
event.stopPropagation();
event.preventDefault();
// close the menu
this.closeMenu();
}
}, {
key: 'handleMouseDownOnMenu',
value: function handleMouseDownOnMenu(event) {
// if the event was triggered by a mousedown and not the primary
// button, or if the component is disabled, ignore it.
if (this.props.disabled || event.type === 'mousedown' && event.button !== 0) {
return;
}
event.stopPropagation();
event.preventDefault();
this._openAfterFocus = true;
this.focus();
}
}, {
key: 'closeMenu',
value: function closeMenu() {
if (this.props.onCloseResetsInput) {
this.setState({
isOpen: false,
isPseudoFocused: this.state.isFocused && !this.props.multi,
inputValue: this.handleInputValueChange('')
});
} else {
this.setState({
isOpen: false,
isPseudoFocused: this.state.isFocused && !this.props.multi
});
}
this.hasScrolledToOption = false;
}
}, {
key: 'handleInputFocus',
value: function handleInputFocus(event) {
if (this.props.disabled) return;
var isOpen = this.state.isOpen || this._openAfterFocus || this.props.openOnFocus;
if (this.props.onFocus) {
this.props.onFocus(event);
}
this.setState({
isFocused: true,
isOpen: isOpen
});
this._openAfterFocus = false;
}
}, {
key: 'handleInputBlur',
value: function handleInputBlur(event) {
// The check for menu.contains(activeElement) is necessary to prevent IE11's scrollbar from closing the menu in certain contexts.
if (this.menu && (this.menu === document.activeElement || this.menu.contains(document.activeElement))) {
this.focus();
return;
}
if (this.props.onBlur) {
this.props.onBlur(event);
}
var onBlurredState = {
isFocused: false,
isOpen: false,
isPseudoFocused: false
};
if (this.props.onBlurResetsInput) {
onBlurredState.inputValue = this.handleInputValueChange('');
}
this.setState(onBlurredState);
}
}, {
key: 'handleInputChange',
value: function handleInputChange(event) {
var newInputValue = event.target.value;
if (this.state.inputValue !== event.target.value) {
newInputValue = this.handleInputValueChange(newInputValue);
}
this.setState({
isOpen: true,
isPseudoFocused: false,
inputValue: newInputValue
});
}
}, {
key: 'handleInputValueChange',
value: function handleInputValueChange(newValue) {
if (this.props.onInputChange) {
var nextState = this.props.onInputChange(newValue);
// Note: != used deliberately here to catch undefined and null
if (nextState != null && (typeof nextState === 'undefined' ? 'undefined' : _typeof(nextState)) !== 'object') {
newValue = '' + nextState;
}
}
return newValue;
}
}, {
key: 'handleKeyDown',
value: function handleKeyDown(event) {
if (this.props.disabled) return;
if (typeof this.props.onInputKeyDown === 'function') {
this.props.onInputKeyDown(event);
if (event.defaultPrevented) {
return;
}
}
switch (event.keyCode) {
case 8:
// backspace
if (!this.state.inputValue && this.props.backspaceRemoves) {
event.preventDefault();
this.popValue();
}
return;
case 9:
// tab
if (event.shiftKey || !this.state.isOpen || !this.props.tabSelectsValue) {
return;
}
event.preventDefault();
this.selectFocusedOption();
return;
case 13:
// enter
event.preventDefault();
event.stopPropagation();
if (this.state.isOpen) {
this.selectFocusedOption();
} else {
this.focusNextOption();
}
return;
break;
case 27:
// escape
if (this.state.isOpen) {
this.closeMenu();
event.stopPropagation();
} else if (this.props.clearable && this.props.escapeClearsValue) {
this.clearValue(event);
event.stopPropagation();
}
break;
case 32:
// space
if (this.props.searchable) {
return;
}
event.preventDefault();
if (!this.state.isOpen) {
this.focusNextOption();
return;
}
event.stopPropagation();
this.selectFocusedOption();
break;
case 38:
// up
this.focusPreviousOption();
break;
case 40:
// down
this.focusNextOption();
break;
case 33:
// page up
this.focusPageUpOption();
break;
case 34:
// page down
this.focusPageDownOption();
break;
case 35:
// end key
if (event.shiftKey) {
return;
}
this.focusEndOption();
break;
case 36:
// home key
if (event.shiftKey) {
return;
}
this.focusStartOption();
break;
case 46:
// delete
if (!this.state.inputValue && this.props.deleteRemoves) {
event.preventDefault();
this.popValue();
}
return;
default:
return;
}
event.preventDefault();
}
}, {
key: 'handleValueClick',
value: function handleValueClick(option, event) {
if (!this.props.onValueClick) return;
this.props.onValueClick(option, event);
}
}, {
key: 'handleMenuScroll',
value: function handleMenuScroll(event) {
if (!this.props.onMenuScrollToBottom) return;
var target = event.target;
if (target.scrollHeight > target.offsetHeight && target.scrollHeight - target.offsetHeight - target.scrollTop <= 0) {
this.props.onMenuScrollToBottom();
}
}
}, {
key: 'handleRequired',
value: function handleRequired(value, multi) {
if (!value) return true;
return multi ? value.length === 0 : Object.keys(value).length === 0;
}
}, {
key: 'getOptionLabel',
value: function getOptionLabel(op) {
return op[this.props.labelKey];
}
/**
* Turns a value into an array from the given options
* @param {String|Number|Array} value - the value of the select input
* @param {Object} nextProps - optionally specify the nextProps so the returned array uses the latest configuration
* @returns {Array} the value of the select represented in an array
*/
}, {
key: 'getValueArray',
value: function getValueArray(value, nextProps) {
var _this2 = this;
/** support optionally passing in the `nextProps` so `componentWillReceiveProps` updates will function as expected */
var props = (typeof nextProps === 'undefined' ? 'undefined' : _typeof(nextProps)) === 'object' ? nextProps : this.props;
if (props.multi) {
if (typeof value === 'string') {
value = value.split(props.delimiter);
}
if (!Array.isArray(value)) {
if (value === null || value === undefined) return [];
value = [value];
}
return value.map(function (value) {
return _this2.expandValue(value, props);
}).filter(function (i) {
return i;
});
}
var expandedValue = this.expandValue(value, props);
return expandedValue ? [expandedValue] : [];
}
/**
* Retrieve a value from the given options and valueKey
* @param {String|Number|Array} value - the selected value(s)
* @param {Object} props - the Select component's props (or nextProps)
*/
}, {
key: 'expandValue',
value: function expandValue(value, props) {
var valueType = typeof value === 'undefined' ? 'undefined' : _typeof(value);
if (valueType !== 'string' && valueType !== 'number' && valueType !== 'boolean') return value;
var options = props.options,
valueKey = props.valueKey;
if (!options) return;
for (var i = 0; i < options.length; i++) {
if (String(options[i][valueKey]) === String(value)) return options[i];
}
}
}, {
key: 'setValue',
value: function setValue(value) {
var _this3 = this;
if (this.props.autoBlur) {
this.blurInput();
}
if (this.props.required) {
var required = this.handleRequired(value, this.props.multi);
this.setState({ required: required });
}
if (this.props.onChange) {
if (this.props.simpleValue && value) {
value = this.props.multi ? value.map(function (i) {
return i[_this3.props.valueKey];
}).join(this.props.delimiter) : value[this.props.valueKey];
}
this.props.onChange(value);
}
}
}, {
key: 'selectValue',
value: function selectValue(value) {
var _this4 = this;
// NOTE: we actually add/set the value in a callback to make sure the
// input value is empty to avoid styling issues in Chrome
if (this.props.closeOnSelect) {
this.hasScrolledToOption = false;
}
if (this.props.multi) {
var updatedValue = this.props.onSelectResetsInput ? '' : this.state.inputValue;
this.setState({
focusedIndex: null,
inputValue: this.handleInputValueChange(updatedValue),
isOpen: !this.props.closeOnSelect
}, function () {
var valueArray = _this4.getValueArray(_this4.props.value);
if (valueArray.some(function (i) {
return i[_this4.props.valueKey] === value[_this4.props.valueKey];
})) {
_this4.removeValue(value);
} else {
_this4.addValue(value);
}
});
} else {
this.setState({
inputValue: this.handleInputValueChange(''),
isOpen: !this.props.closeOnSelect,
isPseudoFocused: this.state.isFocused
}, function () {
_this4.setValue(value);
});
}
}
}, {
key: 'addValue',
value: function addValue(value) {
var valueArray = this.getValueArray(this.props.value);
var visibleOptions = this._visibleOptions.filter(function (val) {
return !val.disabled;
});
var lastValueIndex = visibleOptions.indexOf(value);
this.setValue(valueArray.concat(value));
if (visibleOptions.length - 1 === lastValueIndex) {
// the last option was selected; focus the second-last one
this.focusOption(visibleOptions[lastValueIndex - 1]);
} else if (visibleOptions.length > lastValueIndex) {
// focus the option below the selected one
this.focusOption(visibleOptions[lastValueIndex + 1]);
}
}
}, {
key: 'popValue',
value: function popValue() {
var valueArray = this.getValueArray(this.props.value);
if (!valueArray.length) return;
if (valueArray[valueArray.length - 1].clearableValue === false) return;
this.setValue(this.props.multi ? valueArray.slice(0, valueArray.length - 1) : null);
}
}, {
key: 'removeValue',
value: function removeValue(value) {
var _this5 = this;
var valueArray = this.getValueArray(this.props.value);
this.setValue(valueArray.filter(function (i) {
return i[_this5.props.valueKey] !== value[_this5.props.valueKey];
}));
this.focus();
}
}, {
key: 'clearValue',
value: function clearValue(event) {
// if the event was triggered by a mousedown and not the primary
// button, ignore it.
if (event && event.type === 'mousedown' && event.button !== 0) {
return;
}
event.stopPropagation();
event.preventDefault();
this.setValue(this.getResetValue());
this.setState({
isOpen: false,
inputValue: this.handleInputValueChange('')
}, this.focus);
}
}, {
key: 'getResetValue',
value: function getResetValue() {
if (this.props.resetValue !== undefined) {
return this.props.resetValue;
} else if (this.props.multi) {
return [];
} else {
return null;
}
}
}, {
key: 'focusOption',
value: function focusOption(option) {
this.setState({
focusedOption: option
});
}
}, {
key: 'focusNextOption',
value: function focusNextOption() {
this.focusAdjacentOption('next');
}
}, {
key: 'focusPreviousOption',
value: function focusPreviousOption() {
this.focusAdjacentOption('previous');
}
}, {
key: 'focusPageUpOption',
value: function focusPageUpOption() {
this.focusAdjacentOption('page_up');
}
}, {
key: 'focusPageDownOption',
value: function focusPageDownOption() {
this.focusAdjacentOption('page_down');
}
}, {
key: 'focusStartOption',
value: function focusStartOption() {
this.focusAdjacentOption('start');
}
}, {
key: 'focusEndOption',
value: function focusEndOption() {
this.focusAdjacentOption('end');
}
}, {
key: 'focusAdjacentOption',
value: function focusAdjacentOption(dir) {
var options = this._visibleOptions.map(function (option, index) {
return { option: option, index: index };
}).filter(function (option) {
return !option.option.disabled;
});
this._scrollToFocusedOptionOnUpdate = true;
if (!this.state.isOpen) {
this.setState({
isOpen: true,
inputValue: '',
focusedOption: this._focusedOption || (options.length ? options[dir === 'next' ? 0 : options.length - 1].option : null)
});
return;
}
if (!options.length) return;
var focusedIndex = -1;
for (var i = 0; i < options.length; i++) {
if (this._focusedOption === options[i].option) {
focusedIndex = i;
break;
}
}
if (dir === 'next' && focusedIndex !== -1) {
focusedIndex = (focusedIndex + 1) % options.length;
} else if (dir === 'previous') {
if (focusedIndex > 0) {
focusedIndex = focusedIndex - 1;
} else {
focusedIndex = options.length - 1;
}
} else if (dir === 'start') {
focusedIndex = 0;
} else if (dir === 'end') {
focusedIndex = options.length - 1;
} else if (dir === 'page_up') {
var potentialIndex = focusedIndex - this.props.pageSize;
if (potentialIndex < 0) {
focusedIndex = 0;
} else {
focusedIndex = potentialIndex;
}
} else if (dir === 'page_down') {
var potentialIndex = focusedIndex + this.props.pageSize;
if (potentialIndex > options.length - 1) {
focusedIndex = options.length - 1;
} else {
focusedIndex = potentialIndex;
}
}
if (focusedIndex === -1) {
focusedIndex = 0;
}
this.setState({
focusedIndex: options[focusedIndex].index,
focusedOption: options[focusedIndex].option
});
}
}, {
key: 'getFocusedOption',
value: function getFocusedOption() {
return this._focusedOption;
}
}, {
key: 'selectFocusedOption',
value: function selectFocusedOption() {
if (this._focusedOption) {
return this.selectValue(this._focusedOption);
}
}
}, {
key: 'renderLoading',
value: function renderLoading() {
if (!this.props.isLoading) return;
return React.createElement(
'span',
{ className: 'Select-loading-zone', 'aria-hidden': 'true' },
React.createElement('span', { className: 'Select-loading' })
);
}
}, {
key: 'renderValue',
value: function renderValue(valueArray, isOpen) {
var _this6 = this;
var renderLabel = this.props.valueRenderer || this.getOptionLabel;
var ValueComponent = this.props.valueComponent;
if (!valueArray.length) {
return !this.state.inputValue ? React.createElement(
'div',
{ className: 'Select-placeholder' },
this.props.placeholder
) : null;
}
var onClick = this.props.onValueClick ? this.handleValueClick : null;
if (this.props.multi) {
return valueArray.map(function (value, i) {
return React.createElement(
ValueComponent,
{
id: _this6._instancePrefix + '-value-' + i,
instancePrefix: _this6._instancePrefix,
disabled: _this6.props.disabled || value.clearableValue === false,
key: 'value-' + i + '-' + value[_this6.props.valueKey],
onClick: onClick,
onRemove: _this6.removeValue,
value: value
},
renderLabel(value, i),
React.createElement(
'span',
{ className: 'Select-aria-only' },
'\xA0'
)
);
});
} else if (!this.state.inputValue) {
if (isOpen) onClick = null;
return React.createElement(
ValueComponent,
{
id: this._instancePrefix + '-value-item',
disabled: this.props.disabled,
instancePrefix: this._instancePrefix,
onClick: onClick,
value: valueArray[0]
},
renderLabel(valueArray[0])
);
}
}
}, {
key: 'renderInput',
value: function renderInput(valueArray, focusedOptionIndex) {
var _classNames,
_this7 = this;
var className = classNames('Select-input', this.props.inputProps.className);
var isOpen = !!this.state.isOpen;
var ariaOwns = classNames((_classNames = {}, defineProperty(_classNames, this._instancePrefix + '-list', isOpen), defineProperty(_classNames, this._instancePrefix + '-backspace-remove-message', this.props.multi && !this.props.disabled && this.state.isFocused && !this.state.inputValue), _classNames));
var inputProps = _extends({}, this.props.inputProps, {
role: 'combobox',
'aria-expanded': '' + isOpen,
'aria-owns': ariaOwns,
'aria-haspopup': '' + isOpen,
'aria-activedescendant': isOpen ? this._instancePrefix + '-option-' + focusedOptionIndex : this._instancePrefix + '-value',
'aria-describedby': this.props['aria-describedby'],
'aria-labelledby': this.props['aria-labelledby'],
'aria-label': this.props['aria-label'],
className: className,
tabIndex: this.props.tabIndex,
onBlur: this.handleInputBlur,
onChange: this.handleInputChange,
onFocus: this.handleInputFocus,
ref: function ref(_ref) {
return _this7.input = _ref;
},
required: this.state.required,
value: this.state.inputValue
});
if (this.props.inputRenderer) {
return this.props.inputRenderer(inputProps);
}
if (this.props.disabled || !this.props.searchable) {
var _props$inputProps = this.props.inputProps,
inputClassName = _props$inputProps.inputClassName,
divProps = objectWithoutProperties(_props$inputProps, ['inputClassName']);
var _ariaOwns = classNames(defineProperty({}, this._instancePrefix + '-list', isOpen));
return React.createElement('div', _extends({}, divProps, {
role: 'combobox',
'aria-expanded': isOpen,
'aria-owns': _ariaOwns,
'aria-activedescendant': isOpen ? this._instancePrefix + '-option-' + focusedOptionIndex : this._instancePrefix + '-value',
'aria-labelledby': this.props['aria-labelledby'],
'aria-label': this.props['aria-label'],
className: className,
tabIndex: this.props.tabIndex || 0,
onBlur: this.handleInputBlur,
onFocus: this.handleInputFocus,
ref: function ref(_ref2) {
return _this7.input = _ref2;
},
'aria-disabled': '' + !!this.props.disabled,
style: { border: 0, width: 1, display: 'inline-block' } }));
}
if (this.props.autosize) {
return React.createElement(AutosizeInput, _extends({ id: this.props.id }, inputProps, { minWidth: '5' }));
}
return React.createElement(
'div',
{ className: className, key: 'input-wrap' },
React.createElement('input', _extends({ id: this.props.id }, inputProps))
);
}
}, {
key: 'renderClear',
value: function renderClear() {
var valueArray = this.getValueArray(this.props.value);
if (!this.props.clearable || !valueArray.length || this.props.disabled || this.props.isLoading) return;
var clear = this.props.clearRenderer();
return React.createElement(
'span',
{ className: 'Select-clear-zone', title: this.props.multi ? this.props.clearAllText : this.props.clearValueText,
'aria-label': this.props.multi ? this.props.clearAllText : this.props.clearValueText,
onMouseDown: this.clearValue,
onTouchStart: this.handleTouchStart,
onTouchMove: this.handleTouchMove,
onTouchEnd: this.handleTouchEndClearValue
},
clear
);
}
}, {
key: 'renderArrow',
value: function renderArrow() {
if (!this.props.arrowRenderer) return;
var onMouseDown = this.handleMouseDownOnArrow;
var isOpen = this.state.isOpen;
var arrow = this.props.arrowRenderer({ onMouseDown: onMouseDown, isOpen: isOpen });
if (!arrow) {
return null;
}
return React.createElement(
'span',
{
className: 'Select-arrow-zone',
onMouseDown: onMouseDown
},
arrow
);
}
}, {
key: 'filterOptions',
value: function filterOptions$$1(excludeOptions) {
var filterValue = this.state.inputValue;
var options = this.props.options || [];
if (this.props.filterOptions) {
// Maintain backwards compatibility with boolean attribute
var filterOptions$$1 = typeof this.props.filterOptions === 'function' ? this.props.filterOptions : filterOptions;
return filterOptions$$1(options, filterValue, excludeOptions, {
filterOption: this.props.filterOption,
ignoreAccents: this.props.ignoreAccents,
ignoreCase: this.props.ignoreCase,
labelKey: this.props.labelKey,
matchPos: this.props.matchPos,
matchProp: this.props.matchProp,
valueKey: this.props.valueKey,
trimFilter: this.props.trimFilter
});
} else {
return options;
}
}
}, {
key: 'onOptionRef',
value: function onOptionRef(ref, isFocused) {
if (isFocused) {
this.focused = ref;
}
}
}, {
key: 'renderMenu',
value: function renderMenu(options, valueArray, focusedOption) {
if (options && options.length) {
return this.props.menuRenderer({
focusedOption: focusedOption,
focusOption: this.focusOption,
inputValue: this.state.inputValue,
instancePrefix: this._instancePrefix,
labelKey: this.props.labelKey,
onFocus: this.focusOption,
onSelect: this.selectValue,
optionClassName: this.props.optionClassName,
optionComponent: this.props.optionComponent,
optionRenderer: this.props.optionRenderer || this.getOptionLabel,
options: options,
selectValue: this.selectValue,
removeValue: this.removeValue,
valueArray: valueArray,
valueKey: this.props.valueKey,
onOptionRef: this.onOptionRef
});
} else if (this.props.noResultsText) {
return React.createElement(
'div',
{ className: 'Select-noresults' },
this.props.noResultsText
);
} else {
return null;
}
}
}, {
key: 'renderHiddenField',
value: function renderHiddenField(valueArray) {
var _this8 = this;
if (!this.props.name) return;
if (this.props.joinValues) {
var value = valueArray.map(function (i) {
return stringifyValue(i[_this8.props.valueKey]);
}).join(this.props.delimiter);
return React.createElement('input', {
type: 'hidden',
ref: function ref(_ref3) {
return _this8.value = _ref3;
},
name: this.props.name,
value: value,
disabled: this.props.disabled });
}
return valueArray.map(function (item, index) {
return React.createElement('input', { key: 'hidden.' + index,
type: 'hidden',
ref: 'value' + index,
name: _this8.props.name,
value: stringifyValue(item[_this8.props.valueKey]),
disabled: _this8.props.disabled });
});
}
}, {
key: 'getFocusableOptionIndex',
value: function getFocusableOptionIndex(selectedOption) {
var options = this._visibleOptions;
if (!options.length) return null;
var valueKey = this.props.valueKey;
var focusedOption = this.state.focusedOption || selectedOption;
if (focusedOption && !focusedOption.disabled) {
var focusedOptionIndex = -1;
options.some(function (option, index) {
var isOptionEqual = option[valueKey] === focusedOption[valueKey];
if (isOptionEqual) {
focusedOptionIndex = index;
}
return isOptionEqual;
});
if (focusedOptionIndex !== -1) {
return focusedOptionIndex;
}
}
for (var i = 0; i < options.length; i++) {
if (!options[i].disabled) return i;
}
return null;
}
}, {
key: 'renderOuter',
value: function renderOuter(options, valueArray, focusedOption) {
var _this9 = this;
var menu = this.renderMenu(options, valueArray, focusedOption);
if (!menu) {
return null;
}
return React.createElement(
'div',
{ ref: function ref(_ref5) {
return _this9.menuContainer = _ref5;
}, className: 'Select-menu-outer', style: this.props.menuContainerStyle },
React.createElement(
'div',
{ ref: function ref(_ref4) {
return _this9.menu = _ref4;
}, role: 'listbox', tabIndex: -1, className: 'Select-menu', id: this._instancePrefix + '-list',
style: this.props.menuStyle,
onScroll: this.handleMenuScroll,
onMouseDown: this.handleMouseDownOnMenu },
menu
)
);
}
}, {
key: 'render',
value: function render() {
var _this10 = this;
var valueArray = this.getValueArray(this.props.value);
var options = this._visibleOptions = this.filterOptions(this.props.multi && this.props.removeSelected ? valueArray : null);
var isOpen = this.state.isOpen;
if (this.props.multi && !options.length && valueArray.length && !this.state.inputValue) isOpen = false;
var focusedOptionIndex = this.getFocusableOptionIndex(valueArray[0]);
var focusedOption = null;
if (focusedOptionIndex !== null) {
focusedOption = this._focusedOption = options[focusedOptionIndex];
} else {
focusedOption = this._focusedOption = null;
}
var className = classNames('Select', this.props.className, {
'Select--multi': this.props.multi,
'Select--single': !this.props.multi,
'is-clearable': this.props.clearable,
'is-disabled': this.props.disabled,
'is-focused': this.state.isFocused,
'is-loading': this.props.isLoading,
'is-open': isOpen,
'is-pseudo-focused': this.state.isPseudoFocused,
'is-searchable': this.props.searchable,
'has-value': valueArray.length,
'Select--rtl': this.props.rtl
});
var removeMessage = null;
if (this.props.multi && !this.props.disabled && valueArray.length && !this.state.inputValue && this.state.isFocused && this.props.backspaceRemoves) {
removeMessage = React.createElement(
'span',
{ id: this._instancePrefix + '-backspace-remove-message', className: 'Select-aria-only', 'aria-live': 'assertive' },
this.props.backspaceToRemoveMessage.replace('{label}', valueArray[valueArray.length - 1][this.props.labelKey])
);
}
return React.createElement(
'div',
{ ref: function ref(_ref7) {
return _this10.wrapper = _ref7;
},
className: className,
style: this.props.wrapperStyle },
this.renderHiddenField(valueArray),
React.createElement(
'div',
{ ref: function ref(_ref6) {
return _this10.control = _ref6;
},
className: 'Select-control',
style: this.props.style,
onKeyDown: this.handleKeyDown,
onMouseDown: this.handleMouseDown,
onTouchEnd: this.handleTouchEnd,
onTouchStart: this.handleTouchStart,
onTouchMove: this.handleTouchMove
},
React.createElement(
'span',
{ className: 'Select-multi-value-wrapper', id: this._instancePrefix + '-value' },
this.renderValue(valueArray, isOpen),
this.renderInput(valueArray, focusedOptionIndex)
),
removeMessage,
this.renderLoading(),
this.renderClear(),
this.renderArrow()
),
isOpen ? this.renderOuter(options, valueArray, focusedOption) : null
);
}
}]);
return Select;
}(React.Component);
Select$1.propTypes = {
'aria-describedby': PropTypes.string, // html id(s) of element(s) that should be used to describe this input (for assistive tech)
'aria-label': PropTypes.string, // aria label (for assistive tech)
'aria-labelledby': PropTypes.string, // html id of an element that should be used as the label (for assistive tech)
arrowRenderer: PropTypes.func, // create the drop-down caret element
autoBlur: PropTypes.bool, // automatically blur the component when an option is selected
autoFocus: PropTypes.bool, // autofocus the component on mount
autofocus: PropTypes.bool, // deprecated; use autoFocus instead
autosize: PropTypes.bool, // whether to enable autosizing or not
backspaceRemoves: PropTypes.bool, // whether backspace removes an item if there is no text input
backspaceToRemoveMessage: PropTypes.string, // message to use for screenreaders to press backspace to remove the current item - {label} is replaced with the item label
className: PropTypes.string, // className for the outer element
clearAllText: stringOrNode, // title for the "clear" control when multi: true
clearRenderer: PropTypes.func, // create clearable x element
clearValueText: stringOrNode, // title for the "clear" control
clearable: PropTypes.bool, // should it be possible to reset value
closeOnSelect: PropTypes.bool, // whether to close the menu when a value is selected
deleteRemoves: PropTypes.bool, // whether delete removes an item if there is no text input
delimiter: PropTypes.string, // delimiter to use to join multiple values for the hidden field value
disabled: PropTypes.bool, // whether the Select is disabled or not
escapeClearsValue: PropTypes.bool, // whether escape clears the value when the menu is closed
filterOption: PropTypes.func, // method to filter a single option (option, filterString)
filterOptions: PropTypes.any, // boolean to enable default filtering or function to filter the options array ([options], filterString, [values])
id: PropTypes.string, // html id to set on the input element for accessibility or tests
ignoreAccents: PropTypes.bool, // whether to strip diacritics when filtering
ignoreCase: PropTypes.bool, // whether to perform case-insensitive filtering
inputProps: PropTypes.object, // custom attributes for the Input
inputRenderer: PropTypes.func, // returns a custom input component
instanceId: PropTypes.string, // set the components instanceId
isLoading: PropTypes.bool, // whether the Select is loading externally or not (such as options being loaded)
joinValues: PropTypes.bool, // joins multiple values into a single form field with the delimiter (legacy mode)
labelKey: PropTypes.string, // path of the label value in option objects
matchPos: PropTypes.string, // (any|start) match the start or entire string when filtering
matchProp: PropTypes.string, // (any|label|value) which option property to filter on
menuBuffer: PropTypes.number, // optional buffer (in px) between the bottom of the viewport and the bottom of the menu
menuContainerStyle: PropTypes.object, // optional style to apply to the menu container
menuRenderer: PropTypes.func, // renders a custom menu with options
menuStyle: PropTypes.object, // optional style to apply to the menu
multi: PropTypes.bool, // multi-value input
name: PropTypes.string, // generates a hidden <input /> tag with this field name for html forms
noResultsText: stringOrNode, // placeholder displayed when there are no matching search results
onBlur: PropTypes.func, // onBlur handler: function (event) {}
onBlurResetsInput: PropTypes.bool, // whether input is cleared on blur
onChange: PropTypes.func, // onChange handler: function (newValue) {}
onClose: PropTypes.func, // fires when the menu is closed
onCloseResetsInput: PropTypes.bool, // whether input is cleared when menu is closed through the arrow
onFocus: PropTypes.func, // onFocus handler: function (event) {}
onInputChange: PropTypes.func, // onInputChange handler: function (inputValue) {}
onInputKeyDown: PropTypes.func, // input keyDown handler: function (event) {}
onMenuScrollToBottom: PropTypes.func, // fires when the menu is scrolled to the bottom; can be used to paginate options
onOpen: PropTypes.func, // fires when the menu is opened
onSelectResetsInput: PropTypes.bool, // whether input is cleared on select (works only for multiselect)
onValueClick: PropTypes.func, // onClick handler for value labels: function (value, event) {}
openOnClick: PropTypes.bool, // boolean to control opening the menu when the control is clicked
openOnFocus: PropTypes.bool, // always open options menu on focus
optionClassName: PropTypes.string, // additional class(es) to apply to the <Option /> elements
optionComponent: PropTypes.func, // option component to render in dropdown
optionRenderer: PropTypes.func, // optionRenderer: function (option) {}
options: PropTypes.array, // array of options
pageSize: PropTypes.number, // number of entries to page when using page up/down keys
placeholder: stringOrNode, // field placeholder, displayed when there's no value
removeSelected: PropTypes.bool, // whether the selected option is removed from the dropdown on multi selects
required: PropTypes.bool, // applies HTML5 required attribute when needed
resetValue: PropTypes.any, // value to use when you clear the control
rtl: PropTypes.bool, // set to true in order to use react-select in right-to-left direction
scrollMenuIntoView: PropTypes.bool, // boolean to enable the viewport to shift so that the full menu fully visible when engaged
searchable: PropTypes.bool, // whether to enable searching feature or not
simpleValue: PropTypes.bool, // pass the value to onChange as a simple value (legacy pre 1.0 mode), defaults to false
style: PropTypes.object, // optional style to apply to the control
tabIndex: stringOrNumber, // optional tab index of the control
tabSelectsValue: PropTypes.bool, // whether to treat tabbing out while focused to be value selection
trimFilter: PropTypes.bool, // whether to trim whitespace around filter value
value: PropTypes.any, // initial field value
valueComponent: PropTypes.func, // value component to render
valueKey: PropTypes.string, // path of the label value in option objects
valueRenderer: PropTypes.func, // valueRenderer: function (option) {}
wrapperStyle: PropTypes.object // optional style to apply to the component wrapper
};
Select$1.defaultProps = {
arrowRenderer: arrowRenderer,
autosize: true,
backspaceRemoves: true,
backspaceToRemoveMessage: 'Press backspace to remove {label}',
clearable: true,
clearAllText: 'Clear all',
clearRenderer: clearRenderer,
clearValueText: 'Clear value',
closeOnSelect: true,
deleteRemoves: true,
delimiter: ',',
disabled: false,
escapeClearsValue: true,
filterOptions: filterOptions,
ignoreAccents: true,
ignoreCase: true,
inputProps: {},
isLoading: false,
joinValues: false,
labelKey: 'label',
matchPos: 'any',
matchProp: 'any',
menuBuffer: 0,
menuRenderer: menuRenderer,
multi: false,
noResultsText: 'No results found',
onBlurResetsInput: true,
onSelectResetsInput: true,
onCloseResetsInput: true,
openOnClick: true,
optionComponent: Option,
pageSize: 5,
placeholder: 'Select...',
removeSelected: true,
required: false,
rtl: false,
scrollMenuIntoView: true,
searchable: true,
simpleValue: false,
tabSelectsValue: true,
trimFilter: true,
valueComponent: Value,
valueKey: 'value'
};
var propTypes = {
autoload: PropTypes.bool.isRequired, // automatically call the `loadOptions` prop on-mount; defaults to true
cache: PropTypes.any, // object to use to cache results; set to null/false to disable caching
children: PropTypes.func.isRequired, // Child function responsible for creating the inner Select component; (props: Object): PropTypes.element
ignoreAccents: PropTypes.bool, // strip diacritics when filtering; defaults to true
ignoreCase: PropTypes.bool, // perform case-insensitive filtering; defaults to true
loadOptions: PropTypes.func.isRequired, // callback to load options asynchronously; (inputValue: string, callback: Function): ?Promise
loadingPlaceholder: PropTypes.oneOfType([// replaces the placeholder while options are loading
PropTypes.string, PropTypes.node]),
multi: PropTypes.bool, // multi-value input
noResultsText: PropTypes.oneOfType([// field noResultsText, displayed when no options come back from the server
PropTypes.string, PropTypes.node]),
onChange: PropTypes.func, // onChange handler: function (newValue) {}
onInputChange: PropTypes.func, // optional for keeping track of what is being typed
options: PropTypes.array.isRequired, // array of options
placeholder: PropTypes.oneOfType([// field placeholder, displayed when there's no value (shared with Select)
PropTypes.string, PropTypes.node]),
searchPromptText: PropTypes.oneOfType([// label to prompt for search input
PropTypes.string, PropTypes.node]),
value: PropTypes.any // initial field value
};
var defaultCache = {};
var defaultProps = {
autoload: true,
cache: defaultCache,
children: defaultChildren,
ignoreAccents: true,
ignoreCase: true,
loadingPlaceholder: 'Loading...',
options: [],
searchPromptText: 'Type to search'
};
var Async = function (_Component) {
inherits(Async, _Component);
function Async(props, context) {
classCallCheck(this, Async);
var _this = possibleConstructorReturn(this, (Async.__proto__ || Object.getPrototypeOf(Async)).call(this, props, context));
_this._cache = props.cache === defaultCache ? {} : props.cache;
_this.state = {
inputValue: '',
isLoading: false,
options: props.options
};
_this.onInputChange = _this.onInputChange.bind(_this);
return _this;
}
createClass(Async, [{
key: 'componentDidMount',
value: function componentDidMount() {
var autoload = this.props.autoload;
if (autoload) {
this.loadOptions('');
}
}
}, {
key: 'componentWillReceiveProps',
value: function componentWillReceiveProps(nextProps) {
if (nextProps.options !== this.props.options) {
this.setState({
options: nextProps.options
});
}
}
}, {
key: 'componentWillUnmount',
value: function componentWillUnmount() {
this._callback = null;
}
}, {
key: 'loadOptions',
value: function loadOptions(inputValue) {
var _this2 = this;
var loadOptions = this.props.loadOptions;
var cache = this._cache;
if (cache && Object.prototype.hasOwnProperty.call(cache, inputValue)) {
this._callback = null;
this.setState({
isLoading: false,
options: cache[inputValue]
});
return;
}
var callback = function callback(error, data) {
var options = data && data.options || [];
if (cache) {
cache[inputValue] = options;
}
if (callback === _this2._callback) {
_this2._callback = null;
_this2.setState({
isLoading: false,
options: options
});
}
};
// Ignore all but the most recent request
this._callback = callback;
var promise = loadOptions(inputValue, callback);
if (promise) {
promise.then(function (data) {
return callback(null, data);
}, function (error) {
return callback(error);
});
}
if (this._callback && !this.state.isLoading) {
this.setState({
isLoading: true
});
}
}
}, {
key: 'onInputChange',
value: function onInputChange(inputValue) {
var _props = this.props,
ignoreAccents = _props.ignoreAccents,
ignoreCase = _props.ignoreCase,
onInputChange = _props.onInputChange;
var newInputValue = inputValue;
if (onInputChange) {
var value = onInputChange(newInputValue);
// Note: != used deliberately here to catch undefined and null
if (value != null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) !== 'object') {
newInputValue = '' + value;
}
}
var transformedInputValue = newInputValue;
if (ignoreAccents) {
transformedInputValue = stripDiacritics(transformedInputValue);
}
if (ignoreCase) {
transformedInputValue = transformedInputValue.toLowerCase();
}
this.setState({ inputValue: newInputValue });
this.loadOptions(transformedInputValue);
// Return new input value, but without applying toLowerCase() to avoid modifying the user's view case of the input while typing.
return newInputValue;
}
}, {
key: 'noResultsText',
value: function noResultsText() {
var _props2 = this.props,
loadingPlaceholder = _props2.loadingPlaceholder,
noResultsText = _props2.noResultsText,
searchPromptText = _props2.searchPromptText;
var _state = this.state,
inputValue = _state.inputValue,
isLoading = _state.isLoading;
if (isLoading) {
return loadingPlaceholder;
}
if (inputValue && noResultsText) {
return noResultsText;
}
return searchPromptText;
}
}, {
key: 'focus',
value: function focus() {
this.select.focus();
}
}, {
key: 'render',
value: function render() {
var _this3 = this;
var _props3 = this.props,
children = _props3.children,
loadingPlaceholder = _props3.loadingPlaceholder,
multi = _props3.multi,
onChange = _props3.onChange,
placeholder = _props3.placeholder;
var _state2 = this.state,
isLoading = _state2.isLoading,
options = _state2.options;
var props = {
noResultsText: this.noResultsText(),
placeholder: isLoading ? loadingPlaceholder : placeholder,
options: isLoading && loadingPlaceholder ? [] : options,
ref: function ref(_ref) {
return _this3.select = _ref;
}
};
return children(_extends({}, this.props, props, {
isLoading: isLoading,
onInputChange: this.onInputChange
}));
}
}]);
return Async;
}(Component);
Async.propTypes = propTypes;
Async.defaultProps = defaultProps;
function defaultChildren(props) {
return React.createElement(Select$1, props);
}
var CreatableSelect = function (_React$Component) {
inherits(CreatableSelect, _React$Component);
function CreatableSelect(props, context) {
classCallCheck(this, CreatableSelect);
var _this = possibleConstructorReturn(this, (CreatableSelect.__proto__ || Object.getPrototypeOf(CreatableSelect)).call(this, props, context));
_this.filterOptions = _this.filterOptions.bind(_this);
_this.menuRenderer = _this.menuRenderer.bind(_this);
_this.onInputKeyDown = _this.onInputKeyDown.bind(_this);
_this.onInputChange = _this.onInputChange.bind(_this);
_this.onOptionSelect = _this.onOptionSelect.bind(_this);
return _this;
}
createClass(CreatableSelect, [{
key: 'createNewOption',
value: function createNewOption() {
var _props = this.props,
isValidNewOption = _props.isValidNewOption,
newOptionCreator = _props.newOptionCreator,
onNewOptionClick = _props.onNewOptionClick,
_props$options = _props.options,
options = _props$options === undefined ? [] : _props$options;
if (isValidNewOption({ label: this.inputValue })) {
var option = newOptionCreator({ label: this.inputValue, labelKey: this.labelKey, valueKey: this.valueKey });
var _isOptionUnique = this.isOptionUnique({ option: option });
// Don't add the same option twice.
if (_isOptionUnique) {
if (onNewOptionClick) {
onNewOptionClick(option);
} else {
options.unshift(option);
this.select.selectValue(option);
}
}
}
}
}, {
key: 'filterOptions',
value: function filterOptions$$1() {
var _props2 = this.props,
filterOptions$$1 = _props2.filterOptions,
isValidNewOption = _props2.isValidNewOption,
options = _props2.options,
promptTextCreator = _props2.promptTextCreator;
// TRICKY Check currently selected options as well.
// Don't display a create-prompt for a value that's selected.
// This covers async edge-cases where a newly-created Option isn't yet in the async-loaded array.
var excludeOptions = (arguments.length <= 2 ? undefined : arguments[2]) || [];
var filteredOptions = filterOptions$$1.apply(undefined, arguments) || [];
if (isValidNewOption({ label: this.inputValue })) {
var _newOptionCreator = this.props.newOptionCreator;
var option = _newOptionCreator({
label: this.inputValue,
labelKey: this.labelKey,
valueKey: this.valueKey
});
// TRICKY Compare to all options (not just filtered options) in case option has already been selected).
// For multi-selects, this would remove it from the filtered list.
var _isOptionUnique2 = this.isOptionUnique({
option: option,
options: excludeOptions.concat(filteredOptions)
});
if (_isOptionUnique2) {
var prompt = promptTextCreator(this.inputValue);
this._createPlaceholderOption = _newOptionCreator({
label: prompt,
labelKey: this.labelKey,
valueKey: this.valueKey
});
filteredOptions.unshift(this._createPlaceholderOption);
}
}
return filteredOptions;
}
}, {
key: 'isOptionUnique',
value: function isOptionUnique(_ref) {
var option = _ref.option,
options = _ref.options;
var isOptionUnique = this.props.isOptionUnique;
options = options || this.props.options;
return isOptionUnique({
labelKey: this.labelKey,
option: option,
options: options,
valueKey: this.valueKey
});
}
}, {
key: 'menuRenderer',
value: function menuRenderer$$1(params) {
var menuRenderer$$1 = this.props.menuRenderer;
return menuRenderer$$1(_extends({}, params, {
onSelect: this.onOptionSelect,
selectValue: this.onOptionSelect
}));
}
}, {
key: 'onInputChange',
value: function onInputChange(input) {
var onInputChange = this.props.onInputChange;
// This value may be needed in between Select mounts (when this.select is null)
this.inputValue = input;
if (onInputChange) {
this.inputValue = onInputChange(input);
}
return this.inputValue;
}
}, {
key: 'onInputKeyDown',
value: function onInputKeyDown(event) {
var _props3 = this.props,
shouldKeyDownEventCreateNewOption = _props3.shouldKeyDownEventCreateNewOption,
onInputKeyDown = _props3.onInputKeyDown;
var focusedOption = this.select.getFocusedOption();
if (focusedOption && focusedOption === this._createPlaceholderOption && shouldKeyDownEventCreateNewOption({ keyCode: event.keyCode })) {
this.createNewOption();
// Prevent decorated Select from doing anything additional with this keyDown event
event.preventDefault();
} else if (onInputKeyDown) {
onInputKeyDown(event);
}
}
}, {
key: 'onOptionSelect',
value: function onOptionSelect(option, event) {
if (option === this._createPlaceholderOption) {
this.createNewOption();
} else {
this.select.selectValue(option);
}
}
}, {
key: 'focus',
value: function focus() {
this.select.focus();
}
}, {
key: 'render',
value: function render() {
var _this2 = this;
var _props4 = this.props,
newOptionCreator = _props4.newOptionCreator,
shouldKeyDownEventCreateNewOption = _props4.shouldKeyDownEventCreateNewOption,
refProp = _props4.ref,
restProps = objectWithoutProperties(_props4, ['newOptionCreator', 'shouldKeyDownEventCreateNewOption', 'ref']);
var children = this.props.children;
// We can't use destructuring default values to set the children,
// because it won't apply work if `children` is null. A falsy check is
// more reliable in real world use-cases.
if (!children) {
children = defaultChildren$2;
}
var props = _extends({}, restProps, {
allowCreate: true,
filterOptions: this.filterOptions,
menuRenderer: this.menuRenderer,
onInputChange: this.onInputChange,
onInputKeyDown: this.onInputKeyDown,
ref: function ref(_ref2) {
_this2.select = _ref2;
// These values may be needed in between Select mounts (when this.select is null)
if (_ref2) {
_this2.labelKey = _ref2.props.labelKey;
_this2.valueKey = _ref2.props.valueKey;
}
if (refProp) {
refProp(_ref2);
}
}
});
return children(props);
}
}]);
return CreatableSelect;
}(React.Component);
function defaultChildren$2(props) {
return React.createElement(Select$1, props);
}
function isOptionUnique(_ref3) {
var option = _ref3.option,
options = _ref3.options,
labelKey = _ref3.labelKey,
valueKey = _ref3.valueKey;
return options.filter(function (existingOption) {
return existingOption[labelKey] === option[labelKey] || existingOption[valueKey] === option[valueKey];
}).length === 0;
}
function isValidNewOption(_ref4) {
var label = _ref4.label;
return !!label;
}
function newOptionCreator(_ref5) {
var label = _ref5.label,
labelKey = _ref5.labelKey,
valueKey = _ref5.valueKey;
var option = {};
option[valueKey] = label;
option[labelKey] = label;
option.className = 'Select-create-option-placeholder';
return option;
}
function promptTextCreator(label) {
return 'Create option "' + label + '"';
}
function shouldKeyDownEventCreateNewOption(_ref6) {
var keyCode = _ref6.keyCode;
switch (keyCode) {
case 9: // TAB
case 13: // ENTER
case 188:
// COMMA
return true;
}
return false;
}
// Default prop methods
CreatableSelect.isOptionUnique = isOptionUnique;
CreatableSelect.isValidNewOption = isValidNewOption;
CreatableSelect.newOptionCreator = newOptionCreator;
CreatableSelect.promptTextCreator = promptTextCreator;
CreatableSelect.shouldKeyDownEventCreateNewOption = shouldKeyDownEventCreateNewOption;
CreatableSelect.defaultProps = {
filterOptions: filterOptions,
isOptionUnique: isOptionUnique,
isValidNewOption: isValidNewOption,
menuRenderer: menuRenderer,
newOptionCreator: newOptionCreator,
promptTextCreator: promptTextCreator,
shouldKeyDownEventCreateNewOption: shouldKeyDownEventCreateNewOption
};
CreatableSelect.propTypes = {
// Child function responsible for creating the inner Select component
// This component can be used to compose HOCs (eg Creatable and Async)
// (props: Object): PropTypes.element
children: PropTypes.func,
// See Select.propTypes.filterOptions
filterOptions: PropTypes.any,
// Searches for any matching option within the set of options.
// This function prevents duplicate options from being created.
// ({ option: Object, options: Array, labelKey: string, valueKey: string }): boolean
isOptionUnique: PropTypes.func,
// Determines if the current input text represents a valid option.
// ({ label: string }): boolean
isValidNewOption: PropTypes.func,
// See Select.propTypes.menuRenderer
menuRenderer: PropTypes.any,
// Factory to create new option.
// ({ label: string, labelKey: string, valueKey: string }): Object
newOptionCreator: PropTypes.func,
// input change handler: function (inputValue) {}
onInputChange: PropTypes.func,
// input keyDown handler: function (event) {}
onInputKeyDown: PropTypes.func,
// new option click handler: function (option) {}
onNewOptionClick: PropTypes.func,
// See Select.propTypes.options
options: PropTypes.array,
// Creates prompt/placeholder option text.
// (filterText: string): string
promptTextCreator: PropTypes.func,
ref: PropTypes.func,
// Decides if a keyDown event (eg its `keyCode`) should result in the creation of a new option.
shouldKeyDownEventCreateNewOption: PropTypes.func
};
var AsyncCreatableSelect = function (_React$Component) {
inherits(AsyncCreatableSelect, _React$Component);
function AsyncCreatableSelect() {
classCallCheck(this, AsyncCreatableSelect);
return possibleConstructorReturn(this, (AsyncCreatableSelect.__proto__ || Object.getPrototypeOf(AsyncCreatableSelect)).apply(this, arguments));
}
createClass(AsyncCreatableSelect, [{
key: 'focus',
value: function focus() {
this.select.focus();
}
}, {
key: 'render',
value: function render() {
var _this2 = this;
return React.createElement(
Async,
this.props,
function (_ref) {
var ref = _ref.ref,
asyncProps = objectWithoutProperties(_ref, ['ref']);
var asyncRef = ref;
return React.createElement(
CreatableSelect,
asyncProps,
function (_ref2) {
var ref = _ref2.ref,
creatableProps = objectWithoutProperties(_ref2, ['ref']);
var creatableRef = ref;
return _this2.props.children(_extends({}, creatableProps, {
ref: function ref(select) {
creatableRef(select);
asyncRef(select);
_this2.select = select;
}
}));
}
);
}
);
}
}]);
return AsyncCreatableSelect;
}(React.Component);
function defaultChildren$1(props) {
return React.createElement(Select$1, props);
}
AsyncCreatableSelect.propTypes = {
children: PropTypes.func.isRequired // Child function responsible for creating the inner Select component; (props: Object): PropTypes.element
};
AsyncCreatableSelect.defaultProps = {
children: defaultChildren$1
};
Select$1.Async = Async;
Select$1.AsyncCreatable = AsyncCreatableSelect;
Select$1.Creatable = CreatableSelect;
Select$1.Value = Value;
Select$1.Option = Option;
export { Async, AsyncCreatableSelect as AsyncCreatable, CreatableSelect as Creatable, Value, Option, menuRenderer as defaultMenuRenderer, arrowRenderer as defaultArrowRenderer, clearRenderer as defaultClearRenderer, filterOptions as defaultFilterOptions };
export default Select$1;
|
client/admin/info/UsageSection.stories.js
|
Sing-Li/Rocket.Chat
|
import React from 'react';
import { UsageSection } from './UsageSection';
export default {
title: 'admin/info/UsageSection',
component: UsageSection,
decorators: [
(fn) => <div className='rc-old'>{fn()}</div>,
],
};
const statistics = {
totalUsers: 'statistics.totalUsers',
nonActiveUsers: 'nonActiveUsers',
activeUsers: 'statistics.activeUsers',
totalConnectedUsers: 'statistics.totalConnectedUsers',
onlineUsers: 'statistics.onlineUsers',
awayUsers: 'statistics.awayUsers',
offlineUsers: 'statistics.offlineUsers',
totalRooms: 'statistics.totalRooms',
totalChannels: 'statistics.totalChannels',
totalPrivateGroups: 'statistics.totalPrivateGroups',
totalDirect: 'statistics.totalDirect',
totalLivechat: 'statistics.totalLivechat',
totalDiscussions: 'statistics.totalDiscussions',
totalThreads: 'statistics.totalThreads',
totalMessages: 'statistics.totalMessages',
totalChannelMessages: 'statistics.totalChannelMessages',
totalPrivateGroupMessages: 'statistics.totalPrivateGroupMessages',
totalDirectMessages: 'statistics.totalDirectMessages',
totalLivechatMessages: 'statistics.totalLivechatMessages',
uploadsTotal: 'statistics.uploadsTotal',
uploadsTotalSize: 1024,
integrations: {
totalIntegrations: 'statistics.integrations.totalIntegrations',
totalIncoming: 'statistics.integrations.totalIncoming',
totalIncomingActive: 'statistics.integrations.totalIncomingActive',
totalOutgoing: 'statistics.integrations.totalOutgoing',
totalOutgoingActive: 'statistics.integrations.totalOutgoingActive',
totalWithScriptEnabled: 'statistics.integrations.totalWithScriptEnabled',
},
};
const apps = {
totalInstalled: 'statistics.apps.totalInstalled',
totalActive: 'statistics.apps.totalActive',
};
export const _default = () => <UsageSection statistics={statistics} />;
export const withApps = () => <UsageSection statistics={{ ...statistics, apps }} />;
export const loading = () => <UsageSection statistics={{}} isLoading />;
|
zanata-editor/src/__tests__/components/ProjectVersionLinkTest.js
|
Halcom/zanata-server
|
jest.disableAutomock()
import React from 'react'
import ReactDOMServer from 'react-dom/server'
import ProjectVersionLink from '../../app/components/ProjectVersionLink'
describe('ProjectVersionLinkTest', () => {
it('ProjectVersionLink markup', () => {
const actual = ReactDOMServer.renderToStaticMarkup(
<ProjectVersionLink project={{name: 'Weight Gain'}}
version="4000"
url="https://en.wikipedia.org/wiki/Weight_Gain_4000"/>
)
const expected = ReactDOMServer.renderToStaticMarkup(
<a href="https://en.wikipedia.org/wiki/Weight_Gain_4000"
className="Link--invert Header-item u-inlineBlock">
<span className="u-sPH-1-4 u-sizeWidth1 u-gtemd-hidden">
<i className="i i--arrow-left"></i>
</span>
<span className="Editor-currentProject u-sm-hidden u-sML-1-2">
<span>Weight Gain</span> <span
className="u-textMuted">4000</span>
</span>
</a>
)
expect(actual).toEqual(expected)
})
})
|
js/jqwidgets/demos/react/app/scheduler/monthviewwithautorowheight/app.js
|
luissancheza/sice
|
import React from 'react';
import ReactDOM from 'react-dom';
import JqxScheduler from '../../../jqwidgets-react/react_jqxscheduler.js';
class App extends React.Component {
componentDidMount () {
this.refs.myScheduler.ensureAppointmentVisible('id1');
}
render () {
let appointments = new Array();
let appointment1 = {
id: 'id1',
description: 'George brings projector for presentations.',
location: '',
subject: 'Quarterly Project Review Meeting',
calendar: 'Room 1',
start: new Date(2016, 10, 23, 9, 0, 0),
end: new Date(2016, 10, 23, 16, 0, 0)
}
let appointment2 = {
id: 'id2',
description: '',
location: '',
subject: 'IT Group Mtg.',
calendar: 'Room 2',
start: new Date(2016, 10, 24, 10, 0, 0),
end: new Date(2016, 10, 24, 15, 0, 0)
}
let appointment3 = {
id: 'id3',
description: '',
location: '',
subject: 'Course Social Media',
calendar: 'Room 3',
start: new Date(2016, 10, 23, 11, 0, 0),
end: new Date(2016, 10, 26, 13, 0, 0)
}
let appointment4 = {
id: 'id4',
description: '',
location: '',
subject: 'New Projects Planning',
calendar: 'Room 2',
start: new Date(2016, 10, 23, 16, 0, 0),
end: new Date(2016, 10, 27, 18, 0, 0)
}
let appointment5 = {
id: 'id5',
description: '',
location: '',
subject: 'Interview with James',
calendar: 'Room 1',
start: new Date(2016, 10, 24, 15, 0, 0),
end: new Date(2016, 10, 25, 17, 0, 0)
}
let appointment6 = {
id: 'id6',
description: '',
location: '',
subject: 'Interview with Nancy',
calendar: 'Room 4',
start: new Date(2016, 10, 24, 14, 0, 0),
end: new Date(2016, 10, 30, 16, 0, 0)
}
appointments.push(appointment1);
appointments.push(appointment2);
appointments.push(appointment3);
appointments.push(appointment4);
appointments.push(appointment5);
appointments.push(appointment6);
// prepare the data
let source =
{
dataType: 'array',
dataFields: [
{ name: 'id', type: 'string' },
{ name: 'description', type: 'string' },
{ name: 'location', type: 'string' },
{ name: 'subject', type: 'string' },
{ name: 'calendar', type: 'string' },
{ name: 'start', type: 'date' },
{ name: 'end', type: 'date' }
],
id: 'id',
localData: appointments
};
let adapter = new $.jqx.dataAdapter(source);
let resources =
{
colorScheme: 'scheme05',
dataField: 'calendar',
source: new $.jqx.dataAdapter(source)
};
let appointmentDataFields =
{
from: 'start',
to: 'end',
id: 'id',
description: 'description',
location: 'place',
subject: 'subject',
resourceId: 'calendar'
};
let views =
[
'dayView',
'weekView',
{ type: 'monthView', monthRowAutoHeight: true }
];
return (
<JqxScheduler ref='myScheduler'
width={850} height={600} source={adapter}
date={new $.jqx.date(2016, 11, 23)} showLegend={true}
view={'monthView'} resources={resources} views={views}
appointmentDataFields={appointmentDataFields}
/>
)
}
}
ReactDOM.render(<App />, document.getElementById('app'));
|
app/user/profile/UnselectedProfileSkillListItem.js
|
ecellju/internship-portal
|
import React from 'react';
import { Label, Icon } from 'semantic-ui-react';
import PropTypes from 'prop-types';
export default class UnselectedProfileSkillListItem extends React.Component {
constructor() {
super();
this.handleClick = (event, data) => {
console.log(data.children[0].props.children);
this.props.restoreSkill(data.children[0].props.children);
};
}
render() {
return (
<Label
onClick={this.handleClick}
key={this.props.skill}
className="hover-add-label"
as="a"
>
<span className="hover-label-text">{this.props.skill}</span>
<Icon className="hover-visible" name="checkmark" />
</Label>
);
}
}
UnselectedProfileSkillListItem.propTypes = {
skill: PropTypes.string.isRequired,
restoreSkill: PropTypes.func.isRequired,
};
|
packages/television/src/components/Head/Favicons.js
|
accosine/poltergeist
|
import React from 'react';
export default ({ config: { media, mediasuffix } }) => [
<link
rel="apple-touch-icon"
sizes="57x57"
href={`${media}apple-touch-icon-57x57.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="60x60"
href={`${media}apple-touch-icon-60x60.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="72x72"
href={`${media}apple-touch-icon-72x72.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="76x76"
href={`${media}apple-touch-icon-76x76.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="114x114"
href={`${media}apple-touch-icon-114x114.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="120x120"
href={`${media}apple-touch-icon-120x120.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="144x144"
href={`${media}apple-touch-icon-144x144.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="152x152"
href={`${media}apple-touch-icon-152x152.png${mediasuffix}`}
/>,
<link
rel="apple-touch-icon"
sizes="180x180"
href={`${media}apple-touch-icon-180x180.png${mediasuffix}`}
/>,
<link
rel="icon"
type="image/png"
href={`${media}favicon-32x32.png${mediasuffix}`}
sizes="32x32"
/>,
<link
rel="icon"
type="image/png"
href={`${media}android-chrome-192x192.png${mediasuffix}`}
sizes="192x192"
/>,
<link
rel="icon"
type="image/png"
href={`${media}favicon-96x96.png${mediasuffix}`}
sizes="96x96"
/>,
<link
rel="icon"
type="image/png"
href={`${media}favicon-16x16.png${mediasuffix}`}
sizes="16x16"
/>,
<link
rel="mask-icon"
href={`${media}safari-pinned-tab.svg${mediasuffix}`}
color="#5bbad5"
/>,
<meta name="msapplication-TileColor" content="#da532c" />,
<meta
name="msapplication-TileImage"
content={`${media}mstile-144x144.png${mediasuffix}`}
/>,
<meta name="theme-color" content="#ffffff" />,
];
|
docs/client/components/pages/Focus/SimpleFocusEditor/index.js
|
dagopert/draft-js-plugins
|
import React, { Component } from 'react';
import {
convertFromRaw,
EditorState,
} from 'draft-js';
import Editor, { composeDecorators } from 'draft-js-plugins-editor';
import createFocusPlugin from 'draft-js-focus-plugin';
import createColorBlockPlugin from './colorBlockPlugin';
import editorStyles from './editorStyles.css';
const focusPlugin = createFocusPlugin();
const decorator = composeDecorators(
focusPlugin.decorator,
);
const colorBlockPlugin = createColorBlockPlugin({ decorator });
const plugins = [focusPlugin, colorBlockPlugin];
/* eslint-disable */
const initialState = {
"entityMap": {
"0": {
"type": "colorBlock",
"mutability": "IMMUTABLE",
"data": {}
}
},
"blocks": [{
"key": "9gm3s",
"text": "This is a simple example. Focus the block by clicking on it and change alignment via the toolbar.",
"type": "unstyled",
"depth": 0,
"inlineStyleRanges": [],
"entityRanges": [],
"data": {}
}, {
"key": "ov7r",
"text": " ",
"type": "atomic",
"depth": 0,
"inlineStyleRanges": [],
"entityRanges": [{
"offset": 0,
"length": 1,
"key": 0
}],
"data": {}
}, {
"key": "e23a8",
"text": "More text here to demonstrate how inline left/right alignment works …",
"type": "unstyled",
"depth": 0,
"inlineStyleRanges": [],
"entityRanges": [],
"data": {}
}]
};
/* eslint-enable */
export default class CustomImageEditor extends Component {
state = {
editorState: EditorState.createWithContent(convertFromRaw(initialState)),
};
onChange = (editorState) => {
this.setState({
editorState,
});
};
focus = () => {
this.editor.focus();
};
render() {
return (
<div className={editorStyles.editor} onClick={this.focus}>
<Editor
editorState={this.state.editorState}
onChange={this.onChange}
plugins={plugins}
ref={(element) => { this.editor = element; }}
/>
</div>
);
}
}
|
src/app/modules/cart/components/Cart.spec.js
|
michael-wolfenden/redux-shopping-cart
|
import React from 'react'
import expect from 'expect'
import { mount } from 'enzyme'
import Cart from './Cart'
import Product from 'modules/products/components/Product'
const render = (total, products = []) => {
const actions = {
onCheckoutClicked: expect.createSpy(),
}
const component = mount(
<Cart total={total} products={products} {...actions} />
)
return {
component,
actions,
p: component.find('p'),
em: component.find('em'),
button: component.find('button'),
products: component.find(Product),
}
}
describe('cart', () => {
describe('components', () => {
describe('<Cart />', () => {
describe('when no products', () => {
it('should display total', () => {
const { p } = render('9.99')
expect(p.text())
.toMatch(/Total: \$9.99/)
})
it('should display add some products message', () => {
const { em } = render()
expect(em.text())
.toMatch(/^Please add some products to cart/)
})
it('should disable button', () => {
const { button } = render()
expect(button.prop('disabled'))
.toEqual('disabled')
})
})
describe('when given product', () => {
const product = [{
id: 1,
title: 'Product 1',
price: 9.99,
quantity: 1,
}]
it('should render products', () => {
const { products } = render('9.99', product)
const props = {
title: product[0].title,
price: product[0].price,
quantity: product[0].quantity,
key: product[0].id,
}
expect(products.at(0).props())
.toEqual(props)
})
it('should not disable button', () => {
const { button } = render('9.99', product)
expect(button.prop('disabled'))
.toEqual('')
})
it('should call action on button click', () => {
const { button, actions } = render('9.99', product)
button.simulate('click')
expect(actions.onCheckoutClicked)
.toHaveBeenCalled()
})
})
})
})
})
|
packages/ndla-image-search/src/ImageSearchForm.js
|
netliferesearch/frontend-packages
|
/**
* Copyright (c) 2016-present, NDLA.
*
* This source code is licensed under the GPLv3 license found in the
* LICENSE file in the root directory of this source tree.
*
*/
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { Button } from 'ndla-ui';
import BEMHelper from 'react-bem-helper';
const classes = new BEMHelper({
name: 'image-search',
prefix: 'c-',
});
class SearchForm extends Component {
constructor(props) {
super(props);
this.state = {
query: props.query,
};
this.handleQueryChange = this.handleQueryChange.bind(this);
this.handleSubmit = this.handleSubmit.bind(this);
this.onKeyPress = this.onKeyPress.bind(this);
}
onKeyPress(evt) {
if (evt.key === 'Enter') {
this.handleSubmit(evt);
}
}
handleQueryChange(evt) {
this.setState({ query: evt.target.value });
}
handleSubmit(evt) {
evt.preventDefault();
this.props.onSearchQuerySubmit(this.state.query);
}
render() {
const { searching, searchPlaceholder, searchButtonTitle } = this.props;
return (
<div {...classes('form')}>
<input
{...classes('form-query')}
type="text"
onChange={this.handleQueryChange}
onKeyPress={this.onKeyPress}
value={this.state.query}
placeholder={searchPlaceholder}
/>
<Button
{...classes('form-button')}
onClick={this.handleSubmit}
loading={searching}>
{searchButtonTitle}
</Button>
</div>
);
}
}
SearchForm.propTypes = {
query: PropTypes.string,
searching: PropTypes.bool.isRequired,
onSearchQuerySubmit: PropTypes.func.isRequired,
searchPlaceholder: PropTypes.string.isRequired,
searchButtonTitle: PropTypes.string.isRequired,
};
SearchForm.defaultProps = {
query: '',
};
export default SearchForm;
|
packages/components/src/DateTimePickers/pickers/TimePicker/TimePicker.component.js
|
Talend/ui
|
import React from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames';
import { timeToStr, pad } from '../../Time/time-extraction';
import withListGesture from '../../../Gesture/withListGesture';
import theme from './TimePicker.scss';
function isBefore(a, b) {
if (a.hours > b.hours) {
return false;
} else if (a.hours === b.hours && a.minutes > b.minutes) {
return false;
} else if (a.hours === b.hours && a.minutes === b.minutes && a.seconds >= b.seconds) {
return false;
}
return true;
}
function addInterval({ hours, minutes, ...seconds }, interval = 60) {
let newMinutes = minutes + interval;
let newHours = hours;
if (Math.floor(newMinutes / 60) > 0) {
newHours += Math.floor(newMinutes / 60);
newMinutes %= 60;
}
return {
hours: newHours,
minutes: newMinutes,
...seconds,
};
}
function getOptions(interval = 60, useSeconds) {
const options = [];
const start = { hours: 0, minutes: 0, seconds: 0 };
const end = { hours: 23, minutes: 59, seconds: 59 };
let current = start;
while (isBefore(current, end)) {
options.push({ label: timeToStr(current, useSeconds), value: current });
current = addInterval(current, interval);
}
return options;
}
export class TimePicker extends React.Component {
static propTypes = {
interval: PropTypes.number,
onChange: PropTypes.func.isRequired,
onKeyDown: PropTypes.func.isRequired,
textInput: PropTypes.string,
useSeconds: PropTypes.bool,
};
static defaultProps = {
interval: 60,
useSeconds: false,
};
constructor(props) {
super(props);
this.onSelect = this.onSelect.bind(this);
this.updateHighlightIndex = this.updateHighlightIndex.bind(this);
this.scrollItemIntoView = this.scrollItemIntoView.bind(this);
this.options = getOptions(props.interval, props.useSeconds);
this.state = {
hightlightedItemIndex: this.options.findIndex(option =>
option.label.includes(props.textInput),
),
};
}
componentDidMount() {
if (this.props.textInput) {
this.scrollItemIntoView(this.props.textInput);
}
}
onSelect(event, option, index) {
this.setState({ hightlightedItemIndex: index }, () =>
this.props.onChange(event, {
textInput: option.label,
time: {
hours: pad(option.value.hours),
minutes: pad(option.value.minutes),
seconds: pad(option.value.seconds),
},
}),
);
}
scrollItemIntoView(textInput) {
const found = this.options.findIndex(option => option.label.includes(textInput));
if (found) {
const ref = this.containerRef.childNodes[found];
if (ref) {
ref.scrollIntoView({
block: 'center',
});
}
if (found !== this.state.hightlightedItemIndex) {
this.updateHighlightIndex(found);
}
}
}
updateHighlightIndex(index) {
this.setState(({ hightlightedItemIndex }) => {
if (hightlightedItemIndex !== index) {
return {
hightlightedItemIndex: index,
};
}
return null;
});
}
render() {
return (
<div className={theme.container} ref={ref => (this.containerRef = ref)} role="list">
{this.options.map((option, index) => {
const className = classNames('tc-time-picker-time', {
highlight: index === this.state.hightlightedItemIndex,
});
const ariaProps = {};
if (index === this.state.hightlightedItemIndex) {
ariaProps['aria-current'] = 'time';
}
return (
<button
tabIndex={-1}
role="listitem"
type="button"
key={index}
className={className}
onClick={event => this.onSelect(event, option)}
onKeyDown={event => this.props.onKeyDown(event, this.containerRef.childNodes[index])}
{...ariaProps}
>
{option.label}
</button>
);
})}
</div>
);
}
}
export default withListGesture(TimePicker, true);
|
mdbreact/components/NavItem.js
|
ryanwashburne/react-skeleton
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames';
class NavItem extends Component {
render() {
const {
children,
className,
tag: Tag,
...attributes
} = this.props;
const classes = classNames(
'nav-item',
className,
);
return (
<Tag {...attributes} className={classes}>
{children}
</Tag>
);
}
}
NavItem.propTypes = {
tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
className: PropTypes.string,
children: PropTypes.node
};
NavItem.defaultProps = {
tag: 'li'
};
export default NavItem;
|
graphwalker-studio/src/main/js/index.js
|
KristianKarl/graphwalker-project
|
import "core-js/stable";
import "regenerator-runtime/runtime";
import React from 'react';
import { render } from "react-dom";
import { Provider } from 'react-redux'
import store from './redux/store'
import Application from './Application';
render(<Provider store={store}><Application /></Provider>, document.getElementById('root'));
|
test/components/EnterprisePageComponentTest.js
|
chimo/se-dir-frontend-react
|
/* eslint-env node, mocha */
/* global expect */
/* eslint no-console: 0 */
'use strict';
import React from 'react';
import { shallow } from 'enzyme';
import EnterprisePageComponent from 'components/EnterprisePageComponent.js';
var slug = require('slug');
slug.defaults.mode = 'rfc3986';
describe('EnterprisePageComponent', () => {
let component;
var directoryProp = [],
paramsProp = {
'slug': 'restore'
};
beforeEach(() => {
component = shallow(
<EnterprisePageComponent directory={directoryProp} params={paramsProp} />
);
});
it('should have its component name as default className', () => {
expect(component.hasClass('enterprisepage-component')).to.equal(true);
});
});
|
src/js/admin/articles/filters/label-filter/label-filter.js
|
ucev/blog
|
import React from 'react'
import { connect } from 'react-redux'
import FilterInput from '../filter-input'
const LabelFilter = ({ value }) => (
<FilterInput title="标签" label="label" value={value} />
)
const mapStateToProps = state => ({
value: state.filters.label,
})
const mapDispatchToProps = () => ({})
const _LabelFilter = connect(
mapStateToProps,
mapDispatchToProps
)(LabelFilter)
export default _LabelFilter
|
packages/veritone-react-common/src/components/OAuthLoginButton/story.js
|
veritone/veritone-sdk
|
import React from 'react';
import { storiesOf } from '@storybook/react';
import OAuthLoginButton from './';
storiesOf('OAuthLoginButton', module)
.add('With text', () => {
return <OAuthLoginButton />;
})
.add('Logo icon only', () => {
return <OAuthLoginButton iconOnly />;
});
|
frontend/js/components/ecosystems/LocationForm.js
|
Code4HR/okcandidate-platform
|
'use strict';
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import Hr from './../atoms/Hr';
import Alert from './../organisms/Alert';
import TextField from './../organisms/TextField';
import {
getLocationByGPS,
getLocationByAddress,
fetchNonRegionLimitedSurveys
} from './../../redux/actions/pick-survey-actions';
class LocationForm extends Component {
constructor(props) {
super(props);
this.state = {address: ''};
}
updateAddress(event) {
const address = event.target.value;
this.setState({
address: address
});
}
search(event) {
event && event.preventDefault();
this.props.dispatch(getLocationByAddress(this.state.address), () => {
this.setState({address: ''});
});
}
geolocate() {
this.props.dispatch(getLocationByGPS());
}
skip() {
this.props.dispatch(fetchNonRegionLimitedSurveys());
}
render() {
return (
<form className="location-form" onSubmit={this.search.bind(this)}>
<section>
{this.props.status.message &&
<Alert
level={this.props.status.level}
message={this.props.status.message} />
}
</section>
<section className="by-address">
<TextField
label="Locate Using Address"
name="address"
value={this.state.address}
onChange={this.updateAddress.bind(this)}
button={
<button
type="button"
onClick={this.search.bind(this)}>
Search
</button>
}/>
</section>
<Hr label="or" />
<section className="by-gps">
<label htmlFor="gps">Or use GPS</label>
<button
type="button"
id="gps"
onClick={this.geolocate.bind(this)}>
Use GPS
</button>
</section>
<Hr label="or" />
<section className="skip">
<label htmlFor="skip">Or skip it</label>
<button
type="button"
id="skip"
onClick={this.skip.bind(this)}>
Don't search
</button>
</section>
</form>
);
}
}
LocationForm.propTypes = {
dispatch: PropTypes.func,
addressError: PropTypes.string,
status: PropTypes.object
};
export default LocationForm;
|
src/screens/App/components/Header.js
|
enesTufekci/react-clear-starter-kit
|
/* @flow */
import React from 'react';
const Header = () => (
<div className="App-header">
<h2>React Clear Starter Kit</h2>
</div>
);
export default Header;
|
webpack/containers/questions/QuestionModalContainer.js
|
CDCgov/SDP-Vocabulary-Service
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';
import { Modal, Button, Row, Col } from 'react-bootstrap';
import $ from 'jquery';
import { saveQuestion } from '../../actions/questions_actions';
import { fetchPotentialDuplicateQuestions } from '../../actions/search_results_actions';
import Errors from '../../components/Errors';
import QuestionEdit from '../../components/questions/QuestionEdit';
import ResponseSetList from '../../components/response_sets/ResponseSetList';
import ResponseSetDragWidget from '../response_sets/ResponseSetDragWidget';
import { fetchResponseTypes } from '../../actions/response_type_actions';
import { fetchCategories } from '../../actions/category_actions';
import currentUserProps from '../../prop-types/current_user_props';
const DUPLICATE_QUESTION_MODAL_CONTEXT = "DUPLICATE_QUESTION_MODAL_CONTEXT";
class QuestionModalContainer extends Component {
constructor(props) {
super(props);
this.state = {linkedResponseSets: [], showResponseSetWidget: false, showResponseSets: false};
this.saveNewQuestion = this.saveNewQuestion.bind(this);
this.closeQuestionModal = this.closeQuestionModal.bind(this);
this.handleResponseSetsChange = this.handleResponseSetsChange.bind(this);
this.handleResponseTypeChange = this.handleResponseTypeChange.bind(this);
this.fetchPotentialDuplicateQuestions = this.fetchPotentialDuplicateQuestions.bind(this);
}
componentWillMount() {
this.props.fetchCategories();
this.props.fetchResponseTypes();
}
handleResponseSetsChange(newResponseSets){
this.unsavedState = true;
this.setState({linkedResponseSets: newResponseSets});
}
handleResponseTypeChange(newResponseType){
if(['Choice', 'Open Choice'].indexOf(newResponseType.name)!==-1){
this.setState({showResponseSets: true});
} else {
this.setState({showResponseSets: false, linkedResponseSets: []});
}
}
saveNewQuestion(newQuestion){
newQuestion.linkedResponseSets = this.state.linkedResponseSets;
this.props.saveQuestion(newQuestion, '', false, {}, (successResponse) => {
this.setState({showResponseSetWidget: false, linkedResponseSets: [], errors: null});
this.props.handleSaveQuestionSuccess(successResponse);
}, (failureResponse) => {
this.setState({errors: failureResponse.response.data});
});
}
closeQuestionModal(){
this.setState({showResponseSets: false, showResponseSetWidget:false, linkedResponseSets: [], errors: null});
this.props.closeQuestionModal();
}
fetchPotentialDuplicateQuestions(content, description) {
this.props.fetchPotentialDuplicateQuestions(DUPLICATE_QUESTION_MODAL_CONTEXT, content, description);
}
responseSetWidgetBody(){
return (
<div className={this.state.showResponseSetWidget ? '' : 'hidden'}>
<Modal.Body bsStyle='response-set'>
<Row className="response-set-row">
<Col md={6} className="response-set-label">
<h2>Response Sets</h2>
</Col>
<Col md={6} className="response-set-label">
<h2 className="tags-table-header">Selected Response Sets</h2>
</Col>
</Row>
<ResponseSetDragWidget selectedResponseSets={this.state.linkedResponseSets}
handleResponseSetsChange={this.handleResponseSetsChange} />
</Modal.Body>
<Modal.Footer>
<Button onClick={() => this.setState({showResponseSetWidget:false})} bsStyle="primary">Done</Button>
</Modal.Footer>
</div>
);
}
questionFormFooter(){
if(this.state.showResponseSets){
return (
<Modal.Footer>
<Button onClick={() => $('#submit-question-form').click()}>Add Question</Button>
<Button onClick={() => this.setState({showResponseSetWidget:true})} bsStyle="primary">Response Sets</Button>
</Modal.Footer>
);
} else {
return (
<Modal.Footer>
<Button onClick={() => $('#submit-question-form').click()}>Add Question</Button>
</Modal.Footer>
);
}
}
questionFormBody(){
var responseSetsDiv = (<div></div>);
var footer = (
<Modal.Footer>
<Button onClick={() => $('#submit-question-form').click()}>Add Question</Button>
</Modal.Footer>
);
if(this.state.showResponseSets){
responseSetsDiv = (
<Row className="selected_response_sets">
<Col md={12} className="response-set-label">
<h2>Response Sets</h2>
</Col>
<Col md={8}>
<div className="panel panel-default">
<div className="panel-body">
{this.state.linkedResponseSets.length > 0 ? <ResponseSetList responseSets={this.state.linkedResponseSets} /> : 'No Response Sets selected'}
</div>
</div>
</Col>
</Row>
);
footer = (
<Modal.Footer>
<Button onClick={() => $('#submit-question-form').click()}>Add Question</Button>
<Button onClick={() => this.setState({showResponseSetWidget:true})} bsStyle="primary">Response Sets</Button>
</Modal.Footer>
);
}
return (
<div className={this.state.showResponseSetWidget ? 'hidden' : ''}>
<Modal.Body bsStyle='question'>
<QuestionEdit action={'new'}
question={{}}
categories={this.props.categories}
responseTypes={this.props.responseTypes}
draftSubmitter ={()=>{}}
deleteSubmitter={()=>{}}
publishSubmitter ={()=>{}}
fetchPotentialDuplicateQuestions={this.fetchPotentialDuplicateQuestions}
currentUser={this.props.currentUser}
potentialDuplicates={this.props.potentialDuplicates}
questionSubmitter={this.saveNewQuestion}
handleResponseTypeChange={this.handleResponseTypeChange} />
{responseSetsDiv}
</Modal.Body>
{footer}
</div>
);
}
render() {
if(!this.props.categories || !this.props.responseTypes){
return (
<div>Loading...</div>
);
}
return (
<Modal bsStyle='question' show={this.props.showModal} onHide={this.closeQuestionModal} aria-label="New Question">
<Modal.Header closeButton bsStyle='question'>
<Modal.Title componentClass="h1">New Question</Modal.Title>
</Modal.Header>
<Errors errors={this.state.errors} />
{this.questionFormBody()}
{this.responseSetWidgetBody()}
</Modal>
);
}
}
function mapStateToProps(state) {
return {categories: state.categories, responseTypes: state.responseTypes,
currentUser: state.currentUser,
potentialDuplicates: state.searchResults[DUPLICATE_QUESTION_MODAL_CONTEXT] || {}};
}
function mapDispatchToProps(dispatch) {
return bindActionCreators({fetchCategories, fetchResponseTypes, saveQuestion, fetchPotentialDuplicateQuestions}, dispatch);
}
QuestionModalContainer.propTypes = {
route: PropTypes.object.isRequired,
router: PropTypes.object.isRequired,
showModal: PropTypes.bool.isRequired,
saveQuestion: PropTypes.func,
categories: PropTypes.object,
responseTypes: PropTypes.object,
fetchCategories: PropTypes.func,
fetchResponseTypes: PropTypes.func,
closeQuestionModal: PropTypes.func.isRequired,
handleSaveQuestionSuccess: PropTypes.func.isRequired,
fetchPotentialDuplicateQuestions: PropTypes.func,
currentUser: currentUserProps,
potentialDuplicates: PropTypes.object
};
export default connect(mapStateToProps, mapDispatchToProps)(QuestionModalContainer);
|
src/components/UserDetailSections/ExtendedInfo/components/RequestPreferencesView/RequestPreferencesView.js
|
folio-org/ui-users
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { FormattedMessage } from 'react-intl';
import {
Col,
KeyValue,
Row,
} from '@folio/stripes/components';
import { requestPreferencesShape } from '../../../../../shapes';
import styles from './RequestPreferencesView.css';
class RequestPreferencesView extends Component {
static propTypes = {
requestPreferences: requestPreferencesShape,
defaultServicePointName: PropTypes.string,
defaultDeliveryAddressTypeName: PropTypes.string.isRequired,
};
getHoldShelfStateTranslationKey() {
return this.props.requestPreferences.holdShelf
? 'ui-users.requests.holdShelfYes'
: 'ui-users.requests.holdShelfNo';
}
getDeliveryStateTranslationKey() {
return this.props.requestPreferences.delivery
? 'ui-users.requests.deliveryYes'
: 'ui-users.requests.deliveryNo';
}
render() {
const {
requestPreferences,
defaultServicePointName,
defaultDeliveryAddressTypeName,
} = this.props;
return (
<>
<Row>
<Col xs={4}>
<span className={styles.heading}>
<FormattedMessage id="ui-users.requests.preferences" />
</span>
</Col>
</Row>
<Row className={styles['request-preferences-row']}>
<Col xs={4} data-test-hold-shelf>
<FormattedMessage id={this.getHoldShelfStateTranslationKey()} />
</Col>
<Col xs={4} data-test-delivery>
<FormattedMessage id={this.getDeliveryStateTranslationKey()} />
</Col>
</Row>
<Row>
<Col xs={4}>
{requestPreferences.holdShelf && (
<KeyValue label={<FormattedMessage id="ui-users.requests.defaultPickupServicePoint" />}>
<span data-test-default-pickup-service-point>
{ defaultServicePointName || '-' }
</span>
</KeyValue>
)}
</Col>
<Col xs={4}>
{requestPreferences.delivery && (
<KeyValue label={<FormattedMessage id="ui-users.requests.fulfillmentPreference" />}>
<span data-test-fulfillment-preference>
{ requestPreferences.fulfillment }
</span>
</KeyValue>
)}
</Col>
</Row>
<Row>
<Col xsOffset={4} xs={8}>
{requestPreferences.delivery && (
<KeyValue label={<FormattedMessage id="ui-users.requests.defaultDeliveryAddress" />}>
<span data-test-default-delivery-address>
{ defaultDeliveryAddressTypeName || '-'}
</span>
</KeyValue>
)}
</Col>
</Row>
</>
);
}
}
export default RequestPreferencesView;
|
src/containers/views/PageNew.js
|
jekyll/jekyll-admin
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { bindActionCreators } from 'redux';
import { browserHistory, withRouter } from 'react-router';
import DocumentTitle from 'react-document-title';
import CreateMarkdownPage from '../../components/CreateMarkdownPage';
import { updateTitle, updateBody, updatePath } from '../../ducks/metadata';
import { createPage } from '../../ducks/pages';
import { clearErrors } from '../../ducks/utils';
import { preventDefault, getDocumentTitle } from '../../utils/helpers';
import { ADMIN_PREFIX } from '../../constants';
import translations from '../../translations';
const { getLeaveMessage } = translations;
export class PageNew extends Component {
componentDidMount() {
const { router, route } = this.props;
router.setRouteLeaveHook(route, this.routerWillLeave);
}
componentWillReceiveProps(nextProps) {
if (this.props.updated !== nextProps.updated) {
browserHistory.push(`${ADMIN_PREFIX}/pages/${nextProps.page.path}`);
}
}
componentWillUnmount() {
const { clearErrors, errors } = this.props;
errors.length && clearErrors();
}
routerWillLeave = nextLocation => {
if (this.props.fieldChanged) {
return getLeaveMessage();
}
};
handleClickSave = e => {
preventDefault(e);
const { fieldChanged, createPage, params } = this.props;
fieldChanged && createPage(params.splat);
};
render() {
const {
params,
config,
errors,
updated,
updateBody,
updatePath,
updateTitle,
fieldChanged,
} = this.props;
const title = getDocumentTitle('pages', params.splat, 'New page');
return (
<DocumentTitle title={title}>
<CreateMarkdownPage
type="pages"
params={params}
config={config}
errors={errors}
updated={updated}
updateBody={updateBody}
updatePath={updatePath}
updateTitle={updateTitle}
fieldChanged={fieldChanged}
onClickSave={this.handleClickSave}
/>
</DocumentTitle>
);
}
}
PageNew.propTypes = {
createPage: PropTypes.func.isRequired,
updateTitle: PropTypes.func.isRequired,
updateBody: PropTypes.func.isRequired,
updatePath: PropTypes.func.isRequired,
clearErrors: PropTypes.func.isRequired,
errors: PropTypes.array.isRequired,
fieldChanged: PropTypes.bool.isRequired,
updated: PropTypes.bool.isRequired,
router: PropTypes.object.isRequired,
route: PropTypes.object.isRequired,
params: PropTypes.object.isRequired,
config: PropTypes.object.isRequired,
page: PropTypes.object.isRequired,
};
const mapStateToProps = state => ({
page: state.pages.page,
fieldChanged: state.metadata.fieldChanged,
errors: state.utils.errors,
updated: state.pages.updated,
config: state.config.config,
});
const mapDispatchToProps = dispatch =>
bindActionCreators(
{
updateTitle,
updateBody,
updatePath,
createPage,
clearErrors,
},
dispatch
);
export default withRouter(
connect(mapStateToProps, mapDispatchToProps)(PageNew)
);
|
app/containers/SignUpContainer.js
|
jcarral/cafeADE
|
import React, { Component } from 'react';
import { connect } from 'react-redux';
import SignUp from '../components/SignUp';
import LoadingPage from '../components/LoadingPage';
import { signUp } from '../actions/statusActions';
class SignUpContainer extends Component {
static navigationOptions = {
title: 'Registro'
}
constructor(props){
super(props);
this.state = {
username : '',
pwd: '',
email: ''
};
}
handleUsername = (e) => {
this.setState({username: e});
}
handlePwd = (e) => {
this.setState({pwd: e});
}
handleEmail = (e) => {
this.setState({email: e});
}
handleSubmit = () => {
this.props.dispatch(signUp(this.state))
}
render(){
if(this.props.loading){
return (<LoadingPage />);
}else{
return (
<SignUp
handlePwd={this.handlePwd}
handleUsername={this.handleUsername}
handleEmail={this.handleEmail}
handleSubmit={this.handleSubmit}
error={this.props.error}
pwd={this.state.pwd}
name={this.state.username}
email={this.state.email}
/>
);
}
}
}
const mapStateToProps = (state, action) => ({
error: state.status.error,
loading: state.status.loading
});
export default connect(mapStateToProps)(SignUpContainer);
|
src/routes/authority/account/Filter.js
|
muidea/magicSite
|
import React from 'react'
import PropTypes from 'prop-types'
import { Form, Button, Row, Col, Input, Popconfirm } from 'antd'
const { Search } = Input
const ColProps = {
xs: 24,
sm: 12,
style: { marginBottom: 16 },
}
const TwoColProps = {
...ColProps,
xl: 96,
}
const Filter = ({
onAdd,
onFilterChange,
onDeleteItems,
selectedRowKeys,
filter,
form: {
getFieldDecorator,
getFieldsValue,
setFieldsValue,
},
}) => {
const handleFields = (fields) => {
return fields
}
const handleSubmit = () => {
let fields = getFieldsValue()
fields = handleFields(fields)
onFilterChange(fields)
}
const handleReset = () => {
const fields = getFieldsValue()
for (const item in fields) {
if ({}.hasOwnProperty.call(fields, item)) {
if (fields[item] instanceof Array) {
fields[item] = []
} else {
fields[item] = undefined
}
}
}
setFieldsValue(fields)
handleSubmit()
}
const handleDeleteItems = () => {
onDeleteItems()
}
const { name } = filter
return (
<Row gutter={24}>
<Col {...ColProps} xl={{ span: 14 }} md={{ span: 14 }}>
{getFieldDecorator('name', { initialValue: name })(<Search placeholder="查找分组" size="large" onSearch={handleSubmit} />)}
</Col>
<Col {...TwoColProps} xl={{ span: 10 }} md={{ span: 10 }} sm={{ span: 10 }}>
<div style={{ display: 'flex', justifyContent: 'space-between' }}>
<div >
<Button type="primary" size="large" className="margin-right" onClick={handleSubmit}>查找</Button>
<Button size="large" onClick={handleReset}>重置</Button>
</div>
<div>
{
selectedRowKeys.length > 0 &&
<Popconfirm title="确认删除选中项?" placement="left" onConfirm={handleDeleteItems}>
<Button type="primary" style={{ marginRight: 16 }} size="large">删除</Button>
</Popconfirm>
}
<Button size="large" type="ghost" onClick={onAdd}>新建</Button>
</div>
</div>
</Col>
</Row>
)
}
Filter.propTypes = {
selectedRowKeys: PropTypes.array,
onDeleteItems: PropTypes.func,
onAdd: PropTypes.func,
form: PropTypes.object,
filter: PropTypes.object,
onFilterChange: PropTypes.func,
}
export default Form.create()(Filter)
|
packages/es-components/src/components/controls/radio-buttons/RadioButton.js
|
jrios/es-components
|
import React from 'react';
import PropTypes from 'prop-types';
import styled from 'styled-components';
import Label from '../label/Label';
import getRadioFillVariables from './radio-fill-variables';
import { useTheme } from '../../util/useTheme';
import ValidationContext from '../ValidationContext';
import useUniqueId from '../../util/useUniqueId';
function radioFill(color) {
return `
background-color: ${color};
border-radius: 50%;
content: '';
display: block;
height: 13px;
left: 3px;
position: relative;
width: 13px;
top: 3px;
transition: background 0.25s linear;
`;
}
const RadioLabel = styled(Label)`
align-self: flex-start;
cursor: pointer;
display: flex;
font-family: 'Source Sans Pro', 'Segoe UI', Segoe, Calibri, Tahoma, sans-serif;
font-size: ${props => props.theme.sizes.baseFontSize};
font-weight: normal;
line-height: ${props => props.theme.sizes.baseLineHeight};
margin-right: 15px;
margin-bottom: 10px;
position: relative;
padding: 10px 0 10px 10px;
text-transform: none;
&:hover .es-radio__fill:before {
${props => !props.checked && radioFill(props.hoverFillColor)};
}
@media (min-width: ${props => props.theme.screenSize.tablet}) {
padding: 5px 0;
}
`;
const RadioInput = styled.input`
clip: rect(0, 0, 0, 0);
pointer-events: none;
position: absolute;
&:focus ~ .es-radio__fill {
box-shadow: 0 0 3px 3px ${props => props.theme.colors.inputFocus};
}
`;
const RadioDisplay = styled.span`
border: 3px solid ${props => props.borderColor};
border-radius: 50%;
box-sizing: border-box;
height: 25px;
margin-right: 8px;
min-width: 25px;
&:before {
${props => radioFill(props.fill)};
}
`;
export function RadioButton({ children, ...radioProps }) {
const id = useUniqueId(radioProps.id);
const isChecked = radioProps.checked || radioProps.defaultChecked;
const theme = useTheme();
const validationState = React.useContext(ValidationContext);
const { hover, fill } = getRadioFillVariables(
isChecked,
radioProps.disabled,
validationState,
theme.colors
);
const radioDisplayFill = isChecked ? fill : theme.colors.white;
const labelProps = {
disabled: radioProps.disabled,
htmlFor: id,
hoverFillColor: hover,
validationState,
checked: isChecked
};
return (
<RadioLabel {...labelProps}>
<RadioInput type="radio" id={id} {...radioProps} />
<RadioDisplay
className="es-radio__fill"
borderColor={fill}
fill={radioDisplayFill}
/>
{children}
</RadioLabel>
);
}
RadioButton.propTypes = {
children: PropTypes.any
};
RadioButton.defaultProps = {
children: undefined
};
export default RadioButton;
|
test/integration/scss-fixtures/npm-import-nested/pages/_app.js
|
JeromeFitz/next.js
|
import React from 'react'
import App from 'next/app'
import '../styles/global.scss'
class MyApp extends App {
render() {
const { Component, pageProps } = this.props
return <Component {...pageProps} />
}
}
export default MyApp
|
app/components/Product.js
|
Byte-Code/lm-digital-store-private-test
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import ImmutablePropTypes from 'react-immutable-proptypes';
import { Map, fromJS } from 'immutable';
import glamorous from 'glamorous';
import throttle from 'lodash/throttle';
import inRange from 'lodash/inRange';
import ImageSlider from './ImageSlider';
import ProductInfo from './ProductInfo';
import ProductInfoBadge from './ProductInfoBadge';
import SimilarProducts from './SimilarProducts';
import ScrollableDiv from './ScrollableDiv';
export default class Product extends Component {
static propTypes = {
params: PropTypes.shape({
productCode: PropTypes.string.isRequired
}).isRequired,
productInfo: ImmutablePropTypes.map,
requestFetchProduct: PropTypes.func.isRequired,
clearProductList: PropTypes.func.isRequired,
setAnalyticsProductClick: PropTypes.func.isRequired,
similarProducts: ImmutablePropTypes.list.isRequired,
hasNearbyStores: PropTypes.bool.isRequired
};
static defaultProps = {
productInfo: Map()
};
constructor(props) {
super(props);
this.throttleValue = 500;
this.onScrolling = this.onScrolling.bind(this);
this.setScrollValue = this.setScrollValue.bind(this);
this.renderAnimatedTitle = this.renderAnimatedTitle.bind(this);
this.getOpacity = this.getOpacity.bind(this);
this.state = {
scrollValue: 0
};
}
componentDidMount() {
const { params: { productCode }, requestFetchProduct } = this.props;
requestFetchProduct(productCode);
}
componentWillReceiveProps(nextProps) {
const prevProductCode = this.props.params.productCode;
const { params: { productCode }, requestFetchProduct } = nextProps;
if (prevProductCode !== productCode) {
requestFetchProduct(productCode);
}
}
componentWillUnmount() {
this.props.clearProductList();
}
onScrolling(scrollValue) {
this.setScrollValue(scrollValue);
}
setScrollValue(scrollValue) {
(throttle(() => {
this.setState({ scrollValue });
}, this.throttleValue))();
}
getOpacity() {
const { scrollValue } = this.state;
let opacity = 1;
if (this.state.scrollValue) {
if (inRange(scrollValue, 1, 400)) opacity = 0.75;
if (inRange(scrollValue, 401, 600)) opacity = 0.5;
if (inRange(scrollValue, 601, 1078)) opacity = 0.25;
if (inRange(scrollValue, 1079, 2000)) opacity = 0;
}
return opacity;
}
renderSimilarProducts() {
const { similarProducts, productInfo } = this.props;
if (similarProducts.isEmpty()) {
return null;
}
const relatedProd = productInfo.get('similarProducts');
return relatedProd.map(sp => {
const products = similarProducts.filter(p => sp.get('products').includes(p.get('code')));
return (
<SimilarProducts
key={sp.get('name')}
similarProducts={products}
title={sp.get('name')}
setAnalyticsProductClick={this.props.setAnalyticsProductClick}
/>
);
});
}
renderAnimatedTitle(config) {
const { name, code } = config;
const isShadowBox = this.state.scrollValue >= 1100;
return (
isShadowBox ?
<FixedTitleWrapper>
<Title>{name}</Title>
<Ref>{`REF. ${code}`}</Ref>
</FixedTitleWrapper> : <div />
);
}
render() {
const { productInfo, hasNearbyStores } = this.props;
if (productInfo.isEmpty()) {
return null;
}
const name = productInfo.get('name');
const code = productInfo.get('code');
const slug = productInfo.get('slug');
const productType = productInfo.getIn(['productDetail', 'descriptionType']);
const marketingDescriptions = productInfo.getIn(['productDetail', 'marketingDescriptions']);
const marketingAttributes = productInfo.get('marketingAttributes');
const loyaltyProgram = productInfo.get('loyaltyProgram');
const descriptions = productInfo.getIn(['productDetail', 'descriptions']);
const price = productInfo.getIn(['price', 'selling']);
const pricingInfo = productInfo.get('pricingInformations');
const currentStoreStock = fromJS({
storeStock: productInfo.get('storeStock'),
stockStatus: productInfo.getIn(['productStockInfo', 'vendibilityValue'])
});
const imageIDList = productInfo.get('images');
const imageOptions = { width: 1080, height: 1080, crop: 'fit' };
return (
<Wrapper>
<ScrollableDiv onScrolling={this.onScrolling}>
<Title>{name}</Title>
<Ref>{`REF. ${code}`}</Ref>
{this.renderAnimatedTitle({ name, code })}
<SliderWrapper opacity={this.getOpacity()}>
<ImageSlider imageIDList={imageIDList} imageOptions={imageOptions} alt={name} />
</SliderWrapper>
<ProductInfo
productType={productType}
marketingDescriptions={marketingDescriptions}
descriptions={descriptions}
/>
<SimilarProductsWrapper>
{this.renderSimilarProducts()}
</SimilarProductsWrapper>
<PriceWrapper>
<ProductInfoBadge
productName={name}
productCode={code}
productSlug={slug}
pricingInfo={pricingInfo}
currentStoreStock={currentStoreStock}
marketingAttributes={marketingAttributes}
loyaltyProgram={loyaltyProgram}
price={price}
scrollValue={this.state.scrollValue}
hasNearbyStores={hasNearbyStores}
/>
</PriceWrapper>
</ScrollableDiv>
</Wrapper>
);
}
}
const Wrapper = glamorous.div({
position: 'relative'
});
const Title = glamorous.h1({
padding: '40px 100px 0',
textAlign: 'center',
fontSize: 48,
lineHeight: '70px',
textTransform: 'capitalize'
});
const Ref = glamorous.h3({
textTransform: 'uppercase',
fontSize: 16,
lineHeight: '24px',
textAlign: 'center',
marginBottom: 16
});
const SliderWrapper = glamorous.div(({ opacity }) => ({
width: '100%',
opacity
}));
const PriceWrapper = glamorous.div({
position: 'fixed',
right: '2%',
top: '12%'
});
const SimilarProductsWrapper = glamorous.div({
margin: '60px 0 0',
'&>div': {
marginBottom: 80
}
});
const FixedTitleWrapper = glamorous.div({
width: '100%',
backgroundColor: 'white',
boxShadow: '0px 6px 5px #888888',
zIndex: 1,
position: 'fixed',
top: '0px'
});
|
src/entry-points/client.js
|
shaunstanislaus/react-redux-starter-kit
|
import React from 'react';
import App from 'containers/app';
import { history } from 'react-router/lib/BrowserHistory';
React.render(<App history={history} />, document.getElementById('mount'));
|
src/svg-icons/image/filter-7.js
|
pradel/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let ImageFilter7 = (props) => (
<SvgIcon {...props}>
<path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2l4-8V5h-6v2h4l-4 8h2z"/>
</SvgIcon>
);
ImageFilter7 = pure(ImageFilter7);
ImageFilter7.displayName = 'ImageFilter7';
export default ImageFilter7;
|
__tests__/TestComponentWhichShouldThrow4.js
|
liegeandlief/whitelodge
|
'use strict'
import React from 'react'
import {AddStoreSubscriptions} from '../src/'
class TestComponent extends React.Component {
render () {
return null
}
}
export default AddStoreSubscriptions(TestComponent, ['testStore'], window, ['notAString'])
|
app/javascript/mastodon/components/column_back_button_slim.js
|
esetomo/mastodon
|
import React from 'react';
import { FormattedMessage } from 'react-intl';
import PropTypes from 'prop-types';
export default class ColumnBackButtonSlim extends React.PureComponent {
static contextTypes = {
router: PropTypes.object,
};
handleClick = () => {
if (window.history && window.history.length === 1) this.context.router.history.push('/');
else this.context.router.history.goBack();
}
render () {
return (
<div className='column-back-button--slim'>
<div role='button' tabIndex='0' onClick={this.handleClick} className='column-back-button column-back-button--slim-button'>
<i className='fa fa-fw fa-chevron-left column-back-button__icon' />
<FormattedMessage id='column_back_button.label' defaultMessage='Back' />
</div>
</div>
);
}
}
|
docs/src/app/components/pages/components/Avatar/Page.js
|
pradel/material-ui
|
import React from 'react';
import Title from 'react-title-component';
import CodeExample from '../../../CodeExample';
import PropTypeDescription from '../../../PropTypeDescription';
import MarkdownElement from '../../../MarkdownElement';
import avatarReadmeText from './README';
import AvatarExampleSimple from './ExampleSimple';
import avatarExampleSimpleCode from '!raw!./ExampleSimple';
import avatarCode from '!raw!material-ui/lib/Avatar/Avatar';
const description = 'Examples of `Avatar` using an image, [Font Icon](/#/components/font-icon), ' +
'[SVG Icon](/#/components/svg-icon) and "Letter" (string), with and without custom colors.';
const AvatarsPage = () => (
<div>
<Title render={(previousTitle) => `Avatar - ${previousTitle}`} />
<MarkdownElement text={avatarReadmeText} />
<CodeExample
code={avatarExampleSimpleCode}
title="Examples"
description={description}
>
<AvatarExampleSimple />
</CodeExample>
<PropTypeDescription code={avatarCode} />
</div>
);
export default AvatarsPage;
|
src/bundles/ApplicationsAdmin/components/AppDiff/AppDiff.js
|
AusDTO/dto-digitalmarketplace-frontend
|
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { Control, LocalForm } from 'react-redux-form';
import { appSave } from '../../redux/modules/application';
import { diff_match_patch } from 'diff-match-patch';
import styles from './AppDiff.css';
import traverse from 'traverse';
class AppDiff extends Component {
cleanup(supplier, application) {
if (supplier) {
delete supplier.links;
delete supplier.prices;
delete supplier.domains;
delete supplier.steps;
delete supplier.updated_at;
delete supplier.last_update_time;
delete supplier.lastUpdateTime;
delete supplier.created_at;
delete supplier.createdAt;
delete supplier.creationTime;
delete supplier.creation_time;
delete supplier.text_vector;
delete supplier.contacts;
delete supplier.supplierCode;
delete supplier.supplier_code;
delete supplier.frameworks;
delete supplier.status;
delete supplier.id;
delete supplier.application_id;
delete supplier.signed_agreements;
}
if (application) {
delete application.links;
delete application.steps;
delete application.updated_at;
delete application.last_update_time;
delete application.lastUpdateTime;
delete application.created_at;
delete application.createdAt;
delete application.creationTime;
delete application.creation_time;
delete application.text_vector;
delete application.supplierCode;
delete application.supplier_code;
delete application.frameworks;
delete application.type;
delete application.status;
delete application.id;
delete application.application_id;
}
}
render() {
const { application, meta } = this.props;
this.cleanup(meta.supplier, application.data);
var differences = [];
traverse(meta.supplier).forEach(function (v) {
if (this.isLeaf && this.path.indexOf('links') < 0) {
differences.push({
property: this.path.join('.'),
original: v ? v : '',
updated: '',
html: undefined
});
}
});
traverse(application.data).forEach(function (v) {
if (this.isLeaf && this.path.indexOf('links') < 0) {
const property = this.path.join('.');
const existing = differences.find(e => e.property == property);
if (existing) {
existing.updated = v ? v : '';
} else {
differences.push({
property,
original: '',
updated: v ? v : '',
html: undefined
});
}
}
});
differences.forEach(v => {
if (`${v.original}` !== `${v.updated}`) {
let dmp = new diff_match_patch();
let diffs = dmp.diff_main(`${v.original}`, `${v.updated}`);
dmp.diff_cleanupEfficiency(diffs);
v.html = dmp.diff_prettyHtml(diffs);;
}
})
differences.sort((a, b) => {
if (a.property < b.property) {
return -1;
}
if (a.property > b.property) {
return 1;
}
return 0;
})
return (
<article id="content">
<table styleName="diff-table">
<tbody>
<tr>
<th>{'Property'}</th>
<th>{'Original'}</th>
<th>{'Updated'}</th>
<th>{'Difference'}</th>
</tr>
{differences.map(d => {
return d.html && <tr key={d.property}>
<td>{d.property}</td>
<td>{`${d.original}`}</td>
<td>{`${d.updated}`}</td>
<td><span dangerouslySetInnerHTML={{ __html: d.html }} /></td>
</tr>
})}
</tbody>
</table>
</article>
)
}
}
const mapStateToProps = (ownProps) => {
return {
...ownProps,
};
};
const mapDispatchToProps = (dispatch) => {
return {
onAppSubmit: (values) => {
dispatch(appSave(values))
}
}
};
export default connect(mapStateToProps, mapDispatchToProps)(AppDiff);
|
app/javascript/mastodon/components/missing_indicator.js
|
codl/mastodon
|
import React from 'react';
import { FormattedMessage } from 'react-intl';
const MissingIndicator = () => (
<div className='regeneration-indicator missing-indicator'>
<div>
<div className='regeneration-indicator__figure' />
<div className='regeneration-indicator__label'>
<FormattedMessage id='missing_indicator.label' tagName='strong' defaultMessage='Not found' />
<FormattedMessage id='missing_indicator.sublabel' defaultMessage='This resource could not be found' />
</div>
</div>
</div>
);
export default MissingIndicator;
|
test/specs/modules/Modal/Modal-test.js
|
jcarbo/stardust
|
import _ from 'lodash'
import React from 'react'
import Portal from 'react-portal'
import Modal from 'src/modules/Modal/Modal'
import ModalHeader from 'src/modules/Modal/ModalHeader'
import ModalContent from 'src/modules/Modal/ModalContent'
import ModalActions from 'src/modules/Modal/ModalActions'
import ModalDescription from 'src/modules/Modal/ModalDescription'
import { keyboardKey } from 'src/lib'
import { domEvent, sandbox } from 'test/utils'
import * as common from 'test/specs/commonTests'
// ----------------------------------------
// Wrapper
// ----------------------------------------
let wrapper
// we need to unmount the modal after every test to remove it from the document
// wrap the render methods to update a global wrapper that is unmounted after each test
const wrapperMount = (...args) => (wrapper = mount(...args))
const wrapperShallow = (...args) => (wrapper = shallow(...args))
const assertInBody = (selector, isPresent = true) => {
const didFind = document.body.querySelector(selector) !== null
didFind.should.equal(isPresent, `${didFind ? 'Found' : 'Did not find'} "${selector}" in the document.body.`)
}
const assertBodyClasses = (...rest) => {
const hasClasses = typeof rest[rest.length - 1] === 'boolean' ? rest.pop() : true
rest.forEach(className => {
const didFind = document.body.classList.contains(className)
const message = [
`document.body ${didFind ? 'has' : 'does not have'} class "${className}".`,
`It has class="${document.body.classList}"`,
].join(' ')
didFind.should.equal(hasClasses, message)
})
}
describe('Modal', () => {
beforeEach(() => {
wrapper = undefined
})
afterEach(() => {
if (wrapper && wrapper.unmount) wrapper.unmount()
})
common.hasSubComponents(Modal, [ModalHeader, ModalContent, ModalActions, ModalDescription])
// Heads up!
//
// Our commonTests do not currently handle wrapped components.
// Nor do they handle components rendered to the body with Portal.
// The Modal is wrapped in a Portal, so we manually test a few things here.
it('renders a Portal', () => {
wrapperShallow(<Modal active />)
.type()
.should.equal(Portal)
})
it('renders to the document body', () => {
wrapperMount(<Modal active />)
assertInBody('.ui.modal')
})
it('renders child text', () => {
wrapperMount(<Modal active>child text</Modal>)
document.querySelector('.ui.modal')
.innerText
.should.equal('child text')
})
it('renders child components', () => {
const child = <div data-child />
wrapperMount(<Modal active>{child}</Modal>)
document
.querySelector('.ui.modal')
.querySelector('[data-child]')
.should.not.equal(null, 'Modal did not render the child component.')
})
describe('active', () => {
it('is not active by default', () => {
wrapperMount(<Modal />)
assertInBody('.ui.modal.active', false)
})
it('is passed to Portal isOpened', () => {
shallow(<Modal active />)
.find('Portal')
.should.have.prop('isOpened', true)
shallow(<Modal active={false} />)
.find('Portal')
.should.have.prop('isOpened', false)
})
it('does not show the modal when false', () => {
wrapperMount(<Modal active={false} />)
assertInBody('.ui.modal', false)
})
it('does not show the dimmer when false', () => {
wrapperMount(<Modal active={false} />)
assertInBody('.ui.dimmer', false)
})
it('shows the dimmer when true', () => {
wrapperMount(<Modal active dimmer />)
assertInBody('.ui.dimmer')
})
it('shows the modal when true', () => {
wrapperMount(<Modal active />)
assertInBody('.ui.modal')
})
it('shows the modal and dimmer on changing from false to true', () => {
wrapperMount(<Modal active={false} />)
assertInBody('.ui.modal', false)
assertInBody('.ui.dimmer', false)
wrapper.setProps({ active: true })
assertInBody('.ui.modal')
assertInBody('.ui.dimmer')
})
it('hides the modal and dimmer on changing from true to false', () => {
wrapperMount(<Modal active />)
assertInBody('.ui.modal')
assertInBody('.ui.dimmer')
wrapper.setProps({ active: false })
assertInBody('.ui.modal', false)
assertInBody('.ui.dimmer', false)
})
})
describe('basic', () => {
it('adds basic to the modal className', () => {
wrapperMount(<Modal basic active />)
assertInBody('.ui.basic.modal')
})
})
describe('size', () => {
it('defines prop options in _meta', () => {
Modal._meta.props.should.have.any.keys('size')
Modal._meta.props.size.should.be.an('array')
})
it('adds the size to the modal className', () => {
Modal._meta.props.size.forEach(size => {
wrapperMount(<Modal size={size} active />)
assertInBody(`.ui.${size}.modal`)
})
})
})
describe('dimmer', () => {
describe('defaults', () => {
it('is set to true by default', () => {
Modal.defaultProps.dimmer
.should.equal(true)
})
it('is present by default', () => {
wrapperMount(<Modal active />)
assertInBody('.ui.dimmer')
})
})
describe('true', () => {
it('adds classes "dimmable dimmed" to the body', () => {
wrapperMount(<Modal active dimmer />)
assertBodyClasses('dimmable', 'dimmed')
})
it('adds a dimmer to the body', () => {
wrapperMount(<Modal active dimmer />)
assertInBody('.ui.page.modals.dimmer.transition.visible.active')
})
})
describe('false', () => {
it('does not render a dimmer', () => {
wrapperMount(<Modal active dimmer={false} />)
assertBodyClasses('dimmable', 'dimmed', 'blurring', false)
})
it('does not add any dimmer classes to the body', () => {
wrapperMount(<Modal active dimmer={false} />)
assertBodyClasses('dimmable', 'dimmed', 'blurring', false)
})
})
describe('blurring', () => {
it('adds class "dimmable dimmed blurring" to the body', () => {
wrapperMount(<Modal active dimmer='blurring' />)
assertBodyClasses('dimmable', 'dimmed', 'blurring')
})
it('adds a dimmer to the body', () => {
wrapperMount(<Modal active dimmer='blurring' />)
assertInBody('.ui.page.modals.dimmer.transition.visible.active')
})
})
describe('inverted', () => {
it('adds class "dimmable dimmed" to the body', () => {
wrapperMount(<Modal active dimmer='inverted' />)
assertBodyClasses('dimmable', 'dimmed')
assertBodyClasses('inverted', false)
})
it('adds an inverted dimmer to the body', () => {
wrapperMount(<Modal active dimmer='inverted' />)
assertInBody('.ui.inverted.page.modals.dimmer.transition.visible.active')
})
})
})
describe('onHide', () => {
let spy
beforeEach(() => {
spy = sandbox.spy()
wrapperMount(<Modal onHide={spy} active />)
})
it('is called on dimmer click', () => {
domEvent.click('.ui.dimmer')
spy.should.have.been.calledOnce()
})
it('is called on click outside of the modal', () => {
domEvent.click(document.querySelector('.ui.modal').parentNode)
spy.should.have.been.calledOnce()
})
it('is not called on click inside of the modal', () => {
domEvent.click(document.querySelector('.ui.modal'))
spy.should.have.been.calledOnce()
})
it('is called on body click', () => {
domEvent.click('body')
spy.should.have.been.calledOnce()
})
it('is called when pressing escape', () => {
domEvent.keyDown(document, { key: 'Escape' })
spy.should.have.been.calledOnce()
})
it('is not called when pressing a key other than "Escape"', () => {
_.each(keyboardKey, (val, key) => {
// skip Escape key
if (val === keyboardKey.Escape) return
domEvent.keyDown(document, { key })
spy.should.not.have.been.called(`onHide was called when pressing "${key}"`)
})
})
it('is not called when the active prop changes to false', () => {
wrapper.setProps({ active: false })
spy.should.not.have.been.called()
})
})
describe('with configurable close behaviours, onHide', () => {
let spy
beforeEach(() => {
spy = sandbox.spy()
wrapperMount(<Modal onHide={spy} active closeOnEscape={false} closeOnClickOutside={false} />)
})
it('is not called on dimmer click', () => {
domEvent.click('.ui.dimmer')
spy.should.not.have.been.calledOnce()
})
it('is not called on click outside of the modal', () => {
domEvent.click(document.querySelector('.ui.modal').parentNode)
spy.should.not.have.been.calledOnce()
})
it('is not called on click inside of the modal', () => {
domEvent.click(document.querySelector('.ui.modal'))
spy.should.not.have.been.calledOnce()
})
it('is not called on body click', () => {
domEvent.click('body')
spy.should.not.have.been.calledOnce()
})
it('is not called when pressing escape', () => {
domEvent.keyDown(document, { key: 'Escape' })
spy.should.not.have.been.calledOnce()
})
it('is not called when pressing a key other than "Escape"', () => {
_.each(keyboardKey, (val, key) => {
// skip Escape key
if (val === keyboardKey.Escape) return
domEvent.keyDown(document, { key })
spy.should.not.have.been.called(`onHide was called when pressing "${key}"`)
})
})
it('is not called when the active prop changes to false', () => {
wrapper.setProps({ active: false })
spy.should.not.have.been.called()
})
})
describe('scrolling', () => {
afterEach(() => {
document.body.classList.remove('scrolling')
})
it('does not add the scrolling class to the body by default', () => {
wrapperMount(<Modal active />)
assertBodyClasses('scrolling', false)
})
it('adds the scrolling class to the body when taller than the window', (done) => {
wrapperMount(<Modal active>foo</Modal>)
window.innerHeight = 10
requestAnimationFrame(() => {
assertBodyClasses('scrolling')
done()
})
})
it('removes the scrolling class from the body when the window grows taller', (done) => {
assertBodyClasses('scrolling', false)
wrapperMount(<Modal active>foo</Modal>)
window.innerHeight = 10
requestAnimationFrame(() => {
assertBodyClasses('scrolling')
window.innerHeight = 10000
requestAnimationFrame(() => {
assertBodyClasses('scrolling', false)
done()
})
})
})
})
})
|
src/html/tags/HtmlTagLi.js
|
saketkumar95/zulip-mobile
|
import React from 'react';
import { StyleSheet, View } from 'react-native';
import styles from '../HtmlStyles';
import HtmlNodeText from '../HtmlNodeText';
import renderHtmlChildren from '../renderHtmlChildren';
const BULLET = '\u2022';
const customStyles = StyleSheet.create({
text: {
flexWrap: 'wrap',
flex: 1,
width: '100%',
flexDirection: 'row',
}
});
export default ({ style, ...restProps }) => (
<View style={[styles.li, style]}>
<HtmlNodeText style={styles.bullet} data={` ${BULLET} `} />
<View style={customStyles.text}>
{renderHtmlChildren({ ...restProps })}
</View>
</View>
);
|
src/index.js
|
ebn646/react-moviesearch
|
import React from 'react'
import { render } from 'react-dom'
import { browserHistory, hashHistory,Router, Route, IndexRoute, Link, withRouter } from 'react-router'
import App from './components/app/app.js'
import Home from './components/home/home.js'
import Movie from './components/movie/movie.js'
import MovieList from './components/movielist/movielist.js'
import SearchResults from './components/searchResults/searchResults.js'
import './styles/app.scss'
render((
<Router history={hashHistory}>
<Route path={"/"} component={App}>
<IndexRoute component={Home}/>
<Route path="category/:category" component={MovieList}/>
<Route path="movie/:id" component={Movie}/>
<Route path="search/:query=fight+club" component={SearchResults}/>
</Route>
</Router>
), document.getElementById('main'))
|
src/server.js
|
samerce/lampshade
|
/**
* React Starter Kit (https://www.reactstarterkit.com/)
*
* Copyright © 2014-2016 Kriasoft, LLC. All rights reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE.txt file in the root directory of this source tree.
*/
import 'babel-polyfill';
import path from 'path';
import express from 'express';
import cookieParser from 'cookie-parser';
import bodyParser from 'body-parser';
import expressJwt from 'express-jwt';
import expressGraphQL from 'express-graphql';
import jwt from 'jsonwebtoken';
import React from 'react';
import ReactDOM from 'react-dom/server';
import UniversalRouter from 'universal-router';
import PrettyError from 'pretty-error';
import App from './components/App';
import Html from './components/Html';
import { ErrorPageWithoutStyle } from './routes/error/ErrorPage';
import errorPageStyle from './routes/error/ErrorPage.css';
import passport from './core/passport';
import models from './data/models';
import schema from './data/schema';
import routes from './routes';
import assets from './assets'; // eslint-disable-line import/no-unresolved
import configureStore from './store/configureStore';
import { setRuntimeVariable } from './actions/runtime';
import { port, auth } from './config';
const app = express();
//
// Tell any CSS tooling (such as Material UI) to use all vendor prefixes if the
// user agent is not known.
// -----------------------------------------------------------------------------
global.navigator = global.navigator || {};
global.navigator.userAgent = global.navigator.userAgent || 'all';
//
// Register Node.js middleware
// -----------------------------------------------------------------------------
app.use(express.static(path.join(__dirname, 'public')));
app.use(cookieParser());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
//
// Authentication
// -----------------------------------------------------------------------------
app.use(expressJwt({
secret: auth.jwt.secret,
credentialsRequired: false,
getToken: req => req.cookies.id_token,
}));
app.use(passport.initialize());
if (process.env.NODE_ENV !== 'production') {
app.enable('trust proxy');
}
app.get('/login/facebook',
passport.authenticate('facebook', { scope: ['email', 'user_location'], session: false }),
);
app.get('/login/facebook/return',
passport.authenticate('facebook', { failureRedirect: '/login', session: false }),
(req, res) => {
const expiresIn = 60 * 60 * 24 * 180; // 180 days
const token = jwt.sign(req.user, auth.jwt.secret, { expiresIn });
res.cookie('id_token', token, { maxAge: 1000 * expiresIn, httpOnly: true });
res.redirect('/');
},
);
//
// Register API middleware
// -----------------------------------------------------------------------------
app.use('/graphql', expressGraphQL(req => ({
schema,
graphiql: process.env.NODE_ENV !== 'production',
rootValue: { request: req },
pretty: process.env.NODE_ENV !== 'production',
})));
//
// Register server-side rendering middleware
// -----------------------------------------------------------------------------
app.get('*', async (req, res, next) => {
try {
const store = configureStore({
user: req.user || null,
}, {
cookie: req.headers.cookie,
});
store.dispatch(setRuntimeVariable({
name: 'initialNow',
value: Date.now(),
}));
const css = new Set();
// Global (context) variables that can be easily accessed from any React component
// https://facebook.github.io/react/docs/context.html
const context = {
// Enables critical path CSS rendering
// https://github.com/kriasoft/isomorphic-style-loader
insertCss: (...styles) => {
// eslint-disable-next-line no-underscore-dangle
styles.forEach(style => css.add(style._getCss()));
},
// Initialize a new Redux store
// http://redux.js.org/docs/basics/UsageWithReact.html
store,
};
const route = await UniversalRouter.resolve(routes, {
...context,
path: req.path,
query: req.query,
});
if (route.redirect) {
res.redirect(route.status || 302, route.redirect);
return;
}
const data = { ...route };
data.children = ReactDOM.renderToString(<App context={context}>{route.component}</App>);
data.style = [...css].join('');
data.scripts = [
assets.vendor.js,
assets.client.js,
];
data.state = context.store.getState();
if (assets[route.chunk]) {
data.scripts.push(assets[route.chunk].js);
}
const html = ReactDOM.renderToStaticMarkup(<Html {...data} />);
res.status(route.status || 200);
res.send(`<!doctype html>${html}`);
} catch (err) {
next(err);
}
});
//
// Error handling
// -----------------------------------------------------------------------------
const pe = new PrettyError();
pe.skipNodeFiles();
pe.skipPackage('express');
app.use((err, req, res, next) => { // eslint-disable-line no-unused-vars
console.log(pe.render(err)); // eslint-disable-line no-console
const html = ReactDOM.renderToStaticMarkup(
<Html
title="Internal Server Error"
description={err.message}
style={errorPageStyle._getCss()} // eslint-disable-line no-underscore-dangle
>
{ReactDOM.renderToString(<ErrorPageWithoutStyle error={err} />)}
</Html>,
);
res.status(err.status || 500);
res.send(`<!doctype html>${html}`);
});
//
// Launch the server
// -----------------------------------------------------------------------------
/* eslint-disable no-console */
models.sync().catch(err => console.error(err.stack)).then(() => {
app.listen(port, () => {
console.log(`The server is running at http://localhost:${port}/`);
});
});
/* eslint-enable no-console */
|
app/app.js
|
maciejsikora/react-task-list
|
import React from 'react';
import ReactDOM from 'react-dom';
import injectTapEventPlugin from 'react-tap-event-plugin';
injectTapEventPlugin();
import MuiThemeProvider from 'material-ui/styles/MuiThemeProvider';
import TaskBox from './tasklist/taskbox.jsx';
const App = React.createClass({
render:function(){
return (
<MuiThemeProvider>
<TaskBox />
</MuiThemeProvider>
)
}
});
ReactDOM.render(
<App />,
document.getElementById('content')
);
|
frontend/components/Question.js
|
ParroApp/parro
|
import React from 'react';
import Navbar from './Navbar';
import TypeWriter from 'react-typewriter';
import RecordRTC from 'recordrtc';
const StereoAudioRecorder = RecordRTC.StereoAudioRecorder;
import {captureUserMedia, uploadAudio} from './AppUtils';
class Question extends React.Component {
constructor(props) {
super(props);
this.state = {
doneTyping: false,
isBotAsking: true,
typewriter: '',
isRecording: false,
time: null,
showButtons: false
}
this.nextQuestion = this.nextQuestion.bind(this);
this.index = 0;
}
componentDidMount() {
window.addEventListener("load", function() {
var synth = window.speechSynthesis;
var voices = synth.getVoices();
console.log('VOICES');
});
setTimeout(() => {
this.talk("Thank you for interviewing with us today. Do you have any questions for the company? I will do my best to answer.");
}, 1000);
// show buttons
setTimeout(() => {
console.log('showButtons');
this.setState({ showButtons: true });
}, 9000);
captureUserMedia((stream) => {
this.setState({ stream: stream, src: window.URL.createObjectURL(stream) });
});
// first question
setTimeout(() => {
this.talk("Our employees have said the best part is working with great, intelligent people.");
}, 10000 + 9000);
// first question
setTimeout(() => {
this.talk("We're looking for engineers who bring fresh ideas from all areas, distributed computing, large-scale system design, and mobile; the list goes on and is growing every day.");
}, 20000 + 10000 + 9000);
setTimeout(() => {
this.talk("Thank you! We'll get back to you soon");
}, 15000 + 20000 + 10000 + 9000);
setTimeout(() => {
this.props.history.push('/end');
}, 5000 + 15000 + 20000 + 10000 + 9000);
}
talk(val) {
setTimeout(function() {
var synth = window.speechSynthesis;
var voices = synth.getVoices();
for (var i = 0; i < voices.length; i++) {
if (voices[i].name === 'Google US English') {
voices = voices[i];
break;
}
}
var msg = new SpeechSynthesisUtterance();
msg.text = val;
msg.voice = voices;
msg.pitch = 1;
msg.rate = 0.9;
synth.speak(msg);
this.setState({
typewriter: val
});
}.bind(this), 500);
}
nextQuestion() {
this.setState({ time: null, isRecording: true });
// console.log('next question');
// console.log('start recording here', this.state);
//
// if (this.state.isRecording) {
// console.log('stop audio recording old and upload...');
// this.stopRecord(() => {
// this.startRecord();
// });
// } else {
// this.startRecord();
// }
//
// this.setState({ doneTyping: false });
// this.index++;
// if (this.index === 1) {
// this.talk('Tell me about yourself');
// } else if (this.index === 2) {
// this.talk('Tell me about a project');
// } else if (this.index === 3) {
// this.talk('What is bubble sort?');
// } else {
// // END OF BEHAVIORAL SECTION
// this.state.recordVideo.stopRecording(() => {
// console.log('Stop recording video');
// let params = {
// type: 'video/webm',
// data: this.state.recordVideo.blob,
// id: Math.floor(Math.random() * 90000) + 10000
// }
// clearInterval(this.state.intervalId);
// this.setState({ uploading: true, intervalId: null, time: '' });
// });
// this.state.stream.getVideoTracks().forEach(function(track) {
// track.stop();
// });
// this.props.history.push('/end');
// }
}
startRecord() {
// this.setState({isRecording: true})
// setTimeout(() => {
// console.log('YOYOYO');
// this.setState({ time: 2 });
// }, 3000)
// // start recording audio
// console.log('start audio recording');
// var recordAudio = RecordRTC(this.state.stream, {
// recorderType: StereoAudioRecorder,
// type: 'audio'
// });
// recordAudio.startRecording();
//
// // stores state
// this.setState({
// recordAudio: recordAudio,
// });
}
stopRecord(temp) {
// this.state.recordAudio.stopRecording(() => {
// console.log('Stop recording audio');
//
// uploadAudio(this.state.recordAudio.blob, this.state.userId);
// // console.log(this.state.recordAudio.blob);
// // console.log(this.state.recordAudio);
// // temp();
// });
// this.setState({isRecording: false});
}
// componentWillMount() {
// setTimeout(() => {
// this.setState({doneTyping: true})
// }, 7000)
// }
render() {
console.log('THIS.STATE', this.state);
return(
<div>
<Navbar {...this.props}/>
<video autoPlay muted src={this.state.src} style={{display: 'none'}}/>
<div style={{height: '60px', width: '100%'}}></div>
<div className="robot"><svg className="robotSVG" version="1.1" xmlns="http://www.w3.org/2000/svg">
<g id="hover">
<ellipse id="shadow_2_" opacity="0.4" fill="#2C3332" cx="300" cy="703.375" rx="88.971" ry="30.625"></ellipse>
</g>
<g id="arms">
<g id="left">
<path id="arm_1_" fill="#BABEB7" d="M183.975,430.936c-50.27-21.595-96.437,29.654-96.132,54.383
c0.06,4.868,7.836,11.424,11.509,7.079c12.145-14.369,36.979-35.733,55.676-16.486
C156.498,477.423,189.086,433.132,183.975,430.936z"></path>
<g id="hand_1_">
<path id="shadow" fill="#BABEB7" d="M63.712,520.545l5.657-7.071c0,0-11.453-8.997-9.402-12.554
c4.469-7.751,15.935-9.515,25.612-3.936c9.676,5.579,13.898,16.385,9.43,24.136c-1.736,3.013-7.363,0.091-7.363,0.091
l-5.657,7.071l0.058,6.027c8.473,0.83,16.454-1.564,21.692-6.847c1.235-1.245,6.329-7.287,7.229-8.85
c1.826-3.166-7.579-26.607-18.73-33.036c-8.361-4.82-31.172-5.074-31.172-5.074s-5.691,5.814-8.805,11.216
c-5.77,10.006-2.253,23.271,7.678,32.486L63.712,520.545z"></path>
<path id="top" fill="#DCE0DA" d="M69.37,513.474c-5.443-5.817-7.202-13.631-3.746-19.625c4.469-7.751,15.935-9.514,25.612-3.935
c9.676,5.578,13.899,16.385,9.43,24.135c-2.575,4.468-7.478,6.932-13.02,7.162l0.058,6.027
c10.471,1.026,20.192-2.873,24.911-11.06c6.976-12.099,0.385-28.965-14.719-37.673c-15.104-8.708-33.002-5.957-39.977,6.142
c-5.769,10.007-2.253,23.271,7.679,32.486L69.37,513.474z"></path>
</g>
</g>
<g id="right">
<path id="arm" fill="#DCE0DA" d="M416.025,430.936c50.27-21.595,96.437,29.654,96.131,54.383
c-0.059,4.868-7.836,11.424-11.509,7.079c-12.145-14.369-36.979-35.733-55.676-16.486
C443.502,477.423,410.914,433.132,416.025,430.936z"></path>
<g id="hand">
<path id="shadow_1_" fill="#BABEB7" d="M536.287,520.545l-5.656-7.071c0,0,11.453-8.997,9.402-12.554
c-4.469-7.751-15.936-9.515-25.612-3.936s-13.898,16.385-9.43,24.136c1.736,3.013,7.362,0.091,7.362,0.091l5.657,7.071
l-0.058,6.027c-8.474,0.83-16.455-1.564-21.692-6.847c-1.235-1.245-6.329-7.287-7.229-8.85
c-1.826-3.166,7.578-26.607,18.73-33.036c8.361-4.82,31.172-5.074,31.172-5.074s5.691,5.814,8.805,11.216
c5.77,10.006,2.253,23.271-7.678,32.486L536.287,520.545z"></path>
<path id="top_1_" fill="#DCE0DA" d="M530.631,513.474c5.443-5.817,7.201-13.631,3.745-19.625
c-4.469-7.751-15.935-9.514-25.612-3.935c-9.676,5.578-13.898,16.385-9.43,24.135c2.575,4.468,7.479,6.932,13.02,7.162
l-0.058,6.027c-10.472,1.026-20.192-2.873-24.911-11.06c-6.975-12.099-0.385-28.965,14.72-37.673s33.003-5.957,39.978,6.142
c5.769,10.007,2.252,23.271-7.68,32.486L530.631,513.474z"></path>
</g>
</g>
</g>
<g id="body">
<g id="chassie">
<g id="base">
<path fill="#DCE0DA" d="M137.424,525.622c0-47.887,60.669-219.342,162.576-219.342c101.907,0,162.576,171.854,162.576,219.342
c0,47.489-137.88,56.438-162.576,56.438C275.303,582.06,137.424,573.511,137.424,525.622z"></path>
</g>
<g id="highlight">
<defs>
<path id="SVGID_1_" d="M137.424,525.622c0-47.887,60.669-219.342,162.576-219.342c101.907,0,162.576,171.854,162.576,219.342
c0,47.489-137.88,56.438-162.576,56.438C275.303,582.06,137.424,573.511,137.424,525.622z"></path>
</defs>
<clipPath id="SVGID_2_">
<use xlinkHref="#SVGID_1_" overflow="visible"></use>
</clipPath>
<path clipPath="url(#SVGID_2_)" fill="#BABEB7" d="M455.667,419c0,0-38.299,61.503-156.983,61.503
c-67.685,0-86.351,14.831-96.684,39.164S203.368,588,298.684,588s1.816,21.923,1.816,21.923s-198.833-42.589-198.833-43.589
s54.333-215,54.333-215L455.667,419z"></path>
</g>
</g>
<g id="progress-indicator">
<g id="divet">
<path id="highlight-bottom" fill="#EAECE8" d="M425.182,524.775l-4.682-21.211c0,0-48.18,19.563-120.34,19.563
s-120.82-19.079-120.82-19.079l-4.542,20.636c0,0,37.523,20.052,125.363,20.052S425.182,524.775,425.182,524.775z"></path>
<path id="divet-bottom" fill="#4C4C4C" d="M420.682,521.823l-4.514-16.654c0,0-46.447,17.959-116.014,17.959
c-69.566,0-116.477-17.551-116.477-17.551l-4.379,16.159c0,0,36.174,18.597,120.856,18.597
C384.837,540.333,420.682,521.823,420.682,521.823z"></path>
<polygon id="shadow-right_1_" fill="#BABEB7" points="416.168,505.169 420.5,503.564 425.182,524.775 420.682,521.823 "></polygon>
<polygon id="shadow-left" fill="#8F918D" points="183.677,505.577 179.34,504.049 174.797,524.685 179.297,521.736 "></polygon>
<path id="shadow-bottom" fill="#BABEB7" d="M204.738,530.305l-5.786,2.959c0,0-8.125-2.072-14.702-4.556
s-9.453-4.023-9.453-4.023l4.5-2.948c0,0,4.039,2.192,11.313,4.463S204.738,530.305,204.738,530.305z"></path>
</g>
<g id="completed">
<path id="blue" fill="#84D3E8" d="M300.154,523.128c-69.566,0-116.477-17.551-116.477-17.551l-4.379,16.159
c0,0,36.174,18.597,120.856,18.597c28.812,0,51.965-2.144,69.983-4.971l-1.808-18.073
C349.822,520.518,326.67,523.128,300.154,523.128z"></path>
<path id="blue-shadow" fill="#6DADBC" d="M208.568,512.712c-15.682-3.741-24.93-7.135-24.93-7.135l-4.437,16.159
c0,0,8.037,4.175,25.537,8.568C205.625,524.125,206,520.875,208.568,512.712z"></path>
</g>
</g>
</g>
<g id="head">
<g id="face">
<path id="screen-shadow" fill="#9AB2B0" d="M418.268,235.276C377.932,233.144,327.52,232,300.003,232
c-27.517,0-77.766,1.144-118.102,3.276c-34.071,1.801-41.222,17.035-41.222,69.742s3.15,88.311,24.65,107.819
c35.831,32.511,101.258,47.829,134.673,47.829c33.832,0,99.06-15.318,134.891-47.829c21.5-19.508,24.758-55.112,24.758-107.819
S452.338,237.078,418.268,235.276z"></path>
<path id="screen" fill="#A4BCB9" d="M164.381,353.965c0,55.225,107.043,76.693,135.619,76.693
c28.576,0,135.618-21.469,135.618-76.693c0-100.027-60.717-123.293-135.618-123.293
C225.101,230.671,164.381,253.938,164.381,353.965z"></path>
<path id="case_x5F_shadow" fill="#EAECE8" d="M300,239c27.54,0,78.739,1.16,119.383,3.309c15.837,0.837,18.06,4.715,19.388,7.032
c5.026,8.771,5.671,29.167,5.671,45.955c0,49.954-0.156,81.738-16.287,96.374c-31.639,28.708-96.014,44.997-128.154,44.997
c-32.048,0-95.295-16.289-126.934-44.997c-16.039-14.552-17.176-46.356-17.176-96.374c0-16.825,0.638-37.258,5.614-46
c1.395-2.45,3.503-6.153,19.279-6.987C221.426,240.16,272.541,239,300,239 M300,210.5c-80.5,0-160.11,7.167-160.11,60.795
S141.095,385.151,162.971,405C199.429,438.08,266,453.666,300,453.666c34.424,0,100.792-15.586,137.25-48.666
c21.876-19.849,23.191-80.076,23.191-133.705S380.5,210.5,300,210.5z"></path>
<path id="case" fill="#DCE0DA" d="M300,248c27.54,0,78.739,1.16,119.383,3.309c15.837,0.837,18.06,4.715,19.388,7.032
c5.026,8.771,5.671,29.167,5.671,45.955c0,49.954-3.156,81.738-19.287,96.374c-31.639,28.708-93.014,43.997-125.154,43.997
c-32.048,0-93.295-15.289-124.934-43.997c-16.039-14.552-19.176-46.356-19.176-96.374c0-16.825,0.638-37.258,5.614-46
c1.395-2.45,3.503-6.153,19.279-6.987C221.426,249.16,272.541,248,300,248 M300,230c-27.999,0-79.126,1.164-120.167,3.333
c-34.667,1.833-41.943,17.333-41.943,70.962s3.205,89.856,25.081,109.705C199.429,447.08,266,462.666,300,462.666
c34.424,0,100.792-15.586,137.25-48.666c21.876-19.849,25.191-56.076,25.191-109.705s-7.441-69.129-42.108-70.962
C379.292,231.164,327.998,230,300,230L300,230z"></path>
</g>
<g id="eyes">
<ellipse id="left_1_" fill="#2C3332" cx="231" cy="316.667" rx="6.333" ry="17"></ellipse>
<ellipse id="right_1_" fill="#2C3332" cx="369" cy="316.667" rx="6.334" ry="17"></ellipse>
</g>
<g id="indicators">
<path id="mount" fill="#DCE0DA" d="M354.333,220.333c0-29.916-24.252-54.167-54.167-54.167c-29.916,0-54.167,24.251-54.167,54.167
c0,4.667,24.251,4.667,54.167,4.667C330.081,225,354.333,225,354.333,220.333z"></path>
<g id="leds">
<circle id="yellow" fill="#F0C419" cx="300.418" cy="207" r="8.084"></circle>
<circle id="red" fill="#E64C3C" cx="324.67" cy="206" r="8.084"></circle>
<circle id="green" fill="#4EBA64" cx="275.33" cy="206" r="8.083"></circle>
</g>
</g>
</g>
</svg>
</div>
<div className="container" style={{textAlign: 'center', display: 'flex', justifyContent: 'center', alignItems: 'center'}}>
<div className="columns">
<div className="column is-vertical">
<TypeWriter fixed={true} style={{fontSize: '30px', textAlign: 'center'}} typing={0.8}>
{this.state.typewriter}
</TypeWriter>
</div>
</div>
</div>
{this.state.showButtons && this.state.isRecording &&
(<button onClick={this.stopRecord.bind(this)} style={{position: 'absolute', top: '80%', left: '43%'}} className="button is-info is-large">
<span className="icon">
<i className="fa fa-question"></i>
</span>
<span>Finished asking</span>
</button>)
}
{this.state.showButtons && !this.state.isRecording &&
(<button onClick={this.nextQuestion} style={{position: 'absolute', top: '80%', left: '43%'}} className="button is-info is-large">
<span className="icon">
<i className="fa fa-question"></i>
</span>
<span>Ask a question</span>
</button>)
}
</div>
)
}
}
export default Question;
|
src/DataTables/DataTablesTable.js
|
hyojin/material-ui-datatables
|
import React from 'react';
import {Table} from 'material-ui/Table';
class DataTablesTable extends Table {
createTableBody(base) {
return React.cloneElement(
base,
{
allRowsSelected: this.state.allRowsSelected,
multiSelectable: this.props.multiSelectable,
onCellClick: this.onCellClick,
onCellDoubleClick: this.onCellDoubleClick,
onCellHover: this.onCellHover,
onCellHoverExit: this.onCellHoverExit,
onRowHover: this.onRowHover,
onRowHoverExit: this.onRowHoverExit,
onRowSelection: this.onRowSelection,
selectable: this.props.selectable,
style: Object.assign({height: this.props.height}, base.props.style),
}
);
}
onCellDoubleClick = (rowNumber, columnNumber, event) => {
if (this.props.onCellDoubleClick) this.props.onCellDoubleClick(rowNumber, columnNumber, event);
};
}
export default DataTablesTable;
|
node_modules/react-router/es/Redirect.js
|
juhov/travis-test
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
import React from 'react';
import PropTypes from 'prop-types';
/**
* The public API for updating the location programatically
* with a component.
*/
var Redirect = function (_React$Component) {
_inherits(Redirect, _React$Component);
function Redirect() {
_classCallCheck(this, Redirect);
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
}
Redirect.prototype.isStatic = function isStatic() {
return this.context.router && this.context.router.staticContext;
};
Redirect.prototype.componentWillMount = function componentWillMount() {
if (this.isStatic()) this.perform();
};
Redirect.prototype.componentDidMount = function componentDidMount() {
if (!this.isStatic()) this.perform();
};
Redirect.prototype.perform = function perform() {
var history = this.context.router.history;
var _props = this.props,
push = _props.push,
to = _props.to;
if (push) {
history.push(to);
} else {
history.replace(to);
}
};
Redirect.prototype.render = function render() {
return null;
};
return Redirect;
}(React.Component);
Redirect.propTypes = {
push: PropTypes.bool,
from: PropTypes.string,
to: PropTypes.oneOfType([PropTypes.string, PropTypes.object])
};
Redirect.defaultProps = {
push: false
};
Redirect.contextTypes = {
router: PropTypes.shape({
history: PropTypes.shape({
push: PropTypes.func.isRequired,
replace: PropTypes.func.isRequired
}).isRequired,
staticContext: PropTypes.object
}).isRequired
};
export default Redirect;
|
app/private/indexerApp/imports/ui/pages/Documents.js
|
ericvrp/GameCollie
|
import React from 'react';
import { Link } from 'react-router';
import { Row, Col, Button } from 'react-bootstrap';
import DocumentsList from '../components/DocumentsList';
const Documents = () => (
<div className="Documents">
<Row>
<Col xs={ 12 }>
<div className="page-header clearfix">
<h4 className="pull-left">Documents</h4>
<Link to="/documents/new">
<Button
bsStyle="success"
className="pull-right"
>New Document</Button>
</Link>
</div>
<DocumentsList />
</Col>
</Row>
</div>
);
export default Documents;
|
src/__tests__/MaterialText.js
|
material-native/material-native
|
'use strict';
import React from 'react';
import MaterialTheme from '../styles/MaterialTheme';
import ThemeProvider from '../styles/ThemeProvider';
import MaterialText from '../MaterialText';
import ReactTestRenderer from 'react-test-renderer';
import ToJSX from 'react-element-to-jsx-string';
const theme = new MaterialTheme({});
/* eslint-disable react/jsx-key */
function typoClassSnapshots(props) {
const typoClasses = [
'display4',
'display3',
'display2',
'display1',
'headline',
'title',
'subhead',
'body2',
'body1',
'caption',
'button'
];
return typoClasses.map((typoClass) => (
<MaterialText {...props} {...{[typoClass]: true}}>...</MaterialText>
));
}
const snapshotTests = [
<MaterialText>...</MaterialText>,
<MaterialText secondary>...</MaterialText>,
<MaterialText disabled>...</MaterialText>,
<MaterialText hint>...</MaterialText>,
<MaterialText dark>...</MaterialText>,
<MaterialText dark secondary>...</MaterialText>,
<MaterialText dark disabled>...</MaterialText>,
<MaterialText dark hint>...</MaterialText>,
<MaterialText light>...</MaterialText>,
<MaterialText light secondary>...</MaterialText>,
<MaterialText light disabled>...</MaterialText>,
<MaterialText light hint>...</MaterialText>,
<MaterialText color='#123456'>...</MaterialText>,
...typoClassSnapshots({}),
...typoClassSnapshots({dense: true}),
...typoClassSnapshots({tall: true})
];
/* eslint-enable react/jsx-key */
for ( const root of snapshotTests ) {
test(ToJSX(root, {maxInlineAttributesLineLength: Infinity}), () => {
const host = ReactTestRenderer.create(
<ThemeProvider theme={theme}>
{root}
</ThemeProvider>
);
expect(host.toJSON()).toMatchSnapshot();
});
}
|
src/svg-icons/social/poll.js
|
matthewoates/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let SocialPoll = (props) => (
<SvgIcon {...props}>
<path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"/>
</SvgIcon>
);
SocialPoll = pure(SocialPoll);
SocialPoll.displayName = 'SocialPoll';
SocialPoll.muiName = 'SvgIcon';
export default SocialPoll;
|
client/src/javascript/components/icons/DownloadThickIcon.js
|
jfurrow/flood
|
import React from 'react';
import BaseIcon from './BaseIcon';
export default class DownloadThickIcon extends BaseIcon {
render() {
return (
<svg className={`icon icon--download ${this.props.className}`} viewBox={this.getViewBox()}>
<polygon points="44.1,23 33,39.7 33,4.6 27,4.6 27,39.7 15.9,23 10.9,26.4 30,55 49.1,26.4 " />
</svg>
);
}
}
|
src/index.js
|
arimaulana/rest-api-frontend-in-react
|
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import MuiThemeProvider from 'material-ui/styles/MuiThemeProvider';
import jwtDecode from 'jwt-decode';
import setAuthorizationToken from './utils/setAuthorizationToken';
import { setCurrentUser } from './actions/authActions';
import App from './components/App';
import store from './store';
if (localStorage.jwtToken) {
setAuthorizationToken(localStorage.jwtToken);
store.dispatch(setCurrentUser(jwtDecode(localStorage.jwtToken)));
}
ReactDOM.render(
<Provider store={store}>
<MuiThemeProvider>
<App />
</MuiThemeProvider>
</Provider>,
document.getElementById('root')
);
|
stories/props/drilldownView.stories.js
|
jquense/react-big-calendar
|
import React from 'react'
import moment from 'moment'
import { Calendar, Views, momentLocalizer } from '../../src'
import demoEvents from '../resources/events'
import mdx from './drilldownView.mdx'
const mLocalizer = momentLocalizer(moment)
export default {
title: 'props',
component: Calendar,
argTypes: {
localizer: { control: { type: null } },
events: { control: { type: null } },
defaultDate: {
control: {
type: null,
},
},
drilldownView: {
control: {
type: 'select',
options: ['day', 'agenda'],
defaultValue: Views.DAY,
},
},
},
parameters: {
docs: {
page: mdx,
},
},
}
const Template = (args) => (
<div className="height600">
<Calendar {...args} />
</div>
)
export const DrilldownView = Template.bind({})
DrilldownView.storyName = 'drilldownView'
DrilldownView.args = {
defaultDate: new Date(2015, 3, 1),
drilldownView: Views.AGENDA,
events: demoEvents,
localizer: mLocalizer,
}
|
node_modules/babel-plugin-react-transform/test/fixtures/code-class-extends-component-with-render-method/actual.js
|
leechuanjun/TLReactNativeProject
|
import React, { Component } from 'react';
class Foo extends Component {
render() {}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.