path
stringlengths 5
296
| repo_name
stringlengths 5
85
| content
stringlengths 25
1.05M
|
|---|---|---|
app/components/Slider.js
|
firewenda/testwebsite
|
import React from 'react';
import Slider from 'react-slick';
class SimpleSlider extends React.Component{
render(){
let settings = {
dots: true,
infinite: true,
speed: 500,
slidesToShow: 1,
slidesToScroll: 1,
autoplay: true,
};
return (
<div className='slide-carousel'>
<Slider {...settings}>
<div><img src='/img/banner/banner1.jpg' /></div>
<div><img src='/img/banner/banner2.jpg' /></div>
<div><img src='/img/banner/banner3.jpg' /></div>
</Slider>
</div>
);
}
}
export default SimpleSlider;
|
src/js/Containers/NewsContainer.js
|
RoyalSix/Eagle-Connect
|
/**
* @file This is the container for the actual component
* This file should handle the business logic of the component
* There should be no styling/css properties in this file
* In this way we can have a separation of concerns handle
* will allow for easier testing
* {@link https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0}
*/
import React, { Component } from 'react';
//These are required for react to work
import { connect } from 'react-redux'
/**
* This allows us to get access to the store from the state we pass
* {@see mapStateToProps}
*/
import { ListView } from 'react-native';
//This is the component that we will need to create a List ListView
//type of datasource to feed to the component
//{@link https://facebook.github.io/react-native/docs/listview.html}
import News from '../Components/News';
//This is the actual component that contains styling to be rendered
class NewsContainer extends Component {
render() {
//React render function to be called everytime there is new props
var listSource =
new ListView.DataSource({
rowHasChanged: (row1, row2) => row1 !== row2,
sectionHeaderHasChanged: (s1, s2) => s1 !== s2
});
var dataSource = listSource.cloneWithRows(this.props.news);
/*
* This is going to be the data that will be sent to the child component
* this.props.chapels is defined in chapelActions and is getting fetched in app container
* From the action it goes to the reducer by the tyoe name RECEIVE_CHAPEL_LOAD
* and then merged in the store
* This is a standard redux flow Action -> Reducer -> Container (this file) -> Component (Chapel.js)
*/
return (
<News dataSource={dataSource}/>
)
}
}
const mapStateToProps = (state) => {
return { ...state.newsReducer }
/**
* This function allows us to take whatever is in the store of our choosing (chapelReducer)
* And send it the this containers props {@see this.props.chapel in render function}
* This will take everything from the state in {@see chapelReducer}
*/
}
export default connect(mapStateToProps)(NewsContainer)
|
packages/react/src/views/Server.js
|
wq/wq.app
|
import React from 'react';
import { useRenderContext } from '../hooks';
const HTML = '@@HTML';
export default function Server() {
const html = useRenderContext()[HTML];
return (
<>
<p>This renderer does not (yet) support server-rendered HTML.</p>
<pre>
<code>{html}</code>
</pre>
</>
);
}
|
src/frontend/components/EventView.js
|
Bernie-2016/ground-control
|
import React from 'react'
import Relay from 'react-relay'
import {BernieText} from './styles/bernie-css'
import {Paper, Styles} from 'material-ui'
import EventPreview from './EventPreview'
import EventInvalid from './EventInvalid'
import yup from 'yup'
import MuiThemeProvider from 'material-ui/lib/MuiThemeProvider'
import {BernieTheme} from './styles/bernie-theme'
const publicEventsRootUrl = 'https://secure.berniesanders.com/page/event/detail/'
class EventView extends React.Component {
styles = {
pageContainer: {
margin: '0 auto',
padding: '1rem',
maxWidth: 1100
}
}
render() {
if (!this.props.event)
return <EventInvalid />
let event_type_name = 'volunteer event'
if(this.props.event.eventType.name.toLowerCase().indexOf('phone bank') > -1){
event_type_name = 'phone bank party'
}
else if(this.props.event.eventType.name.toLowerCase().indexOf('barnstorm') > -1){
event_type_name = 'Barnstorm event'
}
return (
<MuiThemeProvider muiTheme={Styles.getMuiTheme(BernieTheme)}>
<div style={this.styles.pageContainer}>
<p style={BernieText.secondaryTitle}>Event Details:</p>
<EventPreview event={this.props.event} />
</div>
</MuiThemeProvider>
)
}
}
export default Relay.createContainer(EventView, {
fragments: {
event: () => Relay.QL`
fragment on Event {
attendeesCount
attendeeVolunteerMessage
attendeeVolunteerShow
capacity
contactPhone
createDate
description
duration
eventIdObfuscated
eventType {
id
name
}
flagApproval
host {
id
firstName
lastName
}
hostReceiveRsvpEmails
id
isSearchable
isOfficial
latitude
localTimezone
localUTCOffset
longitude
name
publicPhone
rsvpEmailReminderHours
rsvpUseReminderEmail
startDate
venueAddr1
venueAddr2
venueCity
venueCountry
venueDirections
venueName
venueState
venueZip
}
`
}
})
|
client/views/directory/ChannelsTab.js
|
VoiSmart/Rocket.Chat
|
import React from 'react';
import NotAuthorizedPage from '../../components/NotAuthorizedPage';
import { usePermission } from '../../contexts/AuthorizationContext';
import ChannelsTable from './ChannelsTable';
function ChannelsTab(props) {
const canViewPublicRooms = usePermission('view-c-room');
if (canViewPublicRooms) {
return <ChannelsTable {...props} />;
}
return <NotAuthorizedPage />;
}
export default ChannelsTab;
|
app/components/H3/index.js
|
rajeshbhatt/shopping-cart-redux
|
import React from 'react';
function H3(props) {
return (
<h3 {...props} />
);
}
export default H3;
|
src/Parser/Druid/Guardian/Modules/Features/FrenziedRegenGoEProcs.js
|
hasseboulen/WoWAnalyzer
|
import React from 'react';
import { formatPercentage } from 'common/format';
import SpellIcon from 'common/SpellIcon';
import StatisticBox, { STATISTIC_ORDER } from 'Main/StatisticBox';
import SPELLS from 'common/SPELLS';
import Analyzer from 'Parser/Core/Analyzer';
import Combatants from 'Parser/Core/Modules/Combatants';
import GuardianOfElune from './GuardianOfElune';
class FrenziedRegenGoEProcs extends Analyzer {
static dependencies = {
combatants: Combatants,
guardianOfElune: GuardianOfElune,
};
on_initialized() {
this.active = this.combatants.selected.hasTalent(SPELLS.GUARDIAN_OF_ELUNE_TALENT.id);
}
statistic() {
const nonGoEFRegen = this.guardianOfElune.nonGoEFRegen;
const GoEFRegen = this.guardianOfElune.GoEFRegen;
if ((nonGoEFRegen + GoEFRegen) === 0) {
return null;
}
return (
<StatisticBox
icon={<SpellIcon id={SPELLS.FRENZIED_REGENERATION.id} />}
value={`${formatPercentage(nonGoEFRegen / (nonGoEFRegen + GoEFRegen))}%`}
label="Unbuffed Frenzied Regen"
tooltip={`You cast <b>${nonGoEFRegen + GoEFRegen}</b> total ${SPELLS.FRENZIED_REGENERATION.name} and <b> ${GoEFRegen}</b> were buffed by 20%.`}
/>
);
}
statisticOrder = STATISTIC_ORDER.CORE(8);
}
export default FrenziedRegenGoEProcs;
|
frontend/src/Settings/CustomFormats/CustomFormats/Specifications/AddSpecificationModalContentConnector.js
|
geogolem/Radarr
|
import PropTypes from 'prop-types';
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { createSelector } from 'reselect';
import { fetchCustomFormatSpecificationSchema, selectCustomFormatSpecificationSchema } from 'Store/Actions/settingsActions';
import AddSpecificationModalContent from './AddSpecificationModalContent';
function createMapStateToProps() {
return createSelector(
(state) => state.settings.customFormatSpecifications,
(specifications) => {
const {
isSchemaFetching,
isSchemaPopulated,
schemaError,
schema
} = specifications;
return {
isSchemaFetching,
isSchemaPopulated,
schemaError,
schema
};
}
);
}
const mapDispatchToProps = {
fetchCustomFormatSpecificationSchema,
selectCustomFormatSpecificationSchema
};
class AddSpecificationModalContentConnector extends Component {
//
// Lifecycle
componentDidMount() {
this.props.fetchCustomFormatSpecificationSchema();
}
//
// Listeners
onSpecificationSelect = ({ implementation, name }) => {
this.props.selectCustomFormatSpecificationSchema({ implementation, presetName: name });
this.props.onModalClose({ specificationSelected: true });
}
//
// Render
render() {
return (
<AddSpecificationModalContent
{...this.props}
onSpecificationSelect={this.onSpecificationSelect}
/>
);
}
}
AddSpecificationModalContentConnector.propTypes = {
fetchCustomFormatSpecificationSchema: PropTypes.func.isRequired,
selectCustomFormatSpecificationSchema: PropTypes.func.isRequired,
onModalClose: PropTypes.func.isRequired
};
export default connect(createMapStateToProps, mapDispatchToProps)(AddSpecificationModalContentConnector);
|
src/js/views/UserArea/UserArea.js
|
TheoZimm/SaltyDashboard
|
import React from 'react';
import {AuthorizedComponent} from 'react-router-role-authorization';
import routes from '../../routes';
class UserArea extends AuthorizedComponent {
constructor(props) {
super(props);
// Get user role from localStorage(session) and define allowed roles
this.userRoles = [JSON.parse(localStorage.getItem('user')).role];
this.notAuthorizedPath = '/unauthorized';
}
// Send props to routes
// This define where to routes redirect depending user roles
render() {
return (
<div>
<routes {...this.props}/>
</div>
);
};
}
;
export default UserArea;
|
src/svg-icons/editor/space-bar.js
|
skarnecki/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let EditorSpaceBar = (props) => (
<SvgIcon {...props}>
<path d="M18 9v4H6V9H4v6h16V9z"/>
</SvgIcon>
);
EditorSpaceBar = pure(EditorSpaceBar);
EditorSpaceBar.displayName = 'EditorSpaceBar';
export default EditorSpaceBar;
|
src/screens/main/main.screen.js
|
Barylskyigb/simple-debts-react-native
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import {
View,
Text,
FlatList,
Image,
RefreshControl,
TouchableWithoutFeedback,
ActivityIndicator
} from 'react-native';
import Icon from 'react-native-vector-icons/FontAwesome';
import IonIcon from 'react-native-vector-icons/Ionicons';
import Debt from '../../components/Debt/Debt.presenter';
import debtScreenStyles from '../debt/debt.styles';
import styles from './main.styles';
import * as colors from '../../utils/colors';
import TouchableArea from '../../components/TouchableArea/TouchableArea';
import AddPopup from './AddPopup/AddPopup';
import AddConfirmationPopup from './AddConfirmationPopup/AddConfirmationPopup.presenter';
import HeaderButton from '../../components/HeaderButton/HeaderButton';
import * as firebase from 'react-native-firebase';
export default class MainScreen extends Component {
static navigationOptions = ({ navigation }) => {
const { params = {} } = navigation.state;
const { signOut } = params;
return {
headerLeft: (
<HeaderButton onPress={signOut}>
<IonIcon name="ios-log-out" size={22} color={colors.white} />
</HeaderButton>
),
headerRight: (
<View style={styles.popupButtonWrapper}>
<TouchableArea
onPress={params.toggleAddPopup}
borderless
style={styles.popupButton}
>
<Icon name="plus" size={20} color="white" />
</TouchableArea>
</View>
),
headerTransparent: true
};
};
static propTypes = {
user: PropTypes.object.isRequired,
navigation: PropTypes.object.isRequired,
fetchDebts: PropTypes.func.isRequired,
debts: PropTypes.array.isRequired,
uploadPushToken: PropTypes.func.isRequired,
signOut: PropTypes.func.isRequired
};
state = {
refreshing: false,
loading: false,
popupVisible: false,
userToAdd: {}
};
componentDidMount() {
const { navigation } = this.props;
navigation.setParams({
toggleAddPopup: this.toggleAddPopup,
signOut: this.signOut
});
navigation.addListener('didFocus', this.onFocus);
this.requestPushNotificationsPermissions();
// if app was in background
this.onNotificationOpened = firebase
.notifications()
.onNotificationOpened(this.handleOpenedNotification);
}
componentWillUnmount() {
// remove the callback
this.onNotificationOpened();
}
requestPushNotificationsPermissions = async () => {
const { uploadPushToken } = this.props;
const enabled = await firebase.messaging().hasPermission();
if (enabled) {
console.log("we've got push permissions");
} else {
try {
console.log('requesting permission');
await firebase.messaging().requestPermission();
} catch (error) {
console.log('permissions rejected :(');
}
}
const fcmToken = await firebase.messaging().getToken();
if (fcmToken) {
uploadPushToken(fcmToken);
} else {
console.log('could not get push token from firebase');
}
};
handleOpenedNotification = ({ notification }) => {
if (notification && notification.data.debtsId) {
this.goToDebt(notification.data.debtsId);
}
};
onFocus = async () => {
const { fetchDebts } = this.props;
this.setState({ loading: true });
await fetchDebts();
this.setState({ loading: false });
};
signOut = () => this.props.signOut();
onRefresh = async () => {
this.setState({ refreshing: true });
await this.props.fetchDebts();
this.setState({ refreshing: false });
};
goToDebt = debtId => {
const { navigation } = this.props;
navigation.navigate('DebtScreen', { debtId });
};
toggleAddPopup = () =>
this.setState(prevState => ({ popupVisible: !prevState.popupVisible }));
toggleConfirmationPopup = () =>
this.setState(prevState => ({
confirmationPopupVisible: !prevState.confirmationPopupVisible
}));
renderEmptyPlaceholder = () => {
const { loading } = this.state;
return loading ? (
<ActivityIndicator size="large" style={debtScreenStyles.spinner} />
) : (
<TouchableWithoutFeedback>
<View style={styles.placeholderContainer}>
<IonIcon name="ios-paper" size={40} color={colors.black} />
<Text style={styles.placeholderText}>
There are no records yet. Tap '+' to add one!
</Text>
</View>
</TouchableWithoutFeedback>
);
};
renderAddPopup = () => (
<AddPopup
isVisible={this.state.popupVisible}
onBackdropPress={this.toggleAddPopup}
onUserSelected={userToAdd => {
this.setState({ userToAdd });
this.toggleAddPopup();
setTimeout(this.toggleConfirmationPopup, 700);
}}
/>
);
renderAddConfirmationPopup = () => (
<AddConfirmationPopup
isVisible={this.state.confirmationPopupVisible}
onBackdropPress={this.toggleConfirmationPopup}
onClose={this.toggleConfirmationPopup}
onConfirmation={debtId => {
this.toggleConfirmationPopup();
this.props.navigation.navigate('DebtScreen', { debtId });
}}
user={this.state.userToAdd}
/>
);
renderSummary = () => {
const { user } = this.props;
return (
<View style={styles.summaryContainer}>
<Image source={{ uri: user.picture }} style={styles.summaryAvatar} />
<Text style={styles.summaryText}>{user.name}</Text>
</View>
);
};
render() {
const { debts } = this.props;
const { refreshing } = this.state;
return (
<View style={styles.container}>
{this.renderAddPopup()}
{this.renderSummary()}
{this.renderAddConfirmationPopup()}
<View style={styles.listContainer}>
<FlatList
data={debts}
renderItem={({ item }) => (
<Debt debt={item} onPress={() => this.goToDebt(item.id)} />
)}
keyExtractor={item => item.id}
ListEmptyComponent={this.renderEmptyPlaceholder}
refreshControl={
<RefreshControl
refreshing={refreshing}
onRefresh={this.onRefresh}
colors={['gray']}
tintColor="gray"
/>
}
/>
</View>
</View>
);
}
}
|
creditcardsimulation_redux_hooks/src/index.js
|
balaSpyrus/code
|
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { createStore } from 'redux';
import rootReducer from './reducers';
import './index.css';
import App from './App';
import * as serviceWorker from './serviceWorker';
const store = createStore(rootReducer);
ReactDOM.render(
<Provider store={store}>
<App />
</Provider>
,
document.getElementById('root'));
// If you want your app to work offline and load faster, you can change
// unregister() to register() below. Note this comes with some pitfalls.
// Learn more about service workers: https://bit.ly/CRA-PWA
serviceWorker.unregister();
|
packages/cf-builder-table/example/basic/component.js
|
manatarms/cf-ui
|
import React from 'react';
import { connect } from 'react-redux';
import { TableBuilder, tableReducer, tableActions } from 'cf-builder-table';
import { TableCell } from 'cf-component-table';
import { Button as ButtonUnstyled, ButtonTheme } from 'cf-component-button';
import { applyTheme } from 'cf-style-container';
const Button = applyTheme(ButtonUnstyled, ButtonTheme);
const EXAMPLE_TABLE = 'EXAMPLE_TABLE';
class BuilderTable extends React.Component {
constructor(props) {
super(props);
this.state = {
data: [
{ id: '1', name: 'James', coolness: 1 },
{ id: '2', name: 'David', coolness: -1 }
]
};
this.handleClick = this.handleClick.bind(this);
}
handleClick(id) {
this.setState(
{
data: this.state.data.map(item => {
return item.id === id
? { ...item, coolness: item.id === '1' ? Infinity : -Infinity }
: item;
})
},
() => {
this.props.dispatch(
tableActions.flashRow(EXAMPLE_TABLE, id, 'success')
);
}
);
}
render() {
return (
<TableBuilder
tableName={EXAMPLE_TABLE}
rows={this.state.data.map(item => {
return { id: item.id, cells: item };
})}
columns={[
{
label: 'Name',
cell: cells => {
return (
<TableCell key="name">
{cells.name}
</TableCell>
);
}
},
{
label: 'Coolness',
cell: cells => {
return (
<TableCell key="coolness">
{cells.coolness.toString()}
</TableCell>
);
}
},
{
label: 'Update',
cell: cells => {
return (
<TableCell key="actions">
<Button
type="default"
onClick={this.handleClick.bind(null, cells.id)}
>
Update
</Button>
</TableCell>
);
}
}
]}
/>
);
}
}
export default connect(() => ({}))(BuilderTable);
|
react/features/base/media/components/native/Video.js
|
bgrozev/jitsi-meet
|
// @flow
import React, { Component } from 'react';
import { RTCView } from 'react-native-webrtc';
import { Pressable } from '../../../react';
import styles from './styles';
import VideoTransform from './VideoTransform';
/**
* The type of the React {@code Component} props of {@link Video}.
*/
type Props = {
mirror: boolean,
onPlaying: Function,
/**
* Callback to invoke when the {@code Video} is clicked/pressed.
*/
onPress: Function,
stream: Object,
/**
* Similarly to the CSS property z-index, specifies the z-order of this
* Video in the stacking space of all Videos. When Videos overlap,
* zOrder determines which one covers the other. A Video with a larger
* zOrder generally covers a Video with a lower one.
*
* Non-overlapping Videos may safely share a z-order (because one does
* not have to cover the other).
*
* The support for zOrder is platform-dependent and/or
* implementation-specific. Thus, specifying a value for zOrder is to be
* thought of as giving a hint rather than as imposing a requirement.
* For example, video renderers such as Video are commonly implemented
* using OpenGL and OpenGL views may have different numbers of layers in
* their stacking space. Android has three: a layer bellow the window
* (aka default), a layer bellow the window again but above the previous
* layer (aka media overlay), and above the window. Consequently, it is
* advisable to limit the number of utilized layers in the stacking
* space to the minimum sufficient for the desired display. For example,
* a video call application usually needs a maximum of two zOrder
* values: 0 for the remote video(s) which appear in the background, and
* 1 for the local video(s) which appear above the remote video(s).
*/
zOrder: number,
/**
* Indicates whether zooming (pinch to zoom and/or drag) is enabled.
*/
zoomEnabled: boolean
};
/**
* The React Native {@link Component} which is similar to Web's
* {@code HTMLVideoElement} and wraps around react-native-webrtc's
* {@link RTCView}.
*/
export default class Video extends Component<Props> {
/**
* React Component method that executes once component is mounted.
*
* @inheritdoc
*/
componentDidMount() {
// RTCView currently does not support media events, so just fire
// onPlaying callback when <RTCView> is rendered.
const { onPlaying } = this.props;
onPlaying && onPlaying();
}
/**
* Implements React's {@link Component#render()}.
*
* @inheritdoc
* @returns {ReactElement|null}
*/
render() {
const { onPress, stream, zoomEnabled } = this.props;
if (stream) {
// RTCView
const style = styles.video;
const objectFit
= zoomEnabled
? 'contain'
: (style && style.objectFit) || 'cover';
const rtcView
= (
<RTCView
mirror = { this.props.mirror }
objectFit = { objectFit }
streamURL = { stream.toURL() }
style = { style }
zOrder = { this.props.zOrder } />
);
// VideoTransform implements "pinch to zoom". As part of "pinch to
// zoom", it implements onPress, of course.
if (zoomEnabled) {
return (
<VideoTransform
enabled = { zoomEnabled }
onPress = { onPress }
streamId = { stream.id }
style = { style }>
{ rtcView }
</VideoTransform>
);
}
// XXX Unfortunately, VideoTransform implements a custom press
// detection which has been observed to be very picky about the
// precision of the press unlike the builtin/default/standard press
// detection which is forgiving to imperceptible movements while
// pressing. It's not acceptable to be so picky, especially when
// "pinch to zoom" is not enabled.
return (
<Pressable onPress = { onPress }>
{ rtcView }
</Pressable>
);
}
// RTCView has peculiarities which may or may not be platform specific.
// For example, it doesn't accept an empty streamURL. If the execution
// reached here, it means that we explicitly chose to not initialize an
// RTCView as a way of dealing with its idiosyncrasies.
return null;
}
}
|
collect-webapp/frontend/src/datamanagement/components/recordeditor/fields/CompositeAttributeFormItem.js
|
openforis/collect
|
import React from 'react'
import { Col, Label, Row } from 'reactstrap'
const CompositeAttributeFormItem = ({ field, label, inputField, labelWidth = 50 }) => {
const widthPx = `${labelWidth}px`
return (
<Row key={field}>
<Col style={{ width: widthPx, maxWidth: widthPx }}>
<Label>{label}</Label>
</Col>
<Col>{inputField}</Col>
</Row>
)
}
export default CompositeAttributeFormItem
|
app/containers/LanguageProvider/index.js
|
oualid-mazouz/fbchallenge
|
/*
*
* LanguageProvider
*
* this component connects the redux state language locale to the
* IntlProvider component and i18n messages (loaded from `app/translations`)
*/
import React from 'react';
import { connect } from 'react-redux';
import { createSelector } from 'reselect';
import { IntlProvider } from 'react-intl';
import { makeSelectLocale } from './selectors';
export class LanguageProvider extends React.PureComponent { // eslint-disable-line react/prefer-stateless-function
render() {
return (
<IntlProvider locale={this.props.locale} key={this.props.locale} messages={this.props.messages[this.props.locale]}>
{React.Children.only(this.props.children)}
</IntlProvider>
);
}
}
LanguageProvider.propTypes = {
locale: React.PropTypes.string,
messages: React.PropTypes.object,
children: React.PropTypes.element.isRequired,
};
const mapStateToProps = createSelector(
makeSelectLocale(),
(locale) => ({ locale })
);
function mapDispatchToProps(dispatch) {
return {
dispatch,
};
}
export default connect(mapStateToProps, mapDispatchToProps)(LanguageProvider);
|
src/Icons/Cancel.js
|
hasseboulen/WoWAnalyzer
|
import React from 'react';
// https://thenounproject.com/search/?q=circled%20cross&i=1144421
// Created by johartcamp from the Noun Project
const Icon = ({ ...other }) => (
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" {...other}>
<path d="M 50 5 C 25.18272 5 5 25.1827 5 50 C 5 74.8173 25.18272 95 50 95 C 74.81728 95 95 74.8173 95 50 C 95 25.1827 74.81728 5 50 5 z M 50 11 C 71.57464 11 89 28.42534 89 50 C 89 71.5746 71.57464 89 50 89 C 28.42536 89 11 71.5746 11 50 C 11 28.42534 28.42536 11 50 11 z M 31.65625 28.96875 A 3.0003 3.0003 0 0 0 29.875 34.09375 L 45.75 50 L 29.875 65.875 A 3.0003 3.0003 0 1 0 34.125 70.09375 L 50 54.21875 L 65.875 70.09375 A 3.0003 3.0003 0 1 0 70.125 65.875 L 54.25 50 L 70.125 34.09375 A 3.0003 3.0003 0 0 0 67.65625 28.96875 A 3.0003 3.0003 0 0 0 65.875 29.875 L 50 45.75 L 34.125 29.875 A 3.0003 3.0003 0 0 0 31.65625 28.96875 z " />
</svg>
);
export default Icon;
|
frontends/xcms/app/index.js
|
suryakencana/niimanga
|
require('es6-shim');
require('./styles.css');
require("font-awesome-webpack");
require('bootstrap-table/dist/bootstrap-table.css');
require('bootstrap-table/dist/bootstrap-table.js');
import React from 'react';
import Router from 'utils/router';
import { Provider } from 'react-redux';
import configureStore from './store';
import fetchData from './utils/fetchData';
import rehydrate from './utils/rehydrate';
import { EventEmitter } from 'events';
const store = configureStore();
var loadingEvents = new EventEmitter();
var token = rehydrate();
var renderState = {
element: document.getElementById('app-container'),
Handler: null,
routerState: null
};
var render = () => {
var { element, Handler, routerState } = renderState;
loadingEvents.emit('start');
fetchData(token, routerState).then((data) => {
loadingEvents.emit('end');
React.render(
<Provider store={store}>
{ () => <Handler routerState={routerState} data={data} token={token} loadingEvents={loadingEvents} />}
</Provider>
, element);
});
};
Router.run((Handler, state) => {
renderState.Handler = Handler;
renderState.routerState = state;
render();
});
|
lib/cli/generators/REACT_NATIVE/template/storybook/stories/index.js
|
shilman/storybook
|
import React from 'react';
import { Text } from 'react-native';
import { storiesOf } from '@storybook/react-native';
import { action } from '@storybook/addon-actions';
import { linkTo } from '@storybook/addon-links';
import Button from './Button';
import CenterView from './CenterView';
import Welcome from './Welcome';
storiesOf('Welcome', module).add('to Storybook', () => <Welcome showApp={linkTo('Button')} />);
storiesOf('Button', module)
.addDecorator(getStory => <CenterView>{getStory()}</CenterView>)
.add('with text', () => (
<Button onPress={action('clicked-text')}>
<Text>Hello Button</Text>
</Button>
))
.add('with some emoji', () => (
<Button onPress={action('clicked-emoji')}>
<Text>😀 😎 👍 💯</Text>
</Button>
));
|
fields/types/relationship/RelationshipField.js
|
ligson/keystone
|
import _ from 'underscore';
import Field from '../Field';
import React from 'react';
import Select from 'react-select';
import superagent from 'superagent';
import { Button, FormInput } from 'elemental';
module.exports = Field.create({
displayName: 'RelationshipField',
shouldCollapse () {
// many:true relationships have an Array for a value
// so need to check length instead
if (this.props.many) {
return this.props.collapse && !this.props.value.length;
}
return this.props.collapse && !this.props.value;
},
getInitialState () {
return {
ready: this.props.value ? false : true,
simpleValue: this.props.value,
expandedValues: null
};
},
componentDidMount () {
this.loadValues(this.props.value);
},
componentWillReceiveProps (newProps) {
if (newProps.value !== this.state.simpleValue) {
this.setState({
ready: false,
simpleValue: newProps.value,
expandedValues: null
});
this.loadValues(newProps.value);
}
},
loadValues (input) {
var expandedValues = [];
var inputs = _.compact([].concat(input));
var self = this;
var finish = function () {
self.setState({
ready: true,
expandedValues: expandedValues
});
};
if (!inputs.length) return finish();
var callbackCount = 0;
_.each(inputs, function(input) {
expandedValues.push({
value: input
});
superagent
.get('/keystone/api/' + self.props.refList.path + '/' + input + '?simple')
.set('Accept', 'application/json')
.end(function (err, res) {
if (err) throw err;
var value = res.body;
_.findWhere(expandedValues, { value: value.id }).label = value.name;
callbackCount++;
if (callbackCount === inputs.length) {
finish();
}
});
});
},
buildFilters () {
var filters = {};
_.each(this.props.filters, function(value, key) {
if(_.isString(value) && value[0] == ':') {//eslint-disable-line eqeqeq
var fieldName = value.slice(1);
var val = this.props.values[fieldName];
if (val) {
filters[key] = val;
return;
}
// check if filtering by id and item was already saved
if (fieldName === ':_id' && Keystone.item) {
filters[key] = Keystone.item.id;
return;
}
} else {
filters[key] = value;
}
}, this);
var parts = [];
_.each(filters, function (val, key) {
parts.push('filters[' + key + ']=' + encodeURIComponent(val));
});
return parts.join('&');
},
buildOptionQuery (input) {
return 'context=relationship&q=' + input +
'&list=' + Keystone.list.path +
'&field=' + this.props.path +
'&' + this.buildFilters();
},
getOptions (input, callback) {
superagent
.get('/keystone/api/' + this.props.refList.path + '/autocomplete?' + this.buildOptionQuery(input))
.set('Accept', 'application/json')
.end(function (err, res) {
if (err) throw err;
var data = res.body;
callback(null, {
options: data.items.map(function (item) {
return {
value: item.id,
label: item.name
};
}),
complete: data.total === data.items.length
});
});
},
renderLoadingUI () {
return <div className='help-block'>loading...</div>;
},
updateValue (simpleValue, expandedValues) {
this.setState({
simpleValue: simpleValue,
expandedValues: expandedValues
});
this.props.onChange({
path: this.props.path,
value: this.props.many ? _.pluck(expandedValues, 'value') : simpleValue
});
},
renderValue () {
if (!this.state.ready) {
return this.renderLoadingUI();
}
// Todo: this is only a temporary fix, remodel
if (this.state.expandedValues && this.state.expandedValues.length) {
var body = [];
_.each(this.state.expandedValues, function (item, i) {
body.push(<FormInput key={i} noedit href={'/keystone/' + this.props.refList.path + '/' + item.value}>{item.label}</FormInput>);
}, this);
return body;
} else {
return <FormInput noedit>not set)</FormInput>;
}
},
renderField () {
if (!this.state.ready) {
return this.renderLoadingUI();
}
let button = (!this.props.many && this.props.value) ? (
<Button key="relational-button" type="link" href={'/keystone/' + this.props.refList.path + '/' + this.props.value} className='keystone-relational-button' title={'Go to "' + this.state.expandedValues[0].label + '"'}>
<span className="octicon octicon-file-symlink-file" />
</Button>
) : null;
return (
<div style={{ position: 'relative' }}>
<Select key="relationship-select" multi={this.props.many} onChange={this.updateValue} name={this.props.path} asyncOptions={this.getOptions} value={this.state.expandedValues} />
{button}
</div>
);
}
});
|
webapp-src/src/MainScreen/FullScreen.js
|
babelouest/taliesin
|
import React, { Component } from 'react';
import { Row, Col, Image, ButtonGroup, Button, MenuItem, DropdownButton } from 'react-bootstrap';
import FontAwesome from 'react-fontawesome';
import StateStore from '../lib/StateStore';
import i18n from '../lib/i18n';
class FullScreen extends Component {
constructor(props) {
super(props);
this.state = {
stream: StateStore.getState().profile.stream,
media: StateStore.getState().profile.mediaNow,
mediaNext: StateStore.getState().profile.mediaNext,
jukeboxIndex: StateStore.getState().profile.jukeboxIndex,
currentPlayer: StateStore.getState().profile.currentPlayer,
show: StateStore.getState().showFullScreen,
title: "",
titleNext: "",
imgBlob: false,
status: StateStore.getState().profile.currentPlayerStatus,
repeat: StateStore.getState().profile.currentPlayerRepeat,
random: StateStore.getState().profile.currentPlayerRandom,
volume: StateStore.getState().profile.currentPlayerVolume,
playerSwitch: StateStore.getState().profile.currentPlayerSwitch
};
StateStore.subscribe(() => {
if (this._ismounted) {
if (StateStore.getState().lastAction === "loadStream") {
this.setState({stream: StateStore.getState().profile.stream}, () => {this.loadMedia();});
} else if (StateStore.getState().lastAction === "setJukeboxIndex") {
this.setState({jukeboxIndex: StateStore.getState().profile.jukeboxIndex}, () => {this.loadMedia();});
} else if (StateStore.getState().lastAction === "setMediaNow") {
this.setState({media: StateStore.getState().profile.mediaNow,}, () => {this.loadMedia();});
} else if (StateStore.getState().lastAction === "setMediaNext") {
this.setState({mediaNext: StateStore.getState().profile.mediaNext}, () => {this.loadMedia();});
} else if (StateStore.getState().lastAction === "setCurrentPlayerStatus") {
this.setState({
status: StateStore.getState().profile.currentPlayerStatus,
repeat: StateStore.getState().profile.currentPlayerRepeat,
random: StateStore.getState().profile.currentPlayerRandom,
volume: StateStore.getState().profile.currentPlayerVolume,
playerSwitch: StateStore.getState().profile.currentPlayerSwitch
});
} else if (StateStore.getState().lastAction === "showFullScreen") {
this.setState({
stream: StateStore.getState().profile.stream,
media: StateStore.getState().profile.mediaNow,
mediaNext: StateStore.getState().profile.mediaNext,
jukeboxIndex: StateStore.getState().profile.jukeboxIndex,
show: StateStore.getState().showFullScreen,
title: "",
titleNext: "",
imgBlob: false,
status: StateStore.getState().profile.currentPlayerStatus,
repeat: StateStore.getState().profile.currentPlayerRepeat,
random: StateStore.getState().profile.currentPlayerRandom,
volume: StateStore.getState().profile.currentPlayerVolume,
playerSwitch: StateStore.getState().profile.currentPlayerSwitch
}, () => {this.loadMedia();});
} else if (StateStore.getState().lastAction === "loadStream" || StateStore.getState().lastAction === "loadStreamAndPlay") {
this.setState({stream: StateStore.getState().profile.stream}, () => {this.loadMedia();});
} else if (StateStore.getState().lastAction === "setJukeboxSwitch") {
this.setState({playerSwitch: StateStore.getState().profile.currentPlayerSwitch});
}
}
});
this.loadMedia = this.loadMedia.bind(this);
this.buildTitle = this.buildTitle.bind(this);
this.buildTitleNext = this.buildTitleNext.bind(this);
this.handleClose = this.handleClose.bind(this);
this.getMediaCover = this.getMediaCover.bind(this);
this.handleSelectArtist = this.handleSelectArtist.bind(this);
this.handleSelectAlbum = this.handleSelectAlbum.bind(this);
this.handleSelectYear = this.handleSelectYear.bind(this);
this.handleSelectGenre = this.handleSelectGenre.bind(this);
this.handlePlayerAction = this.handlePlayerAction.bind(this);
this.handleChangeVolume = this.handleChangeVolume.bind(this);
this.handleSelectFolder = this.handleSelectFolder.bind(this);
this.getMediaFolder = this.getMediaFolder.bind(this);
this.loadMedia();
}
componentWillReceiveProps(nextProps) {
this.setState({
stream: StateStore.getState().profile.stream,
media: StateStore.getState().profile.mediaNow,
mediaNext: StateStore.getState().profile.mediaNext,
jukeboxIndex: StateStore.getState().profile.jukeboxIndex,
show: StateStore.getState().showFullScreen,
title: "",
titleNext: "",
imgBlob: false,
status: StateStore.getState().profile.currentPlayerStatus,
repeat: StateStore.getState().profile.currentPlayerRepeat,
random: StateStore.getState().profile.currentPlayerRandom,
volume: StateStore.getState().profile.currentPlayerVolume,
playerSwitch: StateStore.getState().profile.currentPlayerSwitch
}, () => {
this.loadMedia();
});
}
componentWillUnmount() {
this._ismounted = false;
}
componentDidMount() {
this._ismounted = true;
}
loadMedia() {
if (this._ismounted) {
this.setState({title: this.buildTitle(), titleNext: this.buildTitleNext()});
this.getMediaCover();
this.getMediaFolder();
}
}
buildTitle() {
var title = "";
if (!!this.state.media && !!this.state.media.tags) {
if (this.state.jukeboxIndex > -1 && !this.state.stream.webradio) {
title += ((this.state.jukeboxIndex+1)<10?"0"+(this.state.jukeboxIndex+1):(this.state.jukeboxIndex+1)) + "/" + (this.state.stream.elements<10?"0"+this.state.stream.elements:this.state.stream.elements) + " - ";
}
if (!!this.state.media.tags && !!this.state.media.tags.title) {
title += this.state.media.tags.title;
} else {
title += this.state.media.name.replace(/\.[^/.]+$/, "");
}
}
return title;
}
buildTitleNext() {
var title = "";
if (!!this.state.mediaNext && !!this.state.mediaNext.tags) {
if (this.state.mediaNext.tags.artist) {
title += this.state.mediaNext.tags.artist + " - ";
}
if (this.state.jukeboxIndex > -1 && !this.state.stream.webradio) {
title += ((this.state.jukeboxIndex+1)<10?"0"+(this.state.jukeboxIndex+1):(this.state.jukeboxIndex+1)) + "/" + (this.state.stream.elements<10?"0"+this.state.stream.elements:this.state.stream.elements) + " - ";
}
if (!!this.state.mediaNext.tags && !!this.state.mediaNext.tags.title) {
title += this.state.mediaNext.tags.title;
} else {
title += this.state.mediaNext.name.replace(/\.[^/.]+$/, "");
}
}
return title;
}
handleClose() {
StateStore.dispatch({type: "showFullScreen", show: false});
}
handleSelectArtist(value) {
StateStore.dispatch({type: "showFullScreen", show: false});
StateStore.dispatch({type: "setCurrentBrowse", browse: "category"});
StateStore.dispatch({type: "setCurrentDataSource", currentDataSource: StateStore.getState().dataSourceList.find((ds) => {return ds.name === this.state.media.data_source})});
StateStore.dispatch({type: "setCurrentCategory", category: "artist", categoryValue: value});
}
getMediaFolder() {
var media = this.state.media;
if (media) {
if (media.path) {
if (media.path.lastIndexOf("/") > -1) {
media.folder = media.path.substring(0, media.path.lastIndexOf("/"));
} else {
media.folder = "";
}
this.setState({media: media});
} else {
media.folder = "";
this.setState({media: media});
}
}
}
handleSelectAlbum(value) {
StateStore.dispatch({type: "showFullScreen", show: false});
StateStore.dispatch({type: "setCurrentBrowse", browse: "category"});
StateStore.dispatch({type: "setCurrentDataSource", currentDataSource: StateStore.getState().dataSourceList.find((ds) => {return ds.name === this.state.media.data_source})});
StateStore.dispatch({type: "setCurrentCategory", category: "album", categoryValue: value});
}
handleSelectYear(value) {
StateStore.dispatch({type: "showFullScreen", show: false});
StateStore.dispatch({type: "setCurrentBrowse", browse: "category"});
StateStore.dispatch({type: "setCurrentDataSource", currentDataSource: StateStore.getState().dataSourceList.find((ds) => {return ds.name === this.state.media.data_source})});
StateStore.dispatch({type: "setCurrentCategory", category: "year", categoryValue: value});
}
handleSelectGenre(value) {
StateStore.dispatch({type: "showFullScreen", show: false});
StateStore.dispatch({type: "setCurrentBrowse", browse: "category"});
StateStore.dispatch({type: "setCurrentDataSource", currentDataSource: StateStore.getState().dataSourceList.find((ds) => {return ds.name === this.state.media.data_source})});
StateStore.dispatch({type: "setCurrentCategory", category: "genre", categoryValue: value});
}
handlePlayerAction(action) {
StateStore.dispatch({type: "setPlayerAction", action: action});
}
handleChangeVolume(deltaVolume) {
var volume = this.state.volume + deltaVolume;
if (volume < 0) volume = 0;
if (volume > 100) volume = 100;
if (this._ismounted) {
this.setState({volume: (volume)}, () => {
StateStore.dispatch({type: "setPlayerAction", action: "volume", parameter: (deltaVolume)});
});
}
}
handleSelectFolder(value) {
StateStore.dispatch({type: "showFullScreen", show: false});
StateStore.dispatch({type: "setCurrentDataSource", currentDataSource: StateStore.getState().dataSourceList.find((ds) => {return ds.name === this.state.media.data_source})});
StateStore.dispatch({type: "setCurrentBrowse", browse: "path"});
StateStore.dispatch({type: "setCurrentPath", path: value});
}
getMediaCover() {
if (!!this.state.media && this.state.show && this._ismounted) {
StateStore.getState().APIManager.taliesinApiRequest("GET", "/data_source/" + encodeURIComponent(this.state.media.data_source) + "/browse/path/" + encodeURI(this.state.media.path).replace(/#/g, "%23").replace(/\+/g, "%2B") + "?cover&base64")
.then((result) => {
this.setState({imgBlob: result});
})
.fail(() => {
this.setState({imgBlob: false});
});
}
}
render() {
var mediaImage, metadata = [], separator, playButton, playButtonLarge, switchButton, switchButtonXs;
if (this.state.imgBlob) {
mediaImage = <Image src={"data:image/jpeg;base64," + this.state.imgBlob} className="cover-image-full center-block" responsive />;
} else {
mediaImage = <Image src="images/generic-album.png" className="cover-image-full center-block" responsive />;
}
if (this.state.status === "stop") {
playButton =
<Button title={i18n.t("common.play")} onClick={() => {this.handlePlayerAction("play")}}>
<FontAwesome name={"play"} />
</Button>;
playButtonLarge =
<Button bsSize="large" title={i18n.t("common.play")} onClick={() => {this.handlePlayerAction("play")}}>
<FontAwesome name={"play"} />
</Button>;
} else if (this.state.status === "pause") {
playButton =
<Button title={i18n.t("common.play")} onClick={() => {this.handlePlayerAction("pause")}}>
<FontAwesome name={"play"} />
</Button>;
playButtonLarge =
<Button bsSize="large" title={i18n.t("common.play")} onClick={() => {this.handlePlayerAction("pause")}}>
<FontAwesome name={"play"} />
</Button>;
} else if (!this.state.stream.webradio) {
playButton =
<Button title={i18n.t("common.pause")} onClick={() => {this.handlePlayerAction("pause")}}>
<FontAwesome name={"pause"} />
</Button>;
playButtonLarge =
<Button bsSize="large" title={i18n.t("common.pause")} onClick={() => {this.handlePlayerAction("pause")}}>
<FontAwesome name={"pause"} />
</Button>;
} else {
playButton =
<Button title={i18n.t("common.play")} disabled={true}>
<FontAwesome name={"play"} />
</Button>;
playButtonLarge =
<Button bsSize="large" title={i18n.t("common.play")} disabled={true}>
<FontAwesome name={"play"} />
</Button>;
}
if (this.state.media) {
if (this.state.media.tags.title) {
metadata.push(
<Row key={0}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.title")}</label>
</Col>
<Col xs={6}>
<span className="text-fullscreen">{this.state.media.tags.title}</span>
</Col>
</Row>);
}
var dm = Math.floor(this.state.media.duration/60000);
if (dm < 10) {
dm = "0" + dm;
}
var ds = Math.floor(this.state.media.duration/1000)%60;
if (ds < 10) {
ds = "0" + ds;
}
metadata.push(
<Row key={1}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.duration")}</label>
</Col>
<Col xs={6}>
<span className="text-fullscreen">{dm}:{ds}</span>
</Col>
</Row>);
if (this.state.media.tags.artist) {
metadata.push(
<Row key={2}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.artist")}</label>
</Col>
<Col xs={6}>
<span><a role="button" className="anchor-fullscreen" onClick={() => {this.handleSelectArtist(this.state.media.tags.artist)}}>{this.state.media.tags.artist}</a></span>
</Col>
</Row>);
}
if (this.state.media.tags.album) {
metadata.push(
<Row key={3}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.album")}</label>
</Col>
<Col xs={6}>
<span><a role="button" className="anchor-fullscreen" onClick={() => {this.handleSelectAlbum(this.state.media.tags.album)}}>{this.state.media.tags.album}</a></span>
</Col>
</Row>);
}
if (this.state.media.tags.date) {
metadata.push(
<Row key={4}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.date")}</label>
</Col>
<Col xs={6}>
<span><a role="button" className="anchor-fullscreen" onClick={() => {this.handleSelectYear(this.state.media.tags.date)}}>{this.state.media.tags.date.substring(0, 4)}</a></span>
</Col>
</Row>);
}
if (this.state.media.tags.genre) {
metadata.push(
<Row key={5}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.genre")}</label>
</Col>
<Col xs={6}>
<span><a role="button" className="anchor-fullscreen" onClick={() => {this.handleSelectGenre(this.state.media.tags.genre)}}>{this.state.media.tags.genre}</a></span>
</Col>
</Row>);
}
if (this.state.media.tags.copyright) {
metadata.push(
<Row key={5}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.copyright")}</label>
</Col>
<Col xs={6}>
<span>{this.state.media.tags.copyright}</span>
</Col>
</Row>);
}
metadata.push(
<Row key={6}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.open_folder")}</label>
</Col>
<Col xs={6}>
<span><a role="button" className="anchor-fullscreen" onClick={() => {this.handleSelectFolder(this.state.media.folder)}}>{this.state.media.data_source + "/" + this.state.media.folder}</a></span>
</Col>
</Row>
);
if (this.state.titleNext) {
metadata.push(
<Row key={7}>
<Col xs={6} className="text-right">
<label className="text-fullscreen">{i18n.t("common.title_next")}</label>
</Col>
<Col xs={6}>
<span className="text-fullscreen">{this.state.titleNext}</span>
</Col>
</Row>);
}
}
if (StateStore.getState().profile.currentPlayer.type === "carleon") {
switchButton =
<Button title={i18n.t("player.switch")} onClick={() => {this.handlePlayerAction("switch")}} className={(this.state.playerSwitch)?"btn-primary":""}>
<FontAwesome name={"power-off"} />
</Button>
switchButtonXs =
<Button bsSize="large" title={i18n.t("player.switch")} onClick={() => {this.handlePlayerAction("switch")}} className={(this.state.playerSwitch)?"btn-primary":""}>
<FontAwesome name={"power-off"} />
</Button>
}
return (
<div className={"fullscreen" + (!this.state.show?" hidden":"")} >
<div className="media-background-fullscreen" style={{backgroundImage:this.state.imgBlob?"url(data:image/png;base64,"+this.state.imgBlob+")":"" }}>
</div>
<Row style={{marginTop: "10px"}}>
<Col md={12} className="text-center">
<div className="text-fullscreen">{this.state.title}</div>
</Col>
</Row>
<Row style={{marginTop: "10px"}}>
<Col md={12} className="text-center hidden-sm hidden-xs">
<ButtonGroup>
<Button title={i18n.t("common.previous")} onClick={() => {this.handlePlayerAction("previous")}}>
<FontAwesome name={"fast-backward"} />
</Button>
<Button title={i18n.t("common.stop")} onClick={() => {this.handlePlayerAction("stop")}}>
<FontAwesome name={"stop"} />
</Button>
{playButton}
<Button title={i18n.t("common.next")} onClick={() => {this.handlePlayerAction("next")}}>
<FontAwesome name={"fast-forward"} />
</Button>
<Button title={i18n.t("common.repeat")} onClick={() => {this.handlePlayerAction("repeat")}} className={(this.state.repeat&&!this.state.stream.webradio)?"btn-primary":""} disabled={this.state.stream.webradio}>
<FontAwesome name={"repeat"} />
</Button>
<Button title={i18n.t("common.random")} onClick={() => {this.handlePlayerAction("random")}} className={(this.state.random&&!this.state.stream.webradio)?"btn-primary":""} disabled={this.state.stream.webradio}>
<FontAwesome name={"random"} />
</Button>
<DropdownButton title={<FontAwesome name={"volume-up"} />} pullRight id="dropdown-volume">
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(5)}}>{i18n.t("common.volume_plus_5")}</MenuItem>
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(1)}}>{i18n.t("common.volume_plus_1")}</MenuItem>
<MenuItem className="text-center">{i18n.t("common.volume_current")} {this.state.volume} %</MenuItem>
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(-1)}}>{i18n.t("common.volume_minus_1")}</MenuItem>
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(-5)}}>{i18n.t("common.volume_minus_5")}</MenuItem>
</DropdownButton>
{switchButton}
</ButtonGroup>
</Col>
<Col md={12} className="text-center visible-sm visible-xs">
<ButtonGroup>
<Button bsSize="large" title={i18n.t("common.previous")} onClick={() => {this.handlePlayerAction("previous")}}>
<FontAwesome name={"fast-backward"} />
</Button>
<Button bsSize="large" title={i18n.t("common.stop")} onClick={() => {this.handlePlayerAction("stop")}}>
<FontAwesome name={"stop"} />
</Button>
{playButtonLarge}
<Button bsSize="large" title={i18n.t("common.next")} onClick={() => {this.handlePlayerAction("next")}}>
<FontAwesome name={"fast-forward"} />
</Button>
<DropdownButton bsSize="large" title={<FontAwesome name={"volume-up"} />} pullRight id="dropdown-volume">
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(5)}}>{i18n.t("common.volume_plus_5")}</MenuItem>
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(1)}}>{i18n.t("common.volume_plus_1")}</MenuItem>
<MenuItem className="text-center">{i18n.t("common.volume_current")} {this.state.volume} %</MenuItem>
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(-1)}}>{i18n.t("common.volume_minus_1")}</MenuItem>
<MenuItem eventKey="1" className="text-center" onClick={() => {this.handleChangeVolume(-5)}}>{i18n.t("common.volume_minus_5")}</MenuItem>
</DropdownButton>
{switchButtonXs}
</ButtonGroup>
</Col>
</Row>
<Row style={{marginTop: "10px"}}>
<Col md={12}>
{mediaImage}
</Col>
</Row>
{separator}
{metadata}
<Row style={{marginTop: "10px"}}>
<Col md={12} className="text-center">
<Button onClick={this.handleClose} className="btn btn-success">
{i18n.t("common.close")}
</Button>
</Col>
</Row>
</div>
);
}
}
export default FullScreen;
|
app/javascript/mastodon/features/account_timeline/index.js
|
kirakiratter/mastodon
|
import React from 'react';
import { connect } from 'react-redux';
import ImmutablePropTypes from 'react-immutable-proptypes';
import PropTypes from 'prop-types';
import { fetchAccount } from '../../actions/accounts';
import { expandAccountFeaturedTimeline, expandAccountTimeline } from '../../actions/timelines';
import StatusList from '../../components/status_list';
import LoadingIndicator from '../../components/loading_indicator';
import Column from '../ui/components/column';
import HeaderContainer from './containers/header_container';
import ColumnBackButton from '../../components/column_back_button';
import { List as ImmutableList } from 'immutable';
import ImmutablePureComponent from 'react-immutable-pure-component';
import { FormattedMessage } from 'react-intl';
import { fetchAccountIdentityProofs } from '../../actions/identity_proofs';
import MissingIndicator from 'mastodon/components/missing_indicator';
const emptyList = ImmutableList();
const mapStateToProps = (state, { params: { accountId }, withReplies = false }) => {
const path = withReplies ? `${accountId}:with_replies` : accountId;
return {
isAccount: !!state.getIn(['accounts', accountId]),
statusIds: state.getIn(['timelines', `account:${path}`, 'items'], emptyList),
featuredStatusIds: withReplies ? ImmutableList() : state.getIn(['timelines', `account:${accountId}:pinned`, 'items'], emptyList),
isLoading: state.getIn(['timelines', `account:${path}`, 'isLoading']),
hasMore: state.getIn(['timelines', `account:${path}`, 'hasMore']),
blockedBy: state.getIn(['relationships', accountId, 'blocked_by'], false),
};
};
export default @connect(mapStateToProps)
class AccountTimeline extends ImmutablePureComponent {
static propTypes = {
params: PropTypes.object.isRequired,
dispatch: PropTypes.func.isRequired,
shouldUpdateScroll: PropTypes.func,
statusIds: ImmutablePropTypes.list,
featuredStatusIds: ImmutablePropTypes.list,
isLoading: PropTypes.bool,
hasMore: PropTypes.bool,
withReplies: PropTypes.bool,
blockedBy: PropTypes.bool,
isAccount: PropTypes.bool,
multiColumn: PropTypes.bool,
};
componentWillMount () {
const { params: { accountId }, withReplies } = this.props;
this.props.dispatch(fetchAccount(accountId));
this.props.dispatch(fetchAccountIdentityProofs(accountId));
if (!withReplies) {
this.props.dispatch(expandAccountFeaturedTimeline(accountId));
}
this.props.dispatch(expandAccountTimeline(accountId, { withReplies }));
}
componentWillReceiveProps (nextProps) {
if ((nextProps.params.accountId !== this.props.params.accountId && nextProps.params.accountId) || nextProps.withReplies !== this.props.withReplies) {
this.props.dispatch(fetchAccount(nextProps.params.accountId));
this.props.dispatch(fetchAccountIdentityProofs(nextProps.params.accountId));
if (!nextProps.withReplies) {
this.props.dispatch(expandAccountFeaturedTimeline(nextProps.params.accountId));
}
this.props.dispatch(expandAccountTimeline(nextProps.params.accountId, { withReplies: nextProps.params.withReplies }));
}
}
handleLoadMore = maxId => {
this.props.dispatch(expandAccountTimeline(this.props.params.accountId, { maxId, withReplies: this.props.withReplies }));
}
render () {
const { shouldUpdateScroll, statusIds, featuredStatusIds, isLoading, hasMore, blockedBy, isAccount, multiColumn } = this.props;
if (!isAccount) {
return (
<Column>
<ColumnBackButton multiColumn={multiColumn} />
<MissingIndicator />
</Column>
);
}
if (!statusIds && isLoading) {
return (
<Column>
<LoadingIndicator />
</Column>
);
}
const emptyMessage = blockedBy ? <FormattedMessage id='empty_column.account_unavailable' defaultMessage='Profile unavailable' /> : <FormattedMessage id='empty_column.account_timeline' defaultMessage='No toots here!' />;
return (
<Column>
<ColumnBackButton multiColumn={multiColumn} />
<StatusList
prepend={<HeaderContainer accountId={this.props.params.accountId} />}
alwaysPrepend
scrollKey='account_timeline'
statusIds={blockedBy ? emptyList : statusIds}
featuredStatusIds={featuredStatusIds}
isLoading={isLoading}
hasMore={hasMore}
onLoadMore={this.handleLoadMore}
shouldUpdateScroll={shouldUpdateScroll}
emptyMessage={emptyMessage}
bindToDocument={!multiColumn}
timelineId='account'
/>
</Column>
);
}
}
|
sonar-flow-plugin/src/main/js/components/FlowIssuesList.js
|
I8C/sonar-flow-plugin
|
import React from 'react';
import FlowIssueItem from './FlowIssueItem.js'
import {findIssues} from '../functions/sonar_api.js'
export default class FlowIssuesList extends React.PureComponent {
constructor(props) {
super(props);
// this.props.projectKey
// this.props.selectedIssue
// this.props.onSelection
this.state = {
issues: [],
components: []
};
this.handleSelection = this.handleSelection.bind(this);
}
componentDidMount() {
findIssues(this.props.projectKey).then(
(response) => {
this.setState({
issues: response.issues,
components: response.components
});
}
);
}
handleSelection(issue) {
this.props.onSelection(issue);
}
render() {
let issueItems = [];
let lastComponent=undefined;
this.state.issues.forEach(issue => {
issue.id=issue.key;
issueItems.push(
<div>
{issue.component!=lastComponent?<div className="concise-issue-component note text-ellipsis">{issue.component.replace(/.*:(.+?\/)(.+)(\/.+?\/.+)/,"$1...$3")}</div>:""}
<FlowIssueItem {...issue} onSelection={this.handleSelection} isSelected={this.props.selectedIssue.id==issue.id}/>
</div>
);
lastComponent=issue.component;
});
return (
<div className="search-navigator-facets-list">
<div>{issueItems}</div>
</div>
);
}
}
|
src/index.js
|
grishanin/moviepilot-trending
|
import React from 'react';
import App from './App';
require('./css/main.less');
React.render(<App />, document.getElementById('root'));
|
tests/react_modules/es6class-proptypes-callsite.js
|
facebook/flow
|
/* @flow */
import React from 'react';
import Hello from './es6class-proptypes-module';
import type {Node} from 'react';
class HelloLocal extends React.Component<{name: string}> {
defaultProps = {};
propTypes = {
name: React.PropTypes.string.isRequired,
};
render(): Node {
return <div>{this.props.name}</div>;
}
}
class Callsite extends React.Component<{}> {
render(): Node {
return (
<div>
<Hello />
<HelloLocal />
</div>
);
}
}
module.exports = Callsite;
|
app/components/views/videoTabs/VideoList.js
|
MutatedBread/binary-academy-rn
|
import React, { Component } from 'react';
import { View } from 'react-native';
import {
List,
Content,
Container,
ListItem,
Left,
Right,
Body,
Button,
Thumbnail,
Text,
Icon
} from 'native-base';
import Loading from './Loading.js'
import LoadingMoreVideoSpinner from './LoadingMoreVideoSpinner.js'
import VideoItem from './VideoItem.js'
var YoutubeFetch = require('./../../YoutubeAPI/YoutubeFetch.js');
var YoutubeFetchStatus = require('./../../YoutubeAPI/YoutubeFetchStatus.js');
export default class VideoList extends Component {
constructor(props) {
super(props);
this.youtubeFetch = new YoutubeFetch(this.props.playlistId);
}
async componentWillMount() {
await this.loadVideos(YoutubeFetchStatus.NEW);
}
loadVideos = async (status) => {
if(status === YoutubeFetchStatus.NEXT_PAGE)
this.props.loadingFunction(true);
var vids = this.props.videoArrayStore;
let json = await this.youtubeFetch.getPlaylistDetails(status);
for(var i = 0; i < await json.items.length; i++) {
if(json.items[i].snippet.thumbnails) {
vids.push({
title: json.items[i].snippet.title,
medium_img_url: json.items[i].snippet.thumbnails.medium.url,
videoId: json.items[i].snippet.resourceId.videoId
});
}
}
this.props.videoArrayUpdateFunction(await vids);
if(status === YoutubeFetchStatus.NEXT_PAGE)
this.props.loadingFunction(false);
this.forceUpdate();
}
render() {
return (
<Container>
<Container>
{
(this.props.videoArrayStore.length > 0) ?
<List
dataArray={this.props.videoArrayStore}
renderRow={(video) =>
<VideoItem onPress={this.props.viewVideo} video={video}/>
}
renderFooter={() =>
<ListItem center>
{
this.props.isLoading ?
<Icon name="ios-more" />
:
this.youtubeFetch.hasNextPage() ?
<Button binary onPress={() => this.loadVideos(YoutubeFetchStatus.NEXT_PAGE)}>
<Text> More Videos </Text>
</Button>
:
null
}
</ListItem>
}
>
</List>
:
<Loading />
}
</Container>
{
(this.props.isLoading) ?
<LoadingMoreVideoSpinner /> : null
}
</Container>
);
}''
}
|
src/MultiCascader/test/DropdownMenuSpec.js
|
suitejs/suite
|
import React from 'react';
import ReactTestUtils from 'react-dom/test-utils';
import { getDOMNode, getInstance } from '@test/testUtils';
import DropdownMenu from '../DropdownMenu';
import Dropdown from '../MultiCascader';
const classPrefix = 'rs-picker-cascader-menu';
const items = [
{
value: 'abc',
label: 'abc'
},
{
value: 'abcd',
label: 'abcd'
},
{
value: 'abcde',
label: 'abcde',
children: [
{
value: 'vv-abc',
label: 'vv-abc'
},
{
value: 'vv-abcd',
label: 'vv-abcd'
}
]
}
];
describe('MultiCascader - DropdownMenu', () => {
it('Should output a `cascader-menu-items` ', () => {
const instance = getDOMNode(<DropdownMenu classPrefix={classPrefix} />);
assert.ok(instance.className.match(/\bcascader-menu-items\b/));
});
it('Should output 3 `menu-item` ', () => {
const instance = getInstance(<Dropdown defaultOpen data={items} />);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
assert.equal(menuContainer.querySelectorAll('li').length, 3);
});
it('Should have a menuWidth', () => {
const instance = getInstance(<Dropdown defaultOpen data={items} menuWidth={100} />);
const menuContainer = getDOMNode(instance.menuContainerRef.current).querySelector(
'.rs-picker-cascader-menu-column'
);
assert.ok(menuContainer.style.width, '100px');
});
it('Should output 3 `menu-item` ', () => {
const data = [
{
myValue: 'abc',
myLabel: 'abc'
},
{
myValue: 'abcd',
myLabel: 'abcd'
},
{
myLabel: 'vvv',
items: [
{
myValue: 'vv-abc',
myLabel: 'vv-abc'
},
{
myValue: 'vv-abcd',
myLabel: 'vv-abcd'
}
]
}
];
const instance = getInstance(
<Dropdown defaultOpen labelKey="myLabel" valueKey="myValue" childrenKey="items" data={data} />
);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
assert.equal(menuContainer.querySelectorAll('li').length, 3);
});
it('Should call onSelect callback ', done => {
const doneOp = node => {
if (node.value === 'abcd') {
done();
}
};
const instance = getInstance(<Dropdown defaultOpen data={items} onSelect={doneOp} />);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
ReactTestUtils.Simulate.click(menuContainer.querySelectorAll('.rs-checkbox')[1]);
});
it('Should call onSelect callback 2 count', () => {
const onSelectSpy = sinon.spy();
const instance = getInstance(
<Dropdown defaultOpen data={items} disabledItemValues={['abcd']} onSelect={onSelectSpy} />
);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
setTimeout(() => {
ReactTestUtils.Simulate.click(menuContainer.querySelectorAll('.rs-checkbox')[0]);
ReactTestUtils.Simulate.click(menuContainer.querySelectorAll('.rs-checkbox')[2]);
assert.equal(onSelectSpy.callCount, 2);
}, 1);
});
it('Should not call onSelect callback on disabled item', () => {
const onSelectSpy = sinon.spy();
const instance = getInstance(
<Dropdown defaultOpen data={items} disabledItemValues={['abcd']} onSelect={onSelectSpy} />
);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
ReactTestUtils.Simulate.click(menuContainer.querySelectorAll('.rs-checkbox')[1]);
assert.ok(onSelectSpy.notCalled);
});
it('Should call renderMenuItem callback ', () => {
const instance = getInstance(
<Dropdown defaultOpen data={items} renderMenuItem={item => <i>{item}</i>} />
);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
assert.equal(menuContainer.querySelectorAll('.rs-checkbox i').length, 3);
});
it('Should be disabled item ', () => {
const instance = getInstance(
<Dropdown defaultOpen data={items} disabledItemValues={['abcd', 'abcde']} />
);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
assert.ok(menuContainer.querySelectorAll('.rs-checkbox')[1].className.match(/\bdisabled\b/));
assert.ok(menuContainer.querySelectorAll('.rs-checkbox')[2].className.match(/\bdisabled\b/));
});
it('Should be uncheckable item ', () => {
const instance = getInstance(
<Dropdown defaultOpen data={items} uncheckableItemValues={['abcd', 'abcde']} />
);
const menuContainer = getDOMNode(instance.menuContainerRef.current);
assert.equal(menuContainer.querySelectorAll('input').length, 1);
});
it('Should have a custom className', () => {
const instance = getDOMNode(<DropdownMenu classPrefix="cascader" className="custom" />);
assert.ok(instance.className.match(/\bcustom\b/));
});
it('Should have a custom style', () => {
const fontSize = '12px';
const instance = getDOMNode(<DropdownMenu classPrefix="cascader" style={{ fontSize }} />);
assert.equal(instance.style.fontSize, fontSize);
});
it('Should have a custom className prefix', () => {
const instance = getDOMNode(<DropdownMenu classPrefix="custom-prefix" />);
assert.ok(instance.className.match(/\bcustom-prefix\b/));
});
});
|
app/static/src/diagnostic/EquipmentForm_modules/AditionalEqupmentParameters_modules/TransformerParams.js
|
SnowBeaver/Vision
|
import React from 'react';
import FormControl from 'react-bootstrap/lib/FormControl';
import FormGroup from 'react-bootstrap/lib/FormGroup';
import ControlLabel from 'react-bootstrap/lib/ControlLabel';
import {findDOMNode} from 'react-dom';
import {hashHistory} from 'react-router';
import {Link} from 'react-router';
import Checkbox from 'react-bootstrap/lib/Checkbox';
import OverlayTrigger from 'react-bootstrap/lib/OverlayTrigger';
import Tooltip from 'react-bootstrap/lib/Tooltip';
import HelpBlock from 'react-bootstrap/lib/HelpBlock';
const TextField = React.createClass({
_onChange: function (e) {
this.props.onChange(e);
},
render: function () {
let tooltip = <Tooltip id={this.props.label}>{this.props.label}</Tooltip>;
var label = (this.props.label != null) ? this.props.label : "";
var name = (this.props.name != null) ? this.props.name : "";
var type = (this.props["data-type"] != null) ? this.props["data-type"]: undefined;
var len = (this.props["data-len"] != null) ? this.props["data-len"]: undefined;
var choice = (this.props["data-choice"] != null) ? this.props["data-choice"]: undefined;
var validationState = (this.props.errors[name]) ? 'error' : null;
var error = this.props.errors[name];
var value = (this.props["value"] != null) ? this.props["value"]: "";
return (
<OverlayTrigger overlay={tooltip} placement="top">
<FormGroup validationState={validationState}>
<ControlLabel>{label}</ControlLabel>
<FormControl type="text"
placeholder={label}
name={name}
data-type={type}
data-len={len}
data-choice={choice}
onChange={this._onChange}
value={value}
/>
<HelpBlock className="warning">{error}</HelpBlock>
<FormControl.Feedback />
</FormGroup>
</OverlayTrigger>
);
}
});
var SelectField = React.createClass({
handleChange: function (e) {
this.props.onChange(e);
},
getInitialState: function () {
return {
items: [],
isVisible: false,
value: -1
};
},
isVisible: function () {
return this.state.isVisible;
},
componentDidMount: function () {
var source = '/api/v1.0/' + this.props.source + '/';
this.serverRequest = $.authorizedGet(source, function (result) {
this.setState({items: (result['result'])});
}.bind(this), 'json');
},
componentWillUnmount: function () {
this.serverRequest.abort();
},
setVisible: function () {
this.state.isVisible = true;
},
render: function () {
var label = (this.props.label != null) ? this.props.label : "";
var value = (this.props.value != null) ? this.props.value : "";
var name = (this.props.name != null) ? this.props.name : "";
var validationState = (this.props.errors[name]) ? 'error' : null;
var error = this.props.errors[name];
var required = this.props.required ? this.props.required : null;
var menuItems = [];
for (var key in this.state.items) {
menuItems.push(<option key={this.state.items[key].id}
value={this.state.items[key].id}>{`${this.state.items[key].name ? this.state.items[key].name : this.state.items[key].model}`}</option>);
}
return (
<FormGroup validationState={validationState}>
<ControlLabel>{label}</ControlLabel>
<FormControl componentClass="select"
onChange={this.handleChange}
value={value}
name={name}
required={required}
>
<option value="">{required ? this.props.label + " *" : this.props.label}</option>);
{menuItems}
</FormControl>
<HelpBlock className="warning">{error}</HelpBlock>
</FormGroup>
);
}
});
var BushSerialSelectField = React.createClass({
handleChange: function (event, index, value) {
this.setState({
value: event.target.value
});
},
getInitialState: function () {
return {
items: [],
isVisible: false,
value: -1
};
},
isVisible: function () {
return this.state.isVisible;
},
componentDidMount: function () {
var source = '/api/v1.0/' + this.props.source + '/';
this.serverRequest = $.authorizedGet(source, function (result) {
this.setState({items: (result['result'])});
}.bind(this), 'json');
},
componentWillUnmount: function () {
this.serverRequest.abort();
},
setVisible: function () {
this.state.isVisible = true;
},
render: function () {
var label = (this.props.label != null) ? this.props.label : "";
var value = (this.props.value != null) ? this.props.value : "";
var name = (this.props.name != null) ? this.props.name : "";
var validationState = (this.props.errors[name]) ? 'error' : null;
var error = this.props.errors[name];
var menuItems = [];
for (var key in this.state.items) {
menuItems.push(<option key={this.state.items[key].id}
value={this.state.items[key].id}>{`${this.state.items[key].name}`}</option>);
}
return (
<FormGroup validationState={validationState}>
<FormControl componentClass="select"
onChange={this.handleChange}
defaultValue={value}
name={name}
>
<option>{this.props.label}</option>);
{menuItems}
</FormControl>
<HelpBlock className="warning">{error}</HelpBlock>
</FormGroup>
);
}
});
var TransformerParams = React.createClass({
getInitialState: function () {
return {
'phase_number':'', 'threephase':'', 'fluid_volume':'', 'fluid_type_id':'',
'fluid_level_id':'', 'gassensor_id':'', 'bushing_serial1_id':'', 'bushing_serial2_id':'',
'bushing_serial3_id':'', 'bushing_serial4_id':'', 'bushing_serial5_id':'', 'bushing_serial6_id':'',
'bushing_serial7_id':'', 'bushing_serial8_id':'', 'bushing_serial9_id':'', 'bushing_serial10_id':'',
'bushing_serial11_id':'', 'bushing_serial12_id':'', 'mvaforced11':'', 'mvaforced12':'', 'mvaforced13':'',
'mvaforced14':'', 'imp_base1':'', 'imp_base2':'', 'impbasedmva3':'', 'impbasedmva4':'', 'mvaforced21':'', 'mvaforced22':'',
'mvaforced23':'', 'mvaforced24':'', 'mvaactual':'', 'mvaractual':'',
'mwreserve':'', 'mvareserve':'', 'mwultime':'', 'mvarultime':'',
'ratio_tag1':'', 'ratio_tag2':'', 'ratio_tag3':'', 'ratio_tag4':'',
'static_shield1':'', 'static_shield2':'', 'ratio_tag5':'', 'ratio_tag6':'',
'ratio_tag7':'', 'ratio_tag8':'', 'static_shield3':'', 'static_shield4':'',
'bushing_neutral1':'', 'bushing_neutral2':'', 'bushing_neutral3':'', 'bushing_neutral4':'',
'windings':'', 'winding_metal1':'', 'winding_metal2':'', 'winding_metal3':'', 'winding_metal4':'', 'primary_winding_connection':'', 'secondary_winding_connection':'',
'tertiary_winding_connection':'', 'quaternary_winding_connection':'', 'based_transformer_power':'', 'autotransformer':'',
'bil1':'', 'bil2':'', 'ltc1':'', 'ltc2':'',
'first_cooling_stage_power':'', 'second_cooling_stage_power':'',
'bil3':'', 'bil4':'', 'ltc3':'', 'third_cooling_stage_power':'',
'temperature_rise':'', 'cooling_rating':'', 'primary_tension':'', 'secondary_tension':'',
'tertiary_tension':'', 'impedance1':'', 'impedance2':'', 'impedance3':'', 'impedance4':'',
'formula_ratio1':'', 'formula_ratio2':'', 'formula_ratio3':'',
'sealed':'', 'welded_cover':'','id':'',
'errors': {}
}
},
handleChange: function(e){
var state = this.state;
if (e.target.type == "checkbox"){
state[e.target.name] = e.target.checked;
}
else
state[e.target.name] = e.target.value;
this.setState(state);
},
load:function() {
this.setState(this.props.equipment_item)
},
render: function () {
var errors = (Object.keys(this.state.errors).length) ? this.state.errors : this.props.errors;
return (
<div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Phase Number"
name="phase_number"
value={this.state.phase_number}
errors={errors}
data-choice={['1', '3', '6']}/>
</div>
<div className="col-md-2">
<Checkbox name="threephase" checked={this.state.threephase} onChange={this.handleChange}><b>Three Phase</b></Checkbox>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Fluid Volume"
name="fluid_volume"
value={this.state.fluid_volume}
errors={errors}
data-type="float"/>
</div>
{/*
<div className="col-md-2">
<SelectField
source="fluid_type"
label="Fluid Type"
value={this.state.fluid_type_id}
errors={errors}
name="fluid_type_id"
required={(this.props.edited)}/>
</div>
*/}
{/*<div className="col-md-2">
<SelectField
source="fluid_level"
label="Fluid Level"
value={this.state.fluid_level_id}
errors={errors}
name="fluid_level_id"/>
</div>*/}
<div className="col-md-2">
<SelectField onChange={this.handleChange}
source="gas_sensor"
label="Gas Sensor"
value={this.state.gassensor_id}
errors={errors}
name="gassensor_id"
required={(this.props.edited)}/>
</div>
</div>
{/*<div className="row">
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 1"
value={this.state.bushing_serial1_id}
errors={errors}
name="bushing_serial1_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 2"
value={this.state.bushing_serial2_id}
errors={errors}
name="bushing_serial2_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 3"
value={this.state.bushing_serial3_id}
errors={errors}
name="bushing_serial3_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 4"
value={this.state.bushing_serial4}
errors={errors}
name="bushing_serial4_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 5"
value={this.state.bushing_serial5_id}
errors={errors}
name="bushing_serial5_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 1"
value={this.state.bushing_serial6_id}
errors={errors}
name="bushing_serial6_id"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 7"
value={this.state.bushing_serial7}
errors={errors}
name="bushing_serial7_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 8"
value={this.state.bushing_serial8_id}
errors={errors}
name="bushing_serial8_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 9"
value={this.state.bushing_serial9_id}
errors={errors}
name="bushing_serial9_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 10"
value={this.state.bushing_serial10_id}
errors={errors}
name="bushing_serial10_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 11"
value={this.state.bushing_serial11_id}
errors={errors}
name="bushing_serial11_id"/>
</div>
<div className="col-md-2">
<BushSerialSelectField
source="bushing"
label="Bushing Serial 12"
value={this.state.bushing_serial12_id}
errors={errors}
name="bushing_serial12_id"/>
</div>
</div> */}
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 11"
name="mvaforced11"
value={this.state.mvaforced11}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 12"
name="mvaforced12"
value={this.state.mvaforced12}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 13"
name="mvaforced13"
value={this.state.mvaforced13}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 14"
name="mvaforced14"
value={this.state.mvaforced14}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Base Impedance 1"
name="imp_base1"
value={this.state.imp_base1}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Base Impedance 2"
name="imp_base2"
value={this.state.imp_base2}
errors={errors}
data-type="float"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 21"
name="mvaforced21"
value={this.state.mvaforced21}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 22"
name="mvaforced22"
value={this.state.mvaforced22}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 23"
name="mvaforced23"
value={this.state.mvaforced23}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Forced 24"
name="mvaforced24"
value={this.state.mvaforced24}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Base Impedance 3"
name="impbasedmva3"
value={this.state.impbasedmva3}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Base Impedance 4"
name="impbasedmva4"
value={this.state.impbasedmva4}
errors={errors}
data-type="float"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mva Actual"
name="mvaactual"
value={this.state.mvaactual}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Mvar Actual"
name="mvaractual"
value={this.state.mvaractual}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Reserve Mw"
name="mwreserve"
value={this.state.mwreserve}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Reserve Mva"
name="mvarreserve"
value={this.state.mvarreserve}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ultime Mw"
name="mwultime"
value={this.state.mwultime}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ultime Mvar"
name="mvarultime"
value={this.state.mvarultime}
errors={errors}
data-type="float"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 1"
name="ratio_tag1"
value={this.state.ratio_tag1}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 2"
name="ratio_tag2"
value={this.state.ratio_tag2}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 3"
name="ratio_tag3"
value={this.state.ratio_tag3}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 4"
name="ratio_tag4"
value={this.state.ratio_tag4}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<Checkbox name="static_shield1" checked={this.state.static_shield1} onChange={this.handleChange}><b>Static Shield 1</b></Checkbox>
</div>
<div className="col-md-2">
<Checkbox name="static_shield2" checked={this.state.static_shield2} onChange={this.handleChange}><b>Static Shield 2</b></Checkbox>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 5"
name="ratio_tag5"
value={this.state.ratio_tag5}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 6"
name="ratio_tag6"
value={this.state.ratio_tag6}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 7"
name="ratio_tag7"
value={this.state.ratio_tag7}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ratio Tag 8"
name="ratio_tag8"
value={this.state.ratio_tag8}
errors={errors}
data-len="20"/>
</div>
<div className="col-md-2">
<Checkbox name="static_shield3" checked={this.state.static_shield3} onChange={this.handleChange}><b>Static Shield 3</b></Checkbox>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Static Shield 4"
name="static_shield4"
value={this.state.static_shield4}
errors={errors}
data-type="float"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Bushing Neutral 1"
name="bushing_neutral1"
value={this.state.bushing_neutral1}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Bushing Neutral 2"
name="bushing_neutral2"
value={this.state.bushing_neutral2}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Bushing Neutral 3"
name="bushing_neutral3"
value={this.state.bushing_neutral3}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Bushing Neutral 4"
name="bushing_neutral4"
value={this.state.bushing_neutral4}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Windings"
name="windings"
value={this.state.windings}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Winding Metal 1"
name="winding_metal1"
value={this.state.winding_metal1}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Winding Metal 2"
name="winding_metal2"
value={this.state.winding_metal2}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Winding Metal 3"
name="winding_metal3"
value={this.state.winding_metal3}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Winding Metal 4"
name="winding_metal4"
value={this.state.winding_metal4}
errors={errors}
data-type="int"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Primary Winding Connection"
name="primary_winding_connection"
value={this.state.primary_winding_connection}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Secondary Winding Connection"
name="secondary_winding_connection"
value={this.state.secondary_winding_connection}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Tertiary Winding Connection"
name="tertiary_winding_connection"
value={this.state.tertiary_winding_connection}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Quaternary Winding Connection"
name="quaternary_winding_connection"
value={this.state.quaternary_winding_connection}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Based Power"
name="based_transformer_power"
value={this.state.based_transformer_power}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<Checkbox name="autotransformer" checked={this.state.autotransformer} onChange={this.handleChange}><b>Autotransformer</b></Checkbox>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="BIL 1"
name="bil1"
value={this.state.bil1}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="BIL 2"
name="bil2"
value={this.state.bil2}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ltc 1"
name="ltc1"
value={this.state.ltc1}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ltc 2"
name="ltc2"
value={this.state.ltc2}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="First Cooling Stage Power"
name="first_cooling_stage_power"
value={this.state.first_cooling_stage_power}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Second Cooling Stage Power"
name="second_cooling_stage_power"
value={this.state.second_cooling_stage_power}
errors={errors}
data-type="float"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="BIL 3"
name="bil3"
value={this.state.bil3}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="BIL 4"
name="bil4"
value={this.state.bil4}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Ltc 3"
name="ltc3"
value={this.state.ltc3}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Third colling stage power"
name="third_cooling_stage_power"
value={this.state.third_cooling_stage_power}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Temperature Rise"
name="temperature_rise"
value={this.state.temperature_rise}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Cooling Rating"
name="cooling_rating"
value={this.state.cooling_rating}
errors={errors}
data-type="int"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Primary Tension"
name="primary_tension"
value={this.state.primary_tension}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Secondary Tension"
name="secondary_tension"
value={this.state.secondary_tension}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Tertiary Tension"
name="tertiary_tension"
value={this.state.tertiary_tension}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Impedance 1"
name="impedance1"
value={this.state.impedance1}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Impedance 2"
name="impedance2"
value={this.state.impedance2}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Impedance 3"
name="impedance3"
value={this.state.impedance3}
errors={errors}
data-type="float"/>
</div>
</div>
<div className="row">
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Formula Ratio 1"
name="formula_ratio"
value={this.state.formula_ratio}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Formula Ratio 2"
name="formula_ratio2"
value={this.state.formula_ratio2}
errors={errors}
data-type="int"/>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Formula Ratio 3"
name="formula_ratio3"
value={this.state.formula_ratio3}
errors={errors}
data-type="float"/>
</div>
<div className="col-md-2 ">
<Checkbox name="sealed" checked={this.state.sealed} onChange={this.handleChange}><b>Sealed</b></Checkbox>
</div>
<div className="col-md-2">
<Checkbox name="welded_cover" checked={this.state.welded_cover} onChange={this.handleChange}><b>Welded Cover</b></Checkbox>
</div>
<div className="col-md-2">
<TextField onChange={this.handleChange}
label="Impedance 4"
name="impedance4"
value={this.state.impedance4}
errors={errors}
data-type="float"/>
</div>
</div>
</div>
)
}
});
export default TransformerParams;
|
node_modules/@expo/vector-icons/createIconSet.js
|
RahulDesai92/PHR
|
import React from 'react';
import { Text } from 'react-native';
import { Font } from 'expo';
import createIconSet from './vendor/react-native-vector-icons/lib/create-icon-set';
import createIconButtonComponent from './vendor/react-native-vector-icons/lib/icon-button';
export default function(glyphMap, fontName, expoAssetId) {
const expoFontName = Font.style(fontName, {
ignoreWarning: true,
}).fontFamily;
const font = { [fontName]: expoAssetId };
const RNVIconComponent = createIconSet(glyphMap, expoFontName);
class Icon extends React.Component {
static propTypes = RNVIconComponent.propTypes;
static defaultProps = RNVIconComponent.defaultProps;
state = {
fontIsLoaded: Font.isLoaded(fontName),
};
async componentWillMount() {
this._mounted = true;
if (!this.state.fontIsLoaded) {
await Font.loadAsync(font);
this._mounted && this.setState({ fontIsLoaded: true });
}
}
componentWillUnmount() {
this._mounted = false;
}
setNativeProps(props) {
if (this._icon) {
this._icon.setNativeProps(props);
}
}
render() {
if (!this.state.fontIsLoaded) {
return <Text />;
}
return (
<RNVIconComponent
ref={view => {
this._icon = view;
}}
{...this.props}
/>
);
}
}
Icon.Button = createIconButtonComponent(Icon);
Icon.glyphMap = glyphMap;
Icon.font = font;
return Icon;
}
|
src/components/Main.js
|
Royzx/gallery-by-react
|
require('normalize.css/normalize.css');
require('styles/App.scss');
import React from 'react';
import ReactDOM from 'react-dom';
//获取图片相关数据
var imageDatas = require('../data/imageDatas.json');
//利用自执行函数，将图片名信息转成图片URL路径信息
imageDatas = (function getImageURL(imageDataArr){
for(let i = 0,j=imageDataArr.length;i<j;i++){
let singleImageData = imageDataArr[i];
singleImageData.imageURL = require('../images/'+singleImageData.fileName);
imageDataArr[i] = singleImageData;
}
return imageDataArr;
})(imageDatas);
/**
* 取范围内的随机值
* @param {*} low
* @param {*} high
*/
function getRangeRandom(low,high) {
return Math.ceil(Math.random() * (high - low)) + low;
}
/**
* 取0-30度角
*/
function get30DegRandom() {
return ((Math.random() > 0.5 ? '': '-') + Math.ceil(Math.random() * 30));
}
/**控制按钮组件 */
class ControllerUnit extends React.Component {
handleClick(e) {
//如果点击的是当前正在选中态的按钮，则翻转你图片，否则将对应的图片居中
if (this.props.arrange.isCenter) {
this.props.inverse();
} else {
this.props.center();
}
e.preventDefault();
e.stopPropagation();
}
render() {
var controllerUnitClassName = 'controller-unit';
//如果对应的是居中的图片，显示控制按钮居中态
if (this.props.arrange.isCenter) {
controllerUnitClassName += ' is-center';
//如果对应的是翻转图片，显示控制按钮翻转态
if (this.props.arrange.inverse) {
controllerUnitClassName += ' is-inverse';
}
}
return (
<span className={controllerUnitClassName} onClick={this.handleClick.bind(this)}></span>
);
}
}
/**单个图片组件 */
class ImgFigure extends React.Component {
handleClick(e) {
if(this.props.arrange.isCenter) {
this.props.inverse();
} else {
this.props.center();
}
e.stopPropagation();
e.preventDefault();
}
render() {
var styleObj = {};
//如果props属性中指定了这张图片的位置，则使用
if (this.props.arrange.pos) {
styleObj = this.props.arrange.pos;
}
if(this.props.arrange.rotate) {
(['Moz','ms','Webkit','']).forEach(function(value){
styleObj[value + 'Transform'] = 'rotate(' + this.props.arrange.rotate + 'deg)';
}.bind(this));
}
if(this.props.arrange.isCenter) {
styleObj.zIndex = 11;
}
var imgFigureClassName = 'img-figure';
imgFigureClassName += this.props.arrange.inverse ? ' is-inverse': '';
return(
<figure className={imgFigureClassName} style={styleObj} onClick={this.handleClick.bind(this)}>
<img src={this.props.data.imageURL}
alt={this.props.data.title}/>
<figcaption>
<h2 className="img-title">{this.props.data.title}</h2>
<div className='img-back' onClick={this.handleClick.bind(this)}>
<p>{this.props.data.desc}</p>
</div>
</figcaption>
</figure>
);
}
}
class AppComponent extends React.Component {
/**
* 翻转图片
* @param {*} index 传入当前被执行inverse操作的图片信息数组的index值
* @return {function} 这是一个闭包函数，其中return中一个真正待被执行的函数
*/
inverse(index) {
return (function(){
var imgsArrangeArr = this.state.imgsArrangeArr;
imgsArrangeArr[index].inverse = !imgsArrangeArr[index].inverse;
this.setState({
imgsArrangeArr: imgsArrangeArr
});
}.bind(this));
}
/**
* 利用arrange函数，居中对应index的图片
* @param {*} index 需要背景中的图片对应的图片信息数组的index值
* @return {Function}
*/
center(index) {
return function() {
this.rearrange(index);
}.bind(this);
}
/**
* 重新布局所有图片
* @param {*} centerIndex 指定居中排布哪个卡片
*/
rearrange(centerIndex) {
var imgsArrangeArr = this.state.imgsArrangeArr, //获取图片位置信息数组
Constant = this.Constant, //获取定位位置对象
centerPos = Constant.centerPos, //获取居中位置信息
hPosRange = Constant.hPosRange, //获取水平位置信息
h_leftSecX = hPosRange.leftSecX, //获取左侧X位置信息
h_rightSecX = hPosRange.rightSecX, //获取右侧X位置信息
h_y = hPosRange.h_y, //获取y位置信息
vPosRange = Constant.vPosRange, //获取顶部位置信息
v_x = vPosRange.v_x, //获取顶部X位置信息
v_y = vPosRange.v_y; //获取顶部Y位置信息
//获取居中图片index并居中处理
var imgsArrangeArrCenter = imgsArrangeArr.splice(centerIndex,1);
imgsArrangeArrCenter = {
pos: centerPos,
rotate: 0,
isCenter: true
};
//获取顶部图片index并处理
var topImgNum= Math.ceil(Math.random() * 2),
topIndex = 0,
imgsArrangeArrTop = [];
if(topImgNum) {
topIndex = Math.ceil(Math.random() * (imgsArrangeArr.length - topImgNum + 1));
imgsArrangeArrTop = imgsArrangeArr.splice(topIndex,topImgNum);
imgsArrangeArrTop.forEach(function(value,index) {
imgsArrangeArrTop[index] = {
pos: {
left: getRangeRandom(v_x[0], v_x[1]),
top: getRangeRandom(v_y[0], v_y[1])
},
rotate: get30DegRandom()
};
});
}
//获取水平方向上的图片信息并处理
var k = Math.ceil(imgsArrangeArr.length / 2);
for(var i = 0; i < imgsArrangeArr.length; i++) {
if(i < k) {
imgsArrangeArr[i] = {
pos: {
left: getRangeRandom(h_leftSecX[0], h_leftSecX[1]),
top: getRangeRandom(h_y[0], h_y[1])
},
rotate: get30DegRandom(),
isCenter:false
}
} else {
imgsArrangeArr[i] = {
pos: {
left: getRangeRandom(h_rightSecX[0], h_rightSecX[1]),
top: getRangeRandom(h_y[0], h_y[1])
},
rotate: get30DegRandom(),
isCenter:false
}
}
}
//将去除的数组元素修改之后放回去
if(imgsArrangeArr && imgsArrangeArrTop) {
for(var i = topImgNum-1;i >= 0 ; i--) {
imgsArrangeArr.splice(topIndex,0,imgsArrangeArrTop[i]);
}
}
//中间图片
imgsArrangeArr.splice(centerIndex,0,imgsArrangeArrCenter);
this.setState({
imgsArrangeArr: imgsArrangeArr
})
}
constructor(props) {
super(props);
this.state = {imgsArrangeArr:[]};
/*** 位置范围常量*/
this.Constant = {
centerPos:{
left:0,
top:0
},
hPosRange:{ //水平方向取值范围
leftSecX:[0,0],
rightSecX:[0,0],
h_y:[0,0]
},
vPosRange:{ //垂直方向取值范围
v_x:[0,0],
v_y:[0,0]
}
};
}
componentDidMount(){
/**舞台的宽高以及半宽和半高 */
var stageDOM = ReactDOM.findDOMNode(this.refs.stage),
stageW = stageDOM.scrollWidth,
stageH = stageDOM.scrollHeight,
halfStageW = Math.ceil(stageW / 2),
halfStageH = Math.ceil(stageH / 2);
/**图片的宽高以及半宽和半高 */
var imgDOM = ReactDOM.findDOMNode(this.refs.imgFigure0),
imgW = imgDOM.scrollWidth,
imgH = imgDOM.scrollHeight,
halfImgW = Math.ceil(imgW / 2),
halfImgH = Math.ceil(imgH / 2);
this.Constant.centerPos = {
left:halfStageW - halfImgW,
top:halfStageH - halfImgH
};
/**水平方向上左右两侧图片的范围start */
/** 左*/
this.Constant.hPosRange.leftSecX[0] = -halfImgW;
this.Constant.hPosRange.leftSecX[1] = halfStageW - halfImgW * 3;
/**右 */
this.Constant.hPosRange.rightSecX[0] = halfStageW + halfImgW;
this.Constant.hPosRange.rightSecX[1] = stageW - halfImgW;
/**垂直 */
this.Constant.hPosRange.h_y[0] = - halfImgH;
this.Constant.hPosRange.h_y[1] = stageH - halfImgH;
/**水平方向上左右两侧图片的范围start */
/**垂直方向上顶部图片范围start */
this.Constant.vPosRange.v_x[0] = halfStageW - imgW;
this.Constant.vPosRange.v_x[1] = halfStageW;
this.Constant.vPosRange.v_y[0] = -halfImgH;
this.Constant.vPosRange.v_y[1] = halfStageH - halfImgH * 3;
/**垂直方向上顶部图片范围end */
/**默认居中第一张图片 */
this.rearrange(0);
}
render() {
var controllerUnits = [],
ImgFigures = [];
imageDatas.map(function(value,index) {
if(!this.state.imgsArrangeArr[index]) {
this.state.imgsArrangeArr[index] = {
pos: {
left:0,
top:0
},
rotate: 0,
inverse:false,
isCenter:false
}
}
ImgFigures.push(<ImgFigure data={value} ref={'imgFigure'+index}
arrange={this.state.imgsArrangeArr[index]} key={index} inverse={this.inverse(index)} center={this.center(index)}/>);
controllerUnits.push(<ControllerUnit arrange={this.state.imgsArrangeArr[index]} key={index} inverse={this.inverse(index)} center={this.center(index)}/>)
}.bind(this));
return (
<section className="stage" ref="stage">
<section className="img-sec">
{ImgFigures}
</section>
<nav className="controller-nav">
{controllerUnits}
</nav>
</section>
);
}
}
AppComponent.defaultProps = {
};
export default AppComponent;
|
src/svg-icons/navigation/arrow-drop-down-circle.js
|
w01fgang/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let NavigationArrowDropDownCircle = (props) => (
<SvgIcon {...props}>
<path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 12l-4-4h8l-4 4z"/>
</SvgIcon>
);
NavigationArrowDropDownCircle = pure(NavigationArrowDropDownCircle);
NavigationArrowDropDownCircle.displayName = 'NavigationArrowDropDownCircle';
NavigationArrowDropDownCircle.muiName = 'SvgIcon';
export default NavigationArrowDropDownCircle;
|
fixtures/dom/src/components/fixtures/input-change-events/RadioGroupFixture.js
|
brigand/react
|
import React from 'react';
import Fixture from '../../Fixture';
class RadioGroupFixture extends React.Component {
constructor(props, context) {
super(props, context);
this.state = {
changeCount: 0,
};
}
handleChange = () => {
this.setState(({changeCount}) => {
return {
changeCount: changeCount + 1,
};
});
};
handleReset = () => {
this.setState({
changeCount: 0,
});
};
render() {
const {changeCount} = this.state;
const color = changeCount === 2 ? 'green' : 'red';
return (
<Fixture>
<label>
<input
defaultChecked
name="foo"
type="radio"
onChange={this.handleChange}
/>
Radio 1
</label>
<label>
<input name="foo" type="radio" onChange={this.handleChange} />
Radio 2
</label>
{' '}
<p style={{color}}>
<code>onChange</code>{' calls: '}<strong>{changeCount}</strong>
</p>
<button onClick={this.handleReset}>Reset count</button>
</Fixture>
);
}
}
export default RadioGroupFixture;
|
fields/types/geopoint/GeoPointColumn.js
|
Adam14Four/keystone
|
import React from 'react';
import ItemsTableCell from '../../components/ItemsTableCell';
import ItemsTableValue from '../../components/ItemsTableValue';
var GeoPointColumn = React.createClass({
displayName: 'GeoPointColumn',
propTypes: {
col: React.PropTypes.object,
data: React.PropTypes.object,
},
renderValue () {
const value = this.props.data.fields[this.props.col.path];
if (!value || !value.length) return null;
const formattedValue = `${value[1]}, ${value[0]}`;
const formattedTitle = `Lat: ${value[1]} Lng: ${value[0]}`;
return (
<ItemsTableValue title={formattedTitle} field={this.props.col.type}>
{formattedValue}
</ItemsTableValue>
);
},
render () {
return (
<ItemsTableCell>
{this.renderValue()}
</ItemsTableCell>
);
},
});
module.exports = GeoPointColumn;
|
src/Interpolate.js
|
mengmenglv/react-bootstrap
|
// https://www.npmjs.org/package/react-interpolate-component
// TODO: Drop this in favor of es6 string interpolation
import React from 'react';
import ValidComponentChildren from './utils/ValidComponentChildren';
const REGEXP = /\%\((.+?)\)s/;
const Interpolate = React.createClass({
displayName: 'Interpolate',
propTypes: {
component: React.PropTypes.node,
format: React.PropTypes.string,
unsafe: React.PropTypes.bool
},
getDefaultProps() {
return {
component: 'span',
unsafe: false
};
},
render() {
let format = (ValidComponentChildren.hasValidComponent(this.props.children) ||
(typeof this.props.children === 'string')) ?
this.props.children : this.props.format;
let parent = this.props.component;
let unsafe = this.props.unsafe === true;
let props = {...this.props};
delete props.children;
delete props.format;
delete props.component;
delete props.unsafe;
if (unsafe) {
let content = format.split(REGEXP).reduce(function(memo, match, index) {
let html;
if (index % 2 === 0) {
html = match;
} else {
html = props[match];
delete props[match];
}
if (React.isValidElement(html)) {
throw new Error('cannot interpolate a React component into unsafe text');
}
memo += html;
return memo;
}, '');
props.dangerouslySetInnerHTML = { __html: content };
return React.createElement(parent, props);
} else {
let kids = format.split(REGEXP).reduce(function(memo, match, index) {
let child;
if (index % 2 === 0) {
if (match.length === 0) {
return memo;
}
child = match;
} else {
child = props[match];
delete props[match];
}
memo.push(child);
return memo;
}, []);
return React.createElement(parent, props, kids);
}
}
});
export default Interpolate;
|
docs/src/sections/OverlaySection.js
|
Terminux/react-bootstrap
|
import React from 'react';
import Anchor from '../Anchor';
import PropTable from '../PropTable';
import ReactPlayground from '../ReactPlayground';
import Samples from '../Samples';
export default function OverlaySection() {
return (
<div className="bs-docs-section">
<h2 className="page-header">
<Anchor id="custom-overlays">Custom overlays</Anchor> <small>Overlay</small>
</h2>
<p>
The <code>OverlayTrigger</code> component is great for most use cases, but as a higher level abstraction it can lack the flexibility needed
to build more nuanced or custom behaviors into your Overlay components. For these cases it can be helpful to forgo the trigger and use
the <code>Overlay</code> component directly.
</p>
<ReactPlayground codeText={Samples.Overlay}/>
<h4><Anchor id="custom-overlays-overlay">Use Overlay instead of Tooltip and Popover</Anchor></h4>
<p>
You don't need to use the provided <code>Tooltip</code> or <code>Popover</code> components. Creating custom overlays
is as easy as wrapping some markup in an <code>Overlay</code> component
</p>
<ReactPlayground codeText={Samples.OverlayCustom} />
<h3><Anchor id="custom-overlays-props">Props</Anchor></h3>
<PropTable component="Overlay"/>
</div>
);
}
|
examples/todomvc/index.js
|
STRML/redux
|
import React from 'react';
import App from './containers/App';
import 'todomvc-app-css/index.css';
React.render(
<App />,
document.getElementById('root')
);
|
src/routes.js
|
NathanBWaters/website
|
import React from 'react';
import {IndexRoute, Route} from 'react-router';
import { isLoaded as isAuthLoaded, load as loadAuth } from 'redux/modules/auth';
import {
TheRunners,
ProjectDashboard,
Outfitr,
GoAlgo,
JumpstartGUI,
Website
} from 'components';
import {
App,
Chat,
Home,
Widgets,
About,
Login,
LoginSuccess,
Survey,
NotFound,
ProjectsMain,
} from 'containers';
export default (store) => {
const requireLogin = (nextState, replace, cb) => {
function checkAuth() {
const { auth: { user }} = store.getState();
if (!user) {
// oops, not logged in, so can't be here!
replace('/');
}
cb();
}
if (!isAuthLoaded(store.getState())) {
store.dispatch(loadAuth()).then(checkAuth);
} else {
checkAuth();
}
};
/**
* Please keep routes in alphabetical order
*/
return (
<Route path="/" component={App}>
{ /* Home (main) route */ }
<IndexRoute component={Home}/>
{ /* Routes requiring login */ }
<Route onEnter={requireLogin}>
<Route path="chat" component={Chat}/>
<Route path="loginSuccess" component={LoginSuccess}/>
</Route>
{ /* Routes */ }
<Route path="about" component={About}/>
<Route path="login" component={Login}/>
<Route path="projects" component={ProjectsMain} >
<IndexRoute component={ProjectDashboard}/>
<Route path="the_runners" component={TheRunners}/>
<Route path="outfitr" component={Outfitr}/>
<Route path="go_algo" component={GoAlgo}/>
<Route path="jumpstart_gui" component={JumpstartGUI}/>
<Route path="personal_website" component={Website}/>
</Route>
<Route path="survey" component={Survey}/>
<Route path="widgets" component={Widgets}/>
{ /* Catch all route */ }
<Route path="*" component={NotFound} status={404} />
</Route>
);
};
|
app/renderInBrowser.js
|
theseushu/runcai
|
import React from 'react';
import ReactDOM from 'react-dom';
import { match, applyRouterMiddleware, Router } from 'react-router';
import { useScroll } from 'react-router-scroll';
import AppRoot from 'containers/AppRoot';
import FullScreenGallery from 'modules/fullScreenGallery';
import MapDialog from 'modules/mapDialog';
import { actions as mapActions } from 'api/map';
import { currentUserSelector } from 'modules/data/ducks/selectors';
import { actions as profileActions } from 'api/profile';
export default function renderInBrowser({ messages, store, routes, history, api }) {
match({ history, routes }, (error, redirectLocation, renderProps) => {
ReactDOM.render(
<AppRoot store={store} messages={messages}>
<Router
{...renderProps}
render={
// Scroll to top when going to a new page, imitating default browser behaviour
applyRouterMiddleware(useScroll())
}
/>
</AppRoot>,
document.getElementById('app'), () => {
const ssStyles = document.getElementById('server-side-styles');
ssStyles.parentNode.removeChild(ssStyles);
},
);
const tokenExists = api.tokenExists();
// token exists means there's sessionToken in cookies.
// if currentUser is not null,(which means store state is populated from ssr) we do nothing
// otherwise, fetch user's profile
if (tokenExists) {
const currentUser = currentUserSelector(store.getState());
if (!currentUser) {
store.dispatch(profileActions.fetch());
}
}
store.dispatch(mapActions.getCurrentLocation());
});
if (process.env.browser) { // todo switch to standard client detection
const galleryEl = document.createElement('div');
galleryEl.setAttribute('id', '_fullScreenGallery_');
document.body.appendChild(galleryEl);
ReactDOM.render(
<AppRoot store={store} messages={messages}>
<FullScreenGallery />
</AppRoot>,
galleryEl
);
const mapDialogEl = document.createElement('div');
mapDialogEl.setAttribute('id', '_map_dialog_');
document.body.appendChild(mapDialogEl);
ReactDOM.render(
<AppRoot store={store} messages={messages}>
<MapDialog />
</AppRoot>,
mapDialogEl
);
if (process.env.NODE_ENV !== 'production') {
if (localStorage) {
localStorage.debug = 'funongweb*,funongbackend*,funongcommon*';
}
if (!document.getElementById('_dev_tools_')) {
System.import('./DevTools').then((DevToolsModule) => {
const DevTools = DevToolsModule.default;
const devToolsEl = document.createElement('div');
devToolsEl.setAttribute('id', '_dev_tools_');
document.body.appendChild(devToolsEl);
ReactDOM.render(
<DevTools store={store} />
, devToolsEl
);
});
}
}
}
}
|
packages/cf-component-progress/src/Progress.js
|
mdno/mdno.github.io
|
import React from 'react';
import PropTypes from 'prop-types';
import Link from 'cf-component-link';
import { createComponent } from 'cf-style-container';
import { clearFix } from 'polished';
const styles = () => ({
position: 'relative'
});
const Bar = createComponent(
({ theme }) => ({
display: 'block',
width: '100%',
appearance: 'none',
'&::-webkit-progress-bar': {
backgroundColor: theme.bodyBackground,
color: theme.bodyBackground
},
'&::-webkit-progress-value': {
backgroundColor: theme.color.marine,
color: theme.color.marine,
transition: 'width 500ms ease'
},
/* Mozilla uses progress-bar as the value */
'&::-moz-progress-bar': {
backgroundColor: theme.color.marine,
color: theme.color.marine
}
}),
'progress',
['max', 'value']
);
const Items = createComponent(
() => ({
listStyle: 'none',
...clearFix(),
margin: 0,
padding: 0
}),
'ol'
);
const Item = createComponent(
({ theme, width, disabled, active }) => {
let color = theme.colorGray;
if (disabled) {
color = theme.colorGrayLight;
} else if (active) {
color = theme.color.marine;
}
return {
width: 'auto',
float: 'none',
height: 'auto',
padding: 0,
paddingTop: '7.5px',
color,
fontSize: '0.86667em',
textAlign: 'center',
cursor: disabled ? 'default' : 'pointer',
display: active ? 'list-item' : 'none',
'&::before': {
content: 'none'
},
tablet: {
width,
float: 'left',
display: 'list-item'
},
'& > .cf-link': {
display: 'block',
color: 'inherit',
cursor: 'pointer'
}
};
},
'li',
['key', 'width', 'disabled', 'active']
);
class Progress extends React.Component {
constructor(props) {
super(props);
this.handleClick = this.handleClick.bind(this);
}
handleClick(step) {
if (step.id !== this.props.active) {
this.props.onChange(step.id);
}
}
render() {
const { className, steps, active } = this.props;
const max = steps.length;
const itemWidth = (1 / max * 100).toFixed(4) + '%';
let value;
const items = steps.map((step, index) => {
const isActive = step.id === active;
if (isActive) {
value = index + 1;
}
return (
<Item
key={step.id}
width={itemWidth}
disabled={step.disabled}
active={isActive}
>
<Link
onClick={this.handleClick.bind(null, step)}
disabled={step.disabled}
>
{step.label}
</Link>
</Item>
);
});
return (
<div className={className}>
<Bar max={max} value={value} />
<Items>
{items}
</Items>
</div>
);
}
}
Progress.propTypes = {
active: PropTypes.string.isRequired,
onChange: PropTypes.func.isRequired,
steps: PropTypes.arrayOf(
PropTypes.shape({
id: PropTypes.string.isRequired,
label: PropTypes.string.isRequired,
disabled: PropTypes.bool.isRequired
})
).isRequired,
className: PropTypes.string
};
Progress.defaultProps = {
steps: []
};
export default createComponent(styles, Progress);
|
src/components/theme-legacy/form/instructions/target-state.js
|
MoveOnOrg/mop-frontend
|
import React from 'react'
const TargetState = () => (
<div>
<h4>Targeting Your Governor or State Legislature</h4>
<p>If you choose <strong>The entire State House</strong>, then your petition signers will be asked to sign a petition addressed to their individual representative in the state house of representatives.</p>
<p>If you choose <strong>The entire State Senate</strong>, then your petition signers will be asked to sign a petition addressed to their individual representative in the state senate.</p>
<p>If you choose <strong>Governor of State</strong>, your petition signatures will be addressed to your state’s governor.</p>
<p>If your petition should be addressed to <strong>a specific legislator</strong>, type his or her name in the text area. Be sure to check the spelling and use the individual’s proper title.</p>
</div>
)
export default TargetState
|
src/screens/search/components/DestinationSearch/DestinationSearch.js
|
vio-lets/Larkyo-Client
|
import React from 'react';
// import './PeopleSearch.css';
export default class DestinationSearch extends React.Component {
constructor() {
super();
this.state = {}
}
render() {
return(
<div className="destinationSearchContainer">
<h2>Destination search is coming soon</h2>
</div>
)
}
}
|
src/components/NotFoundPage.js
|
oded-soffrin/gkm_viewer
|
import React from 'react';
import { Link } from 'react-router';
const NotFoundPage = () => {
return (
<div>
<h4>
404 Page Not Found
</h4>
<Link to="/"> Go back to homepage </Link>
</div>
);
};
export default NotFoundPage;
|
frontend/components/AppRoutes.js
|
heekzz/PowerHour
|
'use strict';
import React from 'react';
import { Router, browserHistory } from 'react-router';
import routes from '../routes';
export default class AppRoutes extends React.Component {
render() {
return (
<Router history={browserHistory} routes={routes} onUpdate={() => window.scrollTo(0, 0)}/>
);
}
}
|
fixtures/ssr/src/index.js
|
silvestrijonathan/react
|
import React from 'react';
import {hydrate} from 'react-dom';
import App from './components/App';
hydrate(<App assets={window.assetManifest} />, document);
|
client/my-sites/media-library/list-plan-promo.js
|
allendav/wp-calypso
|
/**
* External dependencies
*/
import React from 'react';
import page from 'page';
import analytics from 'analytics';
import { preventWidows } from 'lib/formatting';
/**
* Internal dependencies
*/
const EmptyContent = require( 'components/empty-content' ),
Button = require( 'components/button' );
module.exports = React.createClass( {
displayName: 'MediaLibraryListPlanPromo',
propTypes: {
site: React.PropTypes.object,
filter: React.PropTypes.string
},
getTitle: function() {
switch ( this.props.filter ) {
case 'videos':
return this.translate( 'Upload Videos', { textOnly: true, context: 'Media upload plan needed' } );
break;
case 'audio':
return this.translate( 'Upload Audio', { textOnly: true, context: 'Media upload plan needed' } );
break;
default:
return this.translate( 'Upload Media', { textOnly: true, context: 'Media upload plan needed' } );
}
},
getSummary: function() {
switch ( this.props.filter ) {
case 'videos':
return preventWidows(
this.translate(
'To upload video files to your site, upgrade your plan.',
{ textOnly: true, context: 'Media upgrade promo' }
), 2 );
break;
case 'audio':
return preventWidows(
this.translate(
'To upload audio files to your site, upgrade your plan.',
{ textOnly: true, context: 'Media upgrade promo' }
), 2 );
break;
default:
return preventWidows(
this.translate(
'To upload audio and video files to your site, upgrade your plan.',
{ textOnly: true, context: 'Media upgrade promo' }
), 2 );
}
},
viewPlansPage: function() {
const { slug = '' } = this.props.site;
analytics.tracks.recordEvent( 'calypso_media_plans_button_click' );
page( `/plans/${ slug }` );
},
render: function() {
const action = (
<Button className="button is-primary" onClick={ this.viewPlansPage }>{ this.translate( 'See Plans' ) }</Button>
);
return (
<EmptyContent
title={ this.getTitle() }
line={ this.getSummary() }
action={ action }
illustration={ '' } />
);
}
} );
|
app/addons/fauxton/notifications/components/NotificationCenterPanel.js
|
michellephung/couchdb-fauxton
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
import PropTypes from 'prop-types';
import React from 'react';
import {TransitionMotion, spring, presets} from 'react-motion';
import NotificationPanelRow from './NotificationPanelRow';
export default class NotificationCenterPanel extends React.Component {
static propTypes = {
isVisible: PropTypes.bool.isRequired,
filter: PropTypes.string.isRequired,
notifications: PropTypes.array.isRequired,
hideNotificationCenter: PropTypes.func.isRequired,
selectNotificationFilter: PropTypes.func.isRequired,
clearAllNotifications: PropTypes.func.isRequired,
clearSingleNotification: PropTypes.func.isRequired
};
getNotifications = (items) => {
let notifications;
if (!items.length && !this.props.notifications.length) {
notifications = <li className="no-notifications">
No notifications.
</li>;
} else {
notifications = items
.map(({key, data: notification, style}) => {
return (
<NotificationPanelRow
item={notification}
filter={this.props.filter}
clearSingleNotification={this.props.clearSingleNotification}
key={key}
style={style}
/>
);
});
}
return (
<ul className="notification-list">
{notifications}
</ul>
);
};
getStyles = (prevItems = []) => {
const styles = this.props.notifications
.map(notification => {
let item = prevItems.find(style => style.key === (notification.notificationId.toString()));
let style = !item ? {opacity: 0, height: 0} : false;
if (!style && (notification.type === this.props.filter || this.props.filter === 'all')) {
style = {
opacity: spring(1, presets.stiff),
height: spring(61, presets.stiff)
};
} else if (notification.type !== this.props.filter) {
style = {
opacity: spring(0, presets.stiff),
height: spring(0, presets.stiff)
};
}
return {
key: notification.notificationId.toString(),
style,
data: notification
};
});
return styles;
};
render() {
if (!this.props.isVisible && this.props.style.x === 0) {
// panelClasses += ' visible';
return null;
}
const filterClasses = {
all: 'flex-body',
success: 'flex-body',
error: 'flex-body',
info: 'flex-body'
};
filterClasses[this.props.filter] += ' selected';
const maskClasses = `notification-page-mask ${((this.props.isVisible) ? ' visible' : '')}`;
const panelClasses = 'notification-center-panel flex-layout flex-col visible';
return (
<div id="notification-center">
<div className={panelClasses} style={{transform: `translate(${this.props.style.x}px)`}}>
<header className="flex-layout flex-row">
<span className="fonticon fonticon-bell" />
<h1 className="flex-body">Notifications</h1>
<button type="button" onClick={this.props.hideNotificationCenter}>×</button>
</header>
<ul className="notification-filter flex-layout flex-row">
<li className={filterClasses.all} title="All notifications" data-filter="all"
onClick={() => this.props.selectNotificationFilter('all')}>All</li>
<li className={filterClasses.success} title="Success notifications" data-filter="success"
onClick={() => this.props.selectNotificationFilter('success')}>
<span className="fonticon fonticon-ok-circled" />
</li>
<li className={filterClasses.error} title="Error notifications" data-filter="error"
onClick={() => this.props.selectNotificationFilter('error')}>
<span className="fonticon fonticon-attention-circled" />
</li>
<li className={filterClasses.info} title="Info notifications" data-filter="info"
onClick={() => this.props.selectNotificationFilter('info')}>
<span className="fonticon fonticon-info-circled" />
</li>
</ul>
<div className="flex-body">
<TransitionMotion styles={this.getStyles}>
{this.getNotifications}
</TransitionMotion>
</div>
<footer>
<input
type="button"
value="Clear All"
className="btn btn-small btn-secondary"
onClick={this.props.clearAllNotifications} />
</footer>
</div>
<div className={maskClasses} onClick={this.props.hideNotificationCenter}></div>
</div>
);
}
}
|
client/main.js
|
jabhishek/react-express-webpack-boilerplate
|
import React from 'react';
import ReactDOM from 'react-dom';
import {Router } from 'react-router';
import routes from './routes';
import Main from './Main.less'; // eslint-disable-line no-unused-vars
import createBrowserHistory from 'history/lib/createBrowserHistory';
ReactDOM.render(
(
<Router history={createBrowserHistory()}>
{routes}
</Router>
),
document.getElementById('root')
);
|
app/static/js/App.js
|
NordicSHIFT/NordicSHIFT
|
// App.js
import React, { Component } from 'react';
import Main from './components/Main';
class App extends Component {
render() {
return (
<div>
<Main />
</div>
);
}
}
export default App;
|
react/liveevent/components/PowerupCount.js
|
jaredhasenklein/the-blue-alliance
|
import React from 'react'
import PropTypes from 'prop-types'
const PowerupCount = (props) => {
const {
color,
type,
count,
played,
isCenter,
} = props
const tooltipTitle = type.charAt(0).toUpperCase() + type.slice(1)
return (
<div className={`powerupCountContainer ${isCenter ? 'powerupCountContainerCenter' : ''} ${count !== 0 ? `${color}Count${count}` : ''} ${played ? color : ''}`}>
<img src={`/images/2018_${type}.png`} className="powerupIcon" role="presentation" rel="tooltip" title={tooltipTitle} />
<div className={`powerCube ${count > 2 ? 'powerCubeActive' : ''}`} />
<div className={`powerCube ${count > 1 ? 'powerCubeActive' : ''}`} />
<div className={`powerCube ${count > 0 ? 'powerCubeActive' : ''}`} />
</div>
)
}
PowerupCount.propTypes = {
color: PropTypes.string.isRequired,
type: PropTypes.string.isRequired,
count: PropTypes.number.isRequired,
played: PropTypes.bool.isRequired,
isCenter: PropTypes.bool,
}
export default PowerupCount
|
app/index.js
|
pengfu/react-resume
|
/**
* Created by chang_su on 2017/5/15.
*/
import React from 'react';
import ReactDOM from 'react-dom';
require('./style/normalize.css')
require('./style/app.css')
require ('./style/fontello/css/fontello.css')
require('./style/transition.css')
import App from './components/App.jsx';
ReactDOM.render(<App />, document.getElementById('root'));
|
src/components/Calculator/Calculator.js
|
Dynatos/personal-website
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import NavBar from "../NavBar/NavBar";
import CalculatorButtons from "./CalculatorButtons";
export default class Calculator extends Component {
handleNumberClick(operand) {
this.props.pushNumber(operand);
}
handleOperator(operator) {
this.props.setOperator(operator);
}
handleCalculate() {
this.props.calculateValue();
}
handleReset() {
this.props.resetCalc();
}
addPeriod() {
this.props.addPeriod();
}
render() {
const { currentStateOfApplication } = this.props;
return(
<div>
<NavBar />
<CalculatorButtons numberClick={(operand) => this.handleNumberClick(operand)}
calculateClick={() => this.handleCalculate()} resetClick={() => this.handleReset()}
setOperator={(operator) => this.handleOperator(operator)} periodClick={() => this.addPeriod()}
currentState={currentStateOfApplication} />
</div>
);
}
}
Calculator.propTypes = {
pushNumber: PropTypes.func.isRequired,
setOperator: PropTypes.func.isRequired,
calculateValue: PropTypes.func.isRequired,
resetCalc: PropTypes.func.isRequired,
addPeriod: PropTypes.func.isRequired,
currentStateOfApplication: PropTypes.object.isRequired
};
|
src/components/ShareExperience/WorkExperiencesForm/WorkInfo/IsEmployed.js
|
goodjoblife/GoodJobShare
|
import React from 'react';
import PropTypes from 'prop-types';
import RadioDefault from 'common/form/RadioDefault';
import Select from 'common/form/Select';
import Unit from 'common/form/Unit';
import InputTitle from '../../common/InputTitle';
import {
isEmployedOptions,
jobEndingTimeYearOptions,
jobEndingTimeMonthOptions,
} from '../../common/optionMap';
import styles from './IsEmployed.module.css';
const IsEmployed = ({
idPrefix4Radio,
isCurrentlyEmployed,
jobEndingTimeYear,
jobEndingTimeMonth,
onIsCurrentlyEmployed,
onJobEndingTimeYear,
onJobEndingTimeMonth,
}) => (
<div className={styles.wrapper}>
<div>
<InputTitle text="你現在在職嗎？" must />
<div className={styles.radios}>
{isEmployedOptions.map(option => (
<RadioDefault
idPrefix={idPrefix4Radio}
key={option.value}
label={option.label}
value={option.value}
onChange={onIsCurrentlyEmployed}
checked={isCurrentlyEmployed === option.value}
/>
))}
</div>
</div>
{isCurrentlyEmployed === 'no' ? (
<div>
<InputTitle text="離職時間" must />
<div className={styles.selects}>
<Select
options={jobEndingTimeYearOptions}
value={jobEndingTimeYear}
onChange={e => onJobEndingTimeYear(Number(e.target.value))}
/>
<Unit marginRight>年</Unit>
<Select
options={jobEndingTimeMonthOptions}
value={jobEndingTimeMonth}
onChange={e => onJobEndingTimeMonth(Number(e.target.value))}
/>
<Unit>月</Unit>
</div>
</div>
) : null}
</div>
);
IsEmployed.propTypes = {
idPrefix4Radio: PropTypes.string,
isCurrentlyEmployed: PropTypes.string,
jobEndingTimeYear: PropTypes.number,
jobEndingTimeMonth: PropTypes.number,
onIsCurrentlyEmployed: PropTypes.func,
onJobEndingTimeYear: PropTypes.func,
onJobEndingTimeMonth: PropTypes.func,
};
export default IsEmployed;
|
docs/src/components/Home/Preface/Preface.js
|
seek-oss/seek-style-guide
|
import React from 'react';
import { PageBlock, Section, Columns, Text } from 'seek-style-guide/react';
export default () => (
<PageBlock>
<Section header>
<Text hero>A principled design process</Text>
</Section>
<Section>
<Text>
SEEK have developed 10 principles that describe the fundamental goals
the design team consider when applying their minds to new design
challenges or refining existing work. Their purpose is to enable the
creation of content that will assist our users to complete tasks easily
and hopefully enjoy the experience.
</Text>
</Section>
<Columns>
<div>
<Section>
<Text subheading>Design with empathy</Text>
<Text>
Understand our customers and end users better than they understand
themselves.
</Text>
</Section>
<Section>
<Text subheading>
A Seek interaction is transparent, honest and trustworthy
</Text>
<Text>
A user experience at Seek should be true to the brand & true to how
people want to be treated. “If we want users to like our software,
we should design it to behave like a likeable person.” – Alan Cooper
</Text>
</Section>
<Section>
<Text subheading>
Use persuasive design to achieve business goals
</Text>
<Text>
It is not enough that our design is usable, it should be used in a
way that encourages users towards the goals of SEEK. A registered
user action is more valuable than an anonymous one, a searchable
profile is more useful than a hidden one.
</Text>
</Section>
<Section>
<Text subheading>Content is king</Text>
<Text>
A person’s focus should be on their content, not on the UI. Help
people work without interference.
</Text>
</Section>
</div>
<div>
<Section>
<Text subheading>Simplicity is powerful</Text>
<Text>
A minimalist form and function keeps users focused on their goals
without distraction. It improves on-screen responsiveness as well as
being suited to small-screen implementations.
</Text>
</Section>
<Section>
<Text subheading>Data informs design</Text>
<Text>
“One accurate measurement is worth more than a thousand expert
opinions.” – Grace Hopper
</Text>
</Section>
<Section>
<Text subheading>Consistency matters</Text>
<Text>
Appearance follows behaviour (Form follows function). Designed
elements should look like they behave—someone should be able to
predict how an interface element will behave merely by looking at
it. Embrace consistency, but not homogeneity. If something looks the
same it should always act the same.
</Text>
</Section>
<Section>
<Text subheading>Accessible design is good design</Text>
<Text>
In principle Seek design should be usable on all devices by all of
the people in all situations. Design is simple, touch friendly and
clear and aims for AA accessibility.
</Text>
</Section>
</div>
<div>
<Section>
<Text subheading>Make it mine</Text>
<Text>
The jobseeking experience is highly personal one that takes place
over extended periods of time. The experience should align to the
way that users conduct their jobseeking, allowing them to continue
where they left off.
</Text>
</Section>
<Section>
<Text subheading>Don’t make users think</Text>
<Text>
Observation shows that users do not read instructions. Interactions
should be task focused, eliminating decision points and generally
use one clear call to action.
</Text>
</Section>
</div>
</Columns>
</PageBlock>
);
|
client/src/app/components/forms/SignupForm.js
|
mtiger2k/graphql-tutorial
|
import React, { Component } from 'react';
import { reduxForm, Field } from 'redux-form';
import { renderTextField } from './formHelpers'
const validate = values => {
const errors = {}
if (!values.dispName) {
errors.dispName = 'Required'
}
if (!values.username) {
errors.username = 'Required'
}
if (!values.role) {
errors.role = 'Required'
}
if (!values.password) {
errors.password = 'Required'
} else if (values.password.length < 4) {
errors.password = 'Must be 4 characters or more'
}
if (values.confirmPassword !== values.password) {
errors.confirmPassword = 'Must match password'
}
return errors
}
class SignupForm extends Component {
render() {
const { handleSubmit, error } = this.props;
return (
<div className="register-box">
<div className="register-logo">
<a href="../../index2.html"><b>Admin</b>LTE</a>
</div>
<div className="register-box-body">
<p className="login-box-msg">Register a new membership</p>
<form onSubmit={handleSubmit}>
{error && <div className="alert alert-danger">{error}</div>}
<Field name="dispName" type="text" component={renderTextField} label="用户名"/>
<Field name="username" type="text" component={renderTextField} label="登录名"/>
<Field name="password" type="password" component={renderTextField} label="密码"/>
<Field name="confirm_password" type="password" component={renderTextField} label="确认密码"/>
<div className="row">
<div className="col-xs-8">
<div className="checkbox icheck">
<label>
<input type="checkbox"/> I agree to the <a href="#">terms</a>
</label>
</div>
</div>
<div className="col-xs-4">
<button type="submit" className="btn btn-primary btn-block btn-flat">Register</button>
</div>
</div>
</form>
<a href="/login" className="text-center">I already have a membership</a>
</div>
</div>
);
}
}
// Decorate the form component
export default reduxForm({
form: 'signupForm',
validate
})(SignupForm);
|
src/components/game/ScoresTable.js
|
marc-ed-raffalli/geo-game
|
import React from 'react';
import ScoreCorrect from '../../containers/ScoreCorrect';
import ScoreError from '../../containers/ScoreError';
export default () => (
<div className="d-flex text-nowrap">
<span className="col py-2 badge badge-success"><ScoreCorrect/></span>
<span className="col py-2 badge badge-danger ml-1"><ScoreError/></span>
</div>
);
|
src/components/header/newGame/NewGameModal.js
|
TechyFatih/Nuzlog
|
import React from 'react';
import { Modal, Button } from 'react-bootstrap';
import { connect } from 'react-redux';
import { actions } from 'react-redux-form';
import games from 'data/games.json';
import ConfirmModal from 'components/other/ConfirmModal';
import { RRForm, RRFControl } from 'components/form/RRF';
import { newGame, newLocation } from 'actions';
import Rules from './Rules';
class NewGameModal extends React.Component {
constructor() {
super();
this.state = {
rules: [],
confirm: false,
values: null
};
this.handleEnter = this.handleEnter.bind(this);
this.addRule = this.addRule.bind(this);
this.removeRule = this.removeRule.bind(this);
this.handleSubmit = this.handleSubmit.bind(this);
this.handleConfirm = this.handleConfirm.bind(this);
}
handleEnter() {
this.setState({
rules: [],
values: null
});
this.dispatch(actions.focus('local.title'));
}
addRule(rule) {
this.setState(({rules}) => ({
rules: [...rules, rule]
}));
}
removeRule(index) {
this.setState(({rules}) => ({
rules: [
...rules.slice(0, index),
...rules.slice(index + 1)
]
}));
}
handleSubmit(values) {
if (!this.props.gameOpen) {
this.props.onNewGame(
values.title,
values.game,
values.name,
values.location,
this.state.rules
);
this.props.onHide();
} else {
this.setState({
confirm: true,
values
});
}
}
handleConfirm() {
const {values} = this.state;
this.props.onNewGame(
values.title,
values.game,
values.name,
values.location,
this.state.rules
);
this.props.onHide();
this.setState({values: null});
}
render() {
return (
<Modal show={this.props.show} onEnter={this.handleEnter}
onHide={this.props.onHide}>
<RRForm getDispatch={dispatch => this.dispatch = dispatch}
onSubmit={this.handleSubmit}>
<Modal.Header closeButton><h2>New Game</h2></Modal.Header>
<Modal.Body>
<RRFControl model='.title' id='new-title' label='Title*'
placeholder='The Great Nuzlocke Challenge' required/>
<RRFControl model='.game' component='combobox' id='new-game'
label='Game*' placeholder='Pokémon Ruby' required>
{games}
</RRFControl>
<RRFControl model='.name' id='new-name' label='Name*'
placeholder='Ruby' required/>
<RRFControl model='.location' id='new-locaiton'
label='Initial Location' placeholder='Littleroot Town'/>
<Rules rules={this.state.rules}
addRule={this.addRule} removeRule={this.removeRule}/>
</Modal.Body>
<Modal.Footer>
<Button type='submit' bsStyle='primary' bsSize='large' block>
Start
</Button>
</Modal.Footer>
</RRForm>
<ConfirmModal show={this.state.confirm} onConfirm={this.handleConfirm}
onHide={() => this.setState({confirm: false})}>
Are you sure you want to start a new game? All unsaved progress
will be lost.
</ConfirmModal>
</Modal>
);
}
}
const mapStateToProps = state => {
return {
gameOpen: state.gameOpen
};
};
const mapDispatchToProps = dispatch => {
return {
onNewGame: (title, game, name, location, rules) => {
dispatch(newGame(title, game, name, rules))
if (location)
dispatch(newLocation(location));
}
};
};
export default connect(mapStateToProps, mapDispatchToProps)(NewGameModal);
|
src-web/js/view/History.js
|
kwangkim/pigment
|
import React from 'react';
export default class HistoryView extends React.Component {
render() {
return <div>
<HistoryViewHeader />
</div>;
}
}
class HistoryViewHeader extends React.Component {
render() {
return <span>HISTORY VIEW</span>;
}
}
|
node_modules/redux-form/es/__tests__/Fields.spec.js
|
Starnes81/ReduxBlogTut
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
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; }
/* eslint react/no-multi-comp:0 */
import React, { Component } from 'react';
import { createSpy, spyOn } from 'expect';
import { Provider } from 'react-redux';
import { combineReducers as plainCombineReducers, createStore } from 'redux';
import { combineReducers as immutableCombineReducers } from 'redux-immutablejs';
import TestUtils from 'react-dom/test-utils';
import createReduxForm from '../reduxForm';
import createReducer from '../reducer';
import createFields from '../Fields';
import FormSection from '../FormSection';
import plain from '../structure/plain';
import plainExpectations from '../structure/plain/expectations';
import immutable from '../structure/immutable';
import immutableExpectations from '../structure/immutable/expectations';
import addExpectations from './addExpectations';
var describeFields = function describeFields(name, structure, combineReducers, expect) {
var reduxForm = createReduxForm(structure);
var Fields = createFields(structure);
var reducer = createReducer(structure);
var fromJS = structure.fromJS,
getIn = structure.getIn;
var makeStore = function makeStore(initial) {
return createStore(combineReducers({ form: reducer }), fromJS({ form: initial }));
};
var TestInput = function (_Component) {
_inherits(TestInput, _Component);
function TestInput() {
_classCallCheck(this, TestInput);
return _possibleConstructorReturn(this, (TestInput.__proto__ || Object.getPrototypeOf(TestInput)).apply(this, arguments));
}
_createClass(TestInput, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
'TEST INPUT'
);
}
}]);
return TestInput;
}(Component);
var testProps = function testProps(state) {
var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var store = makeStore({ testForm: state });
var Form = function (_Component2) {
_inherits(Form, _Component2);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm(_extends({ form: 'testForm' }, config))(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
return TestUtils.findRenderedComponentWithType(dom, TestInput).props;
};
describe(name, function () {
it('should throw an error if not in ReduxForm', function () {
expect(function () {
TestUtils.renderIntoDocument(React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: TestInput })
));
}).toThrow(/must be inside a component decorated with reduxForm/);
});
it('should warn if no names prop is provided', function () {
var spy = spyOn(console, 'error'); // mutes prop type warning
var store = makeStore();
var Form = function (_Component3) {
_inherits(Form, _Component3);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
expect(function () {
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
}).toThrow(/No "names" prop was specified/);
spy.restore();
});
it('should warn if invalid names prop is provided', function () {
var spy = spyOn(console, 'error'); // mutes prop type warning
var store = makeStore();
var Form = function (_Component4) {
_inherits(Form, _Component4);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: 'This is a string', component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
expect(function () {
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
}).toThrow(/Invalid prop "names"/);
spy.restore();
});
it('should get value from Redux state', function () {
var props = testProps({
values: {
foo: 'bar'
}
});
expect(props.foo.input.value).toBe('bar');
});
it('should get meta.form', function () {
var props = testProps({
values: {
foo: 'bar'
}
});
expect(props.foo.meta.form).toBe('testForm');
});
it('should get dirty/pristine from Redux state', function () {
var props1 = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
}
});
expect(props1.foo.meta.pristine).toBe(true);
expect(props1.foo.meta.dirty).toBe(false);
var props2 = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'baz'
}
});
expect(props2.foo.meta.pristine).toBe(false);
expect(props2.foo.meta.dirty).toBe(true);
});
it('should allow an empty value from Redux state to be pristine', function () {
var props1 = testProps({
initial: {
foo: 'bar'
},
values: {
foo: ''
}
});
expect(props1.foo.meta.pristine).toBe(false);
expect(props1.foo.meta.dirty).toBe(true);
var props2 = testProps({
initial: {
foo: ''
},
values: {
foo: ''
}
});
expect(props2.foo.meta.pristine).toBe(true);
expect(props2.foo.meta.dirty).toBe(false);
});
it('should get asyncValidating from Redux state', function () {
var props1 = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
},
asyncValidating: 'dog'
});
expect(props1.foo.meta.asyncValidating).toBe(false);
var props2 = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'baz'
},
asyncValidating: 'foo'
});
expect(props2.foo.meta.asyncValidating).toBe(true);
});
it('should get sync errors from outer reduxForm component', function () {
var props = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
}
}, {
validate: function validate() {
return { foo: 'foo error' };
}
});
expect(props.foo.meta.error).toBe('foo error');
});
it('should get sync warnings from outer reduxForm component', function () {
var props = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
}
}, {
warn: function warn() {
return { foo: 'foo warning' };
}
});
expect(props.foo.meta.warning).toBe('foo warning');
});
it('should get async errors from Redux state', function () {
var props = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
},
asyncErrors: {
foo: 'foo error'
}
});
expect(props.foo.meta.error).toBe('foo error');
});
it('should get submit errors from Redux state', function () {
var props = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
},
submitErrors: {
foo: 'foo error'
}
});
expect(props.foo.meta.error).toBe('foo error');
});
it('should get submitFailed prop from Redux state', function () {
var props = testProps({
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
},
submitFailed: true
});
expect(props.foo.meta.submitFailed).toBe(true);
});
it('should provide names getter', function () {
var store = makeStore({
testForm: {
values: {
foo: 'bar'
}
}
});
var Form = function (_Component5) {
_inherits(Form, _Component5);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.names).toEqual(['foo', 'bar']);
});
it('should provide values getter', function () {
var store = makeStore({
testForm: {
values: {
foo: 'fooValue',
bar: 'barValue'
}
}
});
var Form = function (_Component6) {
_inherits(Form, _Component6);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.values).toEqual({ foo: 'fooValue', bar: 'barValue' });
});
it('should provide dirty getter that is true when any field is dirty', function () {
var store = makeStore({
testForm: {
initial: {
foo: 'fooValue',
bar: 'barValue'
},
values: {
foo: 'fooValue',
bar: 'barValueDirty'
}
}
});
var Form = function (_Component7) {
_inherits(Form, _Component7);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.dirty).toBe(true);
});
it('should provide dirty getter that is false when all fields are pristine', function () {
var store = makeStore({
testForm: {
initial: {
foo: 'fooValue',
bar: 'barValue'
},
values: {
foo: 'fooValue',
bar: 'barValue'
}
}
});
var Form = function (_Component8) {
_inherits(Form, _Component8);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.dirty).toBe(false);
});
it('should provide pristine getter that is false when dirty', function () {
var store = makeStore({
testForm: {
values: {
foo: 'bar'
}
}
});
var Form = function (_Component9) {
_inherits(Form, _Component9);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.pristine).toBe(false);
});
it('should provide pristine getter that is true when pristine', function () {
var store = makeStore({
testForm: {
initial: {
foo: 'bar'
},
values: {
foo: 'bar'
}
}
});
var Form = function (_Component10) {
_inherits(Form, _Component10);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo'], component: TestInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.pristine).toBe(true);
});
it('should have value set to initial value on first render', function () {
var store = makeStore({});
var input = createSpy(function (props) {
return React.createElement('input', props.foo.input);
}).andCallThrough();
var Form = function (_Component11) {
_inherits(Form, _Component11);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: input })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm'
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, { initialValues: { foo: 'fooValue', bar: 'barValue' } })
));
expect(input).toHaveBeenCalled();
expect(input.calls[0].arguments[0].foo.input.value).toBe('fooValue');
expect(input.calls[0].arguments[0].bar.input.value).toBe('barValue');
});
it('should provide sync error for array field', function () {
var store = makeStore({
testForm: {
values: {
foo: ['bar']
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var validate = function validate() {
return { foo: ['first error', 'second error'] };
};
var Form = function (_Component12) {
_inherits(Form, _Component12);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo[0]', 'foo[1]'], component: input })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
validate: validate
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(input).toHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].foo[0].meta.valid).toBe(false);
expect(input.calls[0].arguments[0].foo[0].meta.error).toBe('first error');
expect(input.calls[0].arguments[0].foo[1].meta.valid).toBe(false);
expect(input.calls[0].arguments[0].foo[1].meta.error).toBe('second error');
});
it('should provide sync error for array-of-objects field', function () {
var store = makeStore({
testForm: {
values: {
authors: [{
firstName: 'Erik',
lastName: 'Rasmussen'
}]
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var validate = function validate() {
return {
authors: [{ _error: 'Object Error' }]
};
};
var Form = function (_Component13) {
_inherits(Form, _Component13);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['authors[0]'], component: input })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
validate: validate
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(input).toHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].authors[0].meta.valid).toBe(false);
expect(input.calls[0].arguments[0].authors[0].meta.error).toBe('Object Error');
});
it('should provide sync warning for array field', function () {
var store = makeStore({
testForm: {
values: {
foo: ['bar']
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var warn = function warn() {
return { foo: ['first warning', 'second warning'] };
};
var Form = function (_Component14) {
_inherits(Form, _Component14);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo[0]', 'foo[1]'], component: input })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
warn: warn
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(input).toHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].foo[0].meta.warning).toBe('first warning');
expect(input.calls[0].arguments[0].foo[1].meta.warning).toBe('second warning');
});
it('should provide sync warning for array-of-objects field', function () {
var store = makeStore({
testForm: {
values: {
authors: [{
firstName: 'Erik',
lastName: 'Rasmussen'
}]
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var warn = function warn() {
return {
authors: [{ _warning: 'Object Error' }]
};
};
var Form = function (_Component15) {
_inherits(Form, _Component15);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['authors[0]'], component: input })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
warn: warn
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(input).toHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].authors[0].meta.warning).toBe('Object Error');
});
it('should provide access to rendered component', function () {
var store = makeStore({
testForm: {
values: {
foo: 'fooValue',
bar: 'barValue'
}
}
});
var Form = function (_Component16) {
_inherits(Form, _Component16);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo', 'bar'], component: TestInput, withRef: true })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var field = TestUtils.findRenderedComponentWithType(dom, Fields);
var input = TestUtils.findRenderedComponentWithType(dom, TestInput);
expect(field.getRenderedComponent()).toBe(input);
});
it('should unregister fields when unmounted', function () {
var store = makeStore();
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var Form = function (_Component17) {
_inherits(Form, _Component17);
function Form() {
_classCallCheck(this, Form);
var _this17 = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this));
_this17.state = { toggle: false };
return _this17;
}
_createClass(Form, [{
key: 'render',
value: function render() {
var _this18 = this;
var toggle = this.state.toggle;
return React.createElement(
'div',
null,
!toggle && React.createElement(Fields, { names: ['dog', 'cat'], component: input }),
toggle && React.createElement(Fields, { names: ['cow', 'ewe'], component: input }),
React.createElement(
'button',
{ onClick: function onClick() {
return _this18.setState({ toggle: true });
} },
'Toggle'
)
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(store.getState()).toEqualMap({
form: {
testForm: {
registeredFields: {
dog: { name: 'dog', type: 'Field', count: 1 },
cat: { name: 'cat', type: 'Field', count: 1 }
}
}
}
});
var button = TestUtils.findRenderedDOMComponentWithTag(dom, 'button');
TestUtils.Simulate.click(button);
expect(store.getState()).toEqualMap({
form: {
testForm: {
registeredFields: {
cow: { name: 'cow', type: 'Field', count: 1 },
ewe: { name: 'ewe', type: 'Field', count: 1 }
}
}
}
});
});
it('should reconnect when names change', function () {
var store = makeStore({
testForm: {
values: {
foo: 'fooValue',
bar: 'barValue'
},
fields: {
bar: {
touched: true
}
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var Form = function (_Component18) {
_inherits(Form, _Component18);
function Form() {
_classCallCheck(this, Form);
var _this19 = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this));
_this19.state = { field: 'foo' };
return _this19;
}
_createClass(Form, [{
key: 'render',
value: function render() {
var _this20 = this;
return React.createElement(
'div',
null,
React.createElement(Fields, { names: [this.state.field], component: input }),
React.createElement(
'button',
{ onClick: function onClick() {
return _this20.setState({ field: 'bar' });
} },
'Change'
)
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(input).toHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].foo.input.value).toBe('fooValue');
expect(input.calls[0].arguments[0].foo.meta.touched).toBe(false);
var button = TestUtils.findRenderedDOMComponentWithTag(dom, 'button');
TestUtils.Simulate.click(button);
expect(input.calls.length).toBe(2);
expect(input.calls[1].arguments[0].bar.input.value).toBe('barValue');
expect(input.calls[1].arguments[0].bar.meta.touched).toBe(true);
});
it('should prefix name getter when inside FormSection', function () {
var store = makeStore();
var renderFields = function renderFields(_ref) {
var foo = _ref.foo,
bar = _ref.bar;
return React.createElement(
'div',
null,
React.createElement('input', foo.input),
React.createElement('input', bar.input)
);
};
var Form = function (_Component19) {
_inherits(Form, _Component19);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
FormSection,
{ name: 'foo' },
React.createElement(Fields, { names: ['foo', 'bar'], component: renderFields })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.names).toEqual(['foo.foo', 'foo.bar']);
});
it('should prefix name getter when inside multiple FormSection', function () {
var store = makeStore();
var renderFields = function renderFields(_ref2) {
var foo = _ref2.foo,
bar = _ref2.bar;
return React.createElement(
'div',
null,
React.createElement('input', foo.input),
React.createElement('input', bar.input)
);
};
var Form = function (_Component20) {
_inherits(Form, _Component20);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
FormSection,
{ name: 'foo' },
React.createElement(
FormSection,
{ name: 'fighter' },
React.createElement(Fields, { names: ['foo', 'bar'], component: renderFields })
)
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var stub = TestUtils.findRenderedComponentWithType(dom, Fields);
expect(stub.names).toEqual(['foo.fighter.foo', 'foo.fighter.bar']);
});
it('should prefix name when inside FormSection', function () {
var store = makeStore();
var renderFields = function renderFields(_ref3) {
var foo = _ref3.foo,
bar = _ref3.bar;
return React.createElement(
'div',
null,
React.createElement('input', foo.input),
React.createElement('input', bar.input)
);
};
var Form = function (_Component21) {
_inherits(Form, _Component21);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
FormSection,
{ name: 'foo' },
React.createElement(Fields, { names: ['foo', 'bar'], component: renderFields })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(store.getState()).toEqualMap({
form: {
testForm: {
registeredFields: {
'foo.foo': { name: 'foo.foo', type: 'Field', count: 1 },
'foo.bar': { name: 'foo.bar', type: 'Field', count: 1 }
}
}
}
});
});
it('should prefix name when inside multiple FormSections', function () {
var store = makeStore();
var renderFields = function renderFields(_ref4) {
var foo = _ref4.foo,
bar = _ref4.bar;
return React.createElement(
'div',
null,
React.createElement('input', foo.input),
React.createElement('input', bar.input)
);
};
var Form = function (_Component22) {
_inherits(Form, _Component22);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
FormSection,
{ name: 'foo' },
React.createElement(
FormSection,
{ name: 'fighter' },
React.createElement(Fields, { names: ['foo', 'bar'], component: renderFields })
)
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(store.getState()).toEqualMap({
form: {
testForm: {
registeredFields: {
'foo.fighter.foo': { name: 'foo.fighter.foo', type: 'Field', count: 1 },
'foo.fighter.bar': { name: 'foo.fighter.bar', type: 'Field', count: 1 }
}
}
}
});
});
it('should rerender when props change', function () {
var store = makeStore();
var renderFields = createSpy(function (props) {
return React.createElement(
'div',
null,
props.highlighted,
React.createElement('input', props.foo.input)
);
}).andCallThrough();
var Form = function (_Component23) {
_inherits(Form, _Component23);
function Form() {
_classCallCheck(this, Form);
var _this25 = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this));
_this25.state = { highlighted: 0 };
return _this25;
}
_createClass(Form, [{
key: 'render',
value: function render() {
var _this26 = this;
var highlighted = this.state.highlighted;
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['foo'], highlighted: highlighted, component: renderFields }),
React.createElement(
'button',
{ onClick: function onClick() {
return _this26.setState({ highlighted: highlighted + 1 });
} },
'Change'
)
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(renderFields).toHaveBeenCalled();
expect(renderFields.calls.length).toBe(1);
expect(renderFields.calls[0].arguments[0].highlighted).toBe(0);
var button = TestUtils.findRenderedDOMComponentWithTag(dom, 'button');
TestUtils.Simulate.click(button);
expect(renderFields.calls.length).toBe(2);
expect(renderFields.calls[1].arguments[0].highlighted).toBe(1);
});
it('should NOT rerender when props.props is shallow-equal, but !==', function () {
var store = makeStore();
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var renderSpy = createSpy();
var Form = function (_Component24) {
_inherits(Form, _Component24);
function Form() {
_classCallCheck(this, Form);
var _this27 = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this));
_this27.state = { foo: 'bar' };
return _this27;
}
_createClass(Form, [{
key: 'render',
value: function render() {
var _this28 = this;
renderSpy();
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['myField'], component: input, props: { rel: 'test' } }),
React.createElement(
'button',
{ onClick: function onClick() {
return _this28.setState({ foo: 'qux' });
} },
'Change'
)
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(renderSpy).toHaveBeenCalled();
expect(renderSpy.calls.length).toBe(1);
expect(input).toHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].rel).toBe('test');
var button = TestUtils.findRenderedDOMComponentWithTag(dom, 'button');
TestUtils.Simulate.click(button);
expect(renderSpy.calls.length).toBe(2);
expect(input.calls.length).toBe(1);
});
it('should rerender when one of the fields changes', function () {
var store = makeStore({
testForm: {
values: {
cat: 'catValue',
dog: 'dogValue',
ewe: 'eweValue',
fox: 'foxValue'
}
}
});
var inputPair1 = createSpy(function (_ref5) {
var cat = _ref5.cat,
dog = _ref5.dog;
return React.createElement(
'div',
null,
React.createElement('input', cat.input),
React.createElement('input', dog.input)
);
}).andCallThrough();
var inputPair2 = createSpy(function (_ref6) {
var ewe = _ref6.ewe,
fox = _ref6.fox;
return React.createElement(
'div',
null,
React.createElement('input', ewe.input),
React.createElement('input', fox.input)
);
}).andCallThrough();
var Form = function (_Component25) {
_inherits(Form, _Component25);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['cat', 'dog'], component: inputPair1 }),
React.createElement(Fields, { names: ['ewe', 'fox'], component: inputPair2 })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(inputPair1).toHaveBeenCalled();
expect(inputPair1.calls.length).toBe(1);
expect(inputPair1.calls[0].arguments[0].cat.input.value).toBe('catValue');
expect(inputPair1.calls[0].arguments[0].dog.input.value).toBe('dogValue');
expect(inputPair2).toHaveBeenCalled();
expect(inputPair2.calls.length).toBe(1);
expect(inputPair2.calls[0].arguments[0].ewe.input.value).toBe('eweValue');
expect(inputPair2.calls[0].arguments[0].fox.input.value).toBe('foxValue');
inputPair1.calls[0].arguments[0].dog.input.onChange('FIDO');
// input pair 1 should be rerendered
expect(inputPair1.calls.length).toBe(2);
expect(inputPair1.calls[1].arguments[0].cat.input.value).toBe('catValue');
expect(inputPair1.calls[1].arguments[0].dog.input.value).toBe('FIDO');
// input pair 2 should NOT be rerendered
expect(inputPair2.calls.length).toBe(1);
});
it('should call format function on first render', function () {
var store = makeStore({
testForm: {
values: {
name: 'Redux Form'
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var format = createSpy(function (value) {
return value.toLowerCase();
}).andCallThrough();
var Form = function (_Component26) {
_inherits(Form, _Component26);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['name'], component: input, format: format })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(format).toHaveBeenCalled();
expect(format.calls.length).toBe(1);
expect(format.calls[0].arguments).toEqual(['Redux Form', 'name']);
expect(input.calls[0].arguments[0].name.input.value).toBe('redux form');
});
it('should call parse function on change', function () {
var store = makeStore({
testForm: {
values: {
name: 'redux form'
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var parse = createSpy(function (value) {
return value.toLowerCase();
}).andCallThrough();
var Form = function (_Component27) {
_inherits(Form, _Component27);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['name'], component: input, parse: parse })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(parse).toNotHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].name.input.value).toBe('redux form');
input.calls[0].arguments[0].name.input.onChange('REDUX FORM ROCKS');
expect(parse).toHaveBeenCalled();
expect(parse.calls.length).toBe(1);
expect(parse.calls[0].arguments).toEqual(['REDUX FORM ROCKS', 'name']);
expect(input.calls.length).toBe(2);
expect(input.calls[1].arguments[0].name.input.value).toBe('redux form rocks');
});
it('should call parse function on blur', function () {
var store = makeStore({
testForm: {
values: {
name: 'redux form'
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var parse = createSpy(function (value) {
return value.toLowerCase();
}).andCallThrough();
var Form = function (_Component28) {
_inherits(Form, _Component28);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['name'], component: input, parse: parse })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(parse).toNotHaveBeenCalled();
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].name.input.value).toBe('redux form');
input.calls[0].arguments[0].name.input.onBlur('REDUX FORM ROCKS');
expect(parse).toHaveBeenCalled();
expect(parse.calls.length).toBe(1);
expect(parse.calls[0].arguments).toEqual(['REDUX FORM ROCKS', 'name']);
expect(input.calls.length).toBe(2);
expect(input.calls[1].arguments[0].name.input.value).toBe('redux form rocks');
});
it('should handle on focus', function () {
var store = makeStore({
testForm: {
values: {
name: 'redux form'
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var Form = function (_Component29) {
_inherits(Form, _Component29);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['name'], component: input })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].name.meta.visited).toBe(false);
input.calls[0].arguments[0].name.input.onFocus();
expect(input.calls.length).toBe(2);
expect(input.calls[1].arguments[0].name.meta.visited).toBe(true);
});
it('should parse and format to maintain different type in store', function () {
var store = makeStore({
testForm: {
values: {
age: 42
}
}
});
var input = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var parse = createSpy(function (value) {
return value && parseInt(value, 10);
}).andCallThrough();
var format = createSpy(function (value) {
return value && value.toString();
}).andCallThrough();
var Form = function (_Component30) {
_inherits(Form, _Component30);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['age'], component: input, format: format, parse: parse })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
// format called once
expect(format).toHaveBeenCalled();
expect(format.calls.length).toBe(1);
// parse not called yet
expect(parse).toNotHaveBeenCalled();
// input displaying string value
expect(input.calls.length).toBe(1);
expect(input.calls[0].arguments[0].age.input.value).toBe('42');
// update value
input.calls[0].arguments[0].age.input.onChange('15');
// parse was called
expect(parse).toHaveBeenCalled();
expect(parse.calls.length).toBe(1);
expect(parse.calls[0].arguments).toEqual(['15', 'age']);
// value in store is number
expect(store.getState()).toEqualMap({
form: {
testForm: {
values: {
age: 15 // number
},
registeredFields: { age: { name: 'age', type: 'Field', count: 1 } }
}
}
});
// format called again
expect(format).toHaveBeenCalled();
expect(format.calls.length).toBe(2);
expect(format.calls[1].arguments).toEqual([15, 'age']);
// input rerendered with string value
expect(input.calls.length).toBe(2);
expect(input.calls[1].arguments[0].age.input.value).toBe('15');
});
it('should rerender when sync error changes', function () {
var store = makeStore({
testForm: {
values: {
password: 'redux-form sucks',
confirm: 'redux-form rocks'
}
}
});
var passwordInput = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var confirmInput = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var validate = function validate(values) {
var password = getIn(values, 'password');
var confirm = getIn(values, 'confirm');
return password === confirm ? {} : { confirm: 'Must match!' };
};
var Form = function (_Component31) {
_inherits(Form, _Component31);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['password'], component: passwordInput }),
React.createElement(Fields, { names: ['confirm'], component: confirmInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
validate: validate
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
// password input rendered
expect(passwordInput).toHaveBeenCalled();
expect(passwordInput.calls.length).toBe(1);
// confirm input rendered with error
expect(confirmInput).toHaveBeenCalled();
expect(confirmInput.calls.length).toBe(1);
expect(confirmInput.calls[0].arguments[0].confirm.meta.valid).toBe(false);
expect(confirmInput.calls[0].arguments[0].confirm.meta.error).toBe('Must match!');
// update password field so that they match
passwordInput.calls[0].arguments[0].password.input.onChange('redux-form rocks');
// password input rerendered
expect(passwordInput.calls.length).toBe(2);
// confirm input should also rerender, but with no error
expect(confirmInput.calls.length).toBe(2);
expect(confirmInput.calls[1].arguments[0].confirm.meta.valid).toBe(true);
expect(confirmInput.calls[1].arguments[0].confirm.meta.error).toBe(undefined);
});
it('should rerender when sync error is cleared', function () {
var store = makeStore();
var usernameInput = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var validate = function validate(values) {
var username = getIn(values, 'username');
return username ? {} : { username: 'Required' };
};
var Form = function (_Component32) {
_inherits(Form, _Component32);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['username'], component: usernameInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
validate: validate
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
// username input rendered
expect(usernameInput).toHaveBeenCalled();
expect(usernameInput.calls.length).toBe(1);
// username field has error
expect(usernameInput.calls[0].arguments[0].username.meta.valid).toBe(false);
expect(usernameInput.calls[0].arguments[0].username.meta.error).toBe('Required');
// update username field so it passes
usernameInput.calls[0].arguments[0].username.input.onChange('erikras');
// username input rerendered
expect(usernameInput.calls.length).toBe(2);
// should be valid now
expect(usernameInput.calls[1].arguments[0].username.meta.valid).toBe(true);
expect(usernameInput.calls[1].arguments[0].username.meta.error).toBe(undefined);
});
it('should rerender when sync warning changes', function () {
var store = makeStore({
testForm: {
values: {
password: 'redux-form sucks',
confirm: 'redux-form rocks'
}
}
});
var passwordInput = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var confirmInput = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var warn = function warn(values) {
var password = getIn(values, 'password');
var confirm = getIn(values, 'confirm');
return password === confirm ? {} : { confirm: 'Should match. Or not. Whatever.' };
};
var Form = function (_Component33) {
_inherits(Form, _Component33);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['password'], component: passwordInput }),
React.createElement(Fields, { names: ['confirm'], component: confirmInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
warn: warn
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
// password input rendered
expect(passwordInput).toHaveBeenCalled();
expect(passwordInput.calls.length).toBe(1);
// confirm input rendered with warning
expect(confirmInput).toHaveBeenCalled();
expect(confirmInput.calls.length).toBe(1);
expect(confirmInput.calls[0].arguments[0].confirm.meta.warning).toBe('Should match. Or not. Whatever.');
// update password field so that they match
passwordInput.calls[0].arguments[0].password.input.onChange('redux-form rocks');
// password input rerendered
expect(passwordInput.calls.length).toBe(2);
// confirm input should also rerender, but with no warning
expect(confirmInput.calls.length).toBe(2);
expect(confirmInput.calls[1].arguments[0].confirm.meta.warning).toBe(undefined);
});
it('should rerender when sync warning is cleared', function () {
var store = makeStore();
var usernameInput = createSpy(function (props) {
return React.createElement('input', props.input);
}).andCallThrough();
var warn = function warn(values) {
var username = getIn(values, 'username');
return username ? {} : { username: 'Recommended' };
};
var Form = function (_Component34) {
_inherits(Form, _Component34);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, { names: ['username'], component: usernameInput })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({
form: 'testForm',
warn: warn
})(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
// username input rendered
expect(usernameInput).toHaveBeenCalled();
expect(usernameInput.calls.length).toBe(1);
// username field has warning
expect(usernameInput.calls[0].arguments[0].username.meta.warning).toBe('Recommended');
// update username field so it passes
usernameInput.calls[0].arguments[0].username.input.onChange('erikras');
// username input rerendered
expect(usernameInput.calls.length).toBe(2);
// should be valid now
expect(usernameInput.calls[1].arguments[0].username.meta.warning).toBe(undefined);
});
it('should provide correct prop structure', function () {
var store = makeStore();
var renderFields = createSpy(function () {
return React.createElement('div', null);
}).andCallThrough();
var Form = function (_Component35) {
_inherits(Form, _Component35);
function Form() {
_classCallCheck(this, Form);
return _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).apply(this, arguments));
}
_createClass(Form, [{
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, {
names: ['foo', 'bar', 'deep.dive', 'array[0]', 'array[1]'],
component: renderFields,
someCustomProp: 'testing',
anotherCustomProp: 42,
customBooleanFlag: true })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
expect(renderFields).toHaveBeenCalled();
var fields = renderFields.calls[0].arguments[0];
var expectField = function expectField(field) {
expect(field).toExist();
expect(field.input).toExist();
expect(field.input.onChange).toBeA('function');
expect(field.input.onBlur).toBeA('function');
expect(field.input.onFocus).toBeA('function');
expect(field.meta).toExist();
expect(field.meta.pristine).toBe(true);
expect(field.meta.dirty).toBe(false);
expect(field.someCustomProp).toNotExist();
expect(field.anotherCustomProp).toNotExist();
expect(field.customBooleanFlag).toNotExist();
};
expectField(fields.foo);
expectField(fields.bar);
expect(fields.deep).toExist();
expectField(fields.deep.dive);
expect(fields.array).toExist();
expectField(fields.array[0]);
expectField(fields.array[1]);
expect(fields.someCustomProp).toBe('testing');
expect(fields.anotherCustomProp).toBe(42);
expect(fields.customBooleanFlag).toBe(true);
});
it('should provide correct prop structure after names change', function () {
var store = makeStore();
var renderFields = createSpy(function () {
return React.createElement('div', null);
}).andCallThrough();
var Form = function (_Component36) {
_inherits(Form, _Component36);
function Form(props) {
_classCallCheck(this, Form);
var _this40 = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this, props));
_this40.state = { names: ['foo', 'bar', 'deep.dive', 'array[0]'] };
_this40.changeNames = _this40.changeNames.bind(_this40);
return _this40;
}
_createClass(Form, [{
key: 'changeNames',
value: function changeNames() {
this.setState({ names: ['fighter', 'fly.high', 'array[1]'] });
}
}, {
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, {
names: this.state.names,
component: renderFields,
someCustomProp: 'testing',
anotherCustomProp: 42,
customBooleanFlag: true }),
React.createElement('button', { type: 'button', onClick: this.changeNames })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var button = TestUtils.findRenderedDOMComponentWithTag(dom, 'button');
TestUtils.Simulate.click(button);
expect(renderFields).toHaveBeenCalled();
expect(renderFields.calls.length).toBe(2);
var fields = renderFields.calls[1].arguments[0];
var expectField = function expectField(field) {
expect(field).toExist();
expect(field.input).toExist();
expect(field.input.onChange).toBeA('function');
expect(field.input.onBlur).toBeA('function');
expect(field.input.onFocus).toBeA('function');
expect(field.meta).toExist();
expect(field.meta.pristine).toBe(true);
expect(field.meta.dirty).toBe(false);
expect(field.someCustomProp).toNotExist();
expect(field.anotherCustomProp).toNotExist();
expect(field.customBooleanFlag).toNotExist();
};
expectField(fields.fighter);
expect(fields.fly).toExist();
expectField(fields.fly.high);
expect(fields.array).toExist();
expectField(fields.array[1]);
expect(fields.someCustomProp).toBe('testing');
expect(fields.anotherCustomProp).toBe(42);
expect(fields.customBooleanFlag).toBe(true);
expect(fields.foo).toNotExist();
expect(fields.bar).toNotExist();
expect(fields.deep).toNotExist();
expect(fields.array[0]).toNotExist();
});
it('should reassign event handlers when names change', function () {
var store = makeStore();
var renderFields = createSpy(function () {
return React.createElement('div', null);
}).andCallThrough();
var Form = function (_Component37) {
_inherits(Form, _Component37);
function Form(props) {
_classCallCheck(this, Form);
var _this41 = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this, props));
_this41.state = { names: ['foo', 'bar', 'deep.dive', 'array[0]'] };
_this41.changeNames = _this41.changeNames.bind(_this41);
return _this41;
}
_createClass(Form, [{
key: 'changeNames',
value: function changeNames() {
this.setState({ names: ['fighter', 'fly.high', 'array[1]'] });
}
}, {
key: 'render',
value: function render() {
return React.createElement(
'div',
null,
React.createElement(Fields, {
names: this.state.names,
component: renderFields,
someCustomProp: 'testing',
anotherCustomProp: 42,
customBooleanFlag: true }),
React.createElement('button', { type: 'button', onClick: this.changeNames })
);
}
}]);
return Form;
}(Component);
var TestForm = reduxForm({ form: 'testForm' })(Form);
var dom = TestUtils.renderIntoDocument(React.createElement(
Provider,
{ store: store },
React.createElement(TestForm, null)
));
var button = TestUtils.findRenderedDOMComponentWithTag(dom, 'button');
expect(renderFields).toHaveBeenCalled();
expect(renderFields.calls.length).toBe(1);
// foo is inactive
expect(renderFields.calls[0].arguments[0].foo.meta.active).toBe(false);
// focus on foo
renderFields.calls[0].arguments[0].foo.input.onFocus();
// foo is active
expect(renderFields.calls.length).toBe(2);
expect(renderFields.calls[1].arguments[0].foo.meta.active).toBe(true);
expect(renderFields.calls[1].arguments[0].foo.input.value).toBe('');
// change foo
renderFields.calls[1].arguments[0].foo.input.onChange('erikras');
// foo is changed
expect(renderFields.calls.length).toBe(3);
expect(renderFields.calls[2].arguments[0].foo.meta.active).toBe(true);
expect(renderFields.calls[2].arguments[0].foo.input.value).toBe('erikras');
// blur foo
renderFields.calls[2].arguments[0].foo.input.onBlur('@erikras');
// foo is blurred
expect(renderFields.calls.length).toBe(4);
expect(renderFields.calls[3].arguments[0].foo.meta.active).toBe(false);
expect(renderFields.calls[3].arguments[0].foo.input.value).toBe('@erikras');
// swap out fields
TestUtils.Simulate.click(button);
// original fields gone
expect(renderFields.calls.length).toBe(5);
expect(renderFields.calls[4].arguments[0].foo).toNotExist();
expect(renderFields.calls[4].arguments[0].fighter).toExist();
// fighter is inactive
expect(renderFields.calls[4].arguments[0].fighter.meta.active).toBe(false);
// focus on fighter
renderFields.calls[4].arguments[0].fighter.input.onFocus();
// fighter is active
expect(renderFields.calls.length).toBe(6);
expect(renderFields.calls[5].arguments[0].fighter.meta.active).toBe(true);
expect(renderFields.calls[5].arguments[0].fighter.input.value).toBe('');
// change fighter
renderFields.calls[5].arguments[0].fighter.input.onChange('reduxForm');
// fighter is changed
expect(renderFields.calls.length).toBe(7);
expect(renderFields.calls[6].arguments[0].fighter.meta.active).toBe(true);
expect(renderFields.calls[6].arguments[0].fighter.input.value).toBe('reduxForm');
// blur fighter
renderFields.calls[6].arguments[0].fighter.input.onBlur('@reduxForm');
// fighter is blurred
expect(renderFields.calls.length).toBe(8);
expect(renderFields.calls[7].arguments[0].fighter.meta.active).toBe(false);
expect(renderFields.calls[7].arguments[0].fighter.input.value).toBe('@reduxForm');
});
});
};
describeFields('Fields.plain', plain, plainCombineReducers, addExpectations(plainExpectations));
describeFields('Fields.immutable', immutable, immutableCombineReducers, addExpectations(immutableExpectations));
|
src/routes/Counter/components/Counter.js
|
yoshiyoshi7/react2chv2
|
import React from 'react'
import PropTypes from 'prop-types'
export const Counter = ({ counter, increment, doubleAsync }) => (
<div style={{ margin: '0 auto' }} >
<h2>Counter: {counter}</h2>
<button className='btn btn-primary' onClick={increment}>
Increment
</button>
{' '}
<button className='btn btn-secondary' onClick={doubleAsync}>
Double (Async)
</button>
</div>
)
Counter.propTypes = {
counter: PropTypes.number.isRequired,
increment: PropTypes.func.isRequired,
doubleAsync: PropTypes.func.isRequired,
}
export default Counter
|
src/routes/Music/components/MusicView.js
|
jhash/jhash
|
import './MusicView.scss'
import React from 'react'
import { Link } from 'react-router'
export class MusicView extends React.Component {
static propTypes = {}
render () {
return (
<div className='view--music row'>
<Link to='music/tabitha'>
Tabitha
</Link>
</div>
)
}
}
export default MusicView
|
src/svg-icons/notification/event-busy.js
|
ichiohta/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let NotificationEventBusy = (props) => (
<SvgIcon {...props}>
<path d="M9.31 17l2.44-2.44L14.19 17l1.06-1.06-2.44-2.44 2.44-2.44L14.19 10l-2.44 2.44L9.31 10l-1.06 1.06 2.44 2.44-2.44 2.44L9.31 17zM19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11z"/>
</SvgIcon>
);
NotificationEventBusy = pure(NotificationEventBusy);
NotificationEventBusy.displayName = 'NotificationEventBusy';
NotificationEventBusy.muiName = 'SvgIcon';
export default NotificationEventBusy;
|
react+redux/src/js/compont/unSend.js
|
fruitGirl/mm
|
/**
* Created by Administrator on 2017/8/19 0019.
*/
import React from 'react'
const UnSend = () =>{
return (
<div className="unSend">
<span className="iconfont icon-unhappy icon-md"></span>
<span>还未到配送日期</span>
</div>
)
}
export default UnSend;
|
src/components/TimeAndSalary/MobileInfoButtons.js
|
goodjoblife/GoodJobShare
|
import React from 'react';
import PropTypes from 'prop-types';
import { InfoButton } from 'common/Modal';
import styles from './MobileInfoButtons.module.css';
const MobileInfoButtons = ({ toggleInfoSalaryModal, toggleInfoTimeModal }) => (
<div className={styles.mobileInfoButtons}>
<div className={styles.infoButton}>
<InfoButton onClick={toggleInfoSalaryModal}>估計時薪</InfoButton>
</div>
<div className={styles.infoButton}>
<InfoButton onClick={toggleInfoTimeModal}>參考時間</InfoButton>
</div>
</div>
);
MobileInfoButtons.propTypes = {
toggleInfoSalaryModal: PropTypes.func.isRequired,
toggleInfoTimeModal: PropTypes.func.isRequired,
};
export default MobileInfoButtons;
|
monkey/monkey_island/cc/ui/src/components/attack/techniques/T1158.js
|
guardicore/monkey
|
import React from 'react';
import ReactTable from 'react-table';
import {renderMachineFromSystemData, ScanStatus} from './Helpers';
import MitigationsComponent from './MitigationsComponent';
class T1158 extends React.Component {
constructor(props) {
super(props);
}
static getColumns() {
return ([{
columns: [
{ Header: 'Machine',
id: 'machine',
accessor: x => renderMachineFromSystemData(x.machine),
style: {'whiteSpace': 'unset'}},
{ Header: 'Result',
id: 'result',
accessor: x => x.result,
style: {'whiteSpace': 'unset'}}
]
}])
}
render() {
return (
<div>
<div>{this.props.data.message_html}</div>
<br/>
{this.props.data.status === ScanStatus.USED ?
<ReactTable
columns={T1158.getColumns()}
data={this.props.data.info}
showPagination={false}
defaultPageSize={this.props.data.info.length}
/> : ''}
<MitigationsComponent mitigations={this.props.data.mitigations}/>
</div>
);
}
}
export default T1158;
|
app/javascript/mastodon/features/ui/components/drawer_loading.js
|
TheInventrix/mastodon
|
import React from 'react';
const DrawerLoading = () => (
<div className='drawer'>
<div className='drawer__pager'>
<div className='drawer__inner' />
</div>
</div>
);
export default DrawerLoading;
|
frontend/js/components/commentView.js
|
beetwo/toucan
|
import twitterText from 'twitter-text'
import PropTypes from 'prop-types';
import React from 'react';
import UserLink from './userLink'
class Comment extends React.Component {
render() {
let {comment} = this.props;
let mentions = twitterText.extractMentionsWithIndices(comment);
let parts = [];
if (mentions.length > 0) {
mentions.sort(function(a,b){ return a.indices[0] - b.indices[0]; });
let begin_index = 0;
let counter = 0;
mentions.forEach((value, index, mentions) => {
parts.push(<span key={counter++}>
{comment.substring(begin_index, value.indices[0])}
</span>
)
let username = value.screenName,
linkText = comment.substring(value.indices[0], value.indices[1]);
parts.push(
<UserLink key={counter++}
username={username}>
{linkText}
</UserLink>
)
begin_index = value.indices[1]
})
parts.push(<span key={counter++}>{comment.substring(begin_index, comment.length)}</span>);
}
return <div>{parts.length > 0 ? parts : comment}</div>;
}
}
Comment.propTypes = {
comment: PropTypes.string.isRequired
}
export default Comment
|
frontend/advocatesearch/AdvocateDetail.js
|
datoszs/czech-lawyers
|
import React from 'react';
import PropTypes from 'prop-types';
import {connect} from 'react-redux';
import {Row} from 'react-bootstrap';
import translate from '../translate';
import router from '../router';
import {ADVOCATE_DETAIL} from '../routes';
import {BasicStatistics} from '../components/statistics';
import {DetailPanel} from '../components';
import {Advocate, statusMsg} from '../model';
import {search} from './modules';
import FooterColumn from './FooterColumn';
import Legend from './Legend';
const AdvocateDetailComponent = ({advocate, handleDetail, msgStatus, msgIc, href}) => (
<DetailPanel
footer={
<Row>
<FooterColumn value={advocate.address.city} />
<FooterColumn value={advocate.ic} label={msgIc} />
<FooterColumn value={msgStatus} />
</Row>
}
title={advocate.name}
onClick={handleDetail}
href={href}
>
<BasicStatistics statistics={advocate.statistics} legend={Legend} />
</DetailPanel>
);
AdvocateDetailComponent.propTypes = {
advocate: PropTypes.instanceOf(Advocate).isRequired,
handleDetail: PropTypes.func.isRequired,
msgStatus: PropTypes.string.isRequired,
msgIc: PropTypes.string.isRequired,
href: PropTypes.string.isRequired,
};
const mapStateToProps = (state, {id}) => {
const advocate = search.getResult(state, id);
return {
advocate,
msgStatus: translate.getMessage(state, statusMsg[advocate.status]),
msgIc: translate.getMessage(state, 'advocate.ic'),
href: router.getHref(state, ADVOCATE_DETAIL, {id}),
};
};
const mapDispatchToProps = (dispatch, {id}) => ({
handleDetail: () => dispatch(router.transition(ADVOCATE_DETAIL, {id})),
});
const AdvocateDetail = connect(mapStateToProps, mapDispatchToProps)(AdvocateDetailComponent);
AdvocateDetail.propTypes = {
id: PropTypes.number.isRequired,
};
export default AdvocateDetail;
|
app/javascript/src/components/FormDialog.js
|
michelson/chaskiq
|
import React from 'react'
import { Transition } from '@headlessui/react'
function FormDialog (props) {
const [_open, setOpen] = React.useState(props.open)
function handleClose () {
setOpen(false)
props.handleClose && props.handleClose()
}
React.useEffect(() => setOpen(props.open), [props.open])
return props.open ? (
<Backdrop>
<Transition
show={ Boolean(props.open) }
enter="ease-out duration-300"
enterFrom="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
enterTo="opacity-100 translate-y-0 sm:scale-100"
leave="ease-in duration-200"
leaveFrom="opacity-100 translate-y-0 sm:scale-100"
leaveTo="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
className="relative bg-white dark:bg-black dark:text-gray-100 rounded-lg px-4 pt-5 pb-4 overflow-hidden--- shadow-xl transform transition-all sm:max-w-lg sm:w-full sm:p-6"
>
<div className="absolute top-0 right-0 pt-4 pr-4">
<button
onClick={handleClose}
type="button"
className="text-gray-400 hover:text-gray-500 focus:outline-none focus:text-gray-500 transition ease-in-out duration-150"
>
<svg
className="h-6 w-6"
stroke="currentColor"
fill="none"
viewBox="0 0 24 24"
>
<path
strokeLinecap="round"
strokeLinejoin="round"
strokeWidth="2"
d="M6 18L18 6M6 6l12 12"
></path>
</svg>
</button>
</div>
<div className="sm:flex--dis sm:items-start">
{/* <div className="mx-auto flex-shrink-0 flex items-center justify-center h-12 w-12 rounded-full bg-red-100 sm:mx-0 sm:h-10 sm:w-10">
<svg className="h-6 w-6 text-red-600" stroke="currentColor" fill="none" viewBox="0 0 24 24">
<path strokeLinecap="round"
strokeLinejoin="round"
strokeWidth="2"
d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
</svg>
</div> */}
<div className="mt-3 sm:mt-0 text-left">
{props.titleContent && (
<h3 className="text-lg leading-6 font-medium text-gray-900 dark:text-gray-100">
{props.titleContent}
</h3>
)}
<div className="mt-2">{props.formComponent}</div>
</div>
</div>
<div className="mt-5 sm:mt-4 flex flex-row-reverse">
{props.dialogButtons}
</div>
</Transition>
</Backdrop>
) : null
}
function Backdrop ({ children }) {
return (
<div className="z-50 fixed bottom-0 inset-x-0 px-4 pb-6 sm:inset-0 sm:p-0 sm:flex sm:items-center sm:justify-center">
<div
// x-show="open"
// x-transition:enter="ease-out duration-300"
// x-transition:enter-start="opacity-0"
// x-transition:enter-end="opacity-100"
// x-transition:leave="ease-in duration-200"
// x-transition:leave-start="opacity-100"
// x-transition:leave-end="opacity-0"
className="fixed inset-0 transition-opacity"
>
<div className="absolute inset-0 bg-gray-500 opacity-75" />
</div>
{children}
</div>
)
}
/*
export function AlertModal({title, message, action, onClick}){
return (
<div
//x-show="open"
//x-transition:enter="ease-out duration-300"
//x-transition:enter-start="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
//x-transition:enter-end="opacity-100 translate-y-0 sm:scale-100"
//x-transition:leave="ease-in duration-200"
//x-transition:leave-start="opacity-100 translate-y-0 sm:scale-100"
//x-transition:leave-end="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
className="relative bg-white rounded-lg px-4 pt-5 pb-4 overflow-hidden shadow-xl transform transition-all sm:max-w-lg sm:w-full sm:p-6">
<div className="hidden sm:block absolute top-0 right-0 pt-4 pr-4">
<button type="button" className="text-gray-400 hover:text-gray-500 focus:outline-none focus:text-gray-500 transition ease-in-out duration-150">
<svg className="h-6 w-6" stroke="currentColor" fill="none" viewBox="0 0 24 24">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M6 18L18 6M6 6l12 12"></path>
</svg>
</button>
</div>
<div className="sm:flex sm:items-start">
<div className="mx-auto flex-shrink-0 flex items-center justify-center h-12 w-12 rounded-full bg-red-100 sm:mx-0 sm:h-10 sm:w-10">
<svg className="h-6 w-6 text-red-600" stroke="currentColor" fill="none" viewBox="0 0 24 24">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
</svg>
</div>
<div className="mt-3 text-center sm:mt-0 sm:ml-4 sm:text-left">
<h3 className="text-lg leading-6 font-medium text-gray-900">
{title}
</h3>
<div className="mt-2">
<p className="text-sm leading-5 text-gray-500">
{message}
</p>
</div>
</div>
</div>
<div className="mt-5 sm:mt-4 sm:flex sm:flex-row-reverse">
<span className="flex w-full rounded-md shadow-sm sm:ml-3 sm:w-auto">
<button
type="button"
onClick={onClick}
className="inline-flex justify-center w-full rounded-md border border-transparent px-4 py-2 bg-red-600 text-base leading-6 font-medium text-white shadow-sm hover:bg-red-500 focus:outline-none focus:border-red-700 focus:shadow-outline-red transition ease-in-out duration-150 sm:text-sm sm:leading-5">
{action}
</button>
</span>
<span className="mt-3 flex w-full rounded-md shadow-sm sm:mt-0 sm:w-auto">
<button
type="button"
className="inline-flex justify-center w-full rounded-md border border-gray-300 px-4 py-2 bg-white text-base leading-6 font-medium text-gray-700 shadow-sm hover:text-gray-500 focus:outline-none focus:border-blue-300 focus:shadow-outline transition ease-in-out duration-150 sm:text-sm sm:leading-5">
Cancel
</button>
</span>
</div>
</div>
)
}
export function MessageModal({}){
return (
<div x-show="open"
x-transition:enter="ease-out duration-300"
x-transition:enter-start="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
x-transition:enter-end="opacity-100 translate-y-0 sm:scale-100"
x-transition:leave="ease-in duration-200"
x-transition:leave-start="opacity-100 translate-y-0 sm:scale-100"
x-transition:leave-end="opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"
className="bg-white rounded-lg px-4 pt-5 pb-4 overflow-hidden shadow-xl transform transition-all sm:max-w-lg sm:w-full sm:p-6">
<div>
<div className="mx-auto flex items-center justify-center h-12 w-12 rounded-full bg-green-100">
<svg className="h-6 w-6 text-green-600" stroke="currentColor" fill="none" viewBox="0 0 24 24">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M5 13l4 4L19 7"></path>
</svg>
</div>
<div className="mt-3 text-center sm:mt-5">
<h3 className="text-lg leading-6 font-medium text-gray-900">
Payment successful
</h3>
<div className="mt-2">
<p className="text-sm leading-5 text-gray-500">
Lorem ipsum, dolor sit amet consectetur adipisicing elit. Eius aliquam laudantium explicabo pariatur iste dolorem animi vitae error totam. At sapiente aliquam accusamus facere veritatis.
</p>
</div>
</div>
</div>
<div className="mt-5 sm:mt-6 sm:grid sm:grid-cols-2 sm:gap-3 sm:grid-flow-row-dense">
<span className="flex w-full rounded-md shadow-sm sm:col-start-2">
<button type="button" className="inline-flex justify-center w-full rounded-md border border-transparent px-4 py-2 bg-indigo-600 text-base leading-6 font-medium text-white shadow-sm hover:bg-indigo-500 focus:outline-none focus:border-indigo-700 focus:shadow-outline-indigo transition ease-in-out duration-150 sm:text-sm sm:leading-5">
Deactivate
</button>
</span>
<span className="mt-3 flex w-full rounded-md shadow-sm sm:mt-0 sm:col-start-1">
<button type="button" className="inline-flex justify-center w-full rounded-md border border-gray-300 px-4 py-2 bg-white text-base leading-6 font-medium text-gray-700 shadow-sm hover:text-gray-500 focus:outline-none focus:border-blue-300 focus:shadow-outline transition ease-in-out duration-150 sm:text-sm sm:leading-5">
Cancel
</button>
</span>
</div>
</div>
)
}
*/
export default FormDialog
|
ext/lib/site/topic-layout/topic-article/presupuesto-share/component.js
|
RosarioCiudad/democracyos
|
import React from 'react'
import Pendiente from './pendiente'
import Proyectado from './proyectado'
export default ({ topic, forum, user, toggleVotesModal }) => (
<div className='presupuesto-container'>
{topic.attrs.state === 'pendiente' &&
<Pendiente
topic={topic}
user={user}
toggleVotesModal={toggleVotesModal} /> }
{['proyectado', 'ejecutandose', 'terminado', 'perdedor'].includes(topic.attrs.state) &&
<Proyectado
forum={forum}
topic={topic} /> }
</div>
)
|
src/containers/Application.js
|
hannupekka/yabsa
|
// @flow
import styles from 'styles/containers/Application';
import React, { Component } from 'react';
import CSSModules from 'react-css-modules';
import Header from 'components/Header';
type Props = {
children: ElementType | Array<ElementType>
}
// eslint-disable-next-line react/prefer-stateless-function
class Application extends Component {
props: Props;
render(): ElementType {
const { children } = this.props;
return (
<div>
<Header />
<section styleName="content">
{children}
</section>
</div>
);
}
}
export default CSSModules(Application, styles);
|
addons/comments/src/manager/components/CommentsPanel/index.js
|
nfl/react-storybook
|
import PropTypes from 'prop-types';
import React from 'react';
import CommentList from '../CommentList';
import CommentForm from '../CommentForm';
import style from './style';
export default function CommentsPanel(props) {
if (props.loading) {
return (
<div style={style.wrapper}>
<div style={style.message}>loading...</div>
</div>
);
}
if (props.appNotAvailable) {
const appsUrl = 'https://hub.getstorybook.io/apps';
return (
<div style={style.wrapper}>
<div style={style.message}>
<a style={style.button} href={appsUrl}>Create an app for this repo on Storybook Hub</a>
</div>
</div>
);
}
return (
<div style={style.wrapper}>
<CommentList key="list" {...props} />
<CommentForm key="form" {...props} />
</div>
);
}
CommentsPanel.defaultProps = {
loading: false,
appNotAvailable: false,
};
CommentsPanel.propTypes = {
loading: PropTypes.bool,
appNotAvailable: PropTypes.bool,
};
|
src/svg-icons/editor/format-italic.js
|
ichiohta/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let EditorFormatItalic = (props) => (
<SvgIcon {...props}>
<path d="M10 4v3h2.21l-3.42 8H6v3h8v-3h-2.21l3.42-8H18V4z"/>
</SvgIcon>
);
EditorFormatItalic = pure(EditorFormatItalic);
EditorFormatItalic.displayName = 'EditorFormatItalic';
EditorFormatItalic.muiName = 'SvgIcon';
export default EditorFormatItalic;
|
react-apollo/src/containers/AuthPage/index.js
|
strapi/strapi-examples
|
/**
*
* AuthPage
*
*/
import React from 'react';
import PropTypes from 'prop-types';
import { findIndex, get, map, replace, set } from 'lodash';
import { Link } from 'react-router-dom';
import Button from '../../components/Button';
import FormDivider from '../../components/FormDivider';
import Input from '../../components/InputsIndex';
import Logo from '../../assets/logo_strapi.png';
import SocialLink from '../../components/SocialLink';
// Utils
import auth from '../../utils/auth';
import request from '../../utils/request';
import form from './forms.json';
import './styles.css';
class AuthPage extends React.Component {
state = { value: {}, errors: [], didCheckErrors: false };
componentDidMount() {
this.generateForm(this.props);
}
componentWillReceiveProps(nextProps) {
if (nextProps.match.params.authType !== this.props.match.params.authType) {
this.generateForm(nextProps);
}
}
getRequestURL = () => {
let requestURL;
switch (this.props.match.params.authType) {
case 'login':
requestURL = 'http://localhost:1337/auth/local';
break;
case 'register':
requestURL = 'http://localhost:1337/auth/local/register';
break;
case 'reset-password':
requestURL = 'http://localhost:1337/auth/reset-password';
break;
case 'forgot-password':
requestURL = 'http://localhost:1337/auth/forgot-password';
break;
default:
}
return requestURL;
};
generateForm = props => {
const params = props.location.search
? replace(props.location.search, '?code=', '')
: props.match.params.id;
this.setForm(props.match.params.authType, params);
};
handleChange = ({ target }) =>
this.setState({
value: { ...this.state.value, [target.name]: target.value },
});
handleSubmit = e => {
e.preventDefault();
const body = this.state.value;
const requestURL = this.getRequestURL();
// This line is required for the callback url to redirect your user to app
if (this.props.match.params.authType === 'forgot-password') {
set(body, 'url', 'http://localhost:3000/auth/reset-password');
}
request(requestURL, { method: 'POST', body: this.state.value })
.then(response => {
auth.setToken(response.jwt, body.rememberMe);
auth.setUserInfo(response.user, body.rememberMe);
this.redirectUser();
})
.catch(err => {
// TODO handle errors for other views
// This is just an example
const errors = [
{ name: 'identifier', errors: [err.response.payload.message] },
];
this.setState({ didCheckErrors: !this.state.didCheckErrors, errors });
});
};
redirectUser = () => {
this.props.history.push('/');
};
/**
* Function that allows to set the value to be modified
* @param {String} formType the auth view type ex: login
* @param {String} email Optionnal
*/
setForm = (formType, email) => {
const value = get(form, ['data', formType], {});
if (formType === 'reset-password') {
set(value, 'code', email);
}
this.setState({ value });
};
/**
* Check the URL's params to render the appropriate links
* @return {Element} Returns navigation links
*/
renderLink = () => {
if (this.props.match.params.authType === 'login') {
return (
<div>
<Link to="/auth/forgot-password">Forgot Password</Link>
or
<Link to="/auth/register">register</Link>
</div>
);
}
return (
<div>
<Link to="/auth/login">Ready to signin</Link>
</div>
);
};
render() {
const divStyle =
this.props.match.params.authType === 'register'
? { marginTop: '3.2rem' }
: { marginTop: '.9rem' };
const inputs = get(form, ['views', this.props.match.params.authType], []);
const providers = ['facebook', 'github', 'google', 'twitter']; // To remove a provider from the list just delete it from this array...
return (
<div className="authPage">
<div className="wrapper">
<div className="headerContainer">
{this.props.match.params.authType === 'register' ? (
<span>Welcome !</span>
) : (
<img src={Logo} alt="logo" />
)}
</div>
<div className="headerDescription">
{this.props.match.params.authType === 'register' ? (
<span>Please register to access the app.</span>
) : (
''
)}
</div>
<div className="formContainer" style={divStyle}>
<div className="container-fluid">
<div className="row">
<div className="col-md-12">
{providers.map(provider => (
<SocialLink provider={provider} key={provider} />
))}
</div>
</div>
<FormDivider />
<form onSubmit={this.handleSubmit}>
<div className="row" style={{ textAlign: 'start' }}>
{map(inputs, (input, key) => (
<Input
autoFocus={key === 0}
customBootstrapClass={get(input, 'customBootstrapClass')}
didCheckErrors={this.state.didCheckErrors}
errors={get(
this.state.errors,
[
findIndex(this.state.errors, ['name', input.name]),
'errors',
],
[]
)}
key={get(input, 'name')}
label={get(input, 'label')}
name={get(input, 'name')}
onChange={this.handleChange}
placeholder={get(input, 'placeholder')}
type={get(input, 'type')}
validations={{ required: true }}
value={get(this.state.value, get(input, 'name'), '')}
/>
))}
<div className="col-md-12 buttonContainer">
<Button
label="Submit"
style={{ width: '100%' }}
primary
type="submit"
/>
</div>
</div>
</form>
</div>
</div>
<div className="linkContainer">{this.renderLink()}</div>
</div>
</div>
);
}
}
AuthPage.defaultProps = {};
AuthPage.propTypes = {
location: PropTypes.object.isRequired,
match: PropTypes.object.isRequired,
};
export default AuthPage;
|
src/components/ui/ServiceIcon.js
|
meetfranz/franz
|
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { observer } from 'mobx-react';
import injectSheet from 'react-jss';
import classnames from 'classnames';
import ServiceModel from '../../models/Service';
const styles = theme => ({
root: {
height: 'auto',
},
icon: {
width: theme.serviceIcon.width,
},
isCustomIcon: {
width: theme.serviceIcon.isCustom.width,
border: theme.serviceIcon.isCustom.border,
borderRadius: theme.serviceIcon.isCustom.borderRadius,
},
isDisabled: {
filter: 'grayscale(100%)',
opacity: '.5',
},
});
@injectSheet(styles) @observer
class ServiceIcon extends Component {
static propTypes = {
classes: PropTypes.object.isRequired,
service: PropTypes.instanceOf(ServiceModel).isRequired,
className: PropTypes.string,
};
static defaultProps = {
className: '',
};
render() {
const {
classes,
className,
service,
} = this.props;
return (
<div
className={classnames([
classes.root,
className,
])}
>
<img
src={service.icon}
className={classnames([
classes.icon,
service.isEnabled ? null : classes.isDisabled,
service.hasCustomIcon ? classes.isCustomIcon : null,
])}
alt=""
/>
</div>
);
}
}
export default ServiceIcon;
|
src/svg-icons/device/signal-cellular-no-sim.js
|
hwo411/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let DeviceSignalCellularNoSim = (props) => (
<SvgIcon {...props}>
<path d="M18.99 5c0-1.1-.89-2-1.99-2h-7L7.66 5.34 19 16.68 18.99 5zM3.65 3.88L2.38 5.15 5 7.77V19c0 1.1.9 2 2 2h10.01c.35 0 .67-.1.96-.26l1.88 1.88 1.27-1.27L3.65 3.88z"/>
</SvgIcon>
);
DeviceSignalCellularNoSim = pure(DeviceSignalCellularNoSim);
DeviceSignalCellularNoSim.displayName = 'DeviceSignalCellularNoSim';
DeviceSignalCellularNoSim.muiName = 'SvgIcon';
export default DeviceSignalCellularNoSim;
|
node_modules/react-bootstrap/es/SplitToggle.js
|
darklilium/Factigis_2
|
import _extends from 'babel-runtime/helpers/extends';
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 DropdownToggle from './DropdownToggle';
var SplitToggle = function (_React$Component) {
_inherits(SplitToggle, _React$Component);
function SplitToggle() {
_classCallCheck(this, SplitToggle);
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
}
SplitToggle.prototype.render = function render() {
return React.createElement(DropdownToggle, _extends({}, this.props, {
useAnchor: false,
noCaret: false
}));
};
return SplitToggle;
}(React.Component);
SplitToggle.defaultProps = DropdownToggle.defaultProps;
export default SplitToggle;
|
client/index.js
|
vudayagirivaibhav/freecodecamp
|
import Rx from 'rx';
import React from 'react';
import Fetchr from 'fetchr';
import debugFactory from 'debug';
import { Router } from 'react-router';
import { history } from 'react-router/lib/BrowserHistory';
import { hydrate } from 'thundercats';
import { Render } from 'thundercats-react';
import { app$ } from '../common/app';
const debug = debugFactory('fcc:client');
const DOMContianer = document.getElementById('fcc');
const catState = window.__fcc__.data || {};
const services = new Fetchr({
xhrPath: '/services'
});
Rx.longStackSupport = !!debug.enabled;
// returns an observable
app$(history)
.flatMap(
({ AppCat }) => {
const appCat = AppCat(null, services);
return hydrate(appCat, catState)
.map(() => appCat);
},
({ initialState }, appCat) => ({ initialState, appCat })
)
.flatMap(({ initialState, appCat }) => {
return Render(
appCat,
React.createElement(Router, initialState),
DOMContianer
);
})
.subscribe(
() => {
debug('react rendered');
},
err => {
debug('an error has occured', err.stack);
},
() => {
debug('react closed subscription');
}
);
|
BlindshopApp/__tests__/index.android.js
|
shs11023/Blindshop
|
import 'react-native';
import React from 'react';
import Index from '../index.android.js';
// Note: test renderer must be required after react-native.
import renderer from 'react-test-renderer';
it('renders correctly', () => {
const tree = renderer.create(
<Index />
);
});
|
clients/react/src/routes.js
|
Boychenko/sample-todo-2016
|
import React from 'react';
import {Route, IndexRoute} from 'react-router';
import App from './components/App';
import ItemsListPage from './components/Items/ListPage';
import ItemEdit from './components/Items/EditPage';
import AboutPage from './components/AboutPage';
import NotFoundPage from './components/NotFoundPage';
import CallbackPage from './components/CallbackPage';
import {requireAuth} from './helpers/oidcHelpers';
export default (
<Route path="/" component={App}>
<IndexRoute component={AboutPage}/>
<Route path="items" component={ItemsListPage} onEnter={requireAuth}/>
<Route path="items/create" component={ItemEdit}/>
<Route path="items/edit/:id" component={ItemEdit}/>
<Route path="callback" component={CallbackPage}/>
<Route path="*" component={NotFoundPage}/>
</Route>
);
|
frontend/Login/ConnectedLogin.js
|
fdemian/Morpheus
|
import React from 'react';
import { connect } from 'react-redux';
import Login from './Login';
import {updateUsernameFn, updatePasswordFn} from '../Register/Actions';
import login from './Actions';
const mapStateToProps = (state) => {
return {
oauthProviders: state.app.oauth,
isLoggedIn: state.session.loggedIn,
error: state.session.error,
message: state.session.errorMessage
}
}
const mapDispatchToProps = (dispatch, ownProps) => {
return {
localSignIn: (username, password) => {
dispatch(login(username, password));
},
updateUsername: (username) => {
dispatch(updateUsernameFn(username));
},
updatePassword: (password) => {
dispatch(updatePasswordFn(password));
}
}
}
const ConnectedLogin = connect(
mapStateToProps,
mapDispatchToProps
)(Login)
export default ConnectedLogin;
|
app/components/ConsoleToolbar.js
|
kidaa/fil
|
import React from 'react';
import {connect} from 'react-redux';
import {setPreference} from 'actions/preferences';
import {getExtension} from 'helpers';
import {byExtension} from 'interpreters';
class ConsoleToolbar extends React.Component {
handleRunButton(event) {
event.preventDefault();
this.props.onRun();
}
handleLiveCodingCheckbox(event) {
const checked = event.target.checked;
const {dispatch} = this.props;
dispatch(setPreference('liveCoding', checked));
}
render() {
const block = this.props.className;
const {preferences, currentFile} = this.props;
const extension = getExtension(currentFile);
const interpreterInfo = byExtension(extension);
return (
<div className={block}>
<button
className={block + "__run-button"}
onClick={this.handleRunButton.bind(this)}>
{String.fromCharCode(9654)}
</button>
<div className={block + "__interpreter-info"}>
{interpreterInfo.description}
</div>
<label className={block + "__live-coding"}>
<input
onChange={this.handleLiveCodingCheckbox.bind(this)}
checked={preferences.liveCoding}
type="checkbox" />
<span className={block + "__live-coding-text"}>Live coding</span>
</label>
</div>
);
}
}
function select(state) {
return {
preferences: state.preferences,
currentFile: state.currentFile
};
}
export default connect(select)(ConsoleToolbar);
|
tools/playground/components/Section/Section.js
|
auth0/web-header
|
import React from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames/bind';
import styles from './Section.styl';
const cx = classNames.bind(styles);
const Section = ({ children, title, dark }) =>
<div>
<h2 className="container text-center">{title}</h2>
<div className={cx('section', { dark })}>
<div>{children}</div>
</div>
</div>;
Section.propTypes = {
children: PropTypes.node.isRequired,
title: PropTypes.string.isRequired,
dark: PropTypes.bool
};
export default Section;
|
src/routes/competition-show/competition-show.component.js
|
YGO/compe-frontend
|
import React from 'react'
import Radium from 'radium'
import PropTypes from 'prop-types'
import LeadersBoardContainer from './leadersboard.container'
import ScoreToggler from '../../components/leadersboard/score-toggler.component'
import lineBtnImg from './assets/linebutton_82x20.png'
import gnIconImg from './assets/gn_icon.png'
import appStoreImg from './assets/appstore.svg'
import playStoreImg from './assets/google_play.png'
import Helmet from 'react-helmet/es/Helmet'
import { alignCenter } from '../common.styles'
import { style } from './competition-show.styles'
import { connect } from 'react-redux'
import Header from './header.component'
let SHARE_URL
if (process.env.NODE_ENV === 'development') {
SHARE_URL = 'https://asyridxcpg.localtunnel.me/pgateaching_201709/'
} else {
SHARE_URL = window.location.href
}
const mapStateToProps = state => {
const {
id,
title,
official_url: officialUrl,
club_name: clubName,
club_url: clubUrl,
youtube_url: youtubeUrl,
term,
} = state.mainApp.competition
return {
id,
title,
officialUrl,
clubName,
clubUrl,
youtubeUrl,
term,
}
}
const CompetitionShow = ({
id,
title,
officialUrl,
clubName,
clubUrl,
youtubeUrl,
term,
}) => (
<div style={[style.self]}>
<Helmet>
<title>{title}</title>
</Helmet>
<Header competitionId={id} title={title}/>
<div className='container-fluid' style={[style.container]}>
<section id='competition-info' style={[style.section]}>
{youtubeUrl &&
<div className='row mb-4'>
<div className='col-12' style={[alignCenter]}>
<iframe className='youtubesize' width='560' height='315'
src={youtubeUrl}
frameBorder='0' allowFullScreen=''/>
</div>
</div>
}
<div className='row'>
<div className='col pl-1'>
<ul className='list-unstyled'>
<li><a href={officialUrl}>{title}</a></li>
<li><a href={clubUrl}>{clubName}</a></li>
<li>{term}</li>
</ul>
</div>
</div>
</section>
<section id='buttons' style={[style.section]}>
<div className='row'>
<div className='col-auto p-0 pl-1'>
<ScoreToggler/>
</div>
<div className='col-auto p-0 pl-1'>
<div className='fb-like'
data-href={SHARE_URL}
data-layout='button' data-action='like' data-size='small'
data-show-faces='false' data-share='true'/>
</div>
<div className='col-auto p-0 pl-1'>
<a
href={`http://line.me/R/msg/text/?${encodeURIComponent(SHARE_URL)}`}>
<img src={lineBtnImg} alt='LINE'
style={style.buttons.lineBtn}/>
</a>
</div>
</div>
</section>
<section id='leaders-board' style={[style.section]}>
<LeadersBoardContainer/>
</section>
<section id='comments' style={[style.section]}>
<div className='row'>
<div className='col'>
<div className='fb-like'
data-href={SHARE_URL}
data-layout='button' data-action='like' data-size='small'
data-show-faces='false' data-share='true'/>
</div>
</div>
<div className='row'>
<div className='col'>
<div className='fb-comments'
data-href={SHARE_URL}
data-numposts='5'/>
</div>
</div>
</section>
<footer style={[style.footer.self]}>
<div className='row p-3' style={[style.footer.row]}>
<div className='col'>
このリーダーズボードは、国内ダウンロード数No.1の無料スコア管理アプリ ゴルフネットワークプラス のコンペ機能で提供しています
</div>
</div>
<div className='row pl-3 pr-3 pb-3' style={[style.footer.row]}>
<div className='col mr-auto'>
<img src={gnIconImg} alt='GN+' className='mr-2 float-left'
style={[style.footer.gnIcon]}/>
<p className='pb-0 mb-0' style={{fontSize: '0.7em'}}>
あなたのゴルフライフをもっと楽しく<br/>ダウンロード数 国内No.1 ゴルフスコア管理アプリ</p>
<p>GOLF NETWORK PLUS</p>
</div>
<div className='col-auto'>
<a
className='mr-3'
href='https://play.google.com/store/apps/details?id=com.asai24.golf'><img
src={playStoreImg} alt='googleplay'
style={[style.footer.marketIcon]}/></a>
<a
// eslint-disable-next-line max-len
href='https://itunes.apple.com/jp/app/gorufusukoa-guan-li-gorufu/id561067103?mt=8'><img
src={appStoreImg} alt='appstore'
style={[style.footer.marketIcon]}/></a>
</div>
</div>
</footer>
</div>
</div>
)
CompetitionShow.defaultProps = {
id: '',
title: '',
clubName: '',
clubUrl: '',
term: '',
}
CompetitionShow.propTypes = {
id: PropTypes.string.isRequired,
title: PropTypes.string.isRequired,
officialUrl: PropTypes.string,
clubName: PropTypes.string.isRequired,
clubUrl: PropTypes.string.isRequired,
youtubeUrl: PropTypes.string,
term: PropTypes.string.isRequired,
}
// noinspection JSUnusedGlobalSymbols
export default connect(mapStateToProps)(Radium(CompetitionShow))
|
pages/index.js
|
falconi1812/falconi
|
import React, { Component } from 'react';
import ReactPixel from 'react-facebook-pixel';
import Header from 'components/Header/Header';
import Intro from 'components/Intro/Intro';
import Who from 'components/Who/Who';
import What from 'components/What/What';
import How from 'components/How/How';
import Services from 'components/Services/Services';
import CustomerTypes from 'components/CustomerTypes/CustomerTypes';
import Testimonials from 'components/Testimonials/Testimonials';
import Team from 'components/Team/Team';
import About from 'components/About/About';
import Footer from 'components/Footer/Footer';
import Calendar from 'components/Calendar/Calendar';
const nav = {
home : { id: 'home', label: 'Home' },
how : { id: 'how', label: 'How we help you' },
services : { id: 'services', label: 'Services' },
customers : { id: 'customers', label: 'Customers' },
calendar : { id: 'calendar', label: 'Calendar' },
team : { id: 'our-team', label: 'Our team' },
about : { id: 'about', label: 'About' },
};
export default class App extends Component {
componentDidMount() {
ReactPixel.init('1883580588574747');
ReactPixel.pageView();
if (typeof window.google_trackConversion === 'function') {
window.google_trackConversion({
google_conversion_id: 923014461,
google_remarketing_only: true
});
}
}
render () {
// TODO make a reusable <Section> component to avoid repeat the section tag
// and also enforce passing a TITLE + ID (required)
return (
<main role="main" id={nav.home.id}>
<Header nav={nav} />
<Intro/>
<Who/>
<What/>
<How id={nav.how.id} />
<Services id={nav.services.id} />
<CustomerTypes id={nav.customers.id} />
<Calendar id={nav.calendar.id} />
<Team id={nav.team.id} />
<About id={nav.about.id} />
<Footer nav={nav} />
</main>
)
}
}
|
src/components/common/icons/Comment2.js
|
WendellLiu/GoodJobShare
|
import React from 'react';
/* eslint-disable */
const Comment2 = (props) => (
<svg {...props} width="148" height="148" viewBox="0 0 148 148">
<g transform="translate(0 6)">
<path d="M13.5463199,136.724864 C14.8088582,138.042797 16.5145543,138.767545 18.3425804,138.767545 C20.6922403,138.767545 23.0372839,137.615796 25.3153922,135.34692 L53.5759376,107.107148 C56.2995119,104.392806 62.2752185,101.923124 66.1136118,101.923124 L133.946768,101.923124 C141.609706,101.923124 147.841613,95.7027574 147.841613,88.0536683 L147.841613,13.9585989 C147.841613,6.3095098 141.612014,0.0868349842 133.946768,0.0868349842 L14.0125589,0.0868349842 C6.34962107,0.0868349842 0.117713804,6.30720169 0.117713804,13.9585989 L0.117713804,88.0536683 C0.117713804,95.8135469 4.87473635,101.897735 10.7996645,101.897735 L10.8481349,101.897735 C11.2936008,102.114698 12.3299439,103.695756 12.2168464,106.343162 L11.2543629,129.184256 C11.113568,132.461778 11.884478,134.996087 13.5463199,136.724864 L13.5463199,136.724864 Z M11.1458816,92.6860527 L11.0974112,92.6860527 C10.6127073,92.5014036 9.3801745,90.8511022 9.3801745,88.0513602 L9.3801745,13.9585989 C9.3801745,11.4081332 11.459785,9.335447 14.0125589,9.335447 L133.94446,9.335447 C136.494926,9.335447 138.572228,11.4058251 138.572228,13.9585989 L138.572228,88.0536683 C138.572228,90.6018259 136.497234,92.6768202 133.94446,92.6768202 L66.1136118,92.6768202 C59.7455258,92.6768202 51.5447975,96.0674394 47.0301269,100.568261 L20.6160725,126.956926 L21.4700746,106.730925 C21.6524156,102.359358 20.2883203,98.3270828 17.7401627,95.6681357 C15.8913635,93.747785 13.5232388,92.6860527 11.1458816,92.6860527 L11.1458816,92.6860527 Z"/>
<path d="M27.360381 33.4275389L120.587406 33.4275389C123.142488 33.4275389 125.222098 31.3594689 125.222098 28.8043869 125.222098 26.249305 123.144796 24.181235 120.587406 24.181235L27.360381 24.181235C24.8099153 24.181235 22.7303047 26.249305 22.7303047 28.8043869 22.7303047 31.3594689 24.8099153 33.4275389 27.360381 33.4275389zM27.360381 56.5456067L120.587406 56.5456067C123.142488 56.5456067 125.222098 54.4798449 125.222098 51.9247629 125.222098 49.3696809 123.144796 47.2993028 120.587406 47.2993028L27.360381 47.2993028C24.8099153 47.2993028 22.7303047 49.3673728 22.7303047 51.9247629 22.7303047 54.482153 24.8099153 56.5456067 27.360381 56.5456067zM27.360381 79.7583073L92.6176826 79.7583073C95.1727646 79.7583073 97.2523751 77.6902373 97.2523751 75.1328472 97.2523751 72.5754571 95.1750727 70.5073871 92.6176826 70.5073871L27.360381 70.5073871C24.8099153 70.5073871 22.7303047 72.5754571 22.7303047 75.1328472 22.7303047 77.6902373 24.8099153 79.7583073 27.360381 79.7583073L27.360381 79.7583073z"/>
</g>
</svg>
);
/* eslint-enable */
export default Comment2;
|
src/App.js
|
nihalgonsalves/react-cellular-automata
|
import React from 'react';
import './App.css';
import 'bulma/css/bulma.css';
import { dec2bin, ascii2bin } from './lib/util';
import AutomataIterator from './lib/AutomataIterator';
import SettingsPanel from './components/SettingsPanel';
import PlaybackPanel from './components/PlaybackPanel';
import { MAX_GENERATIONS } from './config';
let gridElement;
const reusableContainer = document.createElement('div');
document.addEventListener('DOMContentLoaded', function(){
gridElement = document.getElementById('grid');
}, false);
const HeaderAndProgress = ({ currentGeneration, generations, componentRefreshRand }) =>
<div className="hero is-primary is-bold" style={{ marginBottom: 20 }}>
<div className="hero-body">
<div className="container">
<h1 className="title">
<i className="fa fa-cube" aria-hidden="true" /> Elementary Cellular Automata in 1 Dimension
<span style={{ display: 'none' }}>{componentRefreshRand}</span>
</h1>
{ currentGeneration > 0 && <progress className="progress is-large is-light" width="100%" value={currentGeneration} max={generations}></progress>}
</div>
</div>
</div>
;
const Display = ({ automataEnabled }) =>
<div className="box" style={{ marginLeft: 25, marginRight: 25, display: automataEnabled ? 'block' : 'none' }}>
<div style={{ fontSize: 0 }} id="grid" />
</div>
;
const Crypto = ({ initialState, lastState, visibleCrypto }) =>
<pre
className="container box has-text-centered"
style={{ textAlign: 'left', background: 'none', whiteSpace: 'pre-wrap', wordBreak: 'break-all', display: visibleCrypto ? 'block' : 'none' }}
>
{JSON.stringify({
instructions: [
'You can use these values to generate a ciphered text with XOR (^)',
'a(c) = a(0) ^ a(k)',
'It can be deciphered using',
'a(0) = a(c) ^ a(k)',
'https://xor.pw/'
],
'a(0)': initialState,
'a(k)': lastState,
}, null, 2)}
</pre>
;
const Diag = ({ automataState, visibleDiag }) =>
<pre className="container box has-text-centered" style={{ display: visibleDiag ? 'block' : 'none', textAlign: 'left', background: 'none', whiteSpace: 'pre-wrap', wordBreak: 'break-all' }}>
{JSON.stringify(automataState, (k, v) => (v instanceof Uint8Array || v instanceof Array) ? v.join('') : v, 2)}
</pre>
;
const Footer = ({ onToggleDiag, automataEnabled }) =>
<footer className="footer" style={{ display: automataEnabled ? 'none' : 'block' }}>
<div className="container">
<div className="content has-text-centered">
<p>
<i className="fa fa-code" /><br />
built with <strong>es6</strong>, <strong>react</strong>, <strong>bulma</strong> & <strong>fontawesome</strong><br />
<a href="http://nihalgonsalv.es/">nihalgonsalv.es</a> - <a onClick={onToggleDiag}>debug</a>
</p>
</div>
</div>
</footer>
;
class App extends React.Component {
constructor(props) {
super(props);
this.state = {
speed: 500,
visibleCrypto: false,
visibleDiag: false,
displayLines: true,
componentRefreshRand: undefined,
}
}
clearAutomata = () => {
this.setState({ lastState: undefined, automata: undefined });
gridElement.innerHTML = '';
}
updateAutomata = () => {
this.clearAutomata();
const { binaryRule, generations, random, initialState } = this.state;
const automata = new AutomataIterator(
binaryRule,
generations,
random,
initialState,
);
const cellWidth = 100/automata.columns;
this.setState({
automata,
cellWidth,
cellOn: `<img style="width:${cellWidth}%" src="${process.env.PUBLIC_URL}/black.png" />`,
cellOff: `<img style="width:${cellWidth}%; visibility:hidden" />`,
});
}
createAutomata = () => {
this.updateAutomata();
this.setState({
automataEnabled: true,
});
}
setDefault = () => {
const decimalRule = 90;
this.setState({
decimalRule,
binaryRule: dec2bin(decimalRule),
generations: 50,
random: false,
});
}
onToggleRandom = () => {
this.setState({ random: !this.state.random, seed: undefined, initialState: undefined });
}
onToggleEnabled = () => {
this.setState({ automataEnabled: !this.state.automataEnabled });
}
onToggleCrypto = () => {
this.setState({ visibleCrypto: !this.state.visibleCrypto });
}
onToggleDiag = () => {
this.setState({ visibleDiag: !this.state.visibleDiag });
}
onToggleLineDisplay = () => {
this.setState({ displayLines: !this.state.displayLines });
}
onChangeGenerations = (event) => {
let generations = event.target.value;
if (generations > MAX_GENERATIONS) {
generations = MAX_GENERATIONS;
}
this.setState({ generations });
}
onChangeDecimalRule = (event) => {
let decimalRule = event.target.value;
if (decimalRule > 255) {
decimalRule = 255;
} else if (decimalRule < 0) {
decimalRule = 0;
}
this.setState({
decimalRule,
binaryRule: decimalRule ? dec2bin(decimalRule) : undefined,
});
}
onChangeSeed = (event) => {
const seed = event.target.value;
if (!seed) {
this.setState({ initialState: undefined, seed: undefined });
return;
}
const initialStateStringArray = ascii2bin(seed).split('');
const initialState = new Uint8Array(initialStateStringArray.length);
initialStateStringArray.forEach((val, i) => {
initialState[i] = val;
});
this.setState({
seed,
initialState,
});
}
onChangeSpeed = (event) => {
this.setState({ speed: event.target.value }, () => {
if (this.state.interval) {
this.onPlay();
}
});
}
onReset = () => {
this.updateAutomata();
}
onPlay = () => {
if (this.state.interval) {
this.onPause();
}
this.setState({
interval: setInterval(() => { this.iterate() }, this.state.speed),
refreshInterval: setInterval(() => {
this.setState({ componentRefreshRand: Math.random() });
}, 500),
});
}
onPause = () => {
clearInterval(this.state.interval);
clearInterval(this.state.refreshInterval);
this.setState({ interval: undefined, refreshInterval: undefined });
}
onFastForward = () => {
this.onPause();
this.setState({ speed: 100 }, () => { this.onPlay() });
}
iterate = () => {
const {
automata: { currentGeneration, generations, currentState, columns },
cellOn,
cellOff,
displayLines,
} = this.state;
const currentGenerationInt = parseInt(currentGeneration, 10);
const generationsInt = parseInt(generations, 10);
if (currentGenerationInt === generationsInt) {
this.setState({
lastState: currentState,
});
} else if((currentGenerationInt - 1) === generationsInt) {
this.onPause();
return;
}
const cells = ['<span>'];
for(let i = 0; i < columns; i++) {
cells.push(currentState[i] ? cellOn : cellOff);
}
cells.push('<br /></span>');
if (displayLines) {
reusableContainer.innerHTML = cells.join('');
gridElement.appendChild(reusableContainer.firstChild);
} else {
gridElement.innerHTML = cells.join('');
}
this.state.automata.next();
}
render() {
const {
state: {
visibleCrypto,
visibleDiag,
binaryRule,
decimalRule,
generations,
random,
seed,
initialState,
lastState,
automataEnabled,
componentRefreshRand,
interval,
},
iterate,
onToggleEnabled,
onToggleCrypto,
onToggleDiag,
onToggleRandom,
onToggleLineDisplay,
onChangeDecimalRule,
onChangeGenerations,
onChangeSeed,
onChangeSpeed,
onReset,
onPlay,
onPause,
onFastForward,
createAutomata,
setDefault,
} = this;
return <div>
<HeaderAndProgress
currentGeneration={this.state.automata && this.state.automata.currentGeneration}
generations={generations}
componentRefreshRand={componentRefreshRand}
/>
<Diag automataState={this.state} visibleDiag={visibleDiag}/>
<SettingsPanel
automataEnabled={automataEnabled}
onChangeGenerations={onChangeGenerations}
generations={generations}
onChangeDecimalRule={onChangeDecimalRule}
decimalRule={decimalRule}
binaryRule={binaryRule}
onToggleRandom={onToggleRandom}
random={random}
createAutomata={createAutomata}
setDefault={setDefault}
onChangeSeed={onChangeSeed}
seed={seed}
/>
<br />
<PlaybackPanel
onToggleLineDisplay={onToggleLineDisplay}
onToggleEnabled={onToggleEnabled}
onToggleCrypto={onToggleCrypto}
visibleCrypto={visibleCrypto}
automataEnabled={automataEnabled}
onReset={onReset}
onPlay={onPlay}
onPause={onPause}
onFastForward={onFastForward}
isLastGeneration={this.state.automata ? (parseInt(this.state.automata.currentGeneration - 1, 10) === parseInt(generations, 10)) : false}
isActive={interval}
iterate={iterate}
onChangeSpeed={onChangeSpeed}
/>
<Display automataEnabled={automataEnabled} />
<Crypto
initialState={initialState ? initialState.join('') : undefined}
lastState={lastState ? lastState.join('') : undefined}
visibleCrypto={visibleCrypto}
/>
<Footer onToggleDiag={onToggleDiag} automataEnabled={automataEnabled} />
</div>
}
}
export default App;
|
src/forms/AddSelection/AddSelectionForm.js
|
jobdoc/selections-app
|
import React from 'react'
import { Field } from 'redux-form'
import MenuItem from 'material-ui/MenuItem'
import {
SelectField,
TextField
} from 'redux-form-material-ui'
export const AddSelectionForm = (props) => (
<form onSubmit={props.handleSubmit}>
<Field name='item' component={TextField} hintText='Item' />
<br />
<Field name='room' component={TextField} hintText='Room' />
</form>
)
AddSelectionForm.propTypes = {
handleSubmit: React.PropTypes.func.isRequired
}
export default AddSelectionForm
|
app/javascript/components/MemberDetailsForm/MemberDetailsForm.js
|
SumOfUs/Champaign
|
// weak
import React, { Component } from 'react';
import { FormattedMessage } from 'react-intl';
import { connect } from 'react-redux';
import _ from 'lodash';
import Button from '../Button/Button';
import { updateForm } from '../../state/fundraiser/actions';
import FieldShape from '../FieldShape/FieldShape';
import ee from '../../shared/pub_sub';
export class MemberDetailsForm extends Component {
static title = <FormattedMessage id="details" defaultMessage="details" />;
HIDDEN_FIELDS = [
'source',
'akid',
'referrer_id',
'rid',
'bucket',
'referring_akid',
];
constructor(props) {
super(props);
this.state = {
errors: {},
loading: false,
};
}
componentDidMount() {
this.prefill();
this.bindGlobalEvents();
}
bindGlobalEvents() {
ee.on('fundraiser:actions:validate_form', this.validate);
}
prefill() {
const data = {};
for (const field of this.props.fields) {
data[field.name] = this.props.formValues[field.name]
? this.props.formValues[field.name]
: field.default_value;
}
for (const name of this.HIDDEN_FIELDS) {
if (this.props.formValues[name]) {
data[name] = this.props.formValues[name];
}
}
this.props.updateForm({ ...this.props.form, ...data });
}
getFieldError(field) {
const error = this.state.errors[field];
if (!error) return null;
return <FormattedMessage {...error} />;
}
buttonText() {
if (this.state.loading) {
return (
<FormattedMessage id="form.processing" defaultMessage="Processing..." />
);
} else if (this.props.buttonText) {
return this.props.buttonText;
} else {
return <FormattedMessage id="form.submit" defaultMessage="Submit" />;
}
}
handleSuccess() {
ee.emit('fundraiser:form:success');
this.setState({ errors: {} }, () => {
if (this.props.proceed) {
this.props.proceed();
}
});
}
handleFailure(response) {
ee.emit('fundraiser:form:error', response);
const errors = _.mapValues(response.errors, ([message]) => {
return {
id: 'errors.this_field_with_message',
defaultMessage: 'This field {message}',
values: { message },
};
});
this.setState({ errors });
}
updateField(key, value) {
this.state.errors[key] = null; // reset error message when field value changes
this.props.updateForm({
...this.props.form,
[key]: value,
});
}
validate = () => {
this.setState({ loading: true });
// TODO
// Use a proper xhr lib if we want to make our lives easy.
fetch(`/api/pages/${this.props.pageId}/actions/validate`, {
method: 'POST',
headers: {
'content-type': 'application/json',
accept: 'application/json',
},
body: JSON.stringify({ ...this.props.form, form_id: this.props.formId }),
}).then(
response => {
this.setState({ loading: false });
if (response.ok) {
return response.json().then(this.handleSuccess.bind(this));
}
return response.json().then(this.handleFailure.bind(this));
},
failure => {
this.setState({ loading: false });
}
);
};
fieldsToDisplay() {
return this.props.fields.filter(field => {
switch (field.display_mode) {
case 'all_members':
return true;
case 'recognized_members_only':
return this.recognizedMemberPresent();
case 'new_members_only':
return !this.recognizedMemberPresent();
default:
console.log(
`Unknown display_mode "${field.display_mode}" for field "${field.name}"`
);
return false;
}
});
}
recognizedMemberPresent() {
return !!this.props.formValues.email;
}
onSubmit = e => {
e.preventDefault();
this.validate();
};
render() {
const { loading } = this.state;
return (
<div className="MemberDetailsForm-root">
<form onSubmit={this.onSubmit} className="form--big action-form">
{this.fieldsToDisplay().map(field => (
<FieldShape
key={field.name}
errorMessage={this.getFieldError(field.name)}
onChange={value => this.updateField(field.name, value)}
value={this.props.form[field.name]}
field={field}
/>
))}
<Button
type="submit"
disabled={loading}
className="action-form__submit-button"
>
{this.buttonText()}
</Button>
</form>
</div>
);
}
}
const mapStateToProps = state => ({
formId: state.fundraiser.formId,
form: state.fundraiser.form,
});
const mapDispatchToProps = dispatch => ({
updateForm: form => dispatch(updateForm(form)),
});
export default connect(
mapStateToProps,
mapDispatchToProps
)(MemberDetailsForm);
|
app/components/Header.js
|
Mikkael3/tiea207projekti2015
|
/*
* Joonas Vilppunen, Markus Muranen, Niko Heikkinen
* MIT Licence
* 2015
*/
import React from 'react';
import {Link} from 'react-router';
/*import FooterStore from '../stores/FooterStore';
import FooterActions from '../actions/FooterActions';
*/
class Header extends React.Component {
/*
constructor(props) {
super(props);
this.state = FooterStore.getState();
this.onChange = this.onChange.bind(this);
}
componentDidMount() {
FooterStore.listen(this.onChange);
FooterActions.
}
componentWillUnmount() {
FooterStore.unlisten(this.onChange);
}
onChange(state) {
this.setState(state);
}
*/
render() {
return (
<header className="header">
<div className="row">
<Link className="col-md-1" to='/'>
<img className="logo" src={'/img/yle.png'}/>
</Link>
<h1 className="col-md-6 col-md-offset-4 ">Kolosseum</h1>
</div>
</header>
);
}
}
export default Header;
|
src/svg-icons/editor/border-clear.js
|
lawrence-yu/material-ui
|
import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let EditorBorderClear = (props) => (
<SvgIcon {...props}>
<path d="M7 5h2V3H7v2zm0 8h2v-2H7v2zm0 8h2v-2H7v2zm4-4h2v-2h-2v2zm0 4h2v-2h-2v2zm-8 0h2v-2H3v2zm0-4h2v-2H3v2zm0-4h2v-2H3v2zm0-4h2V7H3v2zm0-4h2V3H3v2zm8 8h2v-2h-2v2zm8 4h2v-2h-2v2zm0-4h2v-2h-2v2zm0 8h2v-2h-2v2zm0-12h2V7h-2v2zm-8 0h2V7h-2v2zm8-6v2h2V3h-2zm-8 2h2V3h-2v2zm4 16h2v-2h-2v2zm0-8h2v-2h-2v2zm0-8h2V3h-2v2z"/>
</SvgIcon>
);
EditorBorderClear = pure(EditorBorderClear);
EditorBorderClear.displayName = 'EditorBorderClear';
EditorBorderClear.muiName = 'SvgIcon';
export default EditorBorderClear;
|
blueprints/view/files/__test__/views/__name__View.spec.js
|
cargo-transport/web-frontend
|
import React from 'react'
describe('(View) <%= pascalEntityName %>', () => {
it('should exist', () => {
})
})
|
src/slides/observer.js
|
philpl/talk-observe-the-future
|
import React from 'react'
import { Slide, Text, CodePane } from 'spectacle'
import { codeBackground } from '../constants/colors'
import observerPattern from '~/assets/observer-pattern.example'
export default (
<Slide transition={[ 'slide' ]}>
<Text
textColor='tertiary'
textSize='1.8em'
margin='30px'>
Subject / Observer Pattern
</Text>
<CodePane
lang='javascript'
textSize='0.7em'
bgColor={codeBackground}
source={observerPattern}/>
</Slide>
)
|
node_modules/react-bootstrap/es/Breadcrumb.js
|
joekay/awebb
|
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 BreadcrumbItem from './BreadcrumbItem';
import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
var Breadcrumb = function (_React$Component) {
_inherits(Breadcrumb, _React$Component);
function Breadcrumb() {
_classCallCheck(this, Breadcrumb);
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
}
Breadcrumb.prototype.render = function render() {
var _props = this.props,
className = _props.className,
props = _objectWithoutProperties(_props, ['className']);
var _splitBsProps = splitBsProps(props),
bsProps = _splitBsProps[0],
elementProps = _splitBsProps[1];
var classes = getClassSet(bsProps);
return React.createElement('ol', _extends({}, elementProps, {
role: 'navigation',
'aria-label': 'breadcrumbs',
className: classNames(className, classes)
}));
};
return Breadcrumb;
}(React.Component);
Breadcrumb.Item = BreadcrumbItem;
export default bsClass('breadcrumb', Breadcrumb);
|
src/components/hero/hero.js
|
compwhile/compwhile.io
|
import React, { Component } from 'react';
import { Button, Row, Col } from 'react-bootstrap';
import gitHubLogo from './github.png';
import './hero.css';
class Hero extends Component {
render() {
return (
<div className="hero">
<Row>
<Col>
<div className="text"><strong>compwhile</strong></div>
<div className="minitext">
Web IDE for learning, visualizing and running computer programs.
</div>
</Col>
</Row>
<Row>
<Col>
<div className="main-buttons">
<Button
href="#"
bsStyle="warning">
Get Started
</Button>
<Button
href="http://compwhile.readthedocs.io/en/latest/README/"
bsStyle="warning">
DOCS
</Button>
<Button
href="https://github.com/compwhile"
target="_blank"
bsStyle="info">
<img src={gitHubLogo} alt="compwhile at GitHub" height="20"/> GitHub
</Button>
</div>
</Col>
</Row>
</div>
);
}
}
export default Hero;
|
src/views/components/logos/github.js
|
djfrsn/dashboard-cl
|
import React from 'react';
export default function GitHubLogo() {
return (
<svg viewBox="0 0 20 20">
<path d="M10 0C4.5 0 0 4.5 0 10c0 4.4 2.9 8.2 6.8 9.5.5.1.7-.2.7-.5v-1.9c-2.5.5-3.2-.6-3.4-1.1-.1-.3-.6-1.2-1-1.4-.4-.2-.9-.6 0-.7.8 0 1.3.7 1.5 1 .9 1.5 2.4 1.1 3 .9.1-.6.4-1.1.6-1.3-2.2-.3-4.6-1.2-4.6-5 0-1.1.4-2 1-2.7 0-.3-.4-1.3.2-2.7 0 0 .8-.3 2.8 1 .7-.2 1.6-.3 2.4-.3s1.7.1 2.5.3c1.9-1.3 2.8-1 2.8-1 .5 1.4.2 2.4.1 2.7.6.7 1 1.6 1 2.7 0 3.8-2.3 4.7-4.6 4.9.4.3.7.9.7 1.9v2.8c0 .3.2.6.7.5 4-1.3 6.8-5.1 6.8-9.5C20 4.5 15.5 0 10 0z" />
</svg>
);
}
|
duckr/app/components/Duck/Duck.js
|
josedab/react-exercises
|
import React from 'react'
import PropTypes from 'prop-types'
import { formatTimestamp } from 'helpers/utils'
import Reply from 'react-icons/lib/fa/mail-reply'
import Star from 'react-icons/lib/fa/star'
import {
duckContainer, contentContainer, avatar, actionContainer,
header, text, likeReplyContainer, icon, likedIcon, author,
} from './Duck.css'
export default function Duck(props) {
const starIcon = props.isLiked === true ? likedIcon : icon;
const starFn = props.isLiked === true ? props.handleDeleteLike : props.addAndHandleLike;
return (
<div
className={duckContainer}
style={{cursor: props.hideReplyBtn === true ? 'default' : 'pointer'}}
onClick={props.onClick}>
<img src={props.duck.avatar} className={avatar}/>
<div className={contentContainer}>
<div className={header}>
<div onClick={props.goToProfile} className={author}>{props.duck.name}</div>
<div>{formatTimestamp(props.duck.timestamp)}</div>
</div>
<div className={text}>{props.duck.text}</div>
<div className={likeReplyContainer}>
{props.hideReplyBtn === true
? null
: <Reply className={icon}/>}
<div className={actionContainer}>
<Star className={starIcon} onClick={(e) => starFn(props.duck.duckId, e)}/>
{props.hideLikeCount === true ? null : <div>{props.numberOfLikes}</div>}
</div>
</div>
</div>
</div>
)
}
Duck.propTypes = {
duck: PropTypes.shape({
avatar: PropTypes.string.isRequired,
duckId: PropTypes.string.isRequired,
name: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
timestamp: PropTypes.number.isRequired,
uid: PropTypes.string.isRequired,
}),
onClick: PropTypes.func,
isLiked: PropTypes.bool.isRequired,
addAndHandleLike: PropTypes.func.isRequired,
handleDeleteLike: PropTypes.func.isRequired,
numberOfLikes: PropTypes.number,
hideReplyBtn: PropTypes.bool.isRequired,
hideLikeCount: PropTypes.bool.isRequired,
goToProfile: PropTypes.func.isRequired,
}
|
setup/src/universal/features/routing/hoc/HOCRedirect.js
|
ch-apptitude/goomi
|
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { createStructuredSelector } from 'reselect';
import _ from 'lodash';
import { selectUserStatus } from 'features/user/selectors';
import { USER_STATUS } from 'features/user/constants';
import LoginRedirect from 'features/routing/containers/LoginRedirectContainer';
import ProfileCompleteRedirect from 'features/routing/containers/ProfileCompleteRedirectContainer';
import VerifiedRedirect from 'features/routing/containers/VerifiedRedirectContainer';
import NotFound from 'features/routing/components/NotFound';
import Loader from 'features/common_ui/components/Loader';
export default function HOCRedirect(WrappedComponent, requiredStatus, excludedStatus) {
const mapStateToProps = createStructuredSelector({
userStatus: selectUserStatus(),
});
const Enhanced = ({ userStatus, ...etc }) => {
const getRedirectComponent = () => {
switch (requiredStatus) {
case USER_STATUS.LOGGED_IN:
return <LoginRedirect />;
case USER_STATUS.PROFILE_COMPLETE:
return <ProfileCompleteRedirect />;
case USER_STATUS.VERIFIED:
return <VerifiedRedirect />;
default:
return <LoginRedirect />;
}
};
if (userStatus.indexOf(USER_STATUS.LOADING) !== -1) {
return <Loader />;
}
if (excludedStatus) {
const exclStatus = [].concat([], excludedStatus);
if (_.intersection(userStatus, exclStatus).length > 0) {
return <NotFound />;
}
}
if (requiredStatus) {
if (userStatus.indexOf(requiredStatus) !== -1) {
return <WrappedComponent {...etc} />;
}
return getRedirectComponent();
}
return <WrappedComponent {...etc} />;
};
Enhanced.propTypes = {
userStatus: PropTypes.arrayOf(PropTypes.string).isRequired,
};
return connect(mapStateToProps)(Enhanced);
}
|
src/components/IndicHuitre.js
|
olivmarcel/aquack
|
import React, { Component } from 'react';
import { Grid, Col, Jumbotron, Button, ToggleButtonGroup, ToggleButton } from 'react-bootstrap';
import Carte from "./Carte";
export default class Indic extends Component {
altIndic() {
console.log("...");
}
render() {
const indicHuitre = [1,2,4,6,7,8,9,10];
return (
<div>
<h2 className="text-center"><span className="text-primary">Milieu Physique</span> . <span className="text-success">Milieu Naturel</span> . <span className="text-warning">Usages</span></h2>
<ToggleButtonGroup name="physic" type="checkbox" bsStyle="small" defaultValue={indicHuitre}>
<ToggleButton name="bathy" value={1} bsSize="small" bsStyle="primary" onClick={ this.altIndic } >Bathymétrie</ToggleButton>
<ToggleButton name="courants" value={2} bsSize="small" bsStyle="primary">Courants</ToggleButton>
<ToggleButton name="houle" value={3} bsSize="small" bsStyle="primary">Houle</ToggleButton>
<ToggleButton name="hauteur" value={4} bsSize="small" bsStyle="primary">Hauteur d eau</ToggleButton>
<ToggleButton name="vents" value={5} bsSize="small" bsStyle="primary">Vents</ToggleButton>
<ToggleButton name="fonds" value={6} bsSize="small" bsStyle="primary">Nature des fonds</ToggleButton>
<ToggleButton name="especes" bsSize="small" bsStyle="success" value={7}>Espèces spécifiques</ToggleButton>
<ToggleButton name="milieu" bsSize="small" bsStyle="success" value={8}>Qualité du milieu</ToggleButton>
<ToggleButton name="peche" value={9} bsSize="small" bsStyle="warning">Cantonnements de pêche</ToggleButton>
<ToggleButton name="trafic" value={10} bsSize="small" bsStyle="warning">Trafic maritime</ToggleButton>
</ToggleButtonGroup>
<br/>
<Carte
fish = {this.props.fish}/>
</div>
)
}
}
|
client/src/entwine/TinyMCE_ssembed.js
|
open-sausages/silverstripe-assets-gallery
|
/* global tinymce, window */
import jQuery from 'jquery';
import React from 'react';
import ReactDOM from 'react-dom';
import { loadComponent } from 'lib/Injector';
import ShortcodeSerialiser from 'lib/ShortcodeSerialiser';
import InsertEmbedModal from 'components/InsertEmbedModal/InsertEmbedModal';
import i18n from 'i18n';
const InjectableInsertEmbedModal = loadComponent(InsertEmbedModal);
const filter = 'div[data-shortcode="embed"]';
/**
* Embed shortcodes are split into an outer <div> element and an inner <img>
* placeholder based on the thumbnail url provided by the oembed shortcode provider.
*/
(() => {
const ssembed = {
init: (editor) => {
const insertTitle = i18n._t('AssetAdmin.INSERT_VIA_URL', 'Insert media via URL');
const editTitle = i18n._t('AssetAdmin.EDIT_MEDIA', 'Edit media');
const contextTitle = i18n._t('AssetAdmin.MEDIA', 'Media');
editor.addButton('ssembed', {
title: insertTitle,
icon: 'media',
cmd: 'ssembed',
stateSelector: filter
});
editor.addMenuItem('ssembed', {
text: contextTitle,
icon: 'media',
cmd: 'ssembed',
});
editor.addButton('ssembededit', {
title: editTitle,
icon: 'editimage',
cmd: 'ssembed'
});
editor.addContextToolbar(
(embed) => editor.dom.is(embed, filter),
'alignleft aligncenter alignright | ssembededit'
);
editor.addCommand('ssembed', () => {
// See HtmlEditorField.js
jQuery(`#${editor.id}`).entwine('ss').openEmbedDialog();
});
// Replace the tinymce default media commands with the ssembed command
editor.on('BeforeExecCommand', (e) => {
const cmd = e.command;
const ui = e.ui;
const val = e.value;
if (cmd === 'mceAdvMedia' || cmd === 'mceAdvMedia') {
e.preventDefault();
editor.execCommand('ssembed', ui, val);
}
});
editor.on('SaveContent', (o) => {
const content = jQuery(`<div>${o.content}</div>`);
// Transform [embed] shortcodes
content
.find(filter)
.each(function replaceWithShortCode() {
// Note: embed <div> contains placeholder <img>, and potentially caption <p>
const embed = jQuery(this);
// If placeholder has been removed, remove data-* properties and
// convert to non-shortcode div
const placeholder = embed.find('img.placeholder');
if (placeholder.length === 0) {
embed.removeAttr('data-url');
embed.removeAttr('data-shortcode');
return;
}
// Find nested element data
const caption = embed.find('.caption').text();
const width = parseInt(placeholder.attr('width'), 10);
const height = parseInt(placeholder.attr('height'), 10);
const url = embed.data('url');
const properties = {
url,
thumbnail: placeholder.prop('src'),
class: embed.prop('class'),
width: isNaN(width) ? null : width,
height: isNaN(height) ? null : height,
caption,
};
const shortCode = ShortcodeSerialiser.serialise({
name: 'embed',
properties,
wrapped: true,
content: url
});
embed.replaceWith(shortCode);
});
// eslint-disable-next-line no-param-reassign
o.content = content.html();
});
editor.on('BeforeSetContent', (o) => {
let content = o.content;
// Transform [embed] tag
let match = ShortcodeSerialiser.match('embed', true, content);
while (match) {
const data = match.properties;
// Add base div
const base = jQuery('<div/>')
.attr('data-url', data.url || match.content)
.attr('data-shortcode', 'embed')
.addClass(data.class)
.addClass('ss-htmleditorfield-file embed');
// Add placeholder
const placeholder = jQuery('<img />')
.attr('src', data.thumbnail)
.addClass('placeholder');
// Set dimensions
if (data.width) {
placeholder.attr('width', data.width);
}
if (data.height) {
placeholder.attr('height', data.height);
}
base.append(placeholder);
// Add caption p tag
if (data.caption) {
const caption = jQuery('<p />')
.addClass('caption')
.text(data.caption);
base.append(caption);
}
// Inject into code
content = content.replace(match.original, (jQuery('<div/>').append(base).html()));
// Search for next match
match = ShortcodeSerialiser.match('embed', true, content);
}
// eslint-disable-next-line no-param-reassign
o.content = content;
});
},
};
tinymce.PluginManager.add('ssembed', (editor) => ssembed.init(editor));
})();
jQuery.entwine('ss', ($) => {
$('.js-injector-boot #insert-embed-react__dialog-wrapper').entwine({
Element: null,
Data: {},
onunmatch() {
// solves errors given by ReactDOM "no matched root found" error.
this._clearModal();
},
_clearModal() {
ReactDOM.unmountComponentAtNode(this[0]);
// this.empty();
},
open() {
this._renderModal(true);
},
close() {
this.setData({});
this._renderModal(false);
},
/**
* Renders the react modal component
*
* @param {boolean} isOpen
* @private
*/
_renderModal(isOpen) {
const handleHide = () => this.close();
// Inserts embed into page
const handleInsert = (...args) => this._handleInsert(...args);
// Create edit form from url
const handleCreate = (...args) => this._handleCreate(...args);
const handleLoadingError = (...args) => this._handleLoadingError(...args);
const attrs = this.getOriginalAttributes();
// create/update the react component
ReactDOM.render(
<InjectableInsertEmbedModal
isOpen={isOpen}
onCreate={handleCreate}
onInsert={handleInsert}
onClosed={handleHide}
onLoadingError={handleLoadingError}
bodyClassName="modal__dialog"
className="insert-embed-react__dialog-wrapper"
fileAttributes={attrs}
/>,
this[0]
);
},
_handleLoadingError() {
this.setData({});
this.open();
},
/**
* Handles inserting the selected file in the modal
*
* @param {object} data
* @returns {Promise}
* @private
*/
_handleInsert(data) {
const oldData = this.getData();
this.setData(Object.assign({ Url: oldData.Url }, data));
this.insertRemote();
this.close();
},
_handleCreate(data) {
this.setData(Object.assign({}, this.getData(), data));
this.open();
},
/**
* Find the selected node and get attributes associated to attach the data to the form
*
* @returns {object}
*/
getOriginalAttributes() {
const data = this.getData();
const $field = this.getElement();
if (!$field) {
return data;
}
const node = $($field.getEditor().getSelectedNode());
if (!node.length) {
return data;
}
// Find root embed shortcode
const element = node.closest(filter).add(node.filter(filter));
if (!element.length) {
return data;
}
const image = element.find('img.placeholder');
// If image has been removed then this shortcode is invalid
if (image.length === 0) {
return data;
}
const caption = element.find('.caption').text();
const width = parseInt(image.width(), 10);
const height = parseInt(image.height(), 10);
return {
Url: element.data('url') || data.Url,
CaptionText: caption,
PreviewUrl: image.attr('src'),
Width: isNaN(width) ? null : width,
Height: isNaN(height) ? null : height,
Placement: this.findPosition(element.prop('class')),
};
},
/**
* Calculate placement from css class
*/
findPosition(cssClass) {
const alignments = [
'leftAlone',
'center',
'rightAlone',
'left',
'right',
];
if (typeof cssClass !== 'string') {
return '';
}
const classes = cssClass.split(' ');
return alignments.find((alignment) => (
classes.indexOf(alignment) > -1
));
},
insertRemote() {
const $field = this.getElement();
if (!$field) {
return false;
}
const editor = $field.getEditor();
if (!editor) {
return false;
}
const data = this.getData();
// Add base div
const base = jQuery('<div/>')
.attr('data-url', data.Url)
.attr('data-shortcode', 'embed')
.addClass(data.Placement)
.addClass('ss-htmleditorfield-file embed');
// Add placeholder image
const placeholder = jQuery('<img />')
.attr('src', data.PreviewUrl)
.addClass('placeholder');
// Set dimensions
if (data.Width) {
placeholder.attr('width', data.Width);
}
if (data.Height) {
placeholder.attr('height', data.Height);
}
// Add to base
base.append(placeholder);
// Add caption p tag
if (data.CaptionText) {
const caption = jQuery('<p />')
.addClass('caption')
.text(data.CaptionText);
base.append(caption);
}
// Find best place to put this embed
const node = $(editor.getSelectedNode());
let replacee = $(null);
if (node.length) {
replacee = node.filter(filter);
// Find find closest existing embed
if (replacee.length === 0) {
replacee = node.closest(filter);
}
// Fail over to check if the node is an image
if (replacee.length === 0) {
replacee = node.filter('img.placeholder');
}
}
// Inject
if (replacee.length) {
replacee.replaceWith(base);
} else {
// Otherwise insert the whole HTML content
editor.repaint();
editor.insertContent($('<div />').append(base.clone()).html(), { skip_undo: 1 });
}
editor.addUndo();
editor.repaint();
return true;
},
});
});
|
test/helpers/shallowRenderHelper.js
|
malecki/gcmeme
|
/**
* Function to get the shallow output for a given component
* As we are using phantom.js, we also need to include the fn.proto.bind shim!
*
* @see http://simonsmith.io/unit-testing-react-components-without-a-dom/
* @author somonsmith
*/
import React from 'react';
import TestUtils from 'react-addons-test-utils';
/**
* Get the shallow rendered component
*
* @param {Object} component The component to return the output for
* @param {Object} props [optional] The components properties
* @param {Mixed} ...children [optional] List of children
* @return {Object} Shallow rendered output
*/
export default function createComponent(component, props = {}, ...children) {
const shallowRenderer = TestUtils.createRenderer();
shallowRenderer.render(React.createElement(component, props, children.length > 1 ? children : children[0]));
return shallowRenderer.getRenderOutput();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.