path
stringlengths 5
296
| repo_name
stringlengths 5
85
| content
stringlengths 25
1.05M
|
|---|---|---|
src/components/ui/quote.js
|
xavier-besson/react-playground
|
import React from 'react';
import Default from 'components/ui/default';
/**
* @class Quote
* @extends Default
*/
class Quote extends Default {
/**
* React method.
* Return a single React element.
* This element can be either a representation of a native DOM component,
* such as <div />, or another composite component that you've defined yourself.
* You can also return null or false to indicate that you don't want anything rendered.
* When returning null or false, ReactDOM.findDOMNode(this) will return null.
* @method render
* @return {Mixed} A representation of a native DOM component
*/
render() {
const {
children,
...other
} = this.props;
return (
<blockquote
{...other}
>
{children}
</blockquote>
);
}
}
export default Quote;
|
test/JumbotronSpec.js
|
deerawan/react-bootstrap
|
import React from 'react';
import ReactTestUtils from 'react/lib/ReactTestUtils';
import Jumbotron from '../src/Jumbotron';
describe('Jumbotron', function () {
it('Should output a div with content', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Jumbotron>
<strong>Content</strong>
</Jumbotron>
);
assert.equal(React.findDOMNode(instance).nodeName, 'DIV');
assert.ok(ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'strong'));
});
it('Should have a jumbotron class', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Jumbotron>
Content
</Jumbotron>
);
assert.ok(React.findDOMNode(instance).className.match(/\bjumbotron\b/));
});
it('Should override node class', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Jumbotron componentClass='section'>
<strong>Content</strong>
</Jumbotron>
);
assert.equal(React.findDOMNode(instance).nodeName, 'SECTION');
});
});
|
packages/ringcentral-widgets-docs/src/app/pages/Components/ActiveCallPad/Demo.js
|
ringcentral/ringcentral-js-widget
|
import React from 'react';
// eslint-disable-next-line
import ActiveCallPad from 'ringcentral-widgets/components/ActiveCallPad';
import callCtrlLayouts from 'ringcentral-widgets/enums/callCtrlLayouts';
const props = {};
props.onMute = () => null;
props.onUnmute = () => null;
props.onHold = () => null;
props.onUnhold = () => null;
props.onRecord = () => null;
props.onStopRecord = () => null;
props.onHangup = () => null;
props.onPark = () => null;
props.onShowKeyPad = () => null;
props.onAdd = () => null;
props.onMerge = () => null;
props.currentLocale = 'en-US';
props.flipNumbers = [];
props.recordStatus = 'recordStatus-idle';
props.onShowFlipPanel = () => null;
props.onToggleTransferPanel = () => null;
props.layout = callCtrlLayouts.normalCtrl;
/**
* A example of `ActiveCallPad`
*/
const ActiveCallPadDemo = () => <ActiveCallPad {...props} />;
export default ActiveCallPadDemo;
|
pages/blog/test-article-one.js
|
el-besto/examples
|
/**
* React Static Boilerplate
* https://github.com/koistya/react-static-boilerplate
* Copyright (c) Konstantin Tarkus (@koistya) | MIT license
*/
import React, { Component } from 'react';
export default class extends Component {
render() {
return (
<div>
<h1>Test Article 1</h1>
<p>Coming soon.</p>
</div>
);
}
}
|
packages/react/src/components/FluidForm/FluidForm.js
|
carbon-design-system/carbon-components
|
/**
* Copyright IBM Corp. 2016, 2018
*
* This source code is licensed under the Apache-2.0 license found in the
* LICENSE file in the root directory of this source tree.
*/
import PropTypes from 'prop-types';
import React from 'react';
import classnames from 'classnames';
import { settings } from 'carbon-components';
import Form from '../Form';
import { FormContext } from './FormContext';
const { prefix } = settings;
function FluidForm({ className, children, ...other }) {
const classNames = classnames(`${prefix}--form--fluid`, className);
return (
<FormContext.Provider value={{ isFluid: true }}>
<Form className={classNames} {...other}>
{children}
</Form>
</FormContext.Provider>
);
}
FluidForm.propTypes = {
/**
* Provide children to be rendered inside of the <form> element
*/
children: PropTypes.node,
/**
* Provide a custom className to be applied on the containing <form> node
*/
className: PropTypes.string,
};
export default FluidForm;
|
docs/app/Examples/elements/Label/Types/LabelExamplePointingColored.js
|
ben174/Semantic-UI-React
|
import React from 'react'
import { Divider, Form, Label } from 'semantic-ui-react'
const LabelExamplePointing = () => (
<Form>
<Form.Field>
<input type='text' placeholder='First name' />
<Label basic color='red' pointing>Please enter a value</Label>
</Form.Field>
<Divider />
<Form.Field>
<Label basic color='red' pointing='below'>Please enter a value</Label>
<input type='text' placeholder='Last Name' />
</Form.Field>
<Divider />
<Form.Field inline>
<input type='text' placeholder='Username' />
<Label basic color='red' pointing='left'>That name is taken!</Label>
</Form.Field>
<Divider />
<Form.Field inline>
<Label basic color='red' pointing='right'>Your password must be 6 characters or more</Label>
<input type='password' placeholder='Password' />
</Form.Field>
</Form>
)
export default LabelExamplePointing
|
node_modules/react-bootstrap/es/Tabs.js
|
GregSantulli/react-drum-sequencer
|
import _extends from 'babel-runtime/helpers/extends';
import _objectWithoutProperties from 'babel-runtime/helpers/objectWithoutProperties';
import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
import _possibleConstructorReturn from 'babel-runtime/helpers/possibleConstructorReturn';
import _inherits from 'babel-runtime/helpers/inherits';
import React from 'react';
import requiredForA11y from 'react-prop-types/lib/isRequiredForA11y';
import uncontrollable from 'uncontrollable';
import Nav from './Nav';
import NavItem from './NavItem';
import UncontrolledTabContainer from './TabContainer';
import TabContent from './TabContent';
import { bsClass as setBsClass } from './utils/bootstrapUtils';
import ValidComponentChildren from './utils/ValidComponentChildren';
var TabContainer = UncontrolledTabContainer.ControlledComponent;
var propTypes = {
/**
* Mark the Tab with a matching `eventKey` as active.
*
* @controllable onSelect
*/
activeKey: React.PropTypes.any,
/**
* Navigation style
*/
bsStyle: React.PropTypes.oneOf(['tabs', 'pills']),
animation: React.PropTypes.bool,
id: requiredForA11y(React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.number])),
/**
* Callback fired when a Tab is selected.
*
* ```js
* function (
* Any eventKey,
* SyntheticEvent event?
* )
* ```
*
* @controllable activeKey
*/
onSelect: React.PropTypes.func,
/**
* Unmount tabs (remove it from the DOM) when it is no longer visible
*/
unmountOnExit: React.PropTypes.bool
};
var defaultProps = {
bsStyle: 'tabs',
animation: true,
unmountOnExit: false
};
function getDefaultActiveKey(children) {
var defaultActiveKey = void 0;
ValidComponentChildren.forEach(children, function (child) {
if (defaultActiveKey == null) {
defaultActiveKey = child.props.eventKey;
}
});
return defaultActiveKey;
}
var Tabs = function (_React$Component) {
_inherits(Tabs, _React$Component);
function Tabs() {
_classCallCheck(this, Tabs);
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
}
Tabs.prototype.renderTab = function renderTab(child) {
var _child$props = child.props;
var title = _child$props.title;
var eventKey = _child$props.eventKey;
var disabled = _child$props.disabled;
var tabClassName = _child$props.tabClassName;
if (title == null) {
return null;
}
return React.createElement(
NavItem,
{
eventKey: eventKey,
disabled: disabled,
className: tabClassName
},
title
);
};
Tabs.prototype.render = function render() {
var _props = this.props;
var id = _props.id;
var onSelect = _props.onSelect;
var animation = _props.animation;
var unmountOnExit = _props.unmountOnExit;
var bsClass = _props.bsClass;
var className = _props.className;
var style = _props.style;
var children = _props.children;
var _props$activeKey = _props.activeKey;
var activeKey = _props$activeKey === undefined ? getDefaultActiveKey(children) : _props$activeKey;
var props = _objectWithoutProperties(_props, ['id', 'onSelect', 'animation', 'unmountOnExit', 'bsClass', 'className', 'style', 'children', 'activeKey']);
return React.createElement(
TabContainer,
{
id: id,
activeKey: activeKey,
onSelect: onSelect,
className: className,
style: style
},
React.createElement(
'div',
null,
React.createElement(
Nav,
_extends({}, props, {
role: 'tablist'
}),
ValidComponentChildren.map(children, this.renderTab)
),
React.createElement(
TabContent,
{
bsClass: bsClass,
animation: animation,
unmountOnExit: unmountOnExit
},
children
)
)
);
};
return Tabs;
}(React.Component);
Tabs.propTypes = propTypes;
Tabs.defaultProps = defaultProps;
setBsClass('tab', Tabs);
export default uncontrollable(Tabs, { activeKey: 'onSelect' });
|
src/public/js/repository.js
|
TooAngel/democratic-collaboration
|
import React from 'react';
import PropTypes from 'prop-types';
import styles from '../../../static/css/repository.module.css';
/**
* Repository class
**/
export class Repository extends React.Component { // eslint-disable-line no-unused-vars
/**
* contructor - The constructor
*
* @param {object} props - The properties
* @return {void}
**/
constructor(props) {
super(props);
}
/**
* render - renders
* @return {object} - The element to be renderd
**/
render() {
let content = <div className={styles.content}></div>;
if (this.props.repository) {
content = <div className={styles.content}>
<a href={this.props.repository.html_url}><h1>{this.props.repository.full_name}</h1></a>
<div>{this.props.repository.description}</div>
</div>;
}
return content;
}
}
Repository.propTypes = {
repository: PropTypes.object,
};
|
client/src/app/main/dashboard/dashboard-edit-profile/dashboard-edit-profile-page.js
|
opensupports/opensupports
|
import React from 'react';
import {connect} from 'react-redux';
import _ from 'lodash';
import API from 'lib-app/api-call';
import i18n from 'lib-app/i18n';
import { getCustomFieldParamName } from 'lib-core/APIUtils';
import SessionActions from 'actions/session-actions';
import AreYouSure from 'app-components/are-you-sure';
import Header from 'core-components/header';
import Form from 'core-components/form';
import FormField from 'core-components/form-field';
import SubmitButton from 'core-components/submit-button';
import Message from 'core-components/message';
class DashboardEditProfilePage extends React.Component {
static propTypes = {
userCustomFields: React.PropTypes.object,
};
static defaultProps = {
userCustomFields: {},
};
state = {
loadingEmail: false,
loadingPass: false,
messageEmail: '',
messagePass: '',
customFields: [],
customFieldsFrom: {},
loadingCustomFields: false,
showChangeEmailMessage: true,
showChangePasswordMessage: true
};
componentDidMount() {
this.retrieveCustomFields();
}
render() {
return (
<div className="edit-profile-page">
<Header title={i18n('EDIT_PROFILE')} description={i18n('EDIT_PROFILE_VIEW_DESCRIPTION')} />
{this.renderEditEmail()}
{this.renderEditPassword()}
{this.state.customFields.length ? this.renderCustomFields() : null}
</div>
);
}
renderEditEmail() {
return (
<div className="edit-profile-page__edit-email">
<span className="separator" />
<div className="edit-profile-page__title">{i18n('EDIT_EMAIL')}</div>
<Form loading={this.state.loadingEmail} onSubmit={this.onSubmitEditEmail.bind(this)}>
<div className="edit-profile-page__change-email-container">
<FormField name="newEmail" label={i18n('NEW_EMAIL')} field="input" validation="EMAIL" fieldProps={{size: 'large'}} required />
<SubmitButton type="secondary">{i18n('CHANGE_EMAIL')}</SubmitButton>
</div>
{this.renderMessageEmail()}
</Form>
</div>
);
}
renderEditPassword() {
return (
<div className="edit-profile-page__edit-password">
<span className="separator" />
<div className="edit-profile-page__title">{i18n('EDIT_PASSWORD')}</div>
<Form loading={this.state.loadingPass} onSubmit={this.onSubmitEditPassword.bind(this)}>
<div className="edit-profile-page__change-password-container">
<div className="edit-profile-page__change-password-form-fields">
<FormField name="oldPassword" label={i18n('OLD_PASSWORD')} field="input" validation="PASSWORD" fieldProps={{password: true, size: 'large'}} required />
<FormField name="password" label={i18n('NEW_PASSWORD')} field="input" validation="PASSWORD" fieldProps={{password: true, size: 'large'}} required />
<FormField name="repeatNewPassword" label={i18n('REPEAT_NEW_PASSWORD')} field="input" validation="REPEAT_PASSWORD" fieldProps={{password: true, size: 'large'}} required />
</div>
<SubmitButton type="secondary">{i18n('CHANGE_PASSWORD')}</SubmitButton>
</div>
{this.renderMessagePass()}
</Form>
</div>
);
}
renderCustomFields() {
const {
loadingCustomFields,
customFieldsFrom,
customFields
} = this.state;
return (
<div className="edit-profile-page__edit-custom-field">
<span className="separator" />
<div className="edit-profile-page__title">{i18n('ADDITIONAL_FIELDS')}</div>
<Form
className="edit-profile-page__edit-custom-field-form"
loading={loadingCustomFields}
values={customFieldsFrom}
onChange={form => this.setState({customFieldsFrom: form})}
onSubmit={this.onCustomFieldsSubmit.bind(this)}>
<div className="edit-profile-page__custom-fields">
{customFields.map(this.renderCustomField.bind(this))}
</div>
<div className="edit-profile-page__update-custom-fields-button-container">
<SubmitButton className="edit-profile-page__update-custom-fields-button" type="secondary">{i18n('UPDATE_CUSTOM_FIELDS')}</SubmitButton>
</div>
</Form>
</div>
);
}
renderCustomField(customField, key) {
const { type, name, description, options } = customField;
if(type === 'text') {
return (
<div className="edit-profile-page__custom-field" key={key}>
<FormField name={name} label={name} infoMessage={description} field="input" fieldProps={{size: 'small'}} />
</div>
);
} else {
const items = options.map(option => ({content: option.name, value: option.name}));
return (
<div className="edit-profile-page__custom-field" key={key}>
<FormField name={name} label={name} infoMessage={description} field="select" fieldProps={{size: 'small', items}} />
</div>
);
}
}
renderMessageEmail() {
const { messageEmail, showChangeEmailMessage } = this.state;
switch (messageEmail) {
case 'success':
return (
<Message
showMessage={showChangeEmailMessage}
onCloseMessage={this.onCloseMessage.bind(this, "showChangeEmailMessage")}
className="edit-profile-page__message"
type="success">
{i18n('EMAIL_CHANGED')}
</Message>
);
case 'fail':
return (
<Message
showMessage={showChangeEmailMessage}
onCloseMessage={this.onCloseMessage.bind(this, "showChangeEmailMessage")}
className="edit-profile-page__message"
type="error">
{i18n('EMAIL_EXISTS')}
</Message>
);
default:
return null;
}
}
renderMessagePass() {
const { messagePass, showChangePasswordMessage } = this.state;
switch (messagePass) {
case 'success':
return (
<Message
showMessage={showChangePasswordMessage}
onCloseMessage={this.onCloseMessage.bind(this, "showChangePasswordMessage")}
className="edit-profile-page__message"
type="success">
{i18n('PASSWORD_CHANGED')}
</Message>
);
case 'fail':
return (
<Message
showMessage={showChangePasswordMessage}
onCloseMessage={this.onCloseMessage.bind(this, "showChangePasswordMessage")}
className="edit-profile-page__message"
type="error">
{i18n('OLD_PASSWORD_INCORRECT')}
</Message>
);
default:
return null;
}
}
onCustomFieldsSubmit(form) {
const {customFields} = this.state;
const parsedFrom = {};
customFields.forEach(customField => {
const {
type,
name,
options
} = customField;
if(type === 'select') {
parsedFrom[getCustomFieldParamName(name)] = options[form[name]].name;
} else {
parsedFrom[getCustomFieldParamName(name)] = form[name];
}
});
this.setState({
loadingCustomFields: true,
});
API.call({
path: '/user/edit-custom-fields',
data: parsedFrom
}).then(() => {
this.setState({loadingCustomFields: false});
this.props.dispatch(SessionActions.getUserData());
});
}
onSubmitEditEmail(formState) {
AreYouSure.openModal(i18n('EMAIL_WILL_CHANGE'), this.callEditEmailAPI.bind(this, formState));
}
onSubmitEditPassword(formState) {
AreYouSure.openModal(i18n('PASSWORD_WILL_CHANGE'), this.callEditPassAPI.bind(this, formState));
}
callEditEmailAPI(formState){
this.setState({
loadingEmail: true
});
return API.call({
path: "/user/edit-email",
data: {
newEmail: formState.newEmail
}
}).then(function () {
this.setState({
loadingEmail: false,
messageEmail: "success",
showChangeEmailMessage: true
});
}.bind(this)).catch(function (){
this.setState({
loadingEmail: false,
messageEmail: 'fail',
showChangeEmailMessage: true
})
}.bind(this));
}
callEditPassAPI(formState){
this.setState({
loadingPass: true
});
return API.call({
path: "/user/edit-password",
data: {
oldPassword: formState.oldPassword,
newPassword: formState.password
}
}).then(function () {
this.setState({
loadingPass: false,
messagePass: "success",
showChangePasswordMessage: true
});
}.bind(this)).catch(function (){
this.setState({
loadingPass: false,
messagePass: 'fail',
showChangePasswordMessage: true
})
}.bind(this));
}
retrieveCustomFields() {
API.call({
path: '/system/get-custom-fields',
data: {}
})
.then(result => {
const customFieldsFrom = {};
const {userCustomFields} = this.props;
result.data.forEach(customField => {
const {
type,
name,
options
} = customField;
if(type === 'select') {
const index = _.indexOf(options.map(option => option.name), userCustomFields[name]);
customFieldsFrom[name] = ((index === -1) ? 0 : index);
} else {
customFieldsFrom[name] = userCustomFields[name] || '';
}
});
this.setState({
customFields: result.data,
customFieldsFrom,
});
});
}
onCloseMessage(showMessage) {
this.setState({
[showMessage]: false
});
}
}
export default connect((store) => {
const userCustomFields = {};
store.session.userCustomFields.forEach(customField => {
userCustomFields[customField.customfield] = customField.value;
});
return {
userCustomFields: userCustomFields || {},
};
})(DashboardEditProfilePage);
|
definitions/npm/radium_v0.19.x/test_radium-v0.19.x.js
|
davidohayon669/flow-typed
|
// @flow
import React from 'react';
import Radium from 'radium';
import type { FunctionComponent } from 'radium'
type Props1 = {
a: number,
b: string
};
const C1: FunctionComponent<Props1, void> = (props: Props1) => <div>{props.a} {props.b}</div>
type Props2 = {
a: number,
b: string,
};
class C2 extends React.Component<void, Props2, void> {
render () {
return <div>{this.props.a} {this.props.b}</div>
}
}
Radium(<div/>);
Radium(<Radium.StyleRoot/>);
Radium.keyframes({});
// $ExpectError
Radium.keyframes(); // missing object
Radium.getState({}, 'ref', ':hover');
// $ExpectError
Radium.getState({}, 'ref', ':visible') // invalid property
const RC1 = Radium(C1);
<RC1 a={1} b="s" />;
// $ExpectError
<RC1 />; // missing a, b
// $ExpectError
<RC1 a={1} />; // missing b
// $ExpectError
<RC1 a="s" b="s" />; // wrong a type
const RC2 = Radium(C2);
<RC2 a={1} b="s" />;
// $ExpectError
<RC2 />; // missing a, b
// $ExpectError
<RC2 a={1} />; // missing b
// $ExpectError
<RC2 a="s" b="s" />; // wrong a type
const ConfiguredRadium = Radium({ userAgent: 'foo' })
const CRC1 = ConfiguredRadium(C1);
<CRC1 a={1} b="s" />;
// $ExpectError
<CRC1 />; // missing a, b
// $ExpectError
<CRC1 a={1} />; // missing b
// $ExpectError
<CRC1 a="s" b="s" />; // wrong a type
const CRC2 = ConfiguredRadium(C2);
<CRC2 a={1} b="s" />;
// $ExpectError
<CRC2 />; // missing a, b
// $ExpectError
<CRC2 a={1} />; // missing b
// $ExpectError
<CRC2 a="s" b="s" />; // wrong a type
|
templates/rubix/demo/src/routes/Maps.js
|
jeffthemaximum/jeffline
|
import React from 'react';
import {
Row,
Col,
Grid,
Form,
Panel,
Button,
FormGroup,
PanelBody,
InputGroup,
FormControl,
PanelHeader,
PanelContainer,
} from '@sketchpixy/rubix';
class MapContainer extends React.Component {
render() {
return (
<PanelContainer>
<Panel>
<PanelBody style={{padding: 25}}>
<h4 className='text-center' style={{marginTop: 0}}>{this.props.name}</h4>
{this.props.children}
<div id={this.props.id} style={{height: 300}}></div>
</PanelBody>
</Panel>
</PanelContainer>
);
}
}
export default class Maps extends React.Component {
constructor(props) {
super(props);
this.geocode = null;
this.routingmap = null;
this.state = {
routeslist: []
};
}
geoCode(address) {
GMaps.geocode({
address: address,
callback: (results, status) => {
if (status == 'OK') {
var latlng = results[0].geometry.location;
this.geocode.setCenter(latlng.lat(), latlng.lng());
this.geocode.addMarker({
lat: latlng.lat(),
lng: latlng.lng(),
infoWindow: {
content: '<div><strong>Address:</strong> '+results[0].formatted_address+'</div>'
}
});
}
}
});
}
componentDidMount() {
(() => {
new GMaps({
scrollwheel: false,
div: '#basic-map',
lat: -12.043333,
lng: -77.028333
});
})();
(() => {
new GMaps({
scrollwheel: false,
div: '#map-events',
zoom: 16,
lat: -12.043333,
lng: -77.028333,
click: (e) => {
alert('click');
},
dragend: (e) => {
alert('dragend');
}
});
})();
(() => {
var map = new GMaps({
scrollwheel: false,
div: '#markers',
zoom: 16,
lat: -12.043333,
lng: -77.028333
});
map.addMarker({
lat: -12.043333,
lng: -77.028333,
title: 'Lima',
click: (e) => {
alert('You clicked in this marker');
}
});
map.addMarker({
lat: -12.043333,
lng: -77.029333,
title: 'Lima',
infoWindow: {
content: '<p>Some content here!</p>'
}
});
})();
(() => {
this.geocode = new GMaps({
scrollwheel: false,
div: '#geocode',
zoom: 16,
lat: -12.043333,
lng: -77.028333
});
this.geoCode('New York, NY, USA');
})();
(() => {
var map = new GMaps({
scrollwheel: false,
div: '#polyline',
zoom: 12,
lat: -12.043333,
lng: -77.028333
});
var path = [[-12.044012922866312, -77.02470665341184], [-12.05449279282314, -77.03024273281858], [-12.055122327623378, -77.03039293652341], [-12.075917129727586, -77.02764635449216], [-12.07635776902266, -77.02792530422971], [-12.076819390363665, -77.02893381481931], [-12.088527520066453, -77.0241058385925], [-12.090814532191756, -77.02271108990476]];
map.drawPolyline({
path: path,
strokeColor: '#FF0080',
strokeOpacity: 0.75,
strokeWeight: 8
});
})();
(() => {
var map = new GMaps({
scrollwheel: false,
div: '#overlays',
zoom: 18,
lat: 40.7638435,
lng: -73.9729691
});
map.drawOverlay({
lat: 40.7640135,
lng: -73.9729691,
content: '<div class="overlay">Apple Store, NY, USA<div class="overlay_arrow above"></div></div>'
});
})();
(() => {
var map = new GMaps({
scrollwheel: false,
div: '#polygon',
lat: -12.043333,
lng: -77.028333
});
var path = [[-12.040397656836609,-77.03373871559225], [-12.040248585302038,-77.03993927003302], [-12.050047116528843,-77.02448169303511], [-12.044804866577001,-77.02154422636042]];
var polygon = map.drawPolygon({
paths: path, // pre-defined polygon shape
strokeColor: '#D71F4B',
strokeOpacity: 1,
strokeWeight: 3,
fillColor: '#D71F4B',
fillOpacity: 0.6
});
})();
(() => {
var map = new GMaps({
scrollwheel: false,
div: '#geojson',
lat: 39.743296277167325,
lng: -105.00517845153809
});
var paths = [
[
[
[-105.00432014465332, 39.74732195489861],
[-105.00715255737305, 39.74620006835170],
[-105.00921249389647, 39.74468219277038],
[-105.01067161560059, 39.74362625960105],
[-105.01195907592773, 39.74290029616054],
[-105.00989913940431, 39.74078835902781],
[-105.00758171081543, 39.74059036160317],
[-105.00346183776855, 39.74059036160317],
[-105.00097274780272, 39.74059036160317],
[-105.00062942504881, 39.74072235994946],
[-105.00020027160645, 39.74191033368865],
[-105.00071525573731, 39.74276830198601],
[-105.00097274780272, 39.74369225589818],
[-105.00097274780272, 39.74461619742136],
[-105.00123023986816, 39.74534214278395],
[-105.00183105468751, 39.74613407445653],
[-105.00432014465332, 39.74732195489861]
],[
[-105.00361204147337, 39.74354376414072],
[-105.00301122665405, 39.74278480127163],
[-105.00221729278564, 39.74316428375108],
[-105.00283956527711, 39.74390674342741],
[-105.00361204147337, 39.74354376414072]
]
],[
[
[-105.00942707061768, 39.73989736613708],
[-105.00942707061768, 39.73910536278566],
[-105.00685214996338, 39.73923736397631],
[-105.00384807586671, 39.73910536278566],
[-105.00174522399902, 39.73903936209552],
[-105.00041484832764, 39.73910536278566],
[-105.00041484832764, 39.73979836621592],
[-105.00535011291504, 39.73986436617916],
[-105.00942707061768, 39.73989736613708]
]
]
];
var polygon = map.drawPolygon({
paths: paths,
useGeoJSON: true,
strokeColor: '#2EB398',
strokeOpacity: 1,
strokeWeight: 3,
fillColor: '#2EB398',
fillOpacity: 0.6
});
})();
(() => {
this.routingmap = new GMaps({
scrollwheel: false,
div: '#routingmap',
lat: -12.043333,
lng: -77.028333
});
})();
}
handleSubmit(e) {
e.preventDefault();
e.stopPropagation();
this.geoCode($('#address').val());
}
startRouting(e) {
e.preventDefault();
e.stopPropagation();
this.setState({
routeslist: []
}, () => {
var map = this.routingmap;
var list = [];
map.travelRoute({
origin: [-12.044012922866312, -77.02470665341184],
destination: [-12.090814532191756, -77.02271108990476],
travelMode: 'driving',
step: (e) => {
list.push({
instructions: e.instructions,
lat: e.end_location.lat(),
lng: e.end_location.lng(),
path: e.path
});
},
end: (e) => {
var lat, lng, path;
var processList = (i) => {
if(list.length === i) return;
lat = list[i].lat;
lng = list[i].lng;
path = list[i].path;
setTimeout(() => {
this.setState({
routeslist: list.slice(0, i+1)
});
map.setCenter(lat, lng);
map.drawPolyline({
path: path,
strokeColor: '#FF6FCF',
strokeWeight: 8
});
processList(i+1);
}, 500);
};
processList(0);
}
});
});
}
render() {
return (
<div>
<Row>
<Col sm={6} collapseRight>
<MapContainer id='basic-map' name='Basic Map' />
<MapContainer id='markers' name='Map Markers' />
<MapContainer id='polyline' name='Polylines' />
<MapContainer id='polygon' name='Polygon' />
</Col>
<Col sm={6}>
<MapContainer id='map-events' name='Map Events' />
<MapContainer id='geocode' name='Geocoding'>
<Form onSubmit={::this.handleSubmit}>
<FormGroup>
<InputGroup>
<FormControl type='text' id='address' placeholder='Address' defaultValue='New York, NY, USA' />
<InputGroup.Button className='plain'>
<Button outlined onlyOnHover type='submit' bsStyle='darkgreen45'>search</Button>
</InputGroup.Button>
</InputGroup>
</FormGroup>
</Form>
</MapContainer>
<MapContainer id='overlays' name='Overlays' />
<MapContainer id='geojson' name='GeoJSON Polygon' />
</Col>
</Row>
<Row>
<Col xs={12}>
<PanelContainer>
<Panel>
<PanelBody style={{padding: 25}}>
<Grid>
<Row>
<Col xs={12} sm={6} collapseLeft>
<div id='routingmap' style={{height: 300}}></div>
</Col>
<Col xs={12} sm={6} collapseRight>
<hr className='visible-xs' />
<div className='text-center' style={{paddingBottom: 25}}>
<Button outlined onlyOnHover type='button' bsStyle='darkgreen45' onClick={::this.startRouting}>Start routing</Button>
</div>
<div>
<ul>
{this.state.routeslist.map(function(route, i) {
return (<li key={i} dangerouslySetInnerHTML={{__html: route.instructions}}></li>);
})}
</ul>
</div>
</Col>
</Row>
</Grid>
</PanelBody>
</Panel>
</PanelContainer>
</Col>
</Row>
</div>
);
}
}
|
src/components/general/Input.js
|
katima-g33k/blu-react-desktop
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import {
Col,
ControlLabel,
FormControl,
FormGroup,
} from 'react-bootstrap';
const styles = {
label: {
marginTop: '7px',
textAlign: 'right',
},
};
const types = {
EMAIL: 'email',
PHONE: 'phone',
NUMBER: 'number',
PASSWORD: 'password',
TEXT: 'text',
};
export default class Input extends Component {
static propTypes = {
data: PropTypes.shape(),
disabled: PropTypes.bool,
id: PropTypes.string,
inputWidth: PropTypes.shape(),
isValid: PropTypes.bool,
label: PropTypes.string,
labelWidth: PropTypes.shape(),
onChange: PropTypes.func.isRequired,
placeholder: PropTypes.string,
required: PropTypes.bool,
style: PropTypes.shape(),
type: PropTypes.oneOf(Object.values(types)),
value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
};
static defaultProps = {
data: {},
disabled: false,
id: '',
inputWidth: { md: 9, sm: 10 },
isValid: true,
label: '',
labelWidth: { md: 3, sm: 2 },
placeholder: '',
required: false,
style: {},
type: types.TEXT,
value: '',
};
static TYPES = types;
onChange = event => this.props.onChange(event, event.target.value);
getDataAttributes = () => Object.keys(this.props.data).reduce((acc, cur) => ({
...acc,
[`data-${cur}`]: this.props.data[cur],
}), {});
renderLabel = () => this.props.label && (
<Col
{...this.props.labelWidth}
componentClass={ControlLabel}
style={styles.label}
>
{this.props.label}{this.props.required && '*'}
</Col>
);
render() {
return (
<FormGroup
style={this.props.style}
validationState={!this.props.isValid ? 'error' : null}
>
{this.renderLabel()}
<Col {...this.props.inputWidth}>
<FormControl
{...this.getDataAttributes()}
disabled={this.props.disabled}
id={this.props.id}
onChange={this.onChange}
placeholder={this.props.placeholder}
type={this.props.type}
value={this.props.value}
/>
<FormControl.Feedback />
</Col>
</FormGroup>
);
}
}
|
imports/components/Toaster.js
|
naustudio/nau-jukebox
|
/* © 2017 NauStud.io
* @author Eric
*/
import React, { Component } from 'react';
import PropTypes from 'prop-types';
class Toaster extends Component {
static propTypes = {
open: PropTypes.bool,
text: PropTypes.string,
time: PropTypes.number,
type: PropTypes.oneOf(['success', 'error']),
onClose: PropTypes.func.isRequired,
};
static defaultProps = {
open: false,
text: 'Toaster',
time: 3000,
type: 'success',
};
componentWillReceiveProps(nextProps) {
if (nextProps.open !== this.props.open && nextProps.open) {
clearTimeout(this.timeout);
if (nextProps.type === 'success') {
this.timeout = setTimeout(() => {
this.props.onClose();
}, this.props.time);
}
}
}
timeout;
render() {
const { open, text, type, onClose } = this.props;
return (
<div className={`toaster ${open ? 'toaster--open' : ''} toaster--${type}`} onClick={onClose}>
<span>{text}</span>
</div>
);
}
}
export default Toaster;
|
app/javascript/mastodon/features/compose/components/search.js
|
3846masa/mastodon
|
import React from 'react';
import PropTypes from 'prop-types';
import { defineMessages, injectIntl, FormattedMessage } from 'react-intl';
const messages = defineMessages({
placeholder: { id: 'search.placeholder', defaultMessage: 'Search' },
});
class Search extends React.PureComponent {
static propTypes = {
value: PropTypes.string.isRequired,
submitted: PropTypes.bool,
onChange: PropTypes.func.isRequired,
onSubmit: PropTypes.func.isRequired,
onClear: PropTypes.func.isRequired,
onShow: PropTypes.func.isRequired,
intl: PropTypes.object.isRequired,
};
handleChange = (e) => {
this.props.onChange(e.target.value);
}
handleClear = (e) => {
e.preventDefault();
if (this.props.value.length > 0 || this.props.submitted) {
this.props.onClear();
}
}
handleKeyDown = (e) => {
if (e.key === 'Enter') {
e.preventDefault();
this.props.onSubmit();
}
}
noop () {
}
handleFocus = () => {
this.props.onShow();
}
render () {
const { intl, value, submitted } = this.props;
const hasValue = value.length > 0 || submitted;
return (
<div className='search'>
<input
className='search__input'
type='text'
placeholder={intl.formatMessage(messages.placeholder)}
value={value}
onChange={this.handleChange}
onKeyUp={this.handleKeyDown}
onFocus={this.handleFocus}
/>
<div role='button' tabIndex='0' className='search__icon' onClick={this.handleClear}>
<i className={`fa fa-search ${hasValue ? '' : 'active'}`} />
<i aria-label={intl.formatMessage(messages.placeholder)} className={`fa fa-times-circle ${hasValue ? 'active' : ''}`} />
</div>
</div>
);
}
}
export default injectIntl(Search);
|
src/routes/withTracker.js
|
wearepush/redux-starter
|
import React, { Component } from 'react';
import { object } from 'prop-types';
import GoogleAnalytics from 'react-ga';
const googleAnaliticsId = process.env?.GOOGLE_ANALITICS_ID;
if (googleAnaliticsId) {
GoogleAnalytics.initialize(googleAnaliticsId);
}
export default function withTracker(WrappedComponent, options = {}) {
const trackPage = (page) => {
GoogleAnalytics.set({
page,
...options,
});
GoogleAnalytics.pageview(page);
};
const HOC = class extends Component {
componentDidMount() {
if (googleAnaliticsId) {
const { location } = this.props;
const page = location.pathname;
trackPage(page);
}
}
componentDidUpdate(nextProps) {
if (googleAnaliticsId) {
const { location } = this.props;
const currentPage = location.pathname;
const nextPage = nextProps.location.pathname;
if (currentPage !== nextPage) {
trackPage(nextPage);
}
}
}
render() {
return <WrappedComponent {...this.props} />;
}
};
if (typeof WrappedComponent.fetchData !== 'undefined') {
HOC.fetchData = WrappedComponent.fetchData;
}
HOC.propTypes = {
location: object.isRequired,
};
return HOC;
}
|
src/components/MyMainMenu.js
|
fredrikku/rikku-grommet-react-sample
|
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import MenuIcon from 'grommet/components/icons/base/Menu';
import Anchor from 'grommet/components/Anchor';
import Menu from 'grommet/components/Menu';
import Box from 'grommet/components/Box';
const MainMenu = (props) => {
const { myTableStore } = props;
const menuItems = props.menuItems || [];
return (
<Box flex={true}
justify='end'
direction='row'
responsive={false}>
<Menu pad={{ vertical: 'medium', between: 'small'}}
icon={<MenuIcon size="medium" colorIndex="neutral-4"/>}
dropAlign={{"right": "right"}} >
{ menuItems.map( (item, index) =>
<Anchor key={item.key} onClick={ () => props.selectTable( myTableStore[item.key]) }>
{item.title}
</Anchor>
)}
</Menu>
</Box>
);
};
MainMenu.propTypes = {
menuItems: PropTypes.arrayOf(PropTypes.shape({key: PropTypes.number.isRequired, title: PropTypes.string.isRequired})),
selectTable: PropTypes.func.isRequired,
myTableStore: PropTypes.array.isRequired
};
const mapStateToProps = state => (
{
myTableStore: state.myTableStore
}
);
//subscribe MainMenu to redux-store, meaning state will appear as props instead
export default connect(mapStateToProps)(MainMenu);
|
node_modules/@material-ui/core/esm/Link/Link.js
|
pcclarke/civ-techs
|
import _extends from "@babel/runtime/helpers/extends";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
import React from 'react';
import PropTypes from 'prop-types';
import clsx from 'clsx';
import { capitalize } from '../utils/helpers';
import withStyles from '../styles/withStyles';
import Typography from '../Typography';
export var styles = {
/* Styles applied to the root element. */
root: {},
/* Styles applied to the root element if `underline="none"`. */
underlineNone: {
textDecoration: 'none'
},
/* Styles applied to the root element if `underline="hover"`. */
underlineHover: {
textDecoration: 'none',
'&:hover': {
textDecoration: 'underline'
}
},
/* Styles applied to the root element if `underline="always"`. */
underlineAlways: {
textDecoration: 'underline'
},
// Same reset as ButtonBase.root
/* Styles applied to the root element if `component="button"`. */
button: {
position: 'relative',
// Remove grey highlight
WebkitTapHighlightColor: 'transparent',
backgroundColor: 'transparent',
// Reset default value
// We disable the focus ring for mouse, touch and keyboard users.
outline: 'none',
border: 0,
margin: 0,
// Remove the margin in Safari
borderRadius: 0,
padding: 0,
// Remove the padding in Firefox
cursor: 'pointer',
userSelect: 'none',
verticalAlign: 'middle',
'-moz-appearance': 'none',
// Reset
'-webkit-appearance': 'none',
// Reset
'&::-moz-focus-inner': {
borderStyle: 'none' // Remove Firefox dotted outline.
}
}
};
var Link = React.forwardRef(function Link(props, ref) {
var classes = props.classes,
className = props.className,
_props$component = props.component,
component = _props$component === void 0 ? 'a' : _props$component,
_props$color = props.color,
color = _props$color === void 0 ? 'primary' : _props$color,
TypographyClasses = props.TypographyClasses,
_props$underline = props.underline,
underline = _props$underline === void 0 ? 'hover' : _props$underline,
_props$variant = props.variant,
variant = _props$variant === void 0 ? 'inherit' : _props$variant,
other = _objectWithoutProperties(props, ["classes", "className", "component", "color", "TypographyClasses", "underline", "variant"]);
return React.createElement(Typography, _extends({
className: clsx(classes.root, component === 'button' && classes.button, classes["underline".concat(capitalize(underline))], className),
classes: TypographyClasses,
color: color,
component: component,
ref: ref,
variant: variant
}, other));
});
process.env.NODE_ENV !== "production" ? Link.propTypes = {
/**
* The content of the link.
*/
children: PropTypes.node.isRequired,
/**
* Override or extend the styles applied to the component.
* See [CSS API](#css) below for more details.
*/
classes: PropTypes.object.isRequired,
/**
* @ignore
*/
className: PropTypes.string,
/**
* The color of the link.
*/
color: PropTypes.oneOf(['default', 'error', 'inherit', 'primary', 'secondary', 'textPrimary', 'textSecondary']),
/**
* The component used for the root node.
* Either a string to use a DOM element or a component.
*/
component: PropTypes.elementType,
/**
* `classes` property applied to the [`Typography`](/api/typography/) element.
*/
TypographyClasses: PropTypes.object,
/**
* Controls when the link should have an underline.
*/
underline: PropTypes.oneOf(['none', 'hover', 'always']),
/**
* Applies the theme typography styles.
*/
variant: PropTypes.string
} : void 0;
export default withStyles(styles, {
name: 'MuiLink'
})(Link);
|
src/svg-icons/image/colorize.js
|
verdan/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let ImageColorize = (props) => (
<SvgIcon {...props}>
<path d="M20.71 5.63l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"/>
</SvgIcon>
);
ImageColorize = pure(ImageColorize);
ImageColorize.displayName = 'ImageColorize';
ImageColorize.muiName = 'SvgIcon';
export default ImageColorize;
|
src/components/login/LoginForm.js
|
hugofrely/chat-react-redux
|
import React from 'react';
import TextInput from '../common/TextInput';
const LoginForm = ({user, onSave, onChange, saving}) => {
return (
<form>
<h1>Login</h1>
<TextInput
name="email"
label="Email"
onChange={onChange}
value={user.email}
/>
<TextInput
name="password"
label="Password"
onChange={onChange}
value={user.password}
/>
<input
type="submit"
disabled={saving}
value={saving ? 'Logining in...' : 'Login'}
className="btn btn-primary"
onClick={onSave}/>
</form>
);
};
LoginForm.propTypes = {
onSave: React.PropTypes.func.isRequired,
saving: React.PropTypes.bool,
user: React.PropTypes.object.isRequired,
onChange: React.PropTypes.func.isRequired
};
export default LoginForm;
|
frontend/src/Settings/MediaManagement/RootFolder/EditRootFolderModal.js
|
lidarr/Lidarr
|
import PropTypes from 'prop-types';
import React from 'react';
import Modal from 'Components/Modal/Modal';
import EditRootFolderModalContentConnector from './EditRootFolderModalContentConnector';
function EditRootFolderModal({ isOpen, onModalClose, ...otherProps }) {
return (
<Modal
isOpen={isOpen}
onModalClose={onModalClose}
>
<EditRootFolderModalContentConnector
{...otherProps}
onModalClose={onModalClose}
/>
</Modal>
);
}
EditRootFolderModal.propTypes = {
isOpen: PropTypes.bool.isRequired,
onModalClose: PropTypes.func.isRequired
};
export default EditRootFolderModal;
|
src/buttons/Button.js
|
kosiakMD/react-native-elements
|
import PropTypes from 'prop-types';
import React from 'react';
import {
TouchableNativeFeedback,
TouchableHighlight,
StyleSheet,
View,
Platform,
ActivityIndicator,
Text as NativeText,
} from 'react-native';
import colors from '../config/colors';
import Text from '../text/Text';
import MaterialIcon from 'react-native-vector-icons/MaterialIcons';
import getIconType from '../helpers/getIconType';
import normalize from '../helpers/normalizeText';
import ViewPropTypes from '../config/ViewPropTypes';
const log = () => {
console.log('please attach method to this component'); //eslint-disable-line no-console
};
const Button = props => {
const {
disabled,
loading,
loadingRight,
activityIndicatorStyle,
buttonStyle,
borderRadius,
title,
onPress,
icon,
iconComponent,
secondary,
secondary2,
secondary3,
primary1,
primary2,
backgroundColor,
color,
fontSize,
underlayColor,
raised,
textStyle,
large,
iconRight,
fontWeight,
disabledStyle,
fontFamily,
containerViewStyle,
rounded,
outline,
transparent,
textNumberOfLines,
textEllipsizeMode,
allowFontScaling,
...attributes
} = props;
let { Component, rightIcon, leftIcon } = props;
let leftIconElement;
if (!leftIcon && icon) {
leftIcon = icon;
}
if (leftIcon) {
let Icon;
if (iconComponent) {
Icon = iconComponent;
} else if (!leftIcon.type) {
Icon = MaterialIcon;
} else {
Icon = getIconType(leftIcon.type);
}
leftIconElement = (
<Icon
{...leftIcon}
color={leftIcon.color || 'white'}
size={leftIcon.size || (large ? 26 : 18)}
style={[styles.icon, leftIcon.style && leftIcon.style]}
/>
);
}
let rightIconElement;
if (iconRight || rightIcon) {
if (!rightIcon) {
rightIcon = iconRight;
}
let Icon;
if (iconComponent) {
Icon = iconComponent;
} else if (!rightIcon.type) {
Icon = MaterialIcon;
} else {
Icon = getIconType(rightIcon.type);
}
rightIconElement = (
<Icon
{...rightIcon}
color={rightIcon.color || 'white'}
size={rightIcon.size || (large ? 26 : 18)}
style={[styles.iconRight, rightIcon.style && rightIcon.style]}
/>
);
}
let loadingElement;
if (loading) {
loadingElement = (
<ActivityIndicator
animating={true}
style={[styles.activityIndicatorStyle, activityIndicatorStyle]}
color={color || 'white'}
size={(large && 'large') || 'small'}
/>
);
}
if (!Component && Platform.OS === 'ios') {
Component = TouchableHighlight;
}
if (!Component && Platform.OS === 'android') {
Component = TouchableNativeFeedback;
}
if (!Component) {
Component = TouchableHighlight;
}
if (Platform.OS === 'android' && (borderRadius && !attributes.background)) {
attributes.background = TouchableNativeFeedback.Ripple(
'ThemeAttrAndroid',
true
);
}
const baseFont = {
color: (textStyle && textStyle.color) || color || stylesObject.text.color,
size: (textStyle && textStyle.fontSize) ||
fontSize ||
(!large && stylesObject.smallFont.fontSize) ||
stylesObject.text.fontSize,
};
let textOptions = {};
if (textNumberOfLines) {
textOptions.numberOfLines = textNumberOfLines;
if (textEllipsizeMode) {
textOptions.ellipsizeMode = textEllipsizeMode;
}
}
return (
<View
style={[
styles.container,
raised && styles.raised,
containerViewStyle,
borderRadius && { borderRadius },
]}
>
<Component
underlayColor={underlayColor || 'transparent'}
onPress={onPress || log}
disabled={disabled || false}
{...attributes}
>
<View
style={[
styles.button,
secondary && { backgroundColor: colors.secondary },
secondary2 && { backgroundColor: colors.secondary2 },
secondary3 && { backgroundColor: colors.secondary3 },
primary1 && { backgroundColor: colors.primary1 },
primary2 && { backgroundColor: colors.primary2 },
backgroundColor && { backgroundColor: backgroundColor },
borderRadius && { borderRadius },
!large && styles.small,
rounded && {
borderRadius: baseFont.size * 3.8,
paddingHorizontal: !large
? stylesObject.small.padding * 1.5
: stylesObject.button.padding * 1.5,
},
outline && {
borderWidth: 1,
backgroundColor: 'transparent',
borderColor: baseFont.color,
},
transparent && {
borderWidth: 0,
backgroundColor: 'transparent',
},
buttonStyle && buttonStyle,
disabled && { backgroundColor: colors.disabled },
disabled && disabledStyle && disabledStyle,
]}
>
{(icon && !iconRight) || leftIconElement ? leftIconElement : null}
{loading && !loadingRight && loadingElement}
<Text
style={[
styles.text,
color && { color },
!large && styles.smallFont,
fontSize && { fontSize },
textStyle && textStyle,
fontWeight && { fontWeight },
fontFamily && { fontFamily },
]}
{...textOptions}
allowFontScaling={allowFontScaling}
>
{title}
</Text>
{loading && loadingRight && loadingElement}
{(icon && iconRight) || rightIconElement ? rightIconElement : null}
</View>
</Component>
</View>
);
};
Button.propTypes = {
buttonStyle: ViewPropTypes.style,
title: PropTypes.string,
onPress: PropTypes.any,
icon: PropTypes.object,
leftIcon: PropTypes.object,
rightIcon: PropTypes.object,
iconRight: PropTypes.object,
iconComponent: PropTypes.any,
secondary: PropTypes.bool,
secondary2: PropTypes.bool,
secondary3: PropTypes.bool,
primary1: PropTypes.bool,
primary2: PropTypes.bool,
backgroundColor: PropTypes.string,
color: PropTypes.string,
fontSize: PropTypes.any,
underlayColor: PropTypes.string,
raised: PropTypes.bool,
textStyle: NativeText.propTypes.style,
disabled: PropTypes.bool,
loading: PropTypes.bool,
activityIndicatorStyle: ViewPropTypes.style,
loadingRight: PropTypes.bool,
Component: PropTypes.any,
borderRadius: PropTypes.number,
large: PropTypes.bool,
fontWeight: PropTypes.string,
disabledStyle: ViewPropTypes.style,
fontFamily: PropTypes.string,
containerViewStyle: ViewPropTypes.style,
rounded: PropTypes.bool,
outline: PropTypes.bool,
transparent: PropTypes.bool,
allowFontScaling: PropTypes.bool,
textNumberOfLines: PropTypes.number,
textEllipsizeMode: PropTypes.string,
};
const stylesObject = {
container: {
backgroundColor: 'transparent',
marginLeft: 15,
marginRight: 15,
},
button: {
padding: 19,
backgroundColor: colors.primary,
justifyContent: 'center',
alignItems: 'center',
flexDirection: 'row',
},
text: {
color: 'white',
fontSize: normalize(16),
},
icon: {
marginRight: 10,
},
iconRight: {
marginLeft: 10,
},
small: {
padding: 12,
},
smallFont: {
fontSize: normalize(14),
},
activityIndicatorStyle: {
marginHorizontal: 10,
height: 0,
},
raised: {
...Platform.select({
ios: {
shadowColor: 'rgba(0,0,0, .4)',
shadowOffset: { height: 1, width: 1 },
shadowOpacity: 1,
shadowRadius: 1,
},
android: {
backgroundColor: '#fff',
elevation: 2,
},
}),
},
};
const styles = StyleSheet.create(stylesObject);
export default Button;
|
src/routes/index.js
|
cmosguy/react-redux-auth0
|
/**
* 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 React from 'react';
import App from '../components/App';
// Child routes
import home from './home';
import contact from './contact';
import login from './login';
import register from './register';
import content from './content';
import error from './error';
export default {
path: '/',
children: [
home,
contact,
login,
register,
content,
error,
],
async action({ next, render, context }) {
const component = await next();
if (component === undefined) return component;
return render(
<App context={context}>{component}</App>
);
},
};
|
src/js/components/tool-header.js
|
pfb3cn/react_bootcamp_exercise
|
import React from 'react';
export class ToolHeader extends React.Component {
static propTypes = {
header: React.PropTypes.string
};
render() {
return <h1>Color Tool</h1>;
}
}
|
app/javascript/mastodon/features/compose/components/emoji_picker_dropdown.js
|
kibousoft/mastodon
|
import React from 'react';
import PropTypes from 'prop-types';
import { defineMessages, injectIntl } from 'react-intl';
import { EmojiPicker as EmojiPickerAsync } from '../../ui/util/async-components';
import Overlay from 'react-overlays/lib/Overlay';
import classNames from 'classnames';
import ImmutablePropTypes from 'react-immutable-proptypes';
import detectPassiveEvents from 'detect-passive-events';
import { buildCustomEmojis } from '../../emoji/emoji';
const messages = defineMessages({
emoji: { id: 'emoji_button.label', defaultMessage: 'Insert emoji' },
emoji_search: { id: 'emoji_button.search', defaultMessage: 'Search...' },
emoji_not_found: { id: 'emoji_button.not_found', defaultMessage: 'No emojos!! (╯°□°）╯︵ ┻━┻' },
custom: { id: 'emoji_button.custom', defaultMessage: 'Custom' },
recent: { id: 'emoji_button.recent', defaultMessage: 'Frequently used' },
search_results: { id: 'emoji_button.search_results', defaultMessage: 'Search results' },
people: { id: 'emoji_button.people', defaultMessage: 'People' },
nature: { id: 'emoji_button.nature', defaultMessage: 'Nature' },
food: { id: 'emoji_button.food', defaultMessage: 'Food & Drink' },
activity: { id: 'emoji_button.activity', defaultMessage: 'Activity' },
travel: { id: 'emoji_button.travel', defaultMessage: 'Travel & Places' },
objects: { id: 'emoji_button.objects', defaultMessage: 'Objects' },
symbols: { id: 'emoji_button.symbols', defaultMessage: 'Symbols' },
flags: { id: 'emoji_button.flags', defaultMessage: 'Flags' },
});
const assetHost = process.env.CDN_HOST || '';
let EmojiPicker, Emoji; // load asynchronously
const backgroundImageFn = () => `${assetHost}/emoji/sheet.png`;
const listenerOptions = detectPassiveEvents.hasSupport ? { passive: true } : false;
const categoriesSort = [
'recent',
'custom',
'people',
'nature',
'foods',
'activity',
'places',
'objects',
'symbols',
'flags',
];
class ModifierPickerMenu extends React.PureComponent {
static propTypes = {
active: PropTypes.bool,
onSelect: PropTypes.func.isRequired,
onClose: PropTypes.func.isRequired,
};
handleClick = e => {
this.props.onSelect(e.currentTarget.getAttribute('data-index') * 1);
}
componentWillReceiveProps (nextProps) {
if (nextProps.active) {
this.attachListeners();
} else {
this.removeListeners();
}
}
componentWillUnmount () {
this.removeListeners();
}
handleDocumentClick = e => {
if (this.node && !this.node.contains(e.target)) {
this.props.onClose();
}
}
attachListeners () {
document.addEventListener('click', this.handleDocumentClick, false);
document.addEventListener('touchend', this.handleDocumentClick, listenerOptions);
}
removeListeners () {
document.removeEventListener('click', this.handleDocumentClick, false);
document.removeEventListener('touchend', this.handleDocumentClick, listenerOptions);
}
setRef = c => {
this.node = c;
}
render () {
const { active } = this.props;
return (
<div className='emoji-picker-dropdown__modifiers__menu' style={{ display: active ? 'block' : 'none' }} ref={this.setRef}>
<button onClick={this.handleClick} data-index={1}><Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={1} backgroundImageFn={backgroundImageFn} /></button>
<button onClick={this.handleClick} data-index={2}><Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={2} backgroundImageFn={backgroundImageFn} /></button>
<button onClick={this.handleClick} data-index={3}><Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={3} backgroundImageFn={backgroundImageFn} /></button>
<button onClick={this.handleClick} data-index={4}><Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={4} backgroundImageFn={backgroundImageFn} /></button>
<button onClick={this.handleClick} data-index={5}><Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={5} backgroundImageFn={backgroundImageFn} /></button>
<button onClick={this.handleClick} data-index={6}><Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={6} backgroundImageFn={backgroundImageFn} /></button>
</div>
);
}
}
class ModifierPicker extends React.PureComponent {
static propTypes = {
active: PropTypes.bool,
modifier: PropTypes.number,
onChange: PropTypes.func,
onClose: PropTypes.func,
onOpen: PropTypes.func,
};
handleClick = () => {
if (this.props.active) {
this.props.onClose();
} else {
this.props.onOpen();
}
}
handleSelect = modifier => {
this.props.onChange(modifier);
this.props.onClose();
}
render () {
const { active, modifier } = this.props;
return (
<div className='emoji-picker-dropdown__modifiers'>
<Emoji emoji='fist' set='twitter' size={22} sheetSize={32} skin={modifier} onClick={this.handleClick} backgroundImageFn={backgroundImageFn} />
<ModifierPickerMenu active={active} onSelect={this.handleSelect} onClose={this.props.onClose} />
</div>
);
}
}
@injectIntl
class EmojiPickerMenu extends React.PureComponent {
static propTypes = {
custom_emojis: ImmutablePropTypes.list,
frequentlyUsedEmojis: PropTypes.arrayOf(PropTypes.string),
loading: PropTypes.bool,
onClose: PropTypes.func.isRequired,
onPick: PropTypes.func.isRequired,
style: PropTypes.object,
placement: PropTypes.string,
arrowOffsetLeft: PropTypes.string,
arrowOffsetTop: PropTypes.string,
intl: PropTypes.object.isRequired,
skinTone: PropTypes.number.isRequired,
onSkinTone: PropTypes.func.isRequired,
};
static defaultProps = {
style: {},
loading: true,
placement: 'bottom',
frequentlyUsedEmojis: [],
};
state = {
modifierOpen: false,
};
handleDocumentClick = e => {
if (this.node && !this.node.contains(e.target)) {
this.props.onClose();
}
}
componentDidMount () {
document.addEventListener('click', this.handleDocumentClick, false);
document.addEventListener('touchend', this.handleDocumentClick, listenerOptions);
}
componentWillUnmount () {
document.removeEventListener('click', this.handleDocumentClick, false);
document.removeEventListener('touchend', this.handleDocumentClick, listenerOptions);
}
setRef = c => {
this.node = c;
}
getI18n = () => {
const { intl } = this.props;
return {
search: intl.formatMessage(messages.emoji_search),
notfound: intl.formatMessage(messages.emoji_not_found),
categories: {
search: intl.formatMessage(messages.search_results),
recent: intl.formatMessage(messages.recent),
people: intl.formatMessage(messages.people),
nature: intl.formatMessage(messages.nature),
foods: intl.formatMessage(messages.food),
activity: intl.formatMessage(messages.activity),
places: intl.formatMessage(messages.travel),
objects: intl.formatMessage(messages.objects),
symbols: intl.formatMessage(messages.symbols),
flags: intl.formatMessage(messages.flags),
custom: intl.formatMessage(messages.custom),
},
};
}
handleClick = emoji => {
if (!emoji.native) {
emoji.native = emoji.colons;
}
this.props.onClose();
this.props.onPick(emoji);
}
handleModifierOpen = () => {
this.setState({ modifierOpen: true });
}
handleModifierClose = () => {
this.setState({ modifierOpen: false });
}
handleModifierChange = modifier => {
this.props.onSkinTone(modifier);
}
render () {
const { loading, style, intl, custom_emojis, skinTone, frequentlyUsedEmojis } = this.props;
if (loading) {
return <div style={{ width: 299 }} />;
}
const title = intl.formatMessage(messages.emoji);
const { modifierOpen } = this.state;
return (
<div className={classNames('emoji-picker-dropdown__menu', { selecting: modifierOpen })} style={style} ref={this.setRef}>
<EmojiPicker
perLine={8}
emojiSize={22}
sheetSize={32}
custom={buildCustomEmojis(custom_emojis)}
color=''
emoji=''
set='twitter'
title={title}
i18n={this.getI18n()}
onClick={this.handleClick}
include={categoriesSort}
recent={frequentlyUsedEmojis}
skin={skinTone}
showPreview={false}
backgroundImageFn={backgroundImageFn}
emojiTooltip
/>
<ModifierPicker
active={modifierOpen}
modifier={skinTone}
onOpen={this.handleModifierOpen}
onClose={this.handleModifierClose}
onChange={this.handleModifierChange}
/>
</div>
);
}
}
@injectIntl
export default class EmojiPickerDropdown extends React.PureComponent {
static propTypes = {
custom_emojis: ImmutablePropTypes.list,
frequentlyUsedEmojis: PropTypes.arrayOf(PropTypes.string),
intl: PropTypes.object.isRequired,
onPickEmoji: PropTypes.func.isRequired,
onSkinTone: PropTypes.func.isRequired,
skinTone: PropTypes.number.isRequired,
};
state = {
active: false,
loading: false,
};
setRef = (c) => {
this.dropdown = c;
}
onShowDropdown = () => {
this.setState({ active: true });
if (!EmojiPicker) {
this.setState({ loading: true });
EmojiPickerAsync().then(EmojiMart => {
EmojiPicker = EmojiMart.Picker;
Emoji = EmojiMart.Emoji;
this.setState({ loading: false });
}).catch(() => {
this.setState({ loading: false });
});
}
}
onHideDropdown = () => {
this.setState({ active: false });
}
onToggle = (e) => {
if (!this.state.loading && (!e.key || e.key === 'Enter')) {
if (this.state.active) {
this.onHideDropdown();
} else {
this.onShowDropdown();
}
}
}
handleKeyDown = e => {
if (e.key === 'Escape') {
this.onHideDropdown();
}
}
setTargetRef = c => {
this.target = c;
}
findTarget = () => {
return this.target;
}
render () {
const { intl, onPickEmoji, onSkinTone, skinTone, frequentlyUsedEmojis } = this.props;
const title = intl.formatMessage(messages.emoji);
const { active, loading } = this.state;
return (
<div className='emoji-picker-dropdown' onKeyDown={this.handleKeyDown}>
<div ref={this.setTargetRef} className='emoji-button' title={title} aria-label={title} aria-expanded={active} role='button' onClick={this.onToggle} onKeyDown={this.onToggle} tabIndex={0}>
<img
className={classNames('emojione', { 'pulse-loading': active && loading })}
alt='🙂'
src={`${assetHost}/emoji/1f602.svg`}
/>
</div>
<Overlay show={active} placement='bottom' target={this.findTarget}>
<EmojiPickerMenu
custom_emojis={this.props.custom_emojis}
loading={loading}
onClose={this.onHideDropdown}
onPick={onPickEmoji}
onSkinTone={onSkinTone}
skinTone={skinTone}
frequentlyUsedEmojis={frequentlyUsedEmojis}
/>
</Overlay>
</div>
);
}
}
|
test/specs/views/Feed/FeedDate-test.js
|
koenvg/Semantic-UI-React
|
import faker from 'faker'
import React from 'react'
import FeedDate from 'src/views/Feed/FeedDate'
import * as common from 'test/specs/commonTests'
describe('FeedDate', () => {
common.isConformant(FeedDate)
common.rendersChildren(FeedDate)
it('renders text with date prop', () => {
const text = faker.hacker.phrase()
shallow(<FeedDate content={text} />).should.contain.text(text)
})
})
|
code/frontend/src/components/Dashboard/index.js
|
CPSC319-2017w1/coast.the-terminal
|
import React from 'react';
import PropTypes, { instanceOf } from 'prop-types';
import { connect } from 'react-redux';
import { withCookies, Cookies } from 'react-cookie';
import DashboardComponent from './Dashboard.jsx';
import { switchView } from '../../actions/main-actions.js';
const mapStateToProps = state => {
return {
user: state.user,
tables: state.tables
};
};
const mapDispatchToProps = dispatch => {
return {
switchTab: tab => {
dispatch(switchView(tab));
}
};
};
/**
* Class that represents Dashboard Container
*/
class DashboardContainer extends React.Component {
constructor(props) {
super(props);
this.onClick = this.onClick.bind(this);
}
/**
* Redirects to the page based on the button clicked
* @param event
*/
onClick(event) {
event.preventDefault();
const tab = event.target.getAttribute('name');
this.props.cookies.set('tab', tab);
this.props.switchTab(tab);
}
/**
* renders the react component to the screen
* @return {XML}
*/
render() {
return <DashboardComponent onClick={this.onClick} />;
}
}
DashboardContainer.propTypes = {
user: PropTypes.object.isRequired,
tables: PropTypes.object.isRequired,
switchTab: PropTypes.func.isRequired,
cookies: instanceOf(Cookies).isRequired
};
const Dashboard = connect(
mapStateToProps,
mapDispatchToProps
)(DashboardContainer);
export default withCookies(Dashboard);
|
src/js/view/LoginForm.js
|
marqusm/react-client-template
|
import React from 'react';
import {Field, reduxForm} from 'redux-form';
import {RaisedButton} from "material-ui";
import {TextField} from "redux-form-material-ui";
class LoginForm extends React.Component {
componentDidMount() {
this.ref // the Field
.getRenderedComponent() // on Field, returns ReduxFormMaterialUITextField
.getRenderedComponent() // on ReduxFormMaterialUITextField, returns TextField
.focus();
}
saveRef = ref => (this.ref = ref)
render() {
const {handleSubmit} = this.props;
return (
<div className="login">
<form ref="form">
<Field name="username" component={TextField}
hintText="Enter your Username"
// floatingLabelText="Username"
ref={this.saveRef}
withRef
/>
<br/>
<Field name="password" type="password" component={TextField}
hintText="Enter your Password"
// floatingLabelText="Password"
ref={this.saveRef}
withRef
/>
<br/>
<RaisedButton label="Submit" primary={true}
onClick={(event) => {
handleSubmit()
}}/>
</form>
</div>
);
};
}
LoginForm = reduxForm({
form: 'login',
})(LoginForm);
export default LoginForm;
|
src/Xword.js
|
bcopeland/xwordjs
|
// @flow
import React, { Component } from 'react';
import Modal from 'react-modal';
import FileInput from './FileInput.js';
import Server from './Server.js';
import Cell from './Cell.js';
import Clues from './Clues.js';
import Loading from './Loading.js';
import {TimerState, Timer} from './Timer.js';
import { Route, Switch, Link } from 'react-router-dom';
import { ButtonGroup, ButtonToolbar, DropdownButton, MenuItem, ProgressBar, Button } from 'react-bootstrap';
import scrollIntoViewIfNeeded from 'scroll-into-view-if-needed';
import { TextDecoder } from 'text-encoding';
import './Xword.css';
// TODO
// . clue-only entry
// . auto-pause
// . port nav enhancements (no auto next, skip to first blank)
var Xd = require("./xd.js");
var Puz = require("./puz.js");
var Xpf = require("./xpf.js");
class XwordClue {
state: {
index: number,
direction: string,
number: number,
clue: string,
answer: string,
active: boolean,
crossActive: boolean
};
constructor(options) {
this.state = {
'index': 0,
'direction': 'A',
'number': 0,
'clue': '',
'answer': '',
'active': false,
'crossActive': false,
};
Object.assign(this.state, options);
}
setState(newstate) {
Object.assign(this.state, newstate);
}
get(key) : any {
return this.state[key];
}
}
class XwordCell {
state: {
fill: string,
entry: string,
active: boolean,
focus: boolean,
circled: boolean,
incorrect: boolean,
number: number,
version: number,
};
constructor(options) {
this.state = {
fill: '.',
entry: ' ',
active: false,
focus: false,
circled: false,
incorrect: false,
version: 0,
number: 0,
};
Object.assign(this.state, options);
}
setState(newstate) {
Object.assign(this.state, newstate);
}
get(key) : any {
return this.state[key];
}
isBlack() : boolean {
return this.state.fill === '#';
}
}
function Title(props) {
var title = props.title;
var author = props.author ? " by " + props.author : "";
return (
<div className={"xwordjs-title"}>
<span className={"xwordjs-title-text"}>{title}</span>
<span className={"xwordjs-author-text"}>{author}</span>
</div>
);
}
function ClueBar(props) {
var text = '';
for (var i=0; i < props.value.length; i++) {
var clue = props.value[i];
if (clue.get('active')) {
text = clue.get('number') + ". " + clue.get('clue');
}
}
return <div className={"xwordjs-clue-bar"}>{text}</div>;
}
class Grid extends Component {
render() {
var rows = [];
for (var i=0; i < this.props.height; i++) {
var row_cells = [];
for (var j=0; j < this.props.width; j++) {
var ind = i * this.props.width + j;
var fill = this.props.cells[ind].get('fill');
var entry = this.props.cells[ind].get('entry');
var active = this.props.cells[ind].get('active');
var focus = this.props.cells[ind].get('focus');
var circled = this.props.cells[ind].get('circled');
var incorrect = this.props.cells[ind].get('incorrect');
var number = this.props.cells[ind].get('number') || '';
var black = fill === '#';
if (fill === '#' || fill === '.') {
fill = ' ';
}
var cell = <Cell id={"cell_" + ind} value={entry} key={"cell_" + ind}
isBlack={black} isActive={active} isFocus={focus}
isCircled={circled}
isIncorrect={incorrect}
isTop={i===0} isLeft={j===0} number={number}
onClick={(x)=>this.props.handleClick(parseInt(x.substring(5), 10))}/>;
row_cells.push(cell);
}
rows[i] = <div className="xwordjs-grid-row" key={"row_" + i}>{row_cells}</div>;
}
return (
<div id="xwordjs-grid-inner">{rows}</div>
);
}
}
function MobileKeyboardKey(props) {
return <div className="xwordjs-keyboard-key" onClick={() => props.onClick(props.code)}>{props.value}</div>;
}
function MobileKeyboard(props) {
var keys = ["qwertyuiop", "asdfghjkl", "␣zxcvbnm⌫"];
var rows = [];
for (var i=0; i < keys.length; i++) {
var rowstr = keys[i];
var row_keys = [];
for (var j=0; j < rowstr.length; j++) {
var ch = rowstr.charAt(j);
var code;
if (ch === '␣') {
code = 0x20;
} else if (ch === '⌫') {
code = 0x8;
} else {
code = ch.charCodeAt(0);
}
var key = <MobileKeyboardKey key={ch} onClick={props.onClick} code={code} value={ch}/>;
row_keys.push(key);
}
rows[i] = <div className="xwordjs-keyboard-row" key={i}>{row_keys}</div>;
}
return (
<div className="xwordjs-keyboard">{rows}</div>
);
}
class XwordSolver extends Component {
state: {
height: number,
width: number,
cells: Array<XwordCell>,
clues: Array<XwordClue>,
title: string,
author: string,
timer: TimerState,
activecell: number,
direction: string,
cell_to_clue_table: Array<Array<number>>,
clue_to_cell_table: Array<number>,
version: number,
solutionId: ?string,
dismissed_modal: boolean,
modified: boolean,
rebus: boolean,
server: ?Server
};
closeModal: Function;
revealAll: Function;
serverUpdate: Function;
constructor() {
super();
this.state = {
'height': 15,
'width': 15,
'cells': [],
'clues': [],
'title': '',
'author': '',
'timer': new TimerState(),
'activecell': 0,
'direction': 'A',
'cell_to_clue_table': [],
'clue_to_cell_table': [],
'dismissed_modal': false,
'version': 1,
'modified': false,
'solutionId': null,
rebus: false,
'server': null,
}
this.closeModal = this.closeModal.bind(this);
this.revealAll = this.revealAll.bind(this);
this.serverUpdate = this.serverUpdate.bind(this);
}
loadServerPuzzle(id: string) {
if (!process.env.REACT_APP_HAS_SERVER)
return;
var self = this;
var server = new Server({base_url: process.env.PUBLIC_URL})
server
.getSolution(id)
.then(function(obj) {
return server.getPuzzle(obj.PuzzleId)
})
.then(function(data) {
var decoder = new TextDecoder('utf-8');
var puz = new Xpf(decoder.decode(data));
self.setState({solutionId: id, server: server});
self.puzzleLoaded(id, puz);
server.connect(id, self.serverUpdate);
var entries = [];
for (var i=0; i < self.state.cells.length; i++) {
entries.push({'Version': -1, 'Value': ''});
}
server.sendSolution(id, -1, entries);
});
}
loadPuzzle(file: File, filename : ?string) {
var self = this;
if (process.env.REACT_APP_HAS_SERVER) {
var server = new Server({base_url: process.env.PUBLIC_URL})
server.uploadPuzzle(file)
.then(function(obj) {
var id = obj.Id;
return server.startSolution(id);
})
.then(function(obj) {
var solutionId = obj.Id;
document.location.hash = "/s/" + solutionId;
self.loadServerPuzzle(solutionId);
});
} else {
this.loadPuzzleURL(window.URL.createObjectURL(file), filename);
}
}
loadPuzzleURL(url: string, filename : ?string) {
var self = this;
var request = new Request(url);
fetch(request).then(function(response) {
return response.arrayBuffer();
}).then(function(data) {
var puz;
var fn = filename || url;
var decoder;
if (fn.endsWith("xd")) {
decoder = new TextDecoder('utf-8');
// $FlowFixMe
puz = new Xd(decoder.decode(data));
self.puzzleLoaded(url, puz);
} else if (fn.endsWith("xml") || url.match(/^http/)) {
decoder = new TextDecoder('utf-8');
// $FlowFixMe
puz = new Xpf(decoder.decode(data));
self.puzzleLoaded(url, puz);
} else {
puz = new Puz(data);
self.puzzleLoaded(url, puz);
}
});
}
cellPos(clue_id: number) {
var y = Math.floor(clue_id / this.state.width);
var x = clue_id % this.state.width;
return [x, y];
}
navRight() {
var [x, y] = this.cellPos(this.state.activecell);
while (x < this.state.width) {
x += 1;
if (x < this.state.width &&
this.state.cells[y * this.state.width + x].get('fill') !== '#')
break;
}
if (x === this.state.width)
return;
var activecell = y * this.state.width + x;
this.selectCell(activecell, this.state.direction);
}
navLeft() {
var [x, y] = this.cellPos(this.state.activecell);
while (x >= 0) {
x -= 1;
if (x >= 0 &&
this.state.cells[y * this.state.width + x].get('fill') !== '#')
break;
}
if (x < 0)
return;
var activecell = y * this.state.width + x;
this.selectCell(activecell, this.state.direction);
}
navUp() {
var [x, y] = this.cellPos(this.state.activecell);
while (y >= 0) {
y -= 1;
if (y >= 0 &&
this.state.cells[y * this.state.width + x].get('fill') !== '#')
break;
}
if (y < 0)
return;
var activecell = y * this.state.width + x;
this.selectCell(activecell, this.state.direction);
}
navDown() {
var [x, y] = this.cellPos(this.state.activecell);
while (y < this.state.height) {
y += 1;
if (y < this.state.height &&
this.state.cells[y * this.state.width + x].get('fill') !== '#')
break;
}
if (y === this.state.height)
return;
var activecell = y * this.state.width + x;
this.selectCell(activecell, this.state.direction);
}
navNextClue() {
var dind = (this.state.direction === 'A') ? 0 : 1;
var cur_cell_id = this.state.activecell;
var clue_id = this.state.cell_to_clue_table[cur_cell_id][dind];
var next_clue_id = (clue_id + 1) % this.state.clues.length;
this.selectClue(this.state.clues[next_clue_id]);
}
navPrevClue() {
var dind = (this.state.direction === 'A') ? 0 : 1;
var cur_cell_id = this.state.activecell;
var clue_id = this.state.cell_to_clue_table[cur_cell_id][dind];
var next_clue_id = (clue_id - 1) % this.state.clues.length;
this.selectClue(this.state.clues[next_clue_id]);
}
findNextEmptyCell(direction: string,
start_x: number, start_y: number,
end_x: ?number, end_y: ?number): ?number {
var dind = (direction === 'A') ? 0 : 1;
var [x_incr, y_incr] = [1 - dind, dind];
var [x, y] = [start_x, start_y];
if (end_x === null || end_x === undefined)
end_x = this.state.width;
if (end_y === null || end_y === undefined)
end_y = this.state.height;
var len = (!dind) ? end_x - start_x : end_y - start_y;
for (let i = 0; i < len; i++) {
var cell_id = y * this.state.width + x;
var cell = this.state.cells[cell_id];
if (cell.isBlack())
break;
if (cell.get('entry') === ' ')
return cell_id;
x += x_incr;
y += y_incr;
}
return null;
}
navNext() {
var dind = (this.state.direction === 'A') ? 0 : 1;
var cur_cell_id = this.state.activecell;
var clue_id = this.state.cell_to_clue_table[cur_cell_id][dind];
var start_cell_id = this.state.clue_to_cell_table[clue_id];
var clue = this.state.clues[clue_id];
var [x, y] = this.cellPos(cur_cell_id);
var [start_x, start_y] = this.cellPos(start_cell_id);
var alen = clue.get('answer').length;
var empty_cell_id = this.findNextEmptyCell(this.state.direction, x, y);
// wrap
if (empty_cell_id === null || empty_cell_id === undefined) {
empty_cell_id = this.findNextEmptyCell(this.state.direction,
start_x, start_y, x, y);
}
if (empty_cell_id === null || empty_cell_id === undefined) {
// no empty square.
[x, y] = this.cellPos(cur_cell_id);
// if end of word, go to next word
if ((this.state.direction === 'A' && x === start_x + alen - 1) ||
(this.state.direction === 'D' && y === start_y + alen - 1)) {
this.navNextClue();
return;
}
// go to next word
if (this.state.direction === 'A')
x += 1;
else
y += 1;
empty_cell_id = y * this.state.width + x;
}
this.selectCell(empty_cell_id, this.state.direction);
}
navPrev() {
var dind = (this.state.direction === 'A') ? 0 : 1;
var cur_cell_id = this.state.activecell;
var clue_id = this.state.cell_to_clue_table[cur_cell_id][dind];
var start_cell_id = this.state.clue_to_cell_table[clue_id];
var [x, y] = this.cellPos(cur_cell_id);
var [start_x, start_y] = this.cellPos(start_cell_id);
if (this.state.direction === 'A')
x -= 1;
else
y -= 1;
if (x < start_x)
x = start_x;
if (y < start_y)
y = start_y;
var activecell = y * this.state.width + x;
this.selectCell(activecell, this.state.direction);
}
switchDir() {
var dir = this.state.direction === 'A' ? 'D' : 'A';
this.selectCell(this.state.activecell, dir);
}
type(ch: string) {
var cell = this.state.cells[this.state.activecell];
if (this.state.rebus) {
var text = cell.get('entry');
cell.setState({entry: text + ch});
this.setState({modified: true})
} else {
cell.setState({'entry': ch, 'version': cell.get('version') + 1});
this.setState({modified: true})
this.navNext();
}
}
del() {
var cell = this.state.cells[this.state.activecell];
if (this.state.rebus) {
var text = cell.get('entry');
text = text.substr(0, text.length - 1);
cell.setState({entry: text});
this.setState({modified: true})
} else {
cell.setState({'entry': ' ', 'version': cell.get('version') + 1});
this.setState({modified: true})
this.selectCell(this.state.activecell, this.state.direction);
}
}
backspace() {
var cell = this.state.cells[this.state.activecell];
if (this.state.rebus) {
var text = cell.get('entry');
text = text.substr(0, text.length - 1);
cell.setState({entry: text});
this.setState({modified: true})
} else {
cell.setState({'entry': ' ', 'version': cell.get('version') + 1});
this.setState({modified: true})
this.navPrev();
}
}
isCorrect() {
for (var i=0; i < this.state.cells.length; i++) {
var cell = this.state.cells[i];
var fill = cell.get('fill');
var entry = cell.get('entry');
if (fill !== '#' && (entry !== fill && entry !== fill.charAt(0)))
return false;
}
return true;
}
processKeyCode(keyCode: number, shift: boolean)
{
// A-Z
if ((keyCode >= 0x41 && keyCode <= 0x5a) ||
(keyCode >= 0x61 && keyCode <= 0x7a)) {
var ch = String.fromCharCode(keyCode)
this.type(ch.toUpperCase());
return true;
}
switch (keyCode) {
case 0x8:
this.backspace();
return true;
case 0x9:
if (!shift)
this.navNextClue();
else
this.navPrevClue();
return true;
case 0x20:
this.switchDir();
return true;
case 0x25:
this.navLeft();
return true;
case 0x26:
this.navUp();
return true;
case 0x27:
this.navRight();
return true;
case 0x28:
this.navDown();
return true;
case 0x2e:
this.del();
return true;
default:
return false;
}
}
handleKeyDown(e: KeyboardEvent) {
if (e.ctrlKey || e.altKey)
return;
if (this.state.direction === 'A' && (e.keyCode === 0x26 || e.keyCode === 0x28)) {
this.selectCell(this.state.activecell, 'D');
e.preventDefault();
return;
}
if (this.state.direction === 'D' && (e.keyCode === 0x25 || e.keyCode === 0x27)) {
this.selectCell(this.state.activecell, 'A');
e.preventDefault();
return;
}
if (this.processKeyCode(e.keyCode, e.shiftKey)) {
e.preventDefault();
}
}
handleClick(i: number) {
if (this.state.activecell === i) {
this.switchDir();
} else {
this.selectCell(i, this.state.direction);
}
}
puzzleLoaded(url: string, puz: Object) {
var grid = puz.grid;
var flags = puz.flags;
var maxx = grid[0].length;
var maxy = grid.length;
var i;
var title = 'Untitled';
var author = 'Unknown';
for (i=0; i < puz.headers.length; i++) {
var [header, value] = puz.headers[i];
if (header === 'Title') {
title = value;
} else if (header === 'Creator' || header === 'Author') {
author = value;
}
}
var cells = Array(maxx * maxy).fill(null);
var cell_to_clue_table = Array(maxx * maxy).fill(null);
var number_index = [];
for (var y = 0; y < maxy; y++) {
for (var x = 0; x < maxx; x++) {
var fill = grid[y][x];
var is_black = fill === '#';
var number = 0;
var start_of_xslot = (!is_black &&
(x === 0 || grid[y][x-1] === '#') &&
(x + 1 < maxx && grid[y][x+1] !== '#'));
var start_of_yslot = (!is_black &&
(y === 0 || grid[y-1][x] === '#') &&
(y + 1 < maxy && grid[y+1][x] !== '#'));
if (start_of_xslot || start_of_yslot) {
number_index.push([x,y]);
number = number_index.length;
}
var circled = false;
if (flags) {
circled = !!(flags[y][x] & puz.FLAGS.CIRCLED);
}
cells[y * maxx + x] = new XwordCell({
'fill': fill,
'number': number,
'active': false,
'circled': circled
});
cell_to_clue_table[y * maxx + x] = [null, null];
}
}
var clues = [];
var clue_to_cell_table = [];
for (i=0; i < puz.clues.length; i++) {
var [type, cluestr, answer] = puz.clues[i];
var [dir, num] = type;
var clue = new XwordClue({
'index': i, 'direction': dir, 'number': num, 'clue': cluestr,
'answer': answer});
clues.push(clue);
// clue_to_cell table: index into clues[] has the corresponding
// cell id
var xy = number_index[num - 1];
clue_to_cell_table[i] = xy[1] * maxx + xy[0];
// set up cell_to_clue_table: indexed by cell id, each entry
// has a two element array (across, down) which contains the
// index into clues[]. Iterate over answer in the direction
// of the clue to set all cells making up the answer
var ind = 0, xincr = 0, yincr = 0;
if (dir === 'A') {
xincr = 1;
} else {
ind = 1; yincr = 1;
}
[x, y] = xy;
for (var j = 0; y < maxy && x < maxx; j++) {
var cell = y * maxx + x;
if (grid[y][x] === '#')
break;
cell_to_clue_table[cell][ind] = i;
x += xincr; y += yincr;
}
}
this.setState({
'title': title, 'author': author,
'width': maxx, 'height': maxy, 'cells': cells, 'clues': clues,
'clue_to_cell_table': clue_to_cell_table,
'cell_to_clue_table': cell_to_clue_table
});
this.loadStoredData();
this.selectCell(0, 'A', true);
// set cluelist to match grid height
var gridelem = document.getElementById("xwordjs-grid-inner");
var cluediv = document.getElementById("xwordjs-cluelist-container");
var cluelist = document.getElementsByClassName("xwordjs-cluelist");
var gridHeight = window.getComputedStyle(gridelem).getPropertyValue("height");
if (cluediv)
cluediv.style.height = gridHeight;
for (i = 0; i < cluelist.length; i++) {
var e = cluelist[i];
var newheight = String(parseInt(gridHeight, 10) - 60) + "px";
e.style.height = newheight;
}
}
saveStoredData()
{
var key = this.state.cells.map((x) => x.state.fill).join("");
var data = {
entries: this.state.cells.map((x) => x.state.entry),
elapsed: this.state.timer.get('elapsed')
};
// avoid a race condition when first starting up
if (!data.elapsed)
return;
localStorage.setItem(key, JSON.stringify(data));
}
readStoredData()
{
var key = this.state.cells.map((x) => x.state.fill).join("");
var data = localStorage.getItem(key);
if (!data)
return null;
return JSON.parse(data);
}
loadStoredData()
{
var data = this.readStoredData()
if (!data)
return;
var entries = data.entries;
var elapsed = data.elapsed;
for (var i=0; i < entries.length; i++) {
this.state.cells[i].setState({entry: entries[i]});
}
this.setState({modified: true})
this.state.timer.setState({elapsed: elapsed});
this.setState({cells: this.state.cells, timer: this.state.timer});
}
highlightClue(clue: XwordClue, active: boolean)
{
var cluenum = clue.get('index');
var cind = this.state.clue_to_cell_table[cluenum];
var [x, y] = this.cellPos(cind);
var x_incr = clue.get('direction') === 'A' ? 1 : 0;
var y_incr = !x_incr;
for (; x < this.state.width && y < this.state.height; ) {
var cell = this.state.cells[this.state.width * y + x];
if (cell.isBlack())
break;
cell.setState({"active": active});
x += x_incr;
y += y_incr;
}
}
selectCell(cell_id: number, direction: string, initial: ?boolean)
{
var cell = this.state.cells[cell_id];
if (cell.isBlack())
return;
var newclues = this.state.clues.slice();
var newcells = this.state.cells.slice();
// unselect existing selected cell and crosses
var oldcell_id = this.state.activecell;
var old_dind = (this.state.direction === 'A') ? 0 : 1;
var oldclue = this.state.clues[this.state.cell_to_clue_table[oldcell_id][old_dind]];
var oldcross = this.state.clues[this.state.cell_to_clue_table[oldcell_id][1 - old_dind]];
var oldcell = this.state.cells[oldcell_id];
var dind = (direction === 'A') ? 0 : 1;
var clue = this.state.clues[this.state.cell_to_clue_table[cell_id][dind]];
var cross = this.state.clues[this.state.cell_to_clue_table[cell_id][1 - dind]];
var e;
var cluediv = document.getElementById("xwordjs-cluelist-container");
var display = window.getComputedStyle(cluediv).getPropertyValue("display");
var hasClues = display !== "none";
if (initial || oldcross !== cross) {
if (oldcross)
oldcross.setState({"crossActive": false});
if (cross) {
cross.setState({"crossActive": true});
e = document.getElementById("clue_" + cross.get('index'));
if (e && hasClues)
scrollIntoViewIfNeeded(e);
}
}
if (initial || oldclue !== clue) {
if (oldclue) {
oldclue.setState({"active": false});
this.highlightClue(oldclue, false);
}
if (clue) {
clue.setState({"active": true});
this.highlightClue(clue, true);
e = document.getElementById("clue_" + clue.get('index'));
if (e && hasClues)
scrollIntoViewIfNeeded(e);
}
}
if (initial || oldcell_id !== cell_id) {
oldcell.setState({focus: false});
cell.setState({focus: true});
}
e = document.getElementById("cell_" + cell_id);
if (e) {
var rect = e.getBoundingClientRect();
var container = document.getElementById("xwordjs-container");
var prect = container.getBoundingClientRect();
if (prect.left > rect.left || prect.right < rect.right ||
prect.top > rect.top || prect.bottom < rect.bottom) {
scrollIntoViewIfNeeded(e);
}
}
this.setState({'clues': newclues, 'cells': newcells, 'activecell': cell_id, 'direction': direction, rebus: false});
}
revealCell()
{
var cell = this.state.cells[this.state.activecell];
cell.setState({'entry': cell.get('fill')});
this.setState({'cells': this.state.cells.slice()});
}
revealClue()
{
var dind = (this.state.direction === 'A') ? 0 : 1;
var cur_cell_id = this.state.activecell;
var clue_id = this.state.cell_to_clue_table[cur_cell_id][dind];
var cind = this.state.clue_to_cell_table[clue_id];
var [x, y] = this.cellPos(cind);
var x_incr = !dind;
var y_incr = !x_incr;
var cell;
for (; x < this.state.width && y < this.state.height; ) {
cell = this.state.cells[this.state.width * y + x];
if (cell.isBlack())
break;
cell.setState({"entry": cell.get('fill')});
x += x_incr;
y += y_incr;
}
cell = this.state.cells[this.state.activecell];
cell.setState({'entry': cell.get('fill')});
this.setState({'cells': this.state.cells.slice()});
}
selectClue(clue: XwordClue)
{
var cluenum = clue.get('index');
// set first empty cell in this clue as active
var cell = this.state.clue_to_cell_table[cluenum];
var [start_x, start_y] = this.cellPos(cell);
var empty_cell = this.findNextEmptyCell(clue.get('direction'),
start_x, start_y);
if (empty_cell != null)
cell = empty_cell;
this.selectCell(cell, clue.get('direction'));
}
closeModal() {
this.setState({'dismissed_modal': true});
}
showErrors() {
for (var i=0; i < this.state.cells.length; i++) {
var cell = this.state.cells[i];
if (!cell.isBlack()) {
if (cell.get('entry') !== ' ' &&
cell.get('entry') !== cell.get('fill')) {
cell.setState({incorrect: true});
} else {
cell.setState({incorrect: false});
}
}
}
var newcells = this.state.cells.slice();
this.setState({'cells': newcells});
}
revealAll() {
this.setState({'dismissed_modal': true});
for (var i=0; i < this.state.cells.length; i++) {
var cell = this.state.cells[i];
if (!cell.isBlack())
cell.setState({'entry': cell.get('fill')});
}
var newcells = this.state.cells.slice();
this.setState({'cells': newcells});
}
serverUpdate(json: Object) {
console.log("a server update happened...");
for (var i = 0; i < json.Entries.length; i++) {
var ch = json.Entries[i].Value;
var version = json.Entries[i].Version;
var cell = this.state.cells[i];
if (cell && !cell.isBlack() && version > cell.get('version')) {
cell.setState({entry: ch, version: version});
}
}
this.setState({version: json.Version});
}
updateTimer(state: Object) {
if (state.stopped)
return;
if (this.isCorrect()) {
state.stopped = true;
}
this.saveStoredData();
this.state.timer.setState(state);
this.setState({'timer': this.state.timer});
if (!this.state.solutionId)
return;
var entries = [];
for (var i=0; i < this.state.cells.length; i++) {
var cell = this.state.cells[i];
entries.push({'Version': cell.get('version'), 'Value': cell.get('entry')});
}
if (this.state.modified) {
// $FlowFixMe
this.state.server.sendSolution(this.state.solutionId,
this.state.version, entries);
this.setState({modified: false});
}
}
startRebus() {
this.setState({rebus: true});
}
componentDidMount() {
var self = this;
window.addEventListener("keydown", (e) => self.handleKeyDown(e));
if (this.props.filename) {
self.loadPuzzleURL(process.env.PUBLIC_URL + this.props.filename);
return;
}
if (this.props.serverId) {
self.loadServerPuzzle(this.props.serverId);
return;
}
// TODO move to XwordMain ?
// old-style URLs:
// #[^/][hash] -> /s/hash
var puzzle = window.location.hash.substring(1);
if (puzzle.length && puzzle[0] !== '/' && this.props.history) {
this.props.history.push("/s/" + puzzle);
return;
}
// ?filename -> /load/filename
puzzle = window.location.search.substring(1);
if (puzzle.length && this.props.history) {
this.props.history.push("/file/" + puzzle);
return;
}
}
componentWillUnmount() {
var self = this;
window.removeEventListener("keydown", (e) => self.handleKeyDown(e));
}
render() {
if (this.state.cells.length === 0) {
if (this.props.filename || this.props.serverId) {
return <Loading/>;
}
if (process.env.REACT_APP_HAS_SERVER) {
return (
<div className="XwordMain">
<div className="xwordjs-text-box">
<h1>Collaborative XwordJS</h1>
<p>
Upload a crossword puzzle here (.puz or .xpf format).
Once loaded, you can copy the random URL string and share with
someone else to play together.
</p>
<FileInput onChange={(x, filename) => this.loadPuzzle(x, filename)} />
</div>
</div>
);
}
return (
<div className="XwordMain">
<div className="xwordjs-text-box">
<h1>XwordJS</h1>
<p>
Select a crossword puzzle here (.puz or .xpf format) and then
you can solve it in your browser. The file will remain local
and not uploaded anywhere else.
</p>
<FileInput onChange={(x, filename) => this.loadPuzzle(x, filename)} />
</div>
</div>
);
}
return (
<div className="XwordMain">
<Modal isOpen={this.isCorrect() && !this.state.dismissed_modal}>
<h1>Nice job!</h1>
<p>You solved it. Sorry for the anticlimactic dialog.</p>
<p>It took {this.state.timer.elapsedStr(true)}.</p>
<button onClick={this.closeModal}>OK</button>
</Modal>
<div className="xwordjs-vertical-container">
<div className="xwordjs-topbar">
<Title title={this.state.title} author={this.state.author}/>
</div>
<div className="xwordjs-timer-bar">
<Timer value={this.state.timer} onChange={(x) => this.updateTimer(x)}/>
<DropdownButton title="Reveal">
<MenuItem eventKey="1" onClick={() => this.showErrors()}>Show Errors</MenuItem>
<MenuItem divider/>
<MenuItem eventKey="2" onClick={() => this.revealCell()}>Reveal Cell</MenuItem>
<MenuItem eventKey="3" onClick={() => this.revealClue()}>Reveal Clue</MenuItem>
<MenuItem divider/>
<MenuItem eventKey="4" onClick={() => this.revealAll()}>Reveal All</MenuItem>
</DropdownButton>
<ButtonSpacer/>
<Button onClick={() => this.setState({rebus: !this.state.rebus})} active={this.state.rebus} bsSize="xsmall">Rebus</Button>
</div>
<ClueBar value={this.state.clues}/>
<div className="xwordjs-container" id="xwordjs-container">
<div className="xwordjs-grid" id="xwordjs-grid">
<Grid height={this.state.height} width={this.state.width} cells={this.state.cells} handleClick={(x) => this.handleClick(x)}/>
</div>
<Clues selectClue={(i) => this.selectClue(i)} value={this.state.clues}/>
</div>
<BabyLink filename={this.props.filename}/>
<MobileKeyboard onClick={(code) => this.processKeyCode(code, false)}/>
</div>
</div>
);
}
}
function BabyLink(props) {
var link = [];
if (props.filename === "2017-11-13.xd") {
link.push(<a href="/images/syc.jpg">55-Across: healthy 7 lbs, 1 oz</a>)
}
return (
<div>{link}</div>
);
}
function XwordLoadFile(props) {
return (
<XwordSolver filename={props.match.params.name}/>
);
}
function XwordLoadServer(props) {
return (
<XwordSolver serverId={props.match.params.hash}/>
);
}
class XwordPuzzleListLoader extends Component
{
state: {
items: ?array
};
constructor(options) {
super();
this.state = {
items: null
}
Object.assign(this.state, options);
};
componentDidMount()
{
var self = this;
var server = new Server({base_url: process.env.PUBLIC_URL})
server.listSolutions().then(function (data) {
self.setState({items: data});
});
}
render() {
if (!this.state.items) {
return <Loading/>;
}
return <XwordPuzzleList puzzles={this.state.items}/>;
}
}
const ButtonSpacer = (props) => (
<ButtonGroup><span className="xwordjs-button-spacer"/></ButtonGroup>
);
function XwordPuzzleList(props) {
var items = [];
for (var i = 0; i < props.puzzles.length; i++) {
var p = props.puzzles[i];
items.push(<li key={i}><Link to={"/s/" + p.Id}>{p.Title + " " + p.Author}<ProgressBar now={p.Progress} label={`${p.Progress}%`}/></Link></li>);
}
return <ul>{items}</ul>;
}
function XwordMainPanel() {
return (
<Switch>
<Route exact path="/" component={XwordSolver}/>
<Route path="/file/:name" component={XwordLoadFile}/>
<Route path="/s/:hash" component={XwordLoadServer}/>
<Route path="/list" component={XwordPuzzleListLoader}/>
</Switch>
);
}
function XwordMain() {
return (
<div>
<XwordMainPanel />
</div>
);
}
export default XwordMain;
|
app/containers/Home.js
|
sandim27/ReduxApp
|
import React, { Component } from 'react';
import { Button } from 'react-bootstrap';
import UploadBlock from '../components/UploadBlock';
export default class Home extends Component {
constructor(props){
super(props);
this.state = {
newNamePhoto: '',
newPhoto: {},
activeName: true,
};
this.uploadPhoto = this.uploadPhoto.bind(this);
this.addNewPhoto = this.addNewPhoto.bind(this);
this.addPhotoName = this.addPhotoName.bind(this);
}
uploadPhoto(event){
this.props.uploadPhoto(event.target.files[0]);
this.setState({newPhoto: event.target.files[0]});
if(this.state.newNamePhoto)
this.setState({activeName: true})
else
this.setState({activeName: false})
}
addPhotoName(event) {
this.setState({newNamePhoto: event.target.value});
this.setState({activeName: true})
}
addNewPhoto() {
const { photos, uploadedImage, addNewPhoto } = this.props;
const newPhoto = this.state.newPhoto;
const newName = this.state.newNamePhoto;
const newUrl = uploadedImage.url;
const newId = photos[0].id;
addNewPhoto(newPhoto, newName, newUrl, newId);
}
render() {
const { uploadedImage } = this.props;
return (
<div>
<div className="upload-form">
<UploadBlock
addPhotoName={this.addPhotoName}
uploadPhoto={this.uploadPhoto}
uploadedImage={uploadedImage}
newPhoto={this.state.newPhoto}
activeName={this.state.activeName}
/>
<Button
bsStyle="primary"
className="add-photo"
bsSize="small"
disabled={!this.state.newNamePhoto || !uploadedImage.url}
onClick={this.addNewPhoto}>
Add new photo
</Button>
<p hidden={!uploadedImage.name}><strong>{uploadedImage.name }</strong> the photo was successfully uploaded!</p>
</div>
</div>
);
}
}
|
src/components/title/Title.js
|
jshack3r/ws-redux-counters-router
|
import React from 'react'
class Title extends React.Component {
constructor(props) {
super(props)
}
componentDidMount() {
this.props.onLoad()
}
render() {
let { onClick } = this.props
return <h2 className="text-muted" onClick={onClick} style={{cursor:'pointer'}}>Redux Counters</h2>
}
}
Title.propTypes = {
onClick: React.PropTypes.func.isRequired,
onLoad: React.PropTypes.func.isRequired
}
export default Title
|
client/components/App.js
|
Kamill90/Dental
|
import React from 'react';
import NavigationBar from './client/NavigationBar';
export default ({ children }) => {
return(
<div>
<NavigationBar/>
<div className="container">{children}</div>
</div>
)
};
|
packages/react-error-overlay/src/containers/StackFrame.js
|
appier/create-react-app
|
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/* @flow */
import React, { Component } from 'react';
import CodeBlock from './StackFrameCodeBlock';
import { getPrettyURL } from '../utils/getPrettyURL';
import { darkGray } from '../styles';
import type { StackFrame as StackFrameType } from '../utils/stack-frame';
import type { ErrorLocation } from '../utils/parseCompileError';
const linkStyle = {
fontSize: '0.9em',
marginBottom: '0.9em',
};
const anchorStyle = {
textDecoration: 'none',
color: darkGray,
cursor: 'pointer',
};
const codeAnchorStyle = {
cursor: 'pointer',
};
const toggleStyle = {
marginBottom: '1.5em',
color: darkGray,
cursor: 'pointer',
border: 'none',
display: 'block',
width: '100%',
textAlign: 'left',
background: '#fff',
fontFamily: 'Consolas, Menlo, monospace',
fontSize: '1em',
padding: '0px',
lineHeight: '1.5',
};
type Props = {|
frame: StackFrameType,
contextSize: number,
critical: boolean,
showCode: boolean,
editorHandler: (errorLoc: ErrorLocation) => void,
|};
type State = {|
compiled: boolean,
|};
class StackFrame extends Component<Props, State> {
state = {
compiled: false,
};
toggleCompiled = () => {
this.setState(state => ({
compiled: !state.compiled,
}));
};
getErrorLocation(): ErrorLocation | null {
const {
_originalFileName: fileName,
_originalLineNumber: lineNumber,
} = this.props.frame;
// Unknown file
if (!fileName) {
return null;
}
// e.g. "/path-to-my-app/webpack/bootstrap eaddeb46b67d75e4dfc1"
const isInternalWebpackBootstrapCode = fileName.trim().indexOf(' ') !== -1;
if (isInternalWebpackBootstrapCode) {
return null;
}
// Code is in a real file
return { fileName, lineNumber: lineNumber || 1 };
}
editorHandler = () => {
const errorLoc = this.getErrorLocation();
if (!errorLoc) {
return;
}
this.props.editorHandler(errorLoc);
};
onKeyDown = (e: SyntheticKeyboardEvent<>) => {
if (e.key === 'Enter') {
this.editorHandler();
}
};
render() {
const { frame, contextSize, critical, showCode } = this.props;
const {
fileName,
lineNumber,
columnNumber,
_scriptCode: scriptLines,
_originalFileName: sourceFileName,
_originalLineNumber: sourceLineNumber,
_originalColumnNumber: sourceColumnNumber,
_originalScriptCode: sourceLines,
} = frame;
const functionName = frame.getFunctionName();
const compiled = this.state.compiled;
const url = getPrettyURL(
sourceFileName,
sourceLineNumber,
sourceColumnNumber,
fileName,
lineNumber,
columnNumber,
compiled
);
let codeBlockProps = null;
if (showCode) {
if (
compiled &&
scriptLines &&
scriptLines.length !== 0 &&
lineNumber != null
) {
codeBlockProps = {
lines: scriptLines,
lineNum: lineNumber,
columnNum: columnNumber,
contextSize,
main: critical,
};
} else if (
!compiled &&
sourceLines &&
sourceLines.length !== 0 &&
sourceLineNumber != null
) {
codeBlockProps = {
lines: sourceLines,
lineNum: sourceLineNumber,
columnNum: sourceColumnNumber,
contextSize,
main: critical,
};
}
}
const canOpenInEditor =
this.getErrorLocation() !== null && this.props.editorHandler !== null;
return (
<div>
<div>{functionName}</div>
<div style={linkStyle}>
<a
style={canOpenInEditor ? anchorStyle : null}
onClick={canOpenInEditor ? this.editorHandler : null}
onKeyDown={canOpenInEditor ? this.onKeyDown : null}
tabIndex={canOpenInEditor ? '0' : null}
>
{url}
</a>
</div>
{codeBlockProps && (
<span>
<a
onClick={canOpenInEditor ? this.editorHandler : null}
style={canOpenInEditor ? codeAnchorStyle : null}
>
<CodeBlock {...codeBlockProps} />
</a>
<button style={toggleStyle} onClick={this.toggleCompiled}>
{'View ' + (compiled ? 'source' : 'compiled')}
</button>
</span>
)}
</div>
);
}
}
export default StackFrame;
|
resources/assets/js/components/AppComponent.js
|
jrm2k6/i-heart-reading
|
import React, { Component } from 'react';
import { fetchUser } from '../actions/userProfileActions';
import { hideModal } from '../actions/modals/modalActions';
import { connect } from 'react-redux';
import Modal from 'react-modal';
import LateralMenu from './LateralMenu';
import AlertsComponent from './AlertsComponent';
import injectTapEventPlugin from 'react-tap-event-plugin';
injectTapEventPlugin();
const mapStateToProps = (state) => {
return {
user: state.userProfileReducer.user,
currentTypeAlert: state.alertsReducer.currentTypeAlert,
currentContentAlert: state.alertsReducer.currentContentAlert,
modalComponent: state.modalReducer.component,
modalData: state.modalReducer.data,
showingModal: state.modalReducer.showingModal
};
};
const overrideModalDefaultStyles = () => {
Modal.defaultStyles.overlay.backgroundColor = "rgba(0, 0, 0, 0.85)";
Modal.defaultStyles.content.width = "60%";
Modal.defaultStyles.content.height = "60%";
Modal.defaultStyles.content.top = "0";
Modal.defaultStyles.content.bottom = "0";
Modal.defaultStyles.content.left = "0";
Modal.defaultStyles.content.right = "0";
Modal.defaultStyles.content.margin = "auto";
Modal.defaultStyles.content.padding = "0";
Modal.defaultStyles.content.borderRadius = "1px";
Modal.defaultStyles.content.border = "none";
}
overrideModalDefaultStyles();
const mapDispatchToProps = (dispatch) => {
return {
fetchUser: () => {
dispatch(fetchUser());
},
hideModal: () => {
dispatch(hideModal());
}
};
};
class AppComponent extends Component {
componentDidMount() {
this.props.fetchUser();
}
render() {
const { currentTypeAlert, currentContentAlert,
showingModal, modalComponent, modalData
} = this.props;
const alert = (currentTypeAlert && currentContentAlert) ?
<AlertsComponent type={currentTypeAlert} content={currentContentAlert} /> :
null;
const element = (showingModal && modalComponent) ?
React.createElement(modalComponent, modalData) : null;
return (
<div className='root-component'>
{alert}
<LateralMenu history={this.props.history} user={this.props.user} />
<div className='interactive-panel'>
{this.props.children}
</div>
<Modal
contentLabel={'Application Modal'}
isOpen={showingModal}
onRequestClose={this.props.hideModal}
>
{element}
</Modal>
</div>
);
}
}
export default connect(mapStateToProps, mapDispatchToProps)(AppComponent);
|
app/javascript/mastodon/components/admin/ReportReasonSelector.js
|
musashino205/mastodon
|
import React from 'react';
import PropTypes from 'prop-types';
import api from 'mastodon/api';
import { injectIntl, defineMessages } from 'react-intl';
import classNames from 'classnames';
const messages = defineMessages({
other: { id: 'report.categories.other', defaultMessage: 'Other' },
spam: { id: 'report.categories.spam', defaultMessage: 'Spam' },
violation: { id: 'report.categories.violation', defaultMessage: 'Content violates one or more server rules' },
});
class Category extends React.PureComponent {
static propTypes = {
id: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
selected: PropTypes.bool,
disabled: PropTypes.bool,
onSelect: PropTypes.func,
children: PropTypes.node,
};
handleClick = () => {
const { id, disabled, onSelect } = this.props;
if (!disabled) {
onSelect(id);
}
};
render () {
const { id, text, disabled, selected, children } = this.props;
return (
<div tabIndex='0' role='button' className={classNames('report-reason-selector__category', { selected, disabled })} onClick={this.handleClick}>
{selected && <input type='hidden' name='report[category]' value={id} />}
<div className='report-reason-selector__category__label'>
<span className={classNames('poll__input', { active: selected, disabled })} />
{text}
</div>
{(selected && children) && (
<div className='report-reason-selector__category__rules'>
{children}
</div>
)}
</div>
);
}
}
class Rule extends React.PureComponent {
static propTypes = {
id: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
selected: PropTypes.bool,
disabled: PropTypes.bool,
onToggle: PropTypes.func,
};
handleClick = () => {
const { id, disabled, onToggle } = this.props;
if (!disabled) {
onToggle(id);
}
};
render () {
const { id, text, disabled, selected } = this.props;
return (
<div tabIndex='0' role='button' className={classNames('report-reason-selector__rule', { selected, disabled })} onClick={this.handleClick}>
<span className={classNames('poll__input', { checkbox: true, active: selected, disabled })} />
{selected && <input type='hidden' name='report[rule_ids][]' value={id} />}
{text}
</div>
);
}
}
export default @injectIntl
class ReportReasonSelector extends React.PureComponent {
static propTypes = {
id: PropTypes.string.isRequired,
category: PropTypes.string.isRequired,
rule_ids: PropTypes.arrayOf(PropTypes.string),
disabled: PropTypes.bool,
intl: PropTypes.object.isRequired,
};
state = {
category: this.props.category,
rule_ids: this.props.rule_ids || [],
rules: [],
};
componentDidMount() {
api().get('/api/v1/instance').then(res => {
this.setState({
rules: res.data.rules,
});
}).catch(err => {
console.error(err);
});
}
_save = () => {
const { id, disabled } = this.props;
const { category, rule_ids } = this.state;
if (disabled) {
return;
}
api().put(`/api/v1/admin/reports/${id}`, {
category,
rule_ids,
}).catch(err => {
console.error(err);
});
};
handleSelect = id => {
this.setState({ category: id }, () => this._save());
};
handleToggle = id => {
const { rule_ids } = this.state;
if (rule_ids.includes(id)) {
this.setState({ rule_ids: rule_ids.filter(x => x !== id ) }, () => this._save());
} else {
this.setState({ rule_ids: [...rule_ids, id] }, () => this._save());
}
};
render () {
const { disabled, intl } = this.props;
const { rules, category, rule_ids } = this.state;
return (
<div className='report-reason-selector'>
<Category id='other' text={intl.formatMessage(messages.other)} selected={category === 'other'} onSelect={this.handleSelect} disabled={disabled} />
<Category id='spam' text={intl.formatMessage(messages.spam)} selected={category === 'spam'} onSelect={this.handleSelect} disabled={disabled} />
<Category id='violation' text={intl.formatMessage(messages.violation)} selected={category === 'violation'} onSelect={this.handleSelect} disabled={disabled}>
{rules.map(rule => <Rule key={rule.id} id={rule.id} text={rule.text} selected={rule_ids.includes(rule.id)} onToggle={this.handleToggle} disabled={disabled} />)}
</Category>
</div>
);
}
}
|
app/javascript/mastodon/features/list_adder/components/list.js
|
gol-cha/mastodon
|
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import ImmutablePureComponent from 'react-immutable-pure-component';
import ImmutablePropTypes from 'react-immutable-proptypes';
import IconButton from '../../../components/icon_button';
import { defineMessages, injectIntl } from 'react-intl';
import { removeFromListAdder, addToListAdder } from '../../../actions/lists';
import Icon from 'mastodon/components/icon';
const messages = defineMessages({
remove: { id: 'lists.account.remove', defaultMessage: 'Remove from list' },
add: { id: 'lists.account.add', defaultMessage: 'Add to list' },
});
const MapStateToProps = (state, { listId, added }) => ({
list: state.get('lists').get(listId),
added: typeof added === 'undefined' ? state.getIn(['listAdder', 'lists', 'items']).includes(listId) : added,
});
const mapDispatchToProps = (dispatch, { listId }) => ({
onRemove: () => dispatch(removeFromListAdder(listId)),
onAdd: () => dispatch(addToListAdder(listId)),
});
export default @connect(MapStateToProps, mapDispatchToProps)
@injectIntl
class List extends ImmutablePureComponent {
static propTypes = {
list: ImmutablePropTypes.map.isRequired,
intl: PropTypes.object.isRequired,
onRemove: PropTypes.func.isRequired,
onAdd: PropTypes.func.isRequired,
added: PropTypes.bool,
};
static defaultProps = {
added: false,
};
render () {
const { list, intl, onRemove, onAdd, added } = this.props;
let button;
if (added) {
button = <IconButton icon='times' title={intl.formatMessage(messages.remove)} onClick={onRemove} />;
} else {
button = <IconButton icon='plus' title={intl.formatMessage(messages.add)} onClick={onAdd} />;
}
return (
<div className='list'>
<div className='list__wrapper'>
<div className='list__display-name'>
<Icon id='list-ul' className='column-link__icon' fixedWidth />
{list.get('title')}
</div>
<div className='account__relationship'>
{button}
</div>
</div>
</div>
);
}
}
|
client/src/app/components/voice-control/components/SpeechButton.js
|
zraees/sms-project
|
import React from 'react'
import {Popover, OverlayTrigger} from 'react-bootstrap'
import {bindActionCreators} from 'redux'
import * as VoiceActions from '../VoiceActions'
import {connect} from 'react-redux';
import SpeechHelp from './SpeechHelp'
class SpeechButton extends React.Component {
hidePopover = ()=> {
this.refs.vpOverlay.hide()
};
render() {
const popover = (
<Popover
ref="popover"
id="popover-basic"
placement="bottom"
title={null}
>{
!this.props.hasError
?
<h4 className="vc-title">Voice command activated <br />
<small>Please speak clearly into the mic</small>
</h4>
:
<h4 className="vc-title-error text-center">
<i className="fa fa-microphone-slash"/> Voice command failed
<br />
<small className="txt-color-red">Must <strong>"Allow"</strong> Microphone</small>
<br />
<small className="txt-color-red">Must have <strong>Internet Connection</strong>
</small>
</h4>
}
<div>
<a className="btn btn-success" id="speech-help-btn"
onClick={this.props.voiceControlShowHelp}>See Commands</a>
<a className="btn bg-color-purple txt-color-white"
onClick={this.hidePopover}>Close Popup</a>
</div>
</Popover>
)
return (
<div id="speech-btn" className={this.props.className}>
<div>
<OverlayTrigger trigger={this.props.started ? null : "click" } placement="bottom" ref="vpOverlay" overlay={popover}>
<a onClick={this.voiceControlToggle} title="Voice Command" id="voice-command-btn"><i
className="fa fa-microphone"/></a>
</OverlayTrigger>
</div>
<SpeechHelp showHelp={this.props.showHelp} onHide={this.props.voiceControlHideHelp}/>
</div>
)
}
voiceControlToggle = (e)=> {
if (this.props.started) {
this.hidePopover();
this.props.voiceControlOff()
} else {
this.props.voiceControlOn()
}
}
}
export default connect(
(state)=> {
return state.voice
},
(dispatch)=> {
return bindActionCreators(VoiceActions, dispatch)
}
)(SpeechButton)
|
hit-the-road-react/src/components/RentalsMap.prev.js
|
buckmelton/hit-the-road
|
import React, { Component } from 'react';
// import GoogleApiComponent from 'google-maps-react';
import '../css/App.css';
import '../css/normalize.css';
import '../css/skeleton.css';
// Google Maps API key: AIzaSyCFwE9ezzuQGddycwRrZ1K3BvRzFVQGvvg
const __GAPI_KEY__ = "AIzaSyCFwE9ezzuQGddycwRrZ1K3BvRzFVQGvvg";
class RentalsMap extends Component {
render() {
if (!this.props.loaded) {
return <div>Loading...</div>
}
return (
<div>Map will go here</div>
);
}
}
export default RentalsMap;
// export default GoogleApiComponent({
// apiKey: __GAPI_KEY__
// })(RentalsMap)
|
client/src/components/layouts/Sidebar.js
|
banderson/reactive-stock-ticker-demo
|
import React from 'react';
export default ({children}) => (
<aside className="col-xs-3">
{children}
</aside>
);
|
modules/dreamview/frontend/src/components/DefaultRouting/CycleNumberInput.js
|
ApolloAuto/apollo
|
import React from 'react';
import _ from 'lodash';
import CheckboxItem from 'components/common/CheckboxItem';
export default class CycleNumberInput extends React.Component {
constructor(props) {
super(props);
this.state = {
cycleNumber: 1,
isCycling: false,
};
this.sendCycleDefaultRouting = this.sendCycleDefaultRouting.bind(this);
this.cancelSendDefaultRouting = this.cancelSendDefaultRouting.bind(this);
this.toggleCycle = this.toggleCycle.bind(this);
this.handleInput = (event) => {
this.setState({ cycleNumber: event.target.value });
};
}
toggleCycle() {
this.setState((prevState) => {
return { isCycling: !prevState.isCycling };
});
}
sendCycleDefaultRouting() {
const { routeEditingManager, options } = this.props;
if (this.state.isCycling) {
const cycleNumber = parseInt(this.state.cycleNumber, 10);
if (isNaN(cycleNumber) || cycleNumber < 1) {
alert('please input a valid cycle number');
}
else if (!routeEditingManager.checkCycleRoutingAvailable()) {
alert(`Please set the default routing reasonably,the distance from the car position
to the end point should exceed ${routeEditingManager.defaultRoutingDistanceThreshold},
otherwise it will not be able to form a closed loop.`);
}
else {
routeEditingManager.sendCycleRoutingRequest(cycleNumber);
}
}
else {
routeEditingManager.sendRoutingRequest(false, routeEditingManager.currentDefaultRouting);
}
options.showCycleNumberInput = false;
}
cancelSendDefaultRouting() {
const { options } = this.props;
options.showCycleNumberInput = false;
}
render() {
return (
<React.Fragment>
<div className="default-routing-input">
<div>
<div>
<label className="name-label">Start Cycling</label>
<CheckboxItem
extraClasses="start-cycle-checkbox"
id="isReportableData"
isChecked={this.state.isCycling}
disabled={false}
onClick={this.toggleCycle}
/>
</div>
{this.state.isCycling &&
<div>
<label className="name-label">Cycle Number:</label>
<input
className="name-input"
value={this.state.cycleNumber}
onChange={this.handleInput}
type="number"
></input>
</div>}
</div>
<div className="default-routing-input-btn">
<button className="input-button submit-button" onClick={this.sendCycleDefaultRouting}>Send</button>
<button className="input-button" onClick={this.cancelSendDefaultRouting}>Cancel</button>
</div>
</div>
</React.Fragment>
);
}
}
|
src/svg-icons/action/theaters.js
|
tan-jerene/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let ActionTheaters = (props) => (
<SvgIcon {...props}>
<path d="M18 3v2h-2V3H8v2H6V3H4v18h2v-2h2v2h8v-2h2v2h2V3h-2zM8 17H6v-2h2v2zm0-4H6v-2h2v2zm0-4H6V7h2v2zm10 8h-2v-2h2v2zm0-4h-2v-2h2v2zm0-4h-2V7h2v2z"/>
</SvgIcon>
);
ActionTheaters = pure(ActionTheaters);
ActionTheaters.displayName = 'ActionTheaters';
ActionTheaters.muiName = 'SvgIcon';
export default ActionTheaters;
|
react/JobCard/components/SellingPoint/SellingPoint.js
|
seekinternational/seek-asia-style-guide
|
import React from 'react';
import PropTypes from 'prop-types';
import styles from './SellingPoint.less';
import Text from '../../../Text/Text';
const SellingPoint = ({ sellingPoints, showSellingPoint }) => {
if (!showSellingPoint || !sellingPoints) {
return null;
}
return (
<ul className={styles.sellingPoints}>
{sellingPoints.map((sellingPoint, i) => (
<li key={i} className={styles.sellingPoint}>
<Text
whispering
baseline={false}
className={styles.text}>
{sellingPoint}
</Text>
</li>
))}
</ul>
);
};
SellingPoint.propTypes = {
sellingPoints: PropTypes.arrayOf(PropTypes.string),
showSellingPoint: PropTypes.bool
};
export default SellingPoint;
|
src/main.js
|
warcraftlfg/warcrafthub-client
|
import React from 'react'
import ReactDOM from 'react-dom'
import createStore from './store/createStore'
import AppContainer from './containers/AppContainer'
// ========================================================
// Store Instantiation
// ========================================================
const initialState = window.___INITIAL_STATE__
const store = createStore(initialState)
// ========================================================
// Render Setup
// ========================================================
const MOUNT_NODE = document.getElementById('root')
let render = () => {
const routes = require('./routes/index').default(store)
ReactDOM.render(
<AppContainer store={store} routes={routes} />,
MOUNT_NODE
)
}
// This code is excluded from production bundle
if (__DEV__) {
if (module.hot) {
// Development render functions
const renderApp = render
const renderError = (error) => {
const RedBox = require('redbox-react').default
ReactDOM.render(<RedBox error={error} />, MOUNT_NODE)
}
// Wrap render in try/catch
render = () => {
try {
renderApp()
} catch (error) {
console.error(error)
renderError(error)
}
}
// Setup hot module replacement
module.hot.accept('./routes/index', () =>
setImmediate(() => {
ReactDOM.unmountComponentAtNode(MOUNT_NODE)
render()
})
)
}
}
// ========================================================
// Go!
// ========================================================
render()
|
fields/types/text/TextColumn.js
|
dvdcastro/keystone
|
import React from 'react';
import ItemsTableCell from '../../components/ItemsTableCell';
import ItemsTableValue from '../../components/ItemsTableValue';
var TextColumn = React.createClass({
displayName: 'TextColumn',
propTypes: {
col: React.PropTypes.object,
data: React.PropTypes.object,
linkTo: React.PropTypes.string,
},
getValue () {
// cropping text is important for textarea, which uses this column
const value = this.props.data.fields[this.props.col.path];
return value ? value.substr(0, 100) : null;
},
render () {
const value = this.getValue();
const empty = !value && this.props.linkTo ? true : false;
const className = this.props.col.field.monospace ? 'ItemList__value--monospace' : undefined;
return (
<ItemsTableCell>
<ItemsTableValue className={className} href={this.props.linkTo} empty={empty} padded interior field={this.props.col.type}>
{value}
</ItemsTableValue>
</ItemsTableCell>
);
},
});
module.exports = TextColumn;
|
client/components/FlassCommon/Video/VideoTimePanel/VideoTimePanelComponent.js
|
Nexters/flass
|
import React from 'react';
import PropTypes from 'prop-types';
import VideoDurationComponent from '../VideoDurationComponent';
import './VideoTimePanelComponentStyles.scss';
const propTypes = {
duration: PropTypes.number.isRequired,
elapsed: PropTypes.number.isRequired
};
const defaultProps = {
};
const VideoTimePanelComponent = ({ duration, elapsed }) => (
<span className="video-timepanel">
<VideoDurationComponent seconds={ elapsed } />
{ ' / ' }
<VideoDurationComponent seconds={ duration } />
</span>
);
VideoTimePanelComponent.propTypes = propTypes;
VideoTimePanelComponent.defaultProps = defaultProps;
export { VideoTimePanelComponent };
|
src/components/WPSWranglerDemo.spec.js
|
maartenplieger/datascienceplatform-frontend
|
import React from 'react';
import WPSWranglerDemo from './WPSWranglerDemo';
import { mount } from 'enzyme';
import sinon from 'sinon';
describe('(Component) WPSWranglerDemo', () => {
let _component;
const _dispatch = sinon.spy();
const incrementFunc = sinon.spy();
const _actions = {
incrementCounter: incrementFunc
};
beforeEach(() => {
_component = mount(<WPSWranglerDemo count={0} dispatch={_dispatch} actions={_actions} />);
});
it('Can mount', () => {
expect(_component.type()).to.equal(WPSWranglerDemo);
});
it('Can increment the counter', () => {
_component.find('#incrementButton').first().simulate('click');
expect(_dispatch).to.have.been.calledOnce();
expect(incrementFunc).to.have.been.calledOnce();
});
});
|
src/svg-icons/action/view-stream.js
|
ichiohta/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let ActionViewStream = (props) => (
<SvgIcon {...props}>
<path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z"/>
</SvgIcon>
);
ActionViewStream = pure(ActionViewStream);
ActionViewStream.displayName = 'ActionViewStream';
ActionViewStream.muiName = 'SvgIcon';
export default ActionViewStream;
|
src/docs/components/LabelDoc.js
|
karatechops/grommet-docs
|
// (C) Copyright 2014-2016 Hewlett Packard Enterprise Development LP
import React, { Component } from 'react';
import Label from 'grommet/components/Label';
import Anchor from 'grommet/components/Anchor';
import DocsArticle from '../../components/DocsArticle';
import Code from '../../components/Code';
Label.displayName = 'Label';
export default class LabelDoc extends Component {
render () {
return (
<DocsArticle title='Label'>
<section>
<p>A simple text label. This could be used to annotate
a <Anchor path='/docs/value'>Value</Anchor> to indicate
what the value refers to. Or, it can annotate
a <Anchor path='/docs/card'>Card</Anchor> to indicate
a category.</p>
<Label>Sample Label</Label>
</section>
<section>
<h2>Properties</h2>
<dl>
<dt><code>labelFor {"{string}"}</code></dt>
<dd>ID of the form element that the label is for. Optional.</dd>
<dt><code>truncate true|false</code></dt>
<dd>Restrict the text to a single line and truncate with
ellipsis if it is too long to all fit.
Defaults to <code>false</code>.</dd>
<dt><code>uppercase true|false</code></dt>
<dd>Convert the label to uppercase.
Defaults to <code>false</code>.</dd>
</dl>
</section>
<section>
<h2>Usage</h2>
<Code preamble={`import Label from 'grommet/components/Label';`}>
<Label>
{'{contents}'}
</Label>
</Code>
</section>
</DocsArticle>
);
}
};
|
src/components/TabContent/TabContent.js
|
joshblack/carbon-components-react
|
/**
* Copyright IBM Corp. 2016, 2018
*
* This source code is licensed under the Apache-2.0 license found in the
* LICENSE file in the root directory of this source tree.
*/
import PropTypes from 'prop-types';
import React from 'react';
const TabContent = props => {
const { selected, children, ...other } = props;
return (
<div {...other} selected={selected} hidden={!selected}>
{children}
</div>
);
};
TabContent.propTypes = {
/**
* Specify whether the TabContent is selected
*/
selected: PropTypes.bool,
/**
* Pass in content to render inside of the TabContent
*/
children: PropTypes.node,
};
TabContent.defaultProps = {
selected: false,
};
export default TabContent;
|
frontend/src/components/SearchBar.js
|
OwenRay/Remote-MediaServer
|
/* eslint-disable no-underscore-dangle */
/**
* Created by owenray on 19/07/2017.
*/
import React, { Component } from 'react';
import { Button, Icon, Input, Row } from 'react-materialize';
import { deserialize } from 'redux-jsonapi';
import store from '../helpers/stores/settingsStore';
class SearchBar extends Component {
constructor() {
super();
this.toggleGrouped = this.toggleGrouped.bind(this);
this.state = { filters: { title: '' }, settings: { libraries: [] } };
}
componentWillMount() {
this.onChange = this.onChange.bind(this);
store.subscribe(this.onSettingsChange.bind(this));
this.onSettingsChange();
}
/**
* triggered when the settings model changes
*/
onSettingsChange() {
const { api } = store.getState();
if (!api.setting) {
return;
}
this.setState({
settings: deserialize(api.setting[1], store),
});
}
/**
* @param e
* called when user types in field, applies typed value to state
*/
onChange(e) {
e.stopPropagation();
e.preventDefault();
const o = this.state;
o.filters[e.target.name] = e.target.value;
this.setState(o);
if (this.props.onChange) {
this.props.onChange(o.filters);
}
}
toggleGrouped() {
const f = this.props.filters;
f.distinct = f.distinct ? '' : 'external-id';
if (this.props.onChange) {
this.props.onChange(f);
}
}
render() {
if (this.state === null) { return null; }
const { props } = this;
const { filters } = props;
return (
<div className={props.className}>
<Row>
<Input s={3} name="libraryId" type="select" label="Library:" value={filters.libraryId} onChange={this.onChange}>
<option value="">All libraries</option>
{this.state.settings.libraries.map((lib) => {
let { uuid } = lib;
if (lib.type === 'shared') [uuid] = uuid.split('-');
return <option key={uuid} value={uuid}>{lib.name}</option>;
})}
</Input>
<div className="col search s6">
<Input s={12} name="title" type="text" label="" value={filters.title || ''} onChange={this.onChange} />
<Button className="mdi-action-search"><Icon>search</Icon></Button>
</div>
<Input s={3} name="sort" type="select" label="Sort by:" value={filters.sort} onChange={this.onChange}>
<option value="title">Title</option>
<option value="date_added:DESC">Date added</option>
<option value="release-date:DESC">Date released</option>
</Input>
<Button
className="toggleGroup"
data-tip={filters.distinct ? 'Disable grouping' : 'Enable grouping'}
floating
onClick={this.toggleGrouped}
icon={filters.distinct ? 'layers_clear' : 'layers'}
/>
</Row>
</div>
);
}
}
export default SearchBar;
|
src/components/Input.js
|
abdulhannanali/github-organization-repos
|
import React from 'react';
import classnames from 'classnames';
import '../styles/Input.css';
const Input = (props) => {
const classNames = classnames(['form-control', 'Input']);
return (
<div className="form-group">
<input
type="text"
className={classNames} maxLength="39" {...props} />
</div>
);
};
export default Input;
|
Agenda/src/components/esqueciSenha.js
|
interlegis/agenda-evento
|
import React, { Component } from 'react';
import { reduxForm } from 'redux-form';
import _ from 'lodash';
import { recuperarSenha } from '../actions';
import { FIELD_ESQUECI_SENHA } from './forms/fields_types';
class EsqueciSenha extends Component{
handleSubmitForm({ email }){
this.props.recuperarSenha({ email });
}
renderAlert(){
if (this.props.errorMessage) {
return(
<div className="alert alert-danger">
<strong>Oops!</strong> {this.props.errorMessage}
</div>
);
}
}
renderField(fieldConfig, field){
const fieldHelper = this.props.fields[field];
return(
<fieldset className={(fieldHelper.touched && fieldHelper.invalid)
? "form-group has-error has-feedback" : "form-group"}
key={`${fieldConfig.type}\_${fieldConfig.label}`}>
<label className="control-label center">{fieldConfig.titulo}</label>
<input className="form-control" {...fieldHelper} type={fieldConfig.type}
placeholder={`Coloque ${fieldConfig.label}`}/>
{fieldHelper.touched && fieldHelper.error &&
<div className="help-block">{fieldHelper.error}</div>}
</fieldset>
);
}
render(){
const { handleSubmit, submitting, fields: { email }} = this.props;
return(
<div>
<div>
<h2 className="title">Agenda de Eventos Interlegis</h2>
<h3>Sistema para agendamento de eventos a serem realizados no prédio Interlegis</h3>
</div>
<div className="center-div-flex">
<div className="panel panel-primary col-md-5 center">
<div className="panel-heading text-center">Esqueci minha Senha</div>
<div className="panel-body center col-md-12">
<form onSubmit={handleSubmit(this.handleSubmitForm.bind(this))}
className="center col-md-12" style={{paddingBottom: 10}}>
{_.map(FIELD_ESQUECI_SENHA, this.renderField.bind(this))}
{this.renderAlert()}
<div className="login-button">
<button type="submit" disabled={submitting}
className={(email.touched && email.invalid)?
"btn btn-primary btn-md disabled" : "btn btn-primary btn-md"}>
Recuperar Senha
</button>
</div>
</form>
</div>
</div>
</div>
</div>
);
}
}
function validate(values) {
const errors = {};
var re_email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
_.each(FIELD_ESQUECI_SENHA, (fieldConfig, field) => {
if (!values[field]) {
errors[field] = `Por favor, insira ${fieldConfig.label}...`;
}
if (values[field] && fieldConfig.type == 'email' && !re_email.test(values[field])) {
errors[field] = `Por favor, insira um email em formato valido!`;
}
});
return errors;
}
function mapStateToProps(state){
return { errorMessage: state.authentication.error };
}
export default reduxForm({
form: 'login',
fields: _.keys(FIELD_ESQUECI_SENHA),
validate
}, mapStateToProps, { recuperarSenha })(EsqueciSenha);
|
shopping-cart-app/src/components/routes/AddNewStore/AddNewStore.js
|
JCFlores/shoppingCart
|
import React, { Component } from 'react';
import Header from '../../Header';
import AddNewStoreAction from './AddNewStoreAction'
import './AddNewStore.css';
class Signup extends Component {
constructor(props) {
super(props);
console.log(props);
this.state = {
storeName: '',
description: '',
image: ''
};
// use post function from AddNewUserAction.js
this.AddNewStoreAction = new AddNewStoreAction();
this.handleChange = this.handleChange.bind(this);
this.handleSubmit = this.handleSubmit.bind(this);
}
handleChange(event) {
const target = event.target;
const value = target.value;
const name = target.name;
this.setState({
[name]: value
});
}
handleSubmit(event) {
event.preventDefault();
this.AddNewStoreAction.addNewStore(this.state.storeName, this.state.description, this.state.image, this.props.match.params.id);
}
render () {
return (
<div>
<Header />
<section className="hero">
<div className="hero-body">
<div className="container store-name">
<h1 className="title">Tell Us About Your Store</h1>
</div>
</div>
</section>
<section>
<div className="container form-container">
<form onSubmit={this.handleSubmit}>
<div className="field">
<label className="label">
Store Name:
</label>
<input type="text" className="input" placeholder="Store Name" name="storeName" value={this.state.value} onChange={this.handleChange} />
</div>
<div className="field">
<label className="label">
Description of Your Store:
</label>
<input type="text" className="input" placeholder="Description of Your Store" name="description" value={this.state.value} onChange={this.handleChange} />
</div>
<div className="field">
<label className="label">
Image of Your Store:
</label>
<input type="password" className="input" placeholder="Paste a Link to an Image of Your Store" name="image" value={this.state.value} onChange={this.handleChange} />
</div>
<button className="button signup-button"type="submit">Submit</button>
</form>
</div>
</section>
</div>
);
}
}
export default Signup;
|
js/jqwidgets/demos/react/app/grid/foreignkeycolumn/app.js
|
luissancheza/sice
|
import React from 'react';
import ReactDOM from 'react-dom';
import JqxGrid from '../../../jqwidgets-react/react_jqxgrid.js';
class App extends React.Component {
render() {
let employeesSource =
{
datatype: 'xml',
datafields: [
{ name: 'FirstName', type: 'string' },
{ name: 'LastName', type: 'string' }
],
root: 'Employees',
record: 'Employee',
id: 'EmployeeID',
url: '../sampledata/employees.xml',
async: false
};
let employeesAdapter = new $.jqx.dataAdapter(employeesSource, {
autoBind: true,
beforeLoadComplete: (records) => {
let data = new Array();
// update the loaded records. Dynamically add EmployeeName and EmployeeID fields.
for (let i = 0; i < records.length; i++) {
let employee = records[i];
employee.EmployeeName = employee.FirstName + ' ' + employee.LastName;
employee.EmployeeID = employee.uid;
data.push(employee);
}
return data;
}
});
// prepare the data
let ordersSource =
{
datatype: 'xml',
datafields: [
// name - determines the field's name.
// values - specifies the field's values.
// values.source - specifies the foreign source. The expected value is an array.
// values.name - specifies the field's name in the foreign source.
// When the ordersAdapter is loaded, each record will have a field called 'EmployeeID'. The 'EmployeeID' for each record will come from the employeesAdapter where the record's 'EmployeeID' from orders.xml matches to the 'EmployeeID' from employees.xml.
{ name: 'EmployeeID', map: 'm\\:properties>d\\:EmployeeID', values: { source: employeesAdapter.records, name: 'EmployeeName' } },
{ name: 'ShippedDate', map: 'm\\:properties>d\\:ShippedDate', type: 'date' },
{ name: 'Freight', map: 'm\\:properties>d\\:Freight', type: 'float' },
{ name: 'ShipName', map: 'm\\:properties>d\\:ShipName' },
{ name: 'ShipAddress', map: 'm\\:properties>d\\:ShipAddress' },
{ name: 'ShipCity', map: 'm\\:properties>d\\:ShipCity' },
{ name: 'ShipCountry', map: 'm\\:properties>d\\:ShipCountry' }
],
root: 'entry',
record: 'content',
id: 'm\\:properties>d\\:OrderID',
url: '../sampledata/orders.xml',
pager: (pagenum, pagesize, oldpagenum) => {
// callback called when a page or page size is changed.
}
};
let ordersAdapter = new $.jqx.dataAdapter(ordersSource);
let columns =
[
{ text: 'Employee Name', datafield: 'EmployeeID', width: 150 },
{ text: 'Ship City', datafield: 'ShipCity', width: 150 },
{ text: 'Ship Country', datafield: 'ShipCountry', width: 150 },
{ text: 'Ship Name', datafield: 'ShipName' }
];
return (
<JqxGrid
width={850} source={ordersAdapter} pageable={true}
autoheight={true} columns={columns}
selectionmode={'multiplecellsadvanced'}
/>
)
}
}
ReactDOM.render(<App />, document.getElementById('app'));
|
src/components/DropdownButton/DropdownButton.stories.js
|
InsideSalesOfficial/insidesales-components
|
import React from 'react';
import { storiesOf } from '@storybook/react';
import DropdownButton from './DropdownButton';
import Icons from '../icons';
import { wrapComponentWithContainerAndTheme, colors } from "../styles";
const SFIcon = Icons.ColoredSalesforceIcon;
const buttonAction = (selectedOption) => {
alert(`Clicked ${selectedOption.label}!`)
};
const dropdownOptions = [
{ value: '1', label: 'Option 1', },
{ value: '2', label: 'Option 2', }
];
function renderChapterWithTheme(theme) {
return {
info: `
Usage
~~~
import React from 'react';
import { DropdownButton } from 'insidesales-components';
~~~
`,
chapters: [
{
sections: [
{
title: 'Default',
sectionFn: () => wrapComponentWithContainerAndTheme(theme,
<DropdownButton
options={dropdownOptions}
onClick={buttonAction}
/>
)
},
{
title: 'Disabled',
sectionFn: () => wrapComponentWithContainerAndTheme(theme,
<DropdownButton
disabled
options={dropdownOptions}
onClick={buttonAction}
/>
)
},
{
title: 'Danger',
sectionFn: () => wrapComponentWithContainerAndTheme(theme,
<DropdownButton
danger
options={dropdownOptions}
onClick={buttonAction}
/>
)
},
{
title: 'Gray',
sectionFn: () => wrapComponentWithContainerAndTheme(theme,
<DropdownButton
options={dropdownOptions}
onClick={buttonAction}
theme={{gray: true}}
/>
)
},
{
title: 'With Icon',
sectionFn: () => wrapComponentWithContainerAndTheme(theme,
<DropdownButton
options={dropdownOptions}
onClick={buttonAction}
icon={ <SFIcon size={{ width: 24, height: 16.45 }} />}
/>
)
},
{
title: 'Gray with Icon',
sectionFn: () => wrapComponentWithContainerAndTheme(theme,
<DropdownButton
options={dropdownOptions}
onClick={buttonAction}
theme={{gray: true}}
icon={ <SFIcon size={{ width: 24, height: 16.45 }} />}
/>
)
},
]
}
]
};
}
storiesOf('Base', module)
.addWithChapters("Default DropdownButton", renderChapterWithTheme({}))
.addWithChapters(
"DropdownButton w/ BlueYellow Theme",
renderChapterWithTheme(colors.blueYellowTheme)
);
|
src/components/routeToTab1.js
|
dfw-chris-diaz/react-demo
|
import React from 'react';
import MainPage from './mainPage';
const defaultTab = 1;
export default function RouteToTab1(){
return(
<MainPage defaultTab={defaultTab} />
);
}
|
node_modules/react-bootstrap/es/Grid.js
|
ASIX-ALS/asix-final-project-frontend
|
import _extends from 'babel-runtime/helpers/extends';
import _objectWithoutProperties from 'babel-runtime/helpers/objectWithoutProperties';
import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
import _possibleConstructorReturn from 'babel-runtime/helpers/possibleConstructorReturn';
import _inherits from 'babel-runtime/helpers/inherits';
import classNames from 'classnames';
import React from 'react';
import PropTypes from 'prop-types';
import elementType from 'react-prop-types/lib/elementType';
import { bsClass, prefix, splitBsProps } from './utils/bootstrapUtils';
var propTypes = {
/**
* Turn any fixed-width grid layout into a full-width layout by this property.
*
* Adds `container-fluid` class.
*/
fluid: PropTypes.bool,
/**
* You can use a custom element for this component
*/
componentClass: elementType
};
var defaultProps = {
componentClass: 'div',
fluid: false
};
var Grid = function (_React$Component) {
_inherits(Grid, _React$Component);
function Grid() {
_classCallCheck(this, Grid);
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
}
Grid.prototype.render = function render() {
var _props = this.props,
fluid = _props.fluid,
Component = _props.componentClass,
className = _props.className,
props = _objectWithoutProperties(_props, ['fluid', 'componentClass', 'className']);
var _splitBsProps = splitBsProps(props),
bsProps = _splitBsProps[0],
elementProps = _splitBsProps[1];
var classes = prefix(bsProps, fluid && 'fluid');
return React.createElement(Component, _extends({}, elementProps, {
className: classNames(className, classes)
}));
};
return Grid;
}(React.Component);
Grid.propTypes = propTypes;
Grid.defaultProps = defaultProps;
export default bsClass('container', Grid);
|
examples/cra/src/components/Placeholder.js
|
bluetidepro/react-styleguidist
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import './Placeholder.css';
/**
* Image placeholders.
*/
export default class Placeholder extends Component {
static propTypes = {
type: PropTypes.oneOf([
'animal',
'bacon',
'beard',
'bear',
'cat',
'food',
'city',
'nature',
'people',
]),
width: PropTypes.number,
height: PropTypes.number,
};
static defaultProps = {
type: 'animal',
width: 150,
height: 150,
};
getImageUrl() {
const { type, width, height } = this.props;
const types = {
animal: `http://placeimg.com/${width}/${height}/animals`,
bacon: `http://baconmockup.com/${width}/${height}`,
bear: `http://www.placebear.com/${width}/${height}`,
beard: `http://placebeard.it/${width}/${height}`,
cat: `http://lorempixel.com/${width}/${height}/cats`,
city: `http://lorempixel.com/${width}/${height}/city`,
food: `http://lorempixel.com/${width}/${height}/food`,
nature: `http://lorempixel.com/${width}/${height}/nature`,
people: `http://lorempixel.com/${width}/${height}/people`,
};
return types[type];
}
render() {
const { type, width, height } = this.props;
return (
<img
className="placeholder"
src={this.getImageUrl()}
alt={type}
width={width}
height={height}
/>
);
}
}
|
src/components/footer.js
|
ninalouw/portfolio
|
import React, { Component } from 'react';
import { Link } from 'react-router';
import FontAwesome from 'react-fontawesome';
import FontIcon from 'material-ui/FontIcon';
import {red500, yellow500, blue500} from 'material-ui/styles/colors';
import {Row, Col} from 'react-materialize';
class Footer extends Component {
render () {
const iconStyles = {
marginRight: 24,
};
return (
<footer className="footer">
<Row>
<Col s={3} m={2} l={2} className="footer-elem">
<FontIcon className="material-icons" style={iconStyles}>home</FontIcon><p>Get in Touch</p>
</Col>
<Col s={3} m={2} l={2} className="footer-elem">
<FontIcon className="material-icons" style={iconStyles} color={red500}>phone</FontIcon><p>604 405 6789</p>
</Col>
<Col s={3} m={2} l={2} className="footer-elem">
<a className="footer-a" href="mailto:ninamaelouw@gmail.com"><FontIcon className="material-icons" style={iconStyles} color={yellow500}>email</FontIcon><p>ninalouw@mac.com</p></a>
</Col>
<Col s={3} m={2} l={2} className="footer-elem">
<a href="https://www.linkedin.com/in/ninamaelouw/">
<FontAwesome className="fa-icon-footer" name='linkedin' size='2x'/>
</a>
</Col>
<Col s={3} m={2} l={2} className="footer-elem">
<a href="https://twitter.com/ninamaelouw">
<FontAwesome className="fa-icon-footer" name='twitter' size='2x'/>
</a>
</Col>
<Col s={3} m={2} l={2} className="footer-elem">
<a href="https://github.com/ninalouw">
<FontAwesome className="fa-icon-footer" name='github' size='2x'/>
</a>
</Col>
</Row>
</footer>
);
}
}
export default Footer;
|
src/modules/Input/components/SocketSettings/index.js
|
ruebel/synth-react-redux
|
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import styled from 'styled-components';
import Button from '../../../components/Button';
import ButtonGroup from '../../../components/ButtonGroup';
import Close from '../../../components/icons/Close';
import Gear from '../../../components/icons/Gear';
import H1 from '../../../components/typography/H1';
import InputGroup from '../../../components/InputGroup';
import JsonViewer from './JsonViewer';
import MinMax from '../../../components/MinMax';
import Modal from '../../../components/Modal';
import Refresh from '../../../components/icons/Refresh';
import Scale from './Scale';
import Select from '../../../components/Select';
import TextInput from '../../../components/TextInput';
import { getSocketPrevious, getSocketSettings } from '../../selectors';
const Actions = styled.div`
position: absolute;
top: 5px;
right: 5px;
`;
const Wrapper = styled.div`
width: 60vw;
flex: 1;
`;
class SocketSettings extends React.Component {
constructor(props) {
super(props);
this.state = {
hasChange: false,
options: [],
previous: props.settings,
raw: props.previous.raw,
settings: props.settings,
showRaw: false
};
this.handleChange = this.handleChange.bind(this);
this.handleClose = this.handleClose.bind(this);
this.handleSave = this.handleSave.bind(this);
this.hideRaw = this.hideRaw.bind(this);
this.refreshMessage = this.refreshMessage.bind(this);
}
componentWillReceiveProps(next) {
if (next.previous.raw && !this.state.raw) {
this.refreshMessage();
}
}
handleClose() {
if (this.state.hasChange) {
this.props.save(this.state.previous);
}
this.setState({
hasChange: false,
settings: this.state.previous
});
this.props.close();
}
handleChange(e, prop) {
this.setState({
hasChange: true,
settings: Object.assign(this.state.settings, {
[prop]: e.target ? e.target.value : e
}),
raw: prop === 'url' ? this.props.previous.raw : this.state.raw
});
}
handleSave() {
this.props.save(this.state.settings);
this.setState({
previous: this.state.settings
});
}
hideRaw() {
this.setState({
showRaw: false
});
}
refreshMessage() {
this.setState({
raw: this.props.previous.raw,
showRaw: true
});
}
render() {
const icon = (
<Gear fill="rgba(0, 0, 0, 0.3)" height="100vw" width="100vw" />
);
return this.props.show ? (
<Modal close={this.handleClose} icon={icon}>
<Wrapper>
<H1>Event Source Settings</H1>
<InputGroup label="Url" required require={this.state.url}>
<TextInput
change={e => this.handleChange(e, 'url')}
placeholder="Url"
required
value={this.state.settings.url}
/>
</InputGroup>
<JsonViewer data={this.state.raw} minimized={!this.state.showRaw}>
<Actions>
<Refresh click={this.refreshMessage} />
{this.state.showRaw && <Close click={this.hideRaw} />}
</Actions>
</JsonViewer>
<InputGroup label="Velocity Trigger">
<Select
labelKey="name"
onChange={e => this.handleChange(e.id, 'velocityScalar')}
options={Object.keys(this.state.raw || {}).map(k => ({
id: k,
name: k
}))}
searchable={false}
value={this.state.settings.velocityScalar}
valueKey="id"
/>
</InputGroup>
<InputGroup label="Scale">
<Scale
keys={this.state.settings.scale}
onChange={e => this.handleChange(e, 'scale')}
/>
</InputGroup>
<InputGroup label="Note Length">
<MinMax
max={5000}
min={0}
step={10}
onSet={e => this.handleChange(e, 'noteLength')}
value={this.state.settings.noteLength}
/>
</InputGroup>
<ButtonGroup>
<Button
active
click={this.handleClose}
text="Cancel"
type="danger"
/>
<Button
active={Boolean(this.state.hasChange)}
click={this.handleSave}
text="Save"
/>
</ButtonGroup>
</Wrapper>
</Modal>
) : null;
}
}
SocketSettings.propTypes = {
close: PropTypes.func.isRequired,
previous: PropTypes.object,
save: PropTypes.func.isRequired,
settings: PropTypes.object,
show: PropTypes.bool
};
const mapStateToProps = state => ({
previous: getSocketPrevious(state),
settings: getSocketSettings(state)
});
export default connect(mapStateToProps, null)(SocketSettings);
|
src/components/AppContent/index.js
|
currency-cop/currency-cop
|
import React from 'react'
class AppContent extends React.Component {
componentDidMount() {
this.screen = this.props.screenAction
}
componentDidUpdate() {
if (this.props.screenAction != this.screen) {
this._div.scrollTop = 0
this.screen = this.props.screenAction
}
}
render () {
let screen = this.props.screen
return (
<div className="layout-item content" ref={(ref) => this._div = ref}>
{ screen }
</div>
)
}
}
export default AppContent
|
src/components/Header/__tests__/index.js
|
henriquesosa/electron-intro
|
jest.unmock('./')
import React from 'react'
import ReactDOM from 'react-dom'
import TestUtils from 'react-addons-test-utils'
import Header from './'
describe('Header Component', () => {
it('shows a title', () => {
// const Header = TestUtils.renderIntoDocument(
// <Header />
// )
// const HeaderNode = ReactDOM.findDOMNode(Header)
// expect(HeaderNode.textContent).equals('Todos')
})
})
|
src/components/layout/Layout.js
|
gribnoysup/diy-dog-search
|
import React from 'react'
import styled from 'styled-components'
import {fontFamilyMonospace} from '../common/Typography'
export const Container = styled.div`
width: 100%;
height: 100%;
display: flex;
flex-direction: column;
`
Container.displayName = 'Container'
const HeaderDiv = styled.div`
color: #ffffff;
background-color: #000000;
display: flex;
align-items: center;
width: 100%;
min-height: 56px;
padding: 0 20px;
box-sizing: border-box;
justify-content: space-between;
& > *:first-child {
margin-left: 0;
}
& > *:last-child {
margin-right: 0;
}
${(props) => props.sticky ? `
position: fixed;
z-index: 999;
left: 0;
top: 0;
` : ''}
@media screen and (min-width: 48em) {
justify-content: flex-start;
}
`
export class Header extends React.Component {
static propTypes = {
sticky: React.PropTypes.bool
}
fixBody(node) {
document.body.style.paddingTop = this.getHeight(node) + 'px'
}
unfixBody() {
document.body.style.paddingTop = ''
}
getHeight(node) {
return node ? node.getBoundingClientRect().height : 0
}
handleRef(ref) {
if (this.props.sticky) {
ref ? this.fixBody(ref) : this.unfixBody()
}
}
render() {
const {children, sticky} = this.props
return (
<HeaderDiv
sticky={sticky}
innerRef={(ref) => this.handleRef(ref)}
>
{children}
</HeaderDiv>
)
}
}
export const Content = styled.div`
flex: 1 0 auto;
display: flex;
flex-direction: column;
padding: 0 20px;
margin: 20px auto;
width: 100%;
max-width: 760px;
box-sizing: border-box;
`
Content.displayName = 'Content'
export const Body = styled.div`
display: flex;
flex-direction: column;
width: 100%;
min-height: 100%;
`
Body.displayName = 'Body'
export const Footer = styled.div`
width: 100%;
box-sizing: border-box;
background-color: #000000;
color: #ffffff;
font-family: ${fontFamilyMonospace};
font-size: 12px;
font-weight: bold;
display: flex;
flex-direction: column;
align-items: center;
padding: 0 20px;
padding-bottom: 10px;
& a {
color: #ffffff;
&:visited {
color: #afafaf;
}
}
& p {
margin-top: 10px;
margin-bottom: 0;
text-align: center;
max-width: 410px;
}
@media screen and (min-width: 35.5em) {
padding-bottom: 20px;
& p {
margin-top: 20px;
}
}
`
Footer.displayName = 'Footer'
|
app/src/App.js
|
sfelderman/inverted-index
|
import React, { Component } from 'react';
import DragSubmit from './DragSubmit';
import SearchBar from './search/SearchBar';
import DisplaySearch from './display/DisplaySearch';
import styles from './App.css';
class App extends Component {
render() {
return (
<div style={styles}>
<DragSubmit />
<SearchBar />
<DisplaySearch />
</div>
);
}
}
export default App;
|
example/story.js
|
yangshun/react-storybook-addon-chapters
|
import { storiesOf } from '@storybook/react';
import React from 'react';
import Button from './Button';
storiesOf('Addon Chapters', module)
.addWithChapters(
'Story With Chapters',
{
useTheme: false,
subtitle: 'Display multiple components within one story!',
info: `
React Storybook Chapters addon allows showcasing of multiple components within a story by breaking it down into smaller categories (**Chapters**) and subcategories (**Sections**) for more organizational goodness.
This section is called **Story Info** and you can provide an abstract of your story here.
A story consists of multiple chapters and a chapter consists of multiple sections. Each section can render a block of code,
which typically used to showcase one component or a particular state of a component.
Yes, all info sections support markdown formatting!
`,
chapters: [
// List of chapters.
{
title: 'This is a Chapter\'s Title',
subtitle: 'And this is a chapter\'s subtitle',
info: `
Chapters can be used to group related components together, or show varying states of a component.
Each chapter comes with a **Chapter Title**, **Chapter Subtitle**, **Chapter Info** and a list of **Sections**.
Simply omit any of them to hide them from rendering.
`,
sections: [
// List of sections.
{
title: 'This is a Section\'s Title',
subtitle: 'Each section can be used to render a component',
info: `
Provide additional information about your section here.
Each section comes with a **Section Title**, **Section Subtitle**, **Section Info**.
Simply omit any of them to hide them from rendering. The section below does not have a subtitle nor info.
There's also the option of showing the source code and propTypes of the component.
`,
sectionFn: () => (<Button label="My Button" onClick={() => { alert('Hello World!'); }} />),
options: {
showSource: false,
allowSourceToggling: true,
showPropTables: true,
allowPropTablesToggling: true,
},
},
{
title: 'Here\'s another section, but without subtitle and info',
sectionFn: () => (<Button label="My Disabled Button" disabled onClick={() => { }} />),
},
],
},
{
title: 'Usage',
info: `
Install the following npm module:
~~~
npm install --save-dev react-storybook-addon-chapters
~~~
Then set the addon in the place you configure storybook like this:
~~~
import React from 'react';
import { configure, setAddon } from '@storybook/react';
import chaptersAddon from 'react-storybook-addon-chapters';
setAddon(chaptersAddon);
configure(function () {
...
}, module);
~~~
Then create your stories with the **.addWithChapters** API.
~~~
import React from 'react';
import Button from './Button';
import { storiesOf } from '@storybook/react';
storiesOf('Addon Chapters')
.addWithChapters(
'Story With Chapters',
{
subtitle: <Optional story subtitle>,
info: <Optional story info>,
chapters: [
// List of chapters.
{
title: <Optional chapter title>,
subtitle: <Optional chapter subtitle>,
info: <Optional chapter info>,
sections: [
// List of sections.
{
title: <Optional section title>,
subtitle: <Optional section subtitle>,
info: <Optional section info>,
sectionFn: () => (<Button>My Button</Button>),
options: {
showSource: true,
allowSourceToggling: true,
showPropTables: true,
allowPropTablesToggling: true,
},
},
...
],
},
...
]
}
);
~~~
`,
},
],
}
)
.addWithChapters(
'Story Without Chapters',
{
info: `
If you don't require displaying of the chapter information, simply use only one chapter with your list of sections and omit the chapter-related parameters.
You'll end up with just a list of rendered sections. Refer to the example in **example/story.js**.
`,
chapters: [
{
sections: [
{
title: 'Section Title',
subtitle: 'Section Subtitle',
info: `
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
`,
sectionFn: () => (<Button label="My Button" onClick={() => { }} />),
},
{
title: 'Section Title Again',
subtitle: 'Section Subtitle Again',
sectionFn: () => (<Button label="My Button Again" onClick={() => { }} />),
},
],
},
],
}
);
const decorator = story => (
<div
style={{
backgroundColor: 'rgba(0, 0, 0, 0.1)',
display: 'inline-block',
padding: '10px',
}}
>
{story()}
</div>
);
storiesOf('Addon Chapters', module)
.addWithChapters(
'Story With Decorators',
{
info: `
If you don't require displaying of the chapter information, simply use only one chapter with your list of sections and omit the chapter-related parameters.
You'll end up with just a list of rendered sections. Refer to the example in **example/story.js**.
`,
chapters: [
{
sections: [
{
title: 'Section Title',
subtitle: 'Section Subtitle',
info: `
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
`,
sectionFn: () => (<Button label="My Button" onClick={() => { }} />),
options: {
decorator,
},
},
{
title: 'Section Title Again',
subtitle: 'Section Subtitle Again',
sectionFn: () => (<Button label="My Button Again" onClick={() => { }} />),
options: {
decorator,
},
},
],
},
],
}
);
|
source/components/DataHandler/DataHandler.js
|
cloud-walker/react-inspect
|
import React from 'react'
import is from 'ramda/src/is'
import pipe from 'ramda/src/pipe'
import addIndex from 'ramda/src/addIndex'
import map from 'ramda/src/map'
import keys from 'ramda/src/keys'
import stripFunction from '../../utils/stripFunction'
import Level from '../Level'
import Punctuation from '../Punctuation'
import Key from '../Key'
import Value from '../Value'
import CollapseHandler from '../CollapseHandler'
const Component = class extends React.Component {
static displayName = 'ReactInspectDataHandler'
static defaultProps = {
outer: false,
}
render() {
const {data, outer, theme} = this.props
if (is(String)(data)) {
return <Value type="string" theme={theme}>{`"${data}"`}</Value>
}
if (is(Number)(data)) {
return <Value type="number" theme={theme}>{`${data}`}</Value>
}
if (is(Function)(data)) {
const value = (
<Value type="function" theme={theme}>
{stripFunction(String(data))}
</Value>
)
if (outer) {
return value
}
return (
<CollapseHandler>
{show =>
show
? value
: {...value, props: {...value.props, children: 'fn'}}}
</CollapseHandler>
)
}
if (is(Array)(data)) {
const value = addIndex(map)((x, i) => (
<Level key={i}>
<Component data={x} theme={theme} />
</Level>
))(data)
return (
<span>
<Punctuation theme={theme}>{'['}</Punctuation>
{outer ? (
value
) : (
<CollapseHandler>
{show =>
show ? (
value
) : (
<Punctuation theme={theme}>...</Punctuation>
)}
</CollapseHandler>
)}
<Punctuation theme={theme}>{']'}</Punctuation>
</span>
)
}
if (is(Object)(data)) {
const value = pipe(
keys,
map(x => (
<Level key={x}>
<Key theme={theme}>{x}</Key>
<Punctuation theme={theme}>:</Punctuation>{' '}
<Component data={data[x]} theme={theme} />
</Level>
)),
)(data)
return (
<span>
<Punctuation theme={theme}>{'{'}</Punctuation>
{outer ? (
value
) : (
<CollapseHandler>
{show =>
show ? (
value
) : (
<Punctuation theme={theme}>...</Punctuation>
)}
</CollapseHandler>
)}
<Punctuation theme={theme}>{'}'}</Punctuation>
</span>
)
}
return <Value type="keyword" theme={theme}>{`${data}`}</Value>
}
}
export default Component
|
fluent-react/examples/async-messages/src/index.js
|
zbraniecki/fluent.js
|
import React from 'react';
import ReactDOM from 'react-dom';
import { AppLocalizationProvider } from './l10n';
import App from './App';
ReactDOM.render(
<AppLocalizationProvider userLocales={navigator.languages}>
<App />
</AppLocalizationProvider>,
document.getElementById('root')
);
|
src/svg-icons/hardware/keyboard-tab.js
|
ruifortes/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let HardwareKeyboardTab = (props) => (
<SvgIcon {...props}>
<path d="M11.59 7.41L15.17 11H1v2h14.17l-3.59 3.59L13 18l6-6-6-6-1.41 1.41zM20 6v12h2V6h-2z"/>
</SvgIcon>
);
HardwareKeyboardTab = pure(HardwareKeyboardTab);
HardwareKeyboardTab.displayName = 'HardwareKeyboardTab';
HardwareKeyboardTab.muiName = 'SvgIcon';
export default HardwareKeyboardTab;
|
src/components/Svg/Expand.js
|
bibleexchange/be-front-new
|
import React from 'react';
class Expand extends React.Component {
render() {
return (
<svg className='expand' x='0' y='0' viewBox='0, 0,250, 250'>
<g
transform="translate(1.05932,1.0593224)">
<path
d="M 15.217893,234.60694 12.5,231.71388 l 0,-82.10694 C 12.5,69.166666 12.550746,67.449254 15,65 c 2.303515,-2.303515 4.166666,-2.5 23.70602,-2.5 19.686451,0 21.298744,-0.173255 22.5,-2.417824 C 61.943967,58.70331 62.5,49.034899 62.5,37.582176 62.5,19.166666 62.707481,17.292519 65,15 c 2.449439,-2.449439 4.166666,-2.5 84.90927,-2.5 l 82.40928,0 2.59072,3.293574 c 2.56095,3.255722 2.59073,4.232552 2.59073,84.999996 0,80.03977 -0.051,81.75743 -2.5,84.20643 -2.30159,2.30159 -4.16666,2.5 -23.5,2.5 -14.66666,0 -21.45238,0.45237 -22.5,1.5 -1.04763,1.04762 -1.5,7.83334 -1.5,22.5 0,19.33334 -0.19841,21.19841 -2.5,23.5 -2.44936,2.44936 -4.16666,2.5 -84.78211,2.5 l -82.282105,0 -2.717893,-2.89306 z M 170.49126,218.02276 C 171.92861,214.2771 171.3232,190.5732 169.75,189 c -1.11725,-1.11725 -14.40869,-1.5 -52.08907,-1.5 -45.319516,0 -50.82719,-0.21549 -52.875004,-2.06874 C 62.644097,183.49294 62.5,180.21771 62.5,133.47409 62.5,101.47516 62.035991,82.718639 61.20602,81.167824 60.054249,79.015717 58.48568,78.75 46.933255,78.75 39.794922,78.75 33.064714,79.091431 31.977234,79.508736 30.206889,80.188081 30,87.577954 30,150.13374 L 30,220 l 69.866264,0 c 62.555786,0 69.945646,-0.20689 70.624996,-1.97724 z m 47.5315,-47.5315 C 219.79311,169.81191 220,162.42205 220,99.866264 L 220,30 150.13374,30 C 87.577954,30 80.188081,30.206889 79.508736,31.977234 79.091431,33.064714 78.75,64.170964 78.75,101.10223 c 0,50.55938 0.370565,67.51833 1.5,68.64777 1.129435,1.12944 18.088392,1.5 68.64776,1.5 36.93128,0 68.03753,-0.34143 69.125,-0.75874 z M 103.31874,146.46407 c -1.13781,-1.25726 -2.06874,-3.92522 -2.06874,-5.92881 0,-3.09746 4.90752,-8.55305 32.77684,-36.43724 21.62741,-21.638971 32.35593,-33.215242 31.5395,-34.031677 -0.68053,-0.68053 -8.47999,-1.39573 -17.33213,-1.589335 -15.83146,-0.346248 -16.13577,-0.406949 -18.59914,-3.709898 -2.20335,-2.954322 -2.31408,-3.817156 -0.92147,-7.179232 2.38151,-5.749469 7.47775,-6.579084 37.55899,-6.114219 23.45461,0.36246 26.22522,0.63203 28.599,2.782576 2.53362,2.295364 2.62841,3.475408 2.62841,32.723214 0,25.356991 -0.30926,30.651251 -1.8824,32.224381 -3.35229,3.35228 -6.93699,3.7323 -10.45531,1.10838 -3.2153,-2.39793 -3.295,-2.80407 -3.6393,-18.54642 -0.1936,-8.852144 -0.9088,-16.651602 -1.58933,-17.332132 -0.81644,-0.816435 -12.39271,9.912095 -34.03167,31.539512 -28.72864,28.71328 -33.27291,32.77683 -36.65444,32.77683 -2.15209,0 -4.77544,-1.01146 -5.92881,-2.28593 z"
id="path3359"
/>
</g>
</svg>
);
}
}
module.exports = Expand;
|
app/components/FunctionTestForm/requestBodyBuilder.js
|
fission/fission-ui
|
/**
*
* RequestBodyBuilder
*
*/
import React from 'react';
import AceEditor from 'react-ace';
import 'brace/mode/json';
import 'brace/mode/xml';
import 'brace/mode/plain_text';
import 'brace/theme/monokai';
class RequestBodyBuilder extends React.Component { // eslint-disable-line react/prefer-stateless-function
render() {
const { bodytype, content, onSelectType, onContentChange } = this.props;
return (
<div>
<select className="form-control" name="bodytype" value={bodytype} onChange={onSelectType}>
<option value="plain_text">Text</option>
<option value="json">Json</option>
<option value="xml">Xml</option>
</select>
<AceEditor
mode={bodytype}
theme="monokai"
name="RequestBodyForm"
value={content}
editorProps={{ $blockScrolling: true }}
onChange={onContentChange}
height="150px"
width="100%"
/>
</div>
);
}
}
RequestBodyBuilder.propTypes = {
bodytype: React.PropTypes.string.isRequired,
content: React.PropTypes.string.isRequired,
onSelectType: React.PropTypes.func.isRequired,
onContentChange: React.PropTypes.func.isRequired,
};
export default RequestBodyBuilder;
|
src/views/AboutView.js
|
dapplab/babel-client
|
import React from 'react';
import { Link } from 'react-router';
const AboutView = () => (
<div className='container text-center'>
<h1>This is the about view!</h1>
<hr />
<Link to='/'>Back To Home View</Link>
</div>
);
export default AboutView;
|
src/LearnWordsFast/Client/js/components/ChangeLanguages.js
|
drussilla/LearnWordsFast
|
import React from 'react';
import Reflux from 'reflux';
import _ from 'lodash';
import {Input, Button, Panel} from 'react-bootstrap';
import {UserSettingsStore, UserSettingsActions} from '../stores/UserSettingsStore';
import {LanguagesStore, LanguagesActions} from '../stores/LanguagesStore';
const ChangeLanguages = React.createClass({
mixins: [
Reflux.listenTo(UserSettingsStore, 'onUserSettingsLoad'),
Reflux.listenTo(LanguagesStore, 'onLanguagesLoad')
],
getInitialState() {
let {userInfo} = UserSettingsStore;
let {mainLanguage, trainingLanguage, additionalLanguages} = userInfo || {};
let {languages} = LanguagesStore;
return {
userInfo,
languages,
mainLanguage,
trainingLanguage,
additionalLanguages
}
},
componentDidMount() {
UserSettingsActions.getInfo();
LanguagesActions.getAll();
},
onUserSettingsLoad(data) {
let {userInfo} = data;
let {mainLanguage, trainingLanguage, additionalLanguages} = userInfo || {};
this.setState({
userInfo,
mainLanguage,
trainingLanguage,
additionalLanguages
});
},
onLanguagesLoad(languages) {
this.setState({
languages
});
},
createLanguagesOptions(type) {
if (this.state.languages) {
return this.state.languages.filter(language => {
if (type === 'main') {
return !_.contains(this.state.additionalLanguages, language.id)
&& language.id !== this.state.trainingLanguage;
} else {
return !_.contains(this.state.additionalLanguages, language.id)
&& language.id !== this.state.mainLanguage;
}
}).map(language => {
return <option value={language.id} key={language.id}>{language.name}</option>;
});
}
},
selectTrainingLanguage(e) {
var value = e.target.value;
this.setState({
errors: null,
trainingLanguage: value
});
},
selectMainLanguage(e) {
var value = e.target.value;
this.setState({
errors: null,
mainLanguage: value
})
},
selectAdditionalLanguage(id, e) {
var additionalLanguages = _.clone(this.state.additionalLanguages);
var errors = null;
if (e.target.checked) {
if (additionalLanguages.length < 5) {
additionalLanguages.push(id);
} else {
errors = ["Don't select more than 5 languages as additional"]
}
} else {
additionalLanguages = additionalLanguages.filter(language => language !== id);
}
this.setState({
errors: errors,
additionalLanguages: additionalLanguages
});
},
createCheckboxesForAdditionalLanguages() {
if (this.state.languages) {
return this.state.languages.filter(language => {
return language.id !== this.state.mainLanguage
&& language.id !== this.state.trainingLanguage;
}).map(language => {
return <Input type="checkbox" label={language.name}
key={language.id}
checked={_.contains(this.state.additionalLanguages, language.id)}
onChange={this.selectAdditionalLanguage.bind(null, language.id)}/>
});
}
},
changeLanguages() {
let {trainingLanguage, mainLanguage, additionalLanguages} = this.state;
UserSettingsActions.changeLanguages({trainingLanguage, mainLanguage, additionalLanguages})
},
render() {
if(!this.state.languages) {
return (<div>Loading...</div>);
}
let errors = this.state.errors
&& this.state.errors.map((error, i) => <div bsStySle="error" key={'error-' + i}>
{error}
</div>);
return (
<div>
<Input type="select"
label="Training language"
placeholder="select"
value={this.state.trainingLanguage}
onChange={this.selectTrainingLanguage}>
{this.createLanguagesOptions.call(null, 'training')}
</Input>
<Input type="select"
label="Main language"
placeholder="select"
value={this.state.mainLanguage}
onChange={this.selectMainLanguage}>
{this.createLanguagesOptions.call(null, 'main')}
</Input>
<label>Additional Languages</label>
{this.createCheckboxesForAdditionalLanguages()}
<Button bsStyle="primary"
onClick={this.changeLanguages}>Change Languages</Button>
{errors ?
<Panel header="Errors" className="validation-errors" bsStyle="danger">
{errors}
</Panel> : null}
</div>
);
}
});
export default ChangeLanguages;
|
app/components/TemplateItemComponent.js
|
okmttdhr/pull-request-templates
|
import React from 'react';
import { Link } from 'react-router'
import classNames from 'classnames'
import TemplateActions from '../actions/TemplateActions'
class TemplateItemComponent extends React.Component {
static propTypes = {
template: React.PropTypes.object.isRequired
};
static defaultProps = {};
constructor(props) {
super(props);
this.state = {};
}
componentDidMount() {
// ...
}
componentWillUnmount() {
// ...
}
shouldComponentUpdate() {
return true;
}
updateTemplate() {
TemplateActions.updateSelected(this.props.template.id);
}
render() {
var template = this.props.template;
var classes = classNames({
'active': template.selected
});
return (
<li className={classes}>
<p onClick={this.updateTemplate.bind(this)}>{template.name}</p>
</li>
);
}
}
export default TemplateItemComponent;
|
examples/05 Customize/Handles and Previews/Container.js
|
arnif/react-dnd
|
import React, { Component } from 'react';
import { DragDropContext } from 'react-dnd';
import HTML5Backend from 'react-dnd/modules/backends/HTML5';
import BoxWithImage from './BoxWithImage';
import BoxWithHandle from './BoxWithHandle';
@DragDropContext(HTML5Backend)
export default class Container extends Component {
render() {
return (
<div>
<div style={{ marginTop: '1.5rem' }}>
<BoxWithHandle />
<BoxWithImage />
</div>
</div>
);
}
}
|
app/javascript/mastodon/features/compose/components/warning.js
|
theoria24/mastodon
|
import React from 'react';
import PropTypes from 'prop-types';
import Motion from '../../ui/util/optional_motion';
import spring from 'react-motion/lib/spring';
export default class Warning extends React.PureComponent {
static propTypes = {
message: PropTypes.node.isRequired,
};
render () {
const { message } = this.props;
return (
<Motion defaultStyle={{ opacity: 0, scaleX: 0.85, scaleY: 0.75 }} style={{ opacity: spring(1, { damping: 35, stiffness: 400 }), scaleX: spring(1, { damping: 35, stiffness: 400 }), scaleY: spring(1, { damping: 35, stiffness: 400 }) }}>
{({ opacity, scaleX, scaleY }) => (
<div className='compose-form__warning' style={{ opacity: opacity, transform: `scale(${scaleX}, ${scaleY})` }}>
{message}
</div>
)}
</Motion>
);
}
}
|
src/parser/deathknight/blood/modules/core/DeathsCaress.js
|
FaideWW/WoWAnalyzer
|
import React from 'react';
import Analyzer from 'parser/core/Analyzer';
import SPELLS from 'common/SPELLS/index';
import SpellLink from 'common/SpellLink';
import { formatPercentage } from 'common/format';
import SpellUsable from 'parser/shared/modules/SpellUsable';
const RANGE_WHERE_YOU_SHOULDNT_DC = 12; // yrd
class DeathsCaress extends Analyzer {
static dependencies = {
spellUsable: SpellUsable,
};
dcCasts = 0;
cast = [];
spellsThatShouldBeUsedFirst = [
SPELLS.DEATH_AND_DECAY.id,
];
constructor(...args) {
super(...args);
if(this.selectedCombatant.hasTalent(SPELLS.BLOODDRINKER_TALENT.id)) {
this.spellsThatShouldBeUsedFirst.push(SPELLS.BLOODDRINKER_TALENT.id);
}
}
on_byPlayer_cast(event) {
if (event.ability.guid !== SPELLS.DEATHS_CARESS.id) {
return;
}
const hadAnotherRangedSpell = this.spellsThatShouldBeUsedFirst.some(e => this.spellUsable.isAvailable(e));
this.dcCasts += 1;
this.cast.push({
timestamp: event.timestamp,
hadAnotherRangedSpell: hadAnotherRangedSpell,
playerPosition: {
x: event.x,
y: event.y,
},
enemyPosition: {
x: 0,
y: 0,
},
});
}
on_byPlayer_damage(event) {
if (event.ability.guid !== SPELLS.DEATHS_CARESS.id || this.cast.length === 0) {
return;
}
this.cast[this.cast.length - 1].enemyPosition = {
x: event.x,
y: event.y,
};
}
calculateDistance(x1, y1, x2, y2) {
return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) / 100;
}
get badDcCasts() {
let badCasts = 0;
this.cast.forEach(e => {
//only happens when the target died before the damage event occurs
if (e.enemyPosition.x === 0 && e.enemyPosition.y === 0) {
return;
}
const distance = this.calculateDistance(e.enemyPosition.x, e.enemyPosition.y, e.playerPosition.x, e.playerPosition.y);
if (distance <= RANGE_WHERE_YOU_SHOULDNT_DC || e.hadAnotherRangedSpell) { // close to melee-range => bad || when another ranged spell was available
badCasts += 1;
}
});
return badCasts;
}
get averageCastSuggestionThresholds() {
return {
actual: 1 - (this.badDcCasts / this.dcCasts),
isLessThan: {
minor: 1,
average: .95,
major: .9,
},
style: 'percentage',
};
}
suggestions(when) {
when(this.averageCastSuggestionThresholds)
.addSuggestion((suggest, actual, recommended) => {
return suggest(<>Avoid casting <SpellLink id={SPELLS.DEATHS_CARESS.id} /> unless you're out of melee range and about to cap your runes while <SpellLink id={SPELLS.DEATH_AND_DECAY.id} /> and <SpellLink id={SPELLS.BLOODDRINKER_TALENT.id} /> are on cooldown. Dump runes primarily with <SpellLink id={SPELLS.HEART_STRIKE.id} />.</>)
.icon(SPELLS.DEATHS_CARESS.icon)
.actual(`${formatPercentage(this.badDcCasts / this.dcCasts)}% bad ${SPELLS.DEATHS_CARESS.name} casts`)
.recommended(`0% are recommended`);
});
}
}
export default DeathsCaress;
|
frontend/app/index.js
|
briancappello/flask-react-spa
|
import 'babel-polyfill'
// this must come before everything else otherwise style cascading doesn't work as expected
import 'main.scss'
import { AppContainer as HotReloadContainer } from 'react-hot-loader'
import React from 'react'
import ReactDOM from 'react-dom'
import createBrowserHistory from 'history/createBrowserHistory'
import configureStore from 'configureStore'
import App from 'components/App'
import { login } from 'security/actions'
import { flashInfo } from 'site/actions'
import SecurityApi from 'security/api'
import { storage } from 'utils'
const APP_MOUNT_POINT = document.getElementById('app')
const initialState = {}
const history = createBrowserHistory()
const store = configureStore(initialState, history)
const renderRootComponent = (Component) => {
ReactDOM.render(
<HotReloadContainer>
<Component store={store} history={history} />
</HotReloadContainer>,
APP_MOUNT_POINT
)
}
const token = storage.getToken()
store.dispatch(login.request())
SecurityApi.checkAuthToken(token)
.then(({ user }) => {
store.dispatch(login.success({ token, user }))
})
.catch(() => {
store.dispatch(login.failure())
})
.then(() => {
store.dispatch(login.fulfill())
renderRootComponent(App)
const isAuthenticated = store.getState().security.isAuthenticated
const alreadyHasFlash = store.getState().flash.visible
if (isAuthenticated && !alreadyHasFlash) {
store.dispatch(flashInfo('Welcome back!'))
}
})
if (module.hot) {
module.hot.accept('./components/App', () => {
ReactDOM.unmountComponentAtNode(APP_MOUNT_POINT)
const NextApp = require('./components/App').default
renderRootComponent(NextApp)
})
}
|
examples/js/column/column-align-table.js
|
neelvadgama-hailo/react-bootstrap-table
|
/* eslint max-len: 0 */
import React from 'react';
import { BootstrapTable, TableHeaderColumn } from 'react-bootstrap-table';
const products = [];
function addProducts(quantity) {
const startId = products.length;
for (let i = 0; i < quantity; i++) {
const id = startId + i;
products.push({
id: id,
name: 'Item name ' + id,
price: 2100 + i
});
}
}
addProducts(5);
export default class ColumnAlignTable extends React.Component {
render() {
return (
<BootstrapTable data={ products }>
<TableHeaderColumn dataField='id' isKey={ true } dataAlign='center'>Product ID</TableHeaderColumn>
<TableHeaderColumn dataField='name' headerAlign='right'>Product Name</TableHeaderColumn>
<TableHeaderColumn dataField='price' headerAlign='center' dataAlign='right'>Product Price</TableHeaderColumn>
</BootstrapTable>
);
}
}
|
src/components/header/Palette.js
|
numb86/image-editor
|
// @flow
import React from 'react';
import {DRAW_LINE} from '../actionLayer/ActionLayer';
import type {ActionLayerName} from '../actionLayer/ActionLayer';
import type {ChangeableActionLayerSettings} from '../../state/generateActionLayerSettings';
const COLOR_LIST = [
'#000', // 黒
'#fff', // 白
'#f00', // 赤
'#f90', // オレンジ
'#ff3', // 黄色
'#60f', // 青
'#9ff', // 水色
'#f0f', // 紫
'#6f0', // 緑
'#960', // 茶色
];
export default function Palette({
updateActionLayerSettings,
}: {
updateActionLayerSettings: (
target: ActionLayerName,
data: ChangeableActionLayerSettings
) => void,
}) {
function update(color) {
updateActionLayerSettings(DRAW_LINE, {strokeStyle: color});
}
// TODO: Fragments を使う
return (
<span className="palette">
{COLOR_LIST.map(color => (
<button
key={color}
style={{backgroundColor: color}}
onClick={() => {
update(color);
}}
/>
))}
</span>
);
}
|
frontend/src/components/submitcast/CastRoleInput.js
|
tdv-casts/website
|
// @flow
import React from 'react';
import PropTypes from 'prop-types';
import { Card, CardHeader, CardText, CardActions } from 'material-ui/Card';
import Chip from 'material-ui/Chip';
import FlatButton from 'material-ui/FlatButton';
import FastForward from 'material-ui/svg-icons/av/fast-forward';
import Done from 'material-ui/svg-icons/action/done';
import CastRoleAutoComplete from './CastRoleAutoComplete';
const rolesWithMultipleActors = [
'Tanzsolisten',
'Gesangssolisten',
'Tanzensemble',
'Gesangsensemble',
];
const maleRoles = [
'Graf von Krolock',
'Professor Abronsius',
'Alfred',
'Chagal',
'Herbert',
'Koukol',
];
class CastRoleInput extends React.Component {
static propTypes = {
role: PropTypes.string.isRequired,
dataSource: PropTypes.array.isRequired,
onFinish: PropTypes.func.isRequired,
cardStyle: PropTypes.object,
};
static defaultProps = {
cardStyle: {},
};
state = {
actors: [],
};
componentWillReceiveProps(nextProps) {
if (this.props.role !== nextProps.role) {
this.setState({ actors: [] });
}
};
doesAllowMultipleActors() {
const { role } = this.props;
return rolesWithMultipleActors.includes(role);
};
getFilteredDataSource() {
const { dataSource } = this.props;
const { actors } = this.state;
const alreadyListedNames = actors.map(person => person.name);
return dataSource.filter(person => !alreadyListedNames.includes(person.name));
};
toChipKey(person) {
const { role } = this.props;
return `chip-${role}-${person.id}`;
};
fireOnFinish = () => {
const { actors } = this.state;
this.props.onFinish(actors);
};
handleAutoCompletion = person => {
if (this.doesAllowMultipleActors()) {
this.setState({actors: this.state.actors.concat(person)});
} else {
this.setState({actors: [person]}, this.fireOnFinish);
}
};
handleUpdate = (searchText, dataSource, params) => {
if (!this.doesAllowMultipleActors()) {
this.setState({ actors: [] });
}
};
handleRemoveChip = key => {
const {actors} = this.state;
const filtered = actors.filter(actor => this.toChipKey(actor) !== key);
this.setState({ actors: filtered });
this.focus();
};
focus() {
if (this.input) {
this.input.focus();
}
};
getHeaderSubtitle() {
if (this.doesAllowMultipleActors()) {
return 'Welche DarstellerInnen haben diese Rolle gespielt?';
}
if (maleRoles.includes(this.props.role)) {
return 'Welcher Darsteller hat diese Rolle gespielt?';
}
return 'Welche Darstellerin hat diese Rolle gespielt?';
};
renderHeader() {
const { role } = this.props;
return (
<CardHeader
title={role}
subtitle={this.getHeaderSubtitle()}
expandable={false}
/>
);
};
renderInput() {
const { role } = this.props;
if (!this.doesAllowMultipleActors() && this.state.actors.length > 0) {
return null;
}
return (
<CastRoleAutoComplete
role={role}
allowsMultipleEntries={this.doesAllowMultipleActors()}
dataSource={this.getFilteredDataSource()}
onSubmit={this.handleAutoCompletion}
onUpdate={this.handleUpdate}
ref={element => this.input = element}
/>
);
};
renderChips() {
const { actors } = this.state;
if (actors.length === 0 || !this.doesAllowMultipleActors()) {
return null;
}
const chips = actors.map(actor => {
const key = this.toChipKey(actor);
return (
<Chip
key={key}
onRequestDelete={() => this.handleRemoveChip(key)}
>
{actor.name}
</Chip>
);
});
const style = {
display: 'flex',
flexWrap: 'wrap',
marginTop: '1em',
};
return (
<div style={style}>
{chips}
</div>
);
};
renderActions() {
const isSkip = this.state.actors.length === 0;
const label = isSkip
? 'Überspringen'
: 'Weiter';
const icon = isSkip
? (<FastForward />)
: (<Done />);
return (
<CardActions>
<FlatButton
label={label}
onTouchTap={this.fireOnFinish}
icon={icon}
/>
</CardActions>
);
};
// TODO FIXME Display green / icon when name is entered and "Next" can be clicked.
render() {
const { cardStyle } = this.props;
return (
<Card style={cardStyle}>
{this.renderHeader()}
<CardText>
{this.renderInput()}
{this.renderChips()}
</CardText>
{this.renderActions()}
</Card>
);
};
}
export default CastRoleInput;
|
packages/veritone-widgets/src/widgets/EngineSelection/EngineListView/EngineListContainer/EngineSelectionRow/index.js
|
veritone/veritone-sdk
|
import React from 'react';
import { connect } from 'react-redux';
import { bool, object, func, string, shape, any } from 'prop-types';
import { get } from 'lodash';
import { Lozenge, Truncate } from 'veritone-react-common';
import { modules } from 'veritone-redux-common';
const { engine: engineModule } = modules;
import Checkbox from '@material-ui/core/Checkbox';
import { withStyles } from '@material-ui/styles';
import networkIsolatedLogo from '../../../images/networkisolated_logo.png';
import externalAccessLogo from '../../../images/externalaccess_logo.png';
import externalProcessingLogo from '../../../images/externalprocessing_logo.png';
import humanReviewLogo from '../../../images/humanreview_logo.png';
import * as engineSelectionModule from '../../../../../redux/modules/engineSelection';
import ToggleButton from '../../../ToggleButton/';
import styles from './styles';
@withStyles(styles)
@connect(
(state, ownProps) => ({
isSelected: engineSelectionModule.engineIsSelected(
state,
ownProps.engineId,
ownProps.id
),
engine: engineModule.getEngine(state, ownProps.engineId),
isChecked: engineSelectionModule.engineIsChecked(
state,
ownProps.engineId,
ownProps.id
)
}),
{
selectEngines: engineSelectionModule.selectEngines,
deselectEngines: engineSelectionModule.deselectEngines,
checkEngine: engineSelectionModule.checkEngine,
uncheckEngine: engineSelectionModule.uncheckEngine
}
)
export default class EngineSelectionRow extends React.Component {
static propTypes = {
id: string.isRequired,
engine: shape({
id: string.isRequired,
name: string.isRequired,
category: object,
description: string,
iconPath: string,
ownerOrganization: object
}).isRequired,
isSelected: bool.isRequired,
isChecked: bool.isRequired,
onViewDetail: func.isRequired,
selectEngines: func.isRequired,
deselectEngines: func.isRequired,
checkEngine: func.isRequired,
uncheckEngine: func.isRequired,
classes: shape({ any }),
};
handleChange = () => {
this.props.isChecked
? this.props.uncheckEngine(this.props.id, this.props.engine.id)
: this.props.checkEngine(this.props.id, this.props.engine.id);
};
handleClick = () => {
this.props.onViewDetail(this.props.engine);
};
render() {
const { classes } = this.props;
const { name, iconClass, color } = this.props.engine.category || {};
const deploymentModelLogo = {
FullyNetworkIsolated: networkIsolatedLogo,
MostlyNetworkIsolated: externalAccessLogo,
NonNetworkIsolated: externalProcessingLogo,
HumanReview: humanReviewLogo
};
return (
<div className={classes.row}>
<div className={classes.avatar}>
{this.props.engine.iconPath ? (
<img className={classes.icon} src={this.props.engine.iconPath} />
) : (
<i className="icon-engines" />
)}
<div className={classes.engineSelect}>
<Checkbox
color="primary"
onChange={this.handleChange}
checked={this.props.isChecked}
/>
</div>
</div>
<div className={classes.container}>
<div className={classes.primary}>
<div className={classes.main}>
<div className={classes.headings}>
<div className={classes.title} onClick={this.handleClick}>
{this.props.engine.name}
</div>
<div className={classes.orgName}>
{get(this.props, 'engine.ownerOrganization.name')}
</div>
</div>
</div>
<div className={classes.info}>
{name && (
<Lozenge iconClassName={iconClass} backgroundColor={color}>
{name}
</Lozenge>
)}
</div>
<div className={classes.description}>
{this.props.engine.description && (
<Truncate clamp={3}>{this.props.engine.description}</Truncate>
)}
</div>
</div>
<div className={classes.secondary}>
<div className={classes.logos}>
<div className={classes.logo}>
<img
className={classes.icon}
src={deploymentModelLogo[this.props.engine.deploymentModel]}
/>
</div>
</div>
<div>
<ToggleButton
id={this.props.id}
onAdd={this.props.selectEngines}
onRemove={this.props.deselectEngines}
engineId={this.props.engine.id}
isSelected={this.props.isSelected}
/>
</div>
</div>
</div>
</div>
);
}
}
|
packages/cockpit/ui/src/components/Layout.js
|
iurimatias/embark-framework
|
import React from 'react';
import {NavLink as RNavLink} from 'react-router-dom';
import {Link, withRouter} from 'react-router-dom';
import PropTypes from 'prop-types';
import {connect} from 'react-redux';
import {
UncontrolledTooltip,
DropdownItem,
DropdownMenu,
DropdownToggle,
Nav,
NavItem,
NavLink,
Container,
Alert
} from 'reactstrap';
import {explorerSearch} from "../actions";
import {LIGHT_THEME, DARK_THEME} from '../constants';
import FontAwesome from 'react-fontawesome';
import "./Layout.css";
import {
AppHeader,
AppSidebar,
AppSidebarFooter,
AppSidebarForm,
AppSidebarHeader,
AppSidebarMinimizer,
AppSidebarNav,
AppNavbarBrand,
AppHeaderDropdown
} from '@coreui/react';
import {searchResult} from "../reducers/selectors";
import SearchBar from './SearchBar';
import logo from '../images/logo-brand-new.png';
import './Layout.css';
const HEADER_NAV_ITEMS = [
{name: "Dashboard", to: "/", icon: 'tachometer'},
{name: "Deployment", to: "/deployment", icon: "arrow-up"},
{name: "Explorer", to: "/explorer/overview", base: "explorer/", icon: "compass"},
{name: "Editor", to: "/editor", icon: "codepen"},
{name: "Utils", to: "/utilities/converter", base: "utilities/", icon: "cog"}
];
const SIDEBAR_NAV_ITEMS = {
"/explorer" : {items: [
{url: "/explorer/overview", icon: "fa fa-signal", name: "Overview"},
{url: "/explorer/accounts", icon: "fa fa-users", name: "Accounts"},
{url: "/explorer/blocks", icon: "fa fa-stop", name: "Blocks"},
{url: "/explorer/contracts", icon: "fa fa-file-code-o", name: "Contracts"},
{url: "/explorer/transactions", icon: "fa fa-exchange", name: "Transactions"}
]},
"/utilities/": {items: [
{url: "/utilities/converter", icon: "fa fa-plug", name: "Converter"},
{url: "/utilities/communication", icon: "fa fa-phone", name: "Communication"},
{url: "/utilities/ens", icon: "fa fa-circle", name: "ENS"},
{url: "/utilities/sign-and-verify", icon: "fa fa-edit", name: "Sign & Verify"},
{url: "/utilities/transaction-decoder", icon: "fa fa-edit", name: "Transaction Decoder"}
]}
};
const removeCssClasses = () => {
document.body.classList.remove('sidebar-fixed');
document.body.classList.remove('sidebar-lg-show');
};
const getSidebar = (location) => {
const currentItem = Object.keys(SIDEBAR_NAV_ITEMS).find(path => location.pathname.startsWith(path));
return currentItem && SIDEBAR_NAV_ITEMS[currentItem];
};
class Layout extends React.Component {
constructor(props) {
super(props);
this.state = {
searchLoading: false,
searchError: false
};
}
shouldComponentUpdate(nextProps) {
if (nextProps.searchResult && Object.keys(nextProps.searchResult).length &&
nextProps.searchResult !== this.props.searchResult) {
this.setState({searchLoading: false});
if (nextProps.searchResult.error) {
this.setState({searchError: true});
return true;
} else {
this.setState({searchError: false});
}
if (nextProps.searchResult.className) {
this.props.history.push(`/explorer/contracts/${nextProps.searchResult.className}`);
return false;
}
if (nextProps.searchResult.address) {
this.props.history.push(`/explorer/accounts/${nextProps.searchResult.address}`);
return false;
}
if (nextProps.searchResult.hasOwnProperty('transactionIndex')) {
this.props.history.push(`/explorer/transactions/${nextProps.searchResult.hash}`);
return false;
}
if (nextProps.searchResult.hasOwnProperty('number')) {
this.props.history.push(`/explorer/blocks/${nextProps.searchResult.number}`);
return false;
}
// Returned something we didn't know existed
}
return true;
}
searchTheExplorer(value) {
this.props.explorerSearch(value);
this.setState({searchLoading: true});
}
dismissSearchError() {
this.setState({searchError: false});
}
isActive = (itemUrl, baseUrl, match, location) => {
if (itemUrl === location.pathname) {
return true;
}
if (!baseUrl) {
return false;
}
return location.pathname.indexOf(baseUrl) > -1;
};
renderNav() {
return (
<React.Fragment>
<Nav className="header-nav d-lg-down-none" navbar>
{HEADER_NAV_ITEMS.map((item) => {
return (
<NavItem className="px-3" key={item.to}>
<NavLink exact activeClassName="active" tag={RNavLink} to={item.to}
isActive={this.isActive.bind(this, item.to, item.base)}>
<FontAwesome className="mr-2" name={item.icon}/>
{item.name}
</NavLink>
</NavItem>
);
})}
</Nav>
<AppHeaderDropdown className="list-unstyled d-xl-none" direction="down">
<DropdownToggle nav>
<FontAwesome name="bars"/>
</DropdownToggle>
<DropdownMenu>
{HEADER_NAV_ITEMS.map((item) => (
<DropdownItem key={item.to} to={item.to} tag={Link}>
<FontAwesome className="mr-2" name={item.icon} />
{item.name}
</DropdownItem>
))}
</DropdownMenu>
</AppHeaderDropdown>
</React.Fragment>
);
}
renderRightNav() {
return (
<Nav className="ml-auto" navbar>
<NavItem>
<SearchBar loading={this.state.searchLoading} searchSubmit={searchValue => this.searchTheExplorer(searchValue)}/>
</NavItem>
{this.renderTool()}
{this.renderSettings()}
</Nav>
);
}
renderSettings() {
const {logout, toggleTheme, currentTheme} = this.props;
return (
<AppHeaderDropdown direction="down">
<DropdownToggle nav>
<i className="icon-settings" />
</DropdownToggle>
<DropdownMenu right style={{ right: 'auto' }}>
<DropdownItem className="text-capitalize" onClick={() => toggleTheme()}>
<FontAwesome name={currentTheme === DARK_THEME ? 'sun-o' : 'moon-o'} />
{currentTheme === DARK_THEME ? LIGHT_THEME : DARK_THEME} Mode
</DropdownItem>
<DropdownItem onClick={logout}><FontAwesome name="lock" /> Logout</DropdownItem>
</DropdownMenu>
</AppHeaderDropdown>
);
}
renderTool() {
return (
<React.Fragment>
<NavItem>
<NavLink id="open-documentation"
href="https://framework.embarklabs.io"
title="Documentation"
rel="noopener noreferrer"
target="_blank">
<FontAwesome name="book" />
</NavLink>
</NavItem>
<NavItem>
<NavLink id="open-github"
href="https://github.com/embarklabs"
title="Github"
rel="noopener noreferrer"
target="_blank">
<FontAwesome name="github" />
</NavLink>
</NavItem>
<UncontrolledTooltip target="open-documentation">
Open Embark documentation
</UncontrolledTooltip>
<UncontrolledTooltip target="open-github">
Open Github of Embark
</UncontrolledTooltip>
</React.Fragment>
);
}
render() {
const {children, searchResult, location} = this.props;
const sidebar = getSidebar(location);
if (!sidebar) {
removeCssClasses();
}
return (
<div className="app animated fadeIn">
<AppHeader fixed>
<AppNavbarBrand full={{src: logo, width: 50, height: 50, alt: 'Embark Logo'}}
minimized={{src: logo, width: 50, height: 50, alt: 'Embark Logo'}}
/>
{this.renderNav()}
{this.renderRightNav()}
</AppHeader>
<div className="app-body">
{sidebar &&
<AppSidebar fixed display="sm">
<AppSidebarHeader />
<AppSidebarForm />
<AppSidebarNav navConfig={sidebar} location={location} />
<AppSidebarFooter />
<AppSidebarMinimizer />
</AppSidebar>
}
<main className="main">
<Container fluid className="h-100 pt-4">
<Alert color="danger" isOpen={(this.state.searchError && Boolean(searchResult.error))}
className="search-error no-gutters" toggle={() => this.dismissSearchError()}>
{searchResult.error}
</Alert>
{children}
</Container>
</main>
</div>
</div>
);
}
}
Layout.propTypes = {
children: PropTypes.element,
tabs: PropTypes.arrayOf(PropTypes.object),
location: PropTypes.object,
logout: PropTypes.func,
toggleTheme: PropTypes.func,
currentTheme: PropTypes.string,
explorerSearch: PropTypes.func,
searchResult: PropTypes.object,
history: PropTypes.object
};
function mapStateToProps(state) {
return {searchResult: searchResult(state)};
}
export default withRouter(connect(
mapStateToProps,
{
explorerSearch: explorerSearch.request
},
)(Layout));
|
test/InputSpec.js
|
tonylinyy/react-bootstrap
|
import React from 'react';
import ReactTestUtils from 'react/lib/ReactTestUtils';
import Input from '../src/Input';
import Button from '../src/Button';
import DropdownButton from '../src/DropdownButton';
import MenuItem from '../src/MenuItem';
import {shouldWarn} from './helpers';
describe('Input', function () {
it('renders children when type is not set', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input>
<span />
</Input>
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'span'));
assert.throw(instance.getValue);
});
it('renders a select element when type=select', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="select" defaultValue="v">
<option value="v" />
<option value="w" />
</Input>
);
let select = ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'select');
assert.ok(select);
assert.equal(React.findDOMNode(select).children.length, 2);
assert.equal(instance.getValue(), 'v');
});
it('renders a textarea element when type=textarea', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="textarea" defaultValue="v" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'textarea'));
assert.equal(instance.getValue(), 'v');
});
it('throws a warning when type=static', function () {
ReactTestUtils.renderIntoDocument(
<Input type="static" value="v" />
);
shouldWarn('deprecated');
});
it('renders an input element of given type when type is anything else', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="text" defaultValue="v" />
);
let node = React.findDOMNode(ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'input'));
assert.equal(node.getAttribute('type'), 'text');
assert.equal(instance.getValue(), 'v');
});
it('renders form-group wrapper', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input groupClassName="group" bsStyle="error" />
);
let node = React.findDOMNode(instance);
assert.include(node.className, 'form-group');
assert.include(node.className, 'group');
assert.include(node.className, 'has-error');
});
it('renders label', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input label="Label" labelClassName="label" id="input" />
);
let node = React.findDOMNode(ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'label'));
assert.ok(node);
assert.include(node.className, 'label');
assert.equal(node.textContent, 'Label');
assert.equal(node.getAttribute('for'), 'input');
});
it('renders wrapper', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input wrapperClassName="wrapper" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'wrapper'));
});
it('renders input-group', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input addonBefore="$" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group-addon'));
});
it('renders form-group with sm or lg class when bsSize is small or large', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input bsSize="small" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'form-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'form-group-sm'));
instance = ReactTestUtils.renderIntoDocument(
<Input bsSize="large" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'form-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'form-group-lg'));
});
it('renders input-group with sm or lg class name when bsSize is small or large', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input addonBefore="$" bsSize="small" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group-sm'));
instance = ReactTestUtils.renderIntoDocument(
<Input addonBefore="$" bsSize="large" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group-lg'));
});
it('renders btn-group', function() {
let instance = ReactTestUtils.renderIntoDocument(
<Input buttonAfter={<Button>!</Button>} />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group-btn'));
});
it('renders btn-group with dropdown', function() {
let instance = ReactTestUtils.renderIntoDocument(
<Input buttonAfter={<DropdownButton title="dropdown">
<MenuItem key="1">One</MenuItem>
</DropdownButton>} />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'input-group-btn'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'btn'));
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'dropdown-menu'));
});
it('renders help', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input help="Help" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'help-block'));
});
it('renders form-group class', function() {
let instance = ReactTestUtils.renderIntoDocument(
<Input />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'form-group'));
});
it('renders no form-group class', function() {
let instance = ReactTestUtils.renderIntoDocument(
<Input standalone />
);
assert.equal(ReactTestUtils.scryRenderedDOMComponentsWithClass(instance, 'form-group').length, 0);
});
it('renders custom-form-group class', function() {
let instance = ReactTestUtils.renderIntoDocument(
<Input groupClassName='custom-form-class' />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'custom-form-class'));
});
it('renders feedback icon', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input hasFeedback={true} bsStyle="error" />
);
assert.ok(ReactTestUtils.findRenderedDOMComponentWithClass(instance, 'form-control-feedback'));
});
it('renders file correctly', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="file" wrapperClassName="wrapper" label="Label" help="h" />
);
let node = React.findDOMNode(instance);
assert.include(node.className, 'form-group');
assert.equal(node.children[0].tagName.toLowerCase(), 'label');
assert.include(node.children[1].className, 'wrapper');
assert.equal(node.children[1].children[0].tagName.toLowerCase(), 'input');
assert.equal(node.children[1].children[0].className, '');
assert.equal(node.children[1].children[0].type, 'file');
assert.equal(node.children[1].children[1].className, 'help-block');
});
it('renders checkbox/radio correctly', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="checkbox" wrapperClassName="wrapper" label="Label" help="h" />
);
let node = React.findDOMNode(instance);
assert.include(node.className, 'form-group');
assert.include(node.children[0].className, 'wrapper');
assert.include(node.children[0].children[0].className, 'checkbox');
assert.equal(node.children[0].children[0].children[0].tagName.toLowerCase(), 'label');
assert.equal(node.children[0].children[0].children[0].children[0].tagName.toLowerCase(), 'input');
assert.include(node.children[0].children[1].className, 'help-block');
});
it('renders non-checkbox/radio correctly', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="text" label="l" wrapperClassName="wrapper" addonAfter="a" hasFeedback={true} help="h"/>
);
let node = React.findDOMNode(instance);
assert.include(node.className, 'form-group');
assert.equal(node.children[0].tagName.toLowerCase(), 'label');
assert.include(node.children[1].className, 'wrapper');
assert.include(node.children[1].children[0].className, 'input-group');
assert.equal(node.children[1].children[0].children[0].tagName.toLowerCase(), 'input');
assert.equal(node.children[1].children[0].children[1].tagName.toLowerCase(), 'span');
assert.include(node.children[1].children[1].className, 'form-control-feedback');
assert.include(node.children[1].children[2].className, 'help-block');
});
it('returns checked value for checkbox/radio', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="checkbox" checked readOnly />
);
assert.equal(instance.getChecked(), true);
});
it('returns the only selected option for select', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="select" value={'one'}>
<option value="one">one</option>
<option value="two">two</option>
<option value="three">three</option>
</Input>
);
assert.equal(instance.getValue(), 'one');
});
it('returns all selected options for multiple select', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="select" multiple value={['one', 'two']}>
<option value="one">one</option>
<option value="two">two</option>
<option value="three">three</option>
</Input>
);
assert.deepEqual(instance.getValue(), ['one', 'two']);
});
it('renders a disabled input correctly', function () {
let instance = ReactTestUtils.renderIntoDocument(
<Input type="text" disabled={true} />
);
let node = React.findDOMNode(ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'input'));
assert.isNotNull(node.getAttribute('disabled'));
});
});
|
app/components/Home.js
|
mswiszcz/pagebuilder
|
// @flow
import React, { Component } from 'react';
import { Link } from 'react-router';
import styles from './Home.css';
import Card from './Home/Card';
import Header from './common/Header';
import moment from 'moment';
import { PROJECT_DATE_FORMAT } from '../model/project';
import { STATUS } from '../reducers/gatsby';
export default class Home extends Component {
props: {
projects: Object
};
constructor(props) {
super(props);
if (Object.keys(this.props.projects).length == 0) {
this.props.loadProjects();
}
}
componentDidMount() {
if (this.props.gatsbyStatus.develop != STATUS.IDLE)
this.props.gatsbyDevelopStop();
this.props.closeProject();
}
openProject = (project) => {
this.props.openProject(project);
this.props.router.push('/editor');
}
render() {
const { openProject, deleteProject, deleteServer, projects, servers } = this.props;
let sortedProjects = Object.keys(projects).sort((a, b) => {
return projects[a].updatedAt > projects[b].updatedAt ? -1 : 1;
});
return (
<main className='dashboard'>
<div className='main-container'>
<div className={styles.wrapper}>
<Header backButtonVisible={false}
title='Dashboard'
subtitle={ moment().format('dddd[,] D MMMM') }
actionsVisible={true}
/>
<div className={styles.container}>
{ sortedProjects.map((key, i) => {
let project = projects[key];
return (
<Card key={`project-card-${project.id}`}
title={project.name}
subtitle={ `Updated ${moment(project.updatedAt, PROJECT_DATE_FORMAT).fromNow()}` }
icon={project.icon}
color={project.color}
onClick={() => { this.openProject(project) }}
deleteAction={(e) => { deleteProject(project) }}
disabled={project.setupInProgress}
/>);
}, this)}
</div>
</div>
</div>
</main>
);
}
}
|
resources/assets/js/components/SearchBookComponent.js
|
jrm2k6/i-heart-reading
|
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { browserHistory } from 'react-router';
import { runSearch } from '../actions/searchActions';
import { createAssignment } from '../actions/crudActions';
import { showModal } from '../actions/modals/modalActions';
import BookDetailsModal from './modals/BookDetailsModal';
const mapStateToProps = (state) => {
return {
suggestions: state.searchReducer.suggestions,
noSuggestions: state.searchReducer.noSuggestions,
isSearching: state.searchReducer.isSearching,
currentQuery: state.searchReducer.currentQuery,
user: state.userProfileReducer.user
};
};
const mapDispatchToProps = (dispatch) => {
return {
onSearch: (query, type) => {
dispatch(runSearch(query, type));
},
onClickAssign: (bookId, userId) => dispatch(createAssignment(bookId, userId)),
showModal: (component, data) => {
dispatch(showModal(component, data));
},
};
};
class SearchBookComponent extends Component {
constructor(props) {
super(props);
this.state = {
currentQuery: null,
selectedOption: 'title'
};
}
render() {
const { onSearch, onClickAssign, currentQuery,
suggestions, noSuggestions, isSearching, user } = this.props
let results = null;
if (currentQuery === null || currentQuery.length === 0) {
results = <div className='search-hint'>Please enter a query</div>;
} else if (isSearching) {
results = <div className='search-hint'>Searching</div>;
} else if (noSuggestions) {
results = <div className='search-hint'>No books found!</div>;
} else {
results = (
<SearchBookSuggestions
suggestions={suggestions}
showModal={(component, data) => { this.props.showModal(component, data); }}
onClick={(bookId) => {
onClickAssign(bookId, user.id).finally(
function() {
browserHistory.push('/app/books');
}
);
}}
/>
);
}
return (
<div className='search-book-container'>
<div className='search-book-input-btn'>
<input
className='search-book-input'
onChange={(e) => { this.setState({currentQuery: e.target.value}); }}
placeholder='Enter a title or an author'
>
</input>
<button className='search-books-btn'
onClick={() => { onSearch(this.state.currentQuery, this.state.selectedOption); }}
>
Search
</button>
</div>
<div className='search-input-options right-margin'>
<span className='search-option-title'>Select a filter:</span>
<div className='ihr-radio-wrapper'
onClick={() => { this.setState({ selectedOption: 'author' }); }}
>
<input className='ihr-radio'
type='radio'
name='author'
id='author'
value='author'
readOnly={true}
checked={'author' == this.state.selectedOption}
onClick={() => { this.setState({ selectedOption: 'author' }); }}
/>
<div className='ihr-check'></div>
<label className='label-ihr' forName='author'>
Book Authors
</label>
</div>
<div className='ihr-radio-wrapper'
onClick={() => { this.setState({ selectedOption: 'title' }); }}
>
<input className='ihr-radio'
type='radio'
name='title'
id='title'
value='title'
checked={'title' == this.state.selectedOption}
readOnly={true}
onClick={() => { this.setState({ selectedOption: 'title' }); }}
/>
<div className='ihr-check'></div>
<label className='label-ihr' forName='title'>
Book Titles
</label>
</div>
</div>
{results}
</div>
);
}
};
const SearchBookSuggestions = ({ suggestions, onClick, showModal }) => (
<div className='search-book-suggestions-container'>
<div className='search-book-suggestions-header'>
<span className='book-properties'>Title</span>
<span className='book-properties'>Author</span>
<span className='book-properties'># Pages</span>
<span className='book-properties'>Details</span>
<span className='book-actions'></span>
</div>
<div>
{suggestions.map(suggestion => {
return (
<div key={suggestion.google_book_id} className='search-book-suggestion'>
<span className='book-properties'>{suggestion.title}</span>
<span className='book-properties'>{suggestion.authors}</span>
<span className='book-properties'>{suggestion.num_pages}</span>
<span className='book-properties'
onClick={() => { showModal(BookDetailsModal, {suggestion, onClick})}}
>
View more
</span>
<span
className='book-actions assign'
onClick={() => {onClick(suggestion.google_book_id);}}
>
Assign
</span>
</div>
)}
)}
</div>
</div>
);
export default connect(mapStateToProps, mapDispatchToProps)(SearchBookComponent);
|
frontend/src/components/partners/profile/modals/addVerificationModal/verificationQuestion.js
|
unicef/un-partner-portal
|
import React from 'react';
import { withStyles } from 'material-ui/styles';
import PropTypes from 'prop-types';
import Typography from 'material-ui/Typography';
import SpreadContent from '../../../../common/spreadContent';
import PolarRadio from '../../../../forms/fields/PolarRadio';
import TextForm from '../../../../forms/textFieldForm';
import GridColumn from '../../../../common/grid/gridColumn';
const messages = {
comment: 'Comment',
};
const styleSheet = (theme) => {
const spacing = theme.spacing.unit;
return {
padding: {
padding: `0px ${spacing}px ${spacing}px ${spacing}px`,
alignItems: 'center',
},
background: {
backgroundColor: theme.palette.common.lightGreyBackground,
},
questionMargin: {
marginRight: spacing,
},
};
};
const VerificationQuestion = (props) => {
const { classes, question, questionFieldName, commentFieldName, readOnly, warn } = props;
return (
<GridColumn spacing={8}>
<SpreadContent className={`${classes.padding} ${classes.background}`}>
<Typography type="body2" className={classes.questionMargin}>
{question}
</Typography>
<PolarRadio warn={warn} fieldName={questionFieldName} readOnly={readOnly} />
</SpreadContent>
<div className={classes.padding}>
<TextForm
label={messages.comment}
fieldName={commentFieldName}
warn={warn}
textFieldProps={{
multiline: true,
InputProps: {
inputProps: {
maxLength: '300',
},
},
}}
readOnly={readOnly}
/>
</div>
</GridColumn>
);
};
VerificationQuestion.propTypes = {
classes: PropTypes.object,
question: PropTypes.string,
questionFieldName: PropTypes.string,
commentFieldName: PropTypes.string,
readOnly: PropTypes.bool,
warn: PropTypes.bool,
};
export default withStyles(styleSheet, { name: 'VerificationQuestion' })(VerificationQuestion);
|
test/index.spec.js
|
bokuweb/react-balloon
|
import React from 'react';
import { shallow, mount } from 'enzyme';
import assert from 'power-assert';
import sinon from 'sinon';
import ResizableAndMovable from 'react-resizable-and-movable';
import Balloon from '../src/index';
const mouseMove = (node, x, y) => {
const event = document.createEvent('MouseEvents');
event.initMouseEvent('mousemove', true, true, window,
0, 0, 0, x, y, false, false, false, false, 0, null);
document.dispatchEvent(event);
return event;
};
describe('<Balloon/>', () => {
it('should have default properties', () => {
const balloon = mount(<Balloon />);
assert.equal(balloon.props().zIndex, 100);
assert.equal(balloon.props().className, '');
assert.equal(balloon.props().backgroundColor, '#f5f5f5');
assert.equal(balloon.props().minWidth, undefined);
assert.equal(balloon.props().minHeight, undefined);
assert.equal(balloon.props().maxWidth, undefined);
assert.equal(balloon.props().maxHeight, undefined);
assert.deepEqual(balloon.props().style, {});
assert.deepEqual(balloon.props().start, {
box: {
x: 0,
y: 0,
width: 100,
height: 100,
},
destination: {
x: 0,
y: 0,
},
});
});
it('Should root element have expected element and styles', () => {
const balloon = shallow(<Balloon />);
const expectedStyles = { width: '100%', height: '100%', zIndex: 100 };
assert.equal(balloon.type(), 'div');
assert.deepEqual(balloon.prop('style'), expectedStyles);
});
it('Should 1st element have expected type', () => {
const balloon = shallow(<Balloon />);
const first = balloon.children().at(0);
assert.equal(first.text(), '<ResizableAndMovable />');
});
it('Should 1st element have expected element without children', () => {
const balloon = shallow(<Balloon />);
const child = balloon.children().at(0).children();
assert.equal(child.type(), 'div');
assert.equal(child.props().children, undefined);
});
it('Should 1st element have expected element with children', () => {
const balloon = shallow(<Balloon>Test Text</Balloon>);
const child = balloon.children().at(0).children();
assert.equal(child.type(), 'div');
assert(child.children().contains('Test Text'));
});
it('Should chilrdren wrapper have expected styles', () => {
const balloon = shallow(<Balloon>Test Text</Balloon>);
const child = balloon.children().at(0).children();
const expectedStyles = {
padding: '1px',
width: '100%',
height: '100%',
};
assert.deepEqual(child.prop('style'), expectedStyles);
});
it('Should 2nd element have expected type', () => {
const balloon = shallow(<Balloon />);
const second = balloon.children().at(1);
assert.equal(second.text(), '<ResizableAndMovable />');
});
it('Should 2nd element have expected props', () => {
const balloon = shallow(<Balloon />);
const second = balloon.children().at(1);
assert.deepEqual(second.props().start, {x: -15, y: -15});
assert.deepEqual(second.props().isResizable, { x: false, y: false, xy: false });
assert.equal(second.props().bounds, 'parent');
assert.equal(second.props().zIndex, 100);
assert.equal(typeof second.props().onDrag, 'function');
});
it('Should 2nd element have marker component', () => {
const balloon = shallow(<Balloon />);
const child = balloon.children().at(1).children();
assert.equal(child.type(), 'div');
assert.deepEqual(child.prop('style'), { width: '30px', height: '30px' });
});
it('Should 3rd element have expected type', () => {
const balloon = shallow(<Balloon />);
const third = balloon.children().at(2);
assert.equal(third.type(), 'svg');
});
it('Should 3rd element have one path element', () => {
const balloon = shallow(<Balloon />);
const third = balloon.children().at(2);
assert.equal(third.find('path').length, 1);
});
it('Should path on svg have expected props', () => {
const balloon = shallow(<Balloon />);
const path = balloon.children().at(2).children();
assert.equal(path.prop('strokeWidth'), 1);
assert.equal(path.prop('stroke'), '#f5f5f5');
assert.equal(path.prop('fill'), '#f5f5f5');
assert.equal(path.prop('d').replace(/\s+/g, ''), 'M025Q05000Q050075');
});
it('should pass className properly to root ', () => {
const balloon = shallow(<Balloon className="foo" style={{ color: 'black' }} />);
assert.equal(balloon.prop('className'), 'foo');
});
it('should pass zIndex properly to root', () => {
const balloon = shallow(<Balloon zIndex={ 999 } />);
assert.deepEqual(balloon.prop('style'), { width: '100%', height: '100%', zIndex: 999 });
});
it('should pass props properly to first resizable box', () => {
const balloon = shallow(
<Balloon
style={{ color: 'black' }}
start={{ box: { x:100, y: 120, width: 140, height: 160 }, destination: { x:0, y: 0 } }}
zIndex={ 999 }
backgroundColor={'#000000'}
maxHeight={ 200 }
maxWidth={ 220 }
minHeight={ 240 }
minWidth={ 260 }
/>
);
const first = balloon.children().at(0);
assert.equal(first.prop('zIndex'), 999);
assert.equal(first.prop('maxHeight'), 200);
assert.equal(first.prop('maxWidth'), 220);
assert.equal(first.prop('minHeight'), 240);
assert.equal(first.prop('minWidth'), 260);
assert.deepEqual(first.prop('customStyle'), { color: 'black', backgroundColor: '#000000' });
assert.deepEqual(first.prop('start'), { x: 100, y: 120, width: 140, height: 160 });
});
it('should pass props properly to second resizable box', () => {
const balloon = shallow(
<Balloon
start={{ box: { x: 100, y: 120, width: 140, height: 160 }, destination: { x:100, y: 300 } }}
zIndex={ 999 }
marker={<span>foo</span>}
/>
);
const second = balloon.children().at(1);
assert.equal(second.prop('zIndex'), 999);
assert.deepEqual(second.prop('start'), { x: 85, y: 285 });
const marker = second.children();
assert.equal(marker.type(), 'span');
assert(marker.contains('foo'));
});
it('should pass props properly to svg', () => {
const balloon = shallow(
<Balloon
backgroundColor={'#000000'}
zIndex={999}
/>
);
const svg = balloon.children().at(2);
assert.equal(svg.prop('style').zIndex, 999);
const path = svg.children();
assert.equal(path.prop('stroke'), '#000000');
assert.equal(path.prop('fill'), '#000000');
});
it('should onPointerDragxxx called, when maker dragged', () => {
const spy = sinon.spy(Balloon.prototype, 'onPointerDrag');
const onPointerDragStart = sinon.spy();
const onPointerDragStop = sinon.spy();
const onPointerDrag = sinon.spy();
const balloon = mount(
<Balloon
start={{ box: { x: 100, y: 120, width: 140, height: 160 }, destination: { x:100, y: 300 } }}
onPointerDrag={onPointerDrag}
onPointerDragStop={onPointerDragStop}
onPointerDragStart={onPointerDragStart}
/>);
const marker = balloon.children().at(1).children();
marker.find('div').at(0).simulate('mousedown');
// TODO: Not simulated properly
mouseMove(marker.find('div').get(0), 100, 100);
marker.find('div').at(0).simulate('mouseup');
assert(Balloon.prototype.onPointerDrag.calledOnce);
assert(onPointerDragStart.calledOnce);
assert(onPointerDragStop.calledOnce);
assert.deepEqual(onPointerDrag.getCall(0).args[0], {left: 85, top: 285});
// FIXME: dragStop return NaN
//assert.deepEqual(onPointerDragStop.getCall(0).args[0], {left: 85, top: 285});
});
it('should onBoxDragxxx called, when box dragged', () => {
const spy = sinon.spy(Balloon.prototype, 'onBoxDrag');
const onBoxDragStart = sinon.spy();
const onBoxDragStop = sinon.spy();
const onBoxDrag = sinon.spy();
const balloon = mount(
<Balloon
start={{ box: { x: 100, y: 120, width: 140, height: 160 }, destination: { x:100, y: 300 } }}
onBoxDrag={onBoxDrag}
onBoxDragStop={onBoxDragStop}
onBoxDragStart={onBoxDragStart}
/>);
const box = balloon.children().at(0).children();
box.find('div').at(0).simulate('mousedown');
// TODO: Not simulated properly
mouseMove(box.find('div').get(0), 100, 100);
box.find('div').at(0).simulate('mouseup');
assert(Balloon.prototype.onBoxDrag.calledOnce);
assert(onBoxDragStart.calledOnce);
assert(onBoxDragStop.calledOnce);
assert.deepEqual(onBoxDrag.getCall(0).args[0], { left: 100, top: 120 });
});
it('should onBoxResizexxx called, when box resized', () => {
const spy = sinon.spy(Balloon.prototype, 'onBoxResize');
const onBoxResizeStart = sinon.spy();
const onBoxResizeStop = sinon.spy();
const onBoxResize = sinon.spy();
const balloon = mount(
<Balloon
start={{ box: { x: 100, y: 120, width: 140, height: 160 }, destination: { x:100, y: 300 } }}
onBoxResize={onBoxResize}
onBoxResizeStop={onBoxResizeStop}
onBoxResizeStart={onBoxResizeStart}
/>
);
const box = balloon.children().at(0).children();
box.find('div').children().at(1).simulate('mousedown');
mouseMove(box.find('div').children().at(1), 10, 10);
box.find('div').children().at(1).simulate('mouseup');
assert(Balloon.prototype.onBoxResize.calledOnce);
assert(onBoxResizeStart.calledOnce);
// FIXME: onBoxResizeStop not called
//assert(onBoxResizeStop.calledOnce);
});
});
|
modules/Common/SearchBox.js
|
cloudytimemachine/frontend
|
import React from 'react'
import { Link } from 'react-router'
import { browserHistory } from 'react-router'
export default React.createClass({
getInitialState: function() {
return { url: '' };
},
handleURLChange: function(e) {
this.setState({ url: e.target.value });
},
contextTypes: {
router: React.PropTypes.object
},
handleSubmit: function(e) {
e.preventDefault();
var url = this.state.url.trim();
if (!url) {
return;
}
this.setState({ url: '' });
browserHistory.push({
pathname: '/search/',
search: '?host='+this.refs.q.value
});
},
render() {
return (
<form className="navbar-form" role="search" onSubmit={this.handleSubmit}>
<div className="input-group">
<input
type="text"
className="form-control"
placeholder="Search"
ref="q"
value={this.state.url}
onChange={this.handleURLChange}
/>
<div className="input-group-btn">
<button className="btn btn-default" type="submit"><i className="glyphicon glyphicon-search"></i></button>
</div> {/*input-group-btn*/}
</div> {/*input-group*/}
</form>
)
}
});
|
src/index.js
|
miraks/react-autolink-text
|
import React from 'react';
import shouldPureComponentUpdate from 'react-pure-render/function';
import matchParser from './match_parser';
export default class AutoLinkText extends React.Component {
shouldComponentUpdate = shouldPureComponentUpdate
render() {
const text = this.props.text;
const target = this.props.target;
return (
<span>{matchParser(text)::prepareElements(text, target)::truncate(this.props.maxLength)::keyElements()}</span>
);
}
}
function prepareElements(text, target) {
let elements = [];
let lastIndex = 0;
this.forEach((match) => {
if (match.position.start !== 0) {
elements.push(<span>{text.slice(lastIndex, match.position.start)}</span>);
}
elements.push(<a target={target} href={match.getAnchorHref()} >{match.getAnchorText()}</a>);
lastIndex = match.position.end;
});
if (lastIndex < text.length) {
elements.push(<span>{text.slice(lastIndex)}</span>);
}
return elements;
}
function truncate(maxLength) {
if (!maxLength) return this;
let elements = [];
let length = 0;
this.some((el) => {
length += el.props.children.length;
if (length > maxLength) {
const truncatedText = el.props.children.slice(0, -(length - maxLength));
elements.push(
React.cloneElement(el, {}, truncatedText)
);
return true; // stop iterating through the elements
}
elements.push(el);
});
return elements;
}
/*
* Generate unique keys for each of the elements.
* The key will be based on the index of the element.
*/
function keyElements() {
return this.map((el, index) => {
return React.cloneElement(el, {key: index});
});
}
AutoLinkText.propTypes = {
text: React.PropTypes.string,
target: React.PropTypes.string,
maxLength: React.PropTypes.oneOfType([
React.PropTypes.number,
React.PropTypes.string
])
};
AutoLinkText.defaultProps = {
text: '',
target: '_self'
}
|
src/components/RouteRenderer/__tests__/testRouteRenderer.js
|
mixcloud/react-url-router
|
/* @noflow */
import React from 'react';
import RouteRenderer from '../';
import {mount} from 'enzyme';
import Urls from '../../../urls';
import RouteContext from '../../RouteContext';
const urls = new Urls({'home': '/', 'user:profile': '/u/:username/'});
const context = {
router: {
history: {},
location: {},
urls,
listen: () => () => {},
linkMiddleware: [],
navigate: () => {}
}
};
const TestComponent = () => null;
const TestComponent2 = () => null;
describe('<RouteRenderer>', () => {
it('should render a component', () => {
const wrapper = mount(
<RouteRenderer
location={{pathname: '/'}}
routes={[
{urlName: 'user:profile', render: () => <TestComponent2 />, exact: true, strict: true},
{urlName: 'home', component: TestComponent, exact: true, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(1);
});
it('should render with a render function', () => {
const wrapper = mount(
<RouteRenderer
location={{pathname: '/'}}
routes={[
{urlName: 'home', render: () => <TestComponent />, exact: true, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(1);
});
it('should render null on no match', () => {
const wrapper = mount(
<RouteRenderer
location={{pathname: '/'}}
routes={[
{urlName: 'user:profile', render: () => <TestComponent />, exact: true, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(0);
expect(wrapper.find(RouteContext).length).toEqual(0);
});
it('should render non-exact routes', () => {
const wrapper = mount(
<RouteRenderer
location={{pathname: '/u/x/'}}
routes={[
{urlName: 'home', component: TestComponent, exact: false, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(1);
});
it('should render just the first match', () => {
const wrapper = mount(
<RouteRenderer
location={{pathname: '/u/x/'}}
routes={[
{urlName: 'home', component: TestComponent, exact: false, strict: true},
{urlName: 'user:profile', render: () => <TestComponent2 />, exact: true, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(1);
expect(wrapper.find(TestComponent2).length).toEqual(0);
});
it('should match a blank urlName every time', () => {
var wrapper = mount(
<RouteRenderer
location={{pathname: '/u/x/'}}
routes={[
{urlName: 'home', component: TestComponent, exact: true, strict: true},
{render: () => <TestComponent2 />}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(0);
expect(wrapper.find(TestComponent2).length).toEqual(1);
wrapper = mount(
<RouteRenderer
location={{pathname: '/u/x/'}}
routes={[
{render: () => <TestComponent2 />},
{urlName: 'home', component: TestComponent, exact: true, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(TestComponent).length).toEqual(0);
expect(wrapper.find(TestComponent2).length).toEqual(1);
});
it('should set serverResult.hasMatched', () => {});
it('should wrap in a match in a <RouteContext>', () => {
const wrapper = mount(
<RouteRenderer
location={{pathname: '/'}}
routes={[
{urlName: 'home', render: () => <TestComponent />, exact: true, strict: true}
]}
/>,
{context}
);
expect(wrapper.find(RouteContext).length).toEqual(1);
});
it('should call onNavigate upon render', () => {
const onNavigate = jest.fn();
const location = {pathname: '/'};
const wrapper = mount(
<RouteRenderer
location={location}
routes={[
{urlName: 'home', component: TestComponent, exact: true, strict: true}
]}
onNavigate={onNavigate}
/>,
{context}
);
expect(onNavigate).toHaveBeenCalledWith({location, match: {urlName: 'home', params: {}}})
});
});
|
packages/web/src/components/Account/Forgot.js
|
hengkx/note
|
import React from 'react';
import PropTypes from 'prop-types';
import { Form, Input, message, Button } from 'antd';
import { Link } from 'react-router-dom';
import './less/account.less';
const FormItem = Form.Item;
class Forgot extends React.Component {
static propTypes = {
form: PropTypes.object.isRequired,
forgot: PropTypes.func.isRequired,
forgotResult: PropTypes.object
}
componentWillReceiveProps(nextProps) {
const { forgotResult } = nextProps;
if (forgotResult !== this.props.forgotResult) {
if (forgotResult.code !== 0) {
message.error(forgotResult.message);
} else {
message.success('密码已发送到您的邮箱请注意查收！');
}
}
}
handleSubmit = (e) => {
e.preventDefault();
this.props.form.validateFields((err, values) => {
if (!err) {
this.props.forgot({ email: values.email });
}
});
}
render() {
const { getFieldDecorator } = this.props.form;
return (
<Form className="account" onSubmit={this.handleSubmit}>
<h1>云笔记</h1>
<FormItem
hasFeedback
>
{getFieldDecorator('email', {
rules: [
{ type: 'email', message: '请输入正确的邮箱!' },
{ required: true, message: '请输入邮箱!' }
]
})(<Input placeholder="邮箱" />)}
</FormItem>
<FormItem>
<Button type="primary" htmlType="submit" size="large">找回密码</Button>
</FormItem>
<FormItem>
<Link to="/signin">点击返回登录</Link>
</FormItem>
</Form>
);
}
}
export default Form.create()(Forgot);
|
src/svg-icons/image/gradient.js
|
rhaedes/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let ImageGradient = (props) => (
<SvgIcon {...props}>
<path d="M11 9h2v2h-2zm-2 2h2v2H9zm4 0h2v2h-2zm2-2h2v2h-2zM7 9h2v2H7zm12-6H5c-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 18H7v-2h2v2zm4 0h-2v-2h2v2zm4 0h-2v-2h2v2zm2-7h-2v2h2v2h-2v-2h-2v2h-2v-2h-2v2H9v-2H7v2H5v-2h2v-2H5V5h14v6z"/>
</SvgIcon>
);
ImageGradient = pure(ImageGradient);
ImageGradient.displayName = 'ImageGradient';
export default ImageGradient;
|
node_modules/react-router/es/Prompt.js
|
lousanna/sinatrademo
|
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 prompting the user before navigating away
* from a screen with a component.
*/
var Prompt = function (_React$Component) {
_inherits(Prompt, _React$Component);
function Prompt() {
_classCallCheck(this, Prompt);
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
}
Prompt.prototype.enable = function enable(message) {
if (this.unblock) this.unblock();
this.unblock = this.context.router.history.block(message);
};
Prompt.prototype.disable = function disable() {
if (this.unblock) {
this.unblock();
this.unblock = null;
}
};
Prompt.prototype.componentWillMount = function componentWillMount() {
if (this.props.when) this.enable(this.props.message);
};
Prompt.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
if (nextProps.when) {
if (!this.props.when || this.props.message !== nextProps.message) this.enable(nextProps.message);
} else {
this.disable();
}
};
Prompt.prototype.componentWillUnmount = function componentWillUnmount() {
this.disable();
};
Prompt.prototype.render = function render() {
return null;
};
return Prompt;
}(React.Component);
Prompt.propTypes = {
when: PropTypes.bool,
message: PropTypes.oneOfType([PropTypes.func, PropTypes.string]).isRequired
};
Prompt.defaultProps = {
when: true
};
Prompt.contextTypes = {
router: PropTypes.shape({
history: PropTypes.shape({
block: PropTypes.func.isRequired
}).isRequired
}).isRequired
};
export default Prompt;
|
src/components/ResetPasswordForm.js
|
react-auth/react-auth
|
import React from 'react';
import { Link } from 'react-router';
import utils from '../utils';
import LoginLink from '../components/LoginLink';
import { forgotPassword } from '../actions';
class DefaultResetPasswordForm extends React.Component {
render() {
return (
<ResetPasswordForm {...this.props}>
<div className='sp-reset-password-form'>
<div className="row">
<div className="col-sm-offset-4 col-xs-12 col-sm-4" spIf="form.sent">
<p className="alert alert-success">
We have sent a password reset link to the email address of the account that you specified.
Please check your email for this message, then click on the link.
</p>
<p className="pull-right">
<LoginLink>Back to Login</LoginLink>
</p>
</div>
<div className="col-xs-12" spIf="!form.sent">
<div className="form-horizontal">
<div className="form-group">
<label htmlFor="spEmail" className="col-xs-12 col-sm-4 control-label">Email or Username</label>
<div className="col-xs-12 col-sm-4">
<input className="form-control" id="spEmail" name="email" placeholder="Your Email Address" />
</div>
</div>
<div className="form-group">
<div className="col-sm-offset-4 col-xs-12">
<p spIf="form.error"><span spBind="form.errorMessage" /></p>
<button type="submit" className="btn btn-primary">Request Password Reset</button>
</div>
</div>
</div>
</div>
</div>
</div>
</ResetPasswordForm>
);
}
}
export default class ResetPasswordForm extends React.Component {
state = {
fields: {
email: ''
},
errorMessage: null,
isFormProcessing: false,
isFormSent: false
};
onFormSubmit(e) {
e.preventDefault();
e.persist();
var next = (err, data) => {
if (err) {
return this.setState({
isFormProcessing: false,
errorMessage: err.message
});
}
// If the user didn't specify any data,
// then simply default to what we have in state.
data = data || this.state.fields;
forgotPassword(this.state.fields).then(() => {
this.setState({
isFormSent: true,
isFormProcessing: false,
errorMessage: null
});
}).catch((err) => {
this.setState({
isFormProcessing: false,
errorMessage: err.message
});
});
};
this.setState({
isFormProcessing: true
});
if (this.props.onSubmit) {
e.data = this.state.fields;
this.props.onSubmit(e, next);
} else {
next(null, this.state.fields);
}
}
_mapFormFieldHandler(element, tryMapField) {
if (element.type === 'input' || element.type === 'textarea') {
if (element.props.type !== 'submit') {
switch(element.props.name) {
case 'email':
tryMapField('email');
break;
}
}
}
}
_spIfHandler(action, element) {
var test = null;
switch (action) {
case 'form.processing':
test = this.state.isFormProcessing;
break;
case 'form.sent':
test = this.state.isFormSent;
break;
case 'form.error':
test = this.state.errorMessage !== null;
break;
}
return test;
}
_spBindHandler(bind, element) {
var result = false;
switch (bind) {
case 'form.errorMessage':
let className = element.props ? element.props.className : undefined;
result = <span className={className}>{this.state.errorMessage}</span>;
break;
}
return result;
}
render() {
if (this.props.children) {
return (
<form onSubmit={this.onFormSubmit.bind(this)}>
{utils.makeForm(this, this._mapFormFieldHandler.bind(this), this._spIfHandler.bind(this), this._spBindHandler.bind(this))}
</form>
);
} else {
return <DefaultResetPasswordForm {...this.props} />;
}
}
}
|
client/containers/SignUpContainer.js
|
axax/lunuc
|
import React from 'react'
import PropTypes from 'prop-types'
import config from 'gen/config-client'
import BlankLayout from 'client/components/layout/BlankLayout'
import {Link} from 'client/util/route'
import {Card, SimpleButton, TextField, Row, Col, Typography} from 'ui/admin'
import {client} from '../middleware/graphql'
class SignUpContainer extends React.Component {
state = {
loading: false,
usernameError: null,
passwordError: null,
emailError: null,
username: '',
password: '',
email: '',
signupFinished: false
}
handleInputChange = (e) => {
const target = e.target
const value = target.type === 'checkbox' ? target.checked : target.value
const name = target.name
this.setState({
[target.name]: value
})
}
signup = (e) => {
e.preventDefault()
this.setState({usernameError: null, passwordError: null, emailError: null})
let hasError = false
const {email, username, password} = this.state
if (email.trim() === '') {
this.setState({emailError: 'Please enter a valid email address'})
hasError = true
}
if (username.trim() === '') {
this.setState({usernameError: 'Please enter a username'})
hasError = true
}
if (password.trim() === '') {
this.setState({passwordError: 'Please enter a password'})
hasError = true
}
if (hasError) {
return
}
this.setState({loading: true})
client.mutate({
mutation: `
mutation createUser($email: String!, $username: String!, $password: String!) {
createUser(email: $email, username: $username, password: $password) {
email password username _id
}
}
`,
variables: {
email,
username,
password
}
}).then((res) => {
console.log(res)
if (res.errors && res.errors.length) {
res.errors.forEach(e => {
console.log(e)
if (e.state) {
this.setState(e.state)
}
})
this.setState({loading: false})
} else {
this.setState({loading: false, signupFinished: true})
}
})
}
render() {
const {signupFinished, email, username, password, loading, usernameError, passwordError, emailError} = this.state
return (
<BlankLayout style={{marginTop: '5rem'}}>
<Row>
<Col xs={1} sm={2} md={4}></Col>
<Col xs={10} sm={8} md={4}>
<Card>
<Typography variant="h3" gutterBottom>Sign up</Typography>
{signupFinished ?
<Typography gutterBottom>Thanks for your registration! <Link
to={config.ADMIN_BASE_URL + '/login'}>Login</Link></Typography> :
<form>
<TextField label="Username"
error={!!usernameError}
helperText={usernameError}
disabled={!!loading}
autoComplete="username"
fullWidth
autoFocus
value={username}
onChange={this.handleInputChange}
type="text"
placeholder="Enter username"
name="username" required/>
<TextField label="Email"
error={!!emailError}
helperText={emailError}
disabled={!!loading}
autoComplete="email"
fullWidth
value={email}
onChange={this.handleInputChange}
type="text"
placeholder="Enter email"
name="email" required/>
<TextField label="Password"
error={!!passwordError}
helperText={passwordError}
disabled={!!loading}
fullWidth
autoComplete="new-password"
value={password}
onChange={this.handleInputChange}
type="password"
placeholder="Enter Password"
name="password" required/>
<div style={{textAlign: 'right'}}>
<SimpleButton variant="contained" color="primary"
showProgress={loading} onClick={this.signup.bind(this)}>Sign
up</SimpleButton>
</div>
<Typography gutterBottom> Already have an account? <Link
to={config.ADMIN_BASE_URL + '/login'}>Login</Link></Typography>
</form>
}
</Card>
</Col>
<Col xs={1} sm={2} md={4}></Col>
</Row>
</BlankLayout>
)
}
}
SignUpContainer.propTypes = {
mutate: PropTypes.func,
}
export default SignUpContainer
|
src/index.js
|
Aleczhang1992/gallery-by-react
|
import 'core-js/fn/object/assign';
import React from 'react';
import ReactDOM from 'react-dom';
import App from './components/Main';
// Render the main component into the dom
ReactDOM.render(<App />, document.getElementById('app'));
|
demo/components/TodosList.js
|
bradparks/cerebral__web_app_state_with_debugger
|
import React from 'react';
import Todo from './Todo.js';
import {Decorator as Cerebral} from 'cerebral-react';
@Cerebral({
todos: ['visibleTodos'],
isAllChecked: ['isAllChecked']
})
class TodosList extends React.Component {
renderTodo(todo, index) {
return <Todo key={index} index={index} todo={todo}/>
}
render() {
return (
<section id="main">
<input
id="toggle-all"
type="checkbox"
checked={this.props.isAllChecked}
onChange={() => this.props.signals.toggleAllChanged()}
/>
<label htmlFor="toggle-all">Mark all as complete</label>
<ul id="todo-list">
{this.props.todos.map(this.renderTodo.bind(this))}
</ul>
</section>
);
}
}
export default TodosList;
|
actor-apps/app-web/src/app/components/modals/Preferences.react.js
|
hmoraes/actor-platform
|
import _ from 'lodash';
import React from 'react';
import Modal from 'react-modal';
import ReactMixin from 'react-mixin';
import { IntlMixin, FormattedMessage } from 'react-intl';
import { Styles, FlatButton, RadioButtonGroup, RadioButton, DropDownMenu } from 'material-ui';
import { KeyCodes } from 'constants/ActorAppConstants';
import ActorTheme from 'constants/ActorTheme';
import PreferencesActionCreators from 'actions/PreferencesActionCreators';
import PreferencesStore from 'stores/PreferencesStore';
const appElement = document.getElementById('actor-web-app');
Modal.setAppElement(appElement);
const ThemeManager = new Styles.ThemeManager();
const menuItems = [
{ payload: '1', text: 'English', value: 'en'},
{ payload: '2', text: 'Russian', value: 'ru'}
];
const getStateFromStores = () => {
const language = PreferencesStore.language;
return {
isOpen: PreferencesStore.isModalOpen,
preferences: PreferencesStore.preferences,
language: language,
selectedLanguage: _.findIndex(menuItems, {value: language})
};
};
@ReactMixin.decorate(IntlMixin)
class PreferencesModal extends React.Component {
static childContextTypes = {
muiTheme: React.PropTypes.object
};
getChildContext() {
return {
muiTheme: ThemeManager.getCurrentTheme()
};
}
constructor(props) {
super(props);
this.state = getStateFromStores();
ThemeManager.setTheme(ActorTheme);
ThemeManager.setComponentThemes({
button: {
minWidth: 60
}
});
PreferencesStore.addChangeListener(this.onChange);
document.addEventListener('keydown', this.onKeyDown, false);
}
componentWillUnmount() {
PreferencesStore.removeChangeListener(this.onChange);
document.removeEventListener('keydown', this.onKeyDown, false);
}
onChange = () => {
this.setState(getStateFromStores());
};
onClose = () => {
PreferencesActionCreators.hide();
};
onDone = () => {
PreferencesActionCreators.save({
language: this.state.language,
sendByEnter: this.refs.sendByEnter.getSelectedValue()
});
this.onClose();
};
onKeyDown = event => {
if (event.keyCode === KeyCodes.ESC) {
event.preventDefault();
this.onClose();
}
};
onLanguageChange = (event, selectedIndex, menuItem) => {
this.setState({
language: menuItem.value,
selectedLanguage: _.findIndex(menuItems, {value: menuItem.value})
});
};
render() {
const preferences = this.state.preferences;
if (this.state.isOpen === true) {
return (
<Modal className="modal-new modal-new--preferences"
closeTimeoutMS={150}
isOpen={this.state.isOpen}
style={{width: 760}}>
<div className="modal-new__header">
<i className="modal-new__header__icon material-icons">settings</i>
<h3 className="modal-new__header__title">
<FormattedMessage message={this.getIntlMessage('preferencesModalTitle')}/>
</h3>
<div className="pull-right">
<FlatButton hoverColor="rgba(81,145,219,.17)"
label="Done"
labelStyle={{padding: '0 8px'}}
onClick={this.onDone}
secondary={true}
style={{marginTop: -6}}/>
</div>
</div>
<div className="modal-new__body">
<div className="preferences">
<aside className="preferences__tabs">
<a className="preferences__tabs__tab preferences__tabs__tab--active">General</a>
<a className="preferences__tabs__tab hide">Notifications</a>
<a className="preferences__tabs__tab hide">Sidebar colors</a>
<a className="preferences__tabs__tab hide">Security</a>
<a className="preferences__tabs__tab hide">Other Options</a>
</aside>
<div className="preferences__body">
<div className="preferences__list">
<div className="preferences__list__item preferences__list__item--general">
<ul>
<li>
<i className="icon material-icons">keyboard</i>
<RadioButtonGroup defaultSelected={preferences.sendByEnter}
name="send"
ref="sendByEnter">
<RadioButton label="Enter – send message, Shift + Enter – new line"
style={{marginBottom: 12}}
value="true"/>
<RadioButton label="Cmd + Enter – send message, Enter – new line"
value="false"/>
</RadioButtonGroup>
</li>
<li className="language hide">
<i className="icon material-icons">menu</i>
Language: <DropDownMenu labelStyle={{color: '#5191db'}}
menuItemStyle={{height: '40px', lineHeight: '40px'}}
menuItems={menuItems}
onChange={this.onLanguageChange}
selectedIndex={this.state.selectedLanguage}
style={{verticalAlign: 'top', height: 52}}
underlineStyle={{display: 'none'}}/>
</li>
</ul>
</div>
<div className="preferences__list__item preferences__list__item--notifications hide">
<ul>
<li>
<i className="icon material-icons">notifications</i>
<RadioButtonGroup defaultSelected="all" name="notifications">
<RadioButton label="Notifications for activity of any kind"
style={{marginBottom: 12}}
value="all"/>
<RadioButton label="Notifications for Highlight Words and direct messages"
style={{marginBottom: 12}}
value="quiet"/>
<RadioButton label="Never send me notifications"
style={{marginBottom: 12}}
value="disable"/>
</RadioButtonGroup>
<p className="hint">
You can override your desktop notification preference on a case-by-case
basis for channels and groups from the channel or group menu.
</p>
</li>
</ul>
</div>
</div>
</div>
</div>
</div>
</Modal>
);
} else {
return null;
}
}
}
export default PreferencesModal;
|
app/components/workflow-toggle.spec.js
|
jelliotartz/Panoptes-Front-End
|
import React from 'react';
import assert from 'assert';
import { shallow } from 'enzyme';
import sinon from 'sinon';
import WorkflowToggle from './workflow-toggle';
const workflow = {
display_name: 'test workflow',
id: '1'
};
describe('WorkflowToggle', () => {
let wrapper;
let handleToggleSpy;
before(() => {
handleToggleSpy = sinon.spy();
wrapper = shallow(<WorkflowToggle workflow={workflow} handleToggle={handleToggleSpy} />);
});
it('renders without crashing', () => {
const workflowToggleContainer = wrapper.find('span');
assert.equal(workflowToggleContainer.length, 1);
});
it('renders a checkbox input', () => {
assert.equal(wrapper.find('input[type="checkbox"]').length, 1);
});
it('calls the handleToggle handler', () => {
wrapper.find('input').simulate('change');
sinon.assert.calledOnce(handleToggleSpy);
});
it('renders workflow prop text correctly', () => {
const spanText = wrapper.find('span').text();
assert.ok(spanText.match('1 - test workflow'), true);
});
it('renders a label for the input via Translate', () => {
assert.equal(wrapper.find('Translate').prop('content'), 'workflowToggle.label');
});
});
|
src/components/build_panel.js
|
RexSkz/drone-ui
|
import Humanize from './humanize';
import React from 'react';
import TimeAgo from 'react-timeago';
import zhStrings from 'react-timeago/lib/language-strings/zh-CN'
import buildFormatter from 'react-timeago/lib/formatters/buildFormatter'
import './build_panel.less';
export default
class BuildPanel extends React.Component {
renderParentLink(parent) {
const {repo} = this.props;
if (parent > 0) {
return (
<div>
<em>上级：</em> #{parent}
<a href={`/${repo.owner}/${repo.name}/${parent}`} className="parent-link">
<i className="material-icons">insert_link</i>
</a>
</div>
);
}
}
render() {
const { build, job } = this.props;
const formatter = buildFormatter(zhStrings);
let classes = ['build-panel', job.state || job.status];
let environs = [];
if (job && job.environ) {
Object.keys(job.environ).map((key) => {
environs.push(
<code key={key}>{key}={job.environ[key]}</code>
);
});
}
let branch = (build.refspec != '' && build.event == 'pull_request') ?
build.refspec : build.branch;
return (
<div className={classes.join(' ')}>
<h1>#{build.number} <span>{build.message}</span></h1>
<div className="build-panel-detail">
<div>
<div><em>分支：</em><span>{branch}</span></div>
<div>
<em>提交记录：</em><span>{build.commit.substr(0,8)}</span>
<a href={build.link_url} target="_blank" className="commit-link">
<i className="material-icons">insert_link</i>
</a>
</div>
<div><em>作者：</em><span>{build.author}</span></div>
{this.renderParentLink(build.parent)}
<p>{environs}</p>
</div>
<div>
<div>
<i className="material-icons">access_time</i>
{job.started_at ?
<TimeAgo date={(job.started_at || build.created_at) * 1000} formatter={formatter} /> :
<span>--</span>
}
</div>
<div>
<i className="material-icons">timelapse</i>
{job.finished_at ?
<Humanize finished={job.finished_at} start={job.started_at} /> :
<TimeAgo date={(job.started_at || build.created_at) * 1000} formatter={formatter} />
}
</div>
</div>
</div>
<div>{this.props.children}</div>
</div>
);
}
}
|
admin/client/App/elemental/ScreenReaderOnly/index.js
|
rafmsou/keystone
|
import React from 'react';
import { css, StyleSheet } from 'aphrodite/no-important';
function ScreenReaderOnly ({ className, ...props }) {
props.className = css(classes.srOnly, className);
return <span {...props} />;
};
const classes = StyleSheet.create({
srOnly: {
border: 0,
clip: 'rect(0,0,0,0)',
height: 1,
margin: -1,
overflow: 'hidden',
padding: 0,
position: 'absolute',
width: 1,
},
});
module.exports = ScreenReaderOnly;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.