code
stringlengths 2
1.05M
|
|---|
'use strict';
describe('Books Factory Tests', function() {
var $httpBackend, _list;
beforeEach(module('app'));
beforeEach(function() {
_list = [{
"author": {
"avatar": "http://lorempixel.com/250/250/",
"name": "JRR Tolkien"
},
"genre": {
"category": "Non-Fiction",
"name": "History"
},
"id": "b841267346",
"name": "The Lord of the Rings",
}, {
"author": {
"avatar": "http://lorempixel.com/250/250/",
"name": "Rabindranath Tagore"
},
"genre": {
"category": "Non-Fiction",
"name": "Christian Books"
},
"id": "b283256024",
"name": "The Home and the World"
}];
});
describe('getAll', function() {
beforeEach(inject(function($injector) {
$httpBackend = $injector.get('$httpBackend');
$httpBackend.when('GET', '/datastore/books.json').respond({
"genre": {
"category": "Non-Fiction",
"name": "History"
},
"id": "b841267346",
"name": "The Lord of the Rings",
});
}));
afterEach(function() {
$httpBackend.verifyNoOutstandingExpectation();
$httpBackend.verifyNoOutstandingRequest();
});
it('should populate book list', inject(function($http, books) {
$httpBackend.expectGET('/datastore/books.json');
books.getAll();
$httpBackend.flush();
}));
});
describe('populateGenre', function() {
it('should populate category list', inject(function(books) {
books.list = _list;
books.populateGenre();
expect(books.category.length).toEqual(1);
}));
it('should populate genre list', inject(function(books) {
books.list = _list;
books.populateGenre();
expect(books.genre.length).toEqual(2);
}));
});
describe('filter', function() {
it('should filter list by genre', inject(function(books) {
books.list = _list;
var filtered = books.filter({ genre: "History" });
expect(filtered.length).toEqual(1);
}));
it('should filter list by category', inject(function(books) {
books.list = _list;
var filtered = books.filter({ category: "Non-Fiction" });
expect(filtered.length).toEqual(2);
}));
it('should filter list by category/genre', inject(function(books) {
books.list = _list;
var filtered = books.filter({ category: "Non-Fiction", genre: "Technology" });
expect(filtered.length).toEqual(0);
}));
});
describe('search', function() {
it('should find by title and author', inject(function(books) {
books.list = _list;
var filtered = books.search({ keyword: "Lord" });
expect(filtered.length).toEqual(1);
}));
it('should return nothing on no match', inject(function(books) {
books.list = _list;
var filtered = books.search({ keyword: "Baseball" });
expect(filtered.length).toEqual(0);
}));
});
describe('getPage', function() {
it('should return correct page', inject(function(books) {
books.list = _list;
var payload = books.getPage(undefined, 1);
expect(payload.page).toEqual(1);
expect(payload.data[0].name).toEqual("The Lord of the Rings");
}));
});
describe('maxPage', function() {
it('should return last page for books.list', inject(function(books) {
var list = _list;
expect(books.maxPage(list)).toEqual(1);
}));
});
describe('getBook', function() {
it('should return correct book', inject(function(books) {
books.list = _list;
var book = books.getBook("b841267346");
expect(book.id).toEqual("b841267346");
}));
});
describe('getRelated', function() {
it('should return correct book', inject(function(books) {
books.list = _list;
var related = books.getRelated({ id: "b841267346", genre: { category: "Non-Fiction" } });
expect(related.length).toEqual(1);
}));
});
});
|
const { test, expect } = require('../utils/tester')
function reduce (obj, predicate, acc = 0) {
const keys = Object.keys(obj)
const keysLength = keys.length
for (var i = 0; i < keysLength; i++) {
const key = keys[i]
const value = obj[key]
acc = predicate.call(obj, acc, key, value, i, keys)
}
return acc
}
test('Test 1', () => {
const obj = {a: 3, b: 5, c: 9}
const expected = {3: 'a', 5: 'b', 9: 'c'}
const res = reduce(obj, (acc, key, value, index, keys) => {
acc[value] = key
return acc
}, {})
expect(JSON.stringify(res) === JSON.stringify(expected))
})
test('Test 2', () => {
const obj = {a: 3, b: 5, c: 9}
const expected = 17
const res = reduce(obj, (acc, key, value, index, keys) => {
acc += value
return acc
})
expect(JSON.stringify(res) === JSON.stringify(expected))
})
|
const puppeteer = require( 'puppeteer' );
const fs = require( 'fs' );
const path = require( 'path' );
const yargs = require( 'yargs' );
let args = yargs.argv;
/**
* Loads any of the sensitive props in the config json
*/
function loadSensitiveProps( config, configPath ) {
function loadProp( parentProp, prop, path ) {
if ( typeof ( path ) === 'string' ) {
if ( !fs.existsSync( configPath + '/' + path ) )
throw new Error( `Property file '${ configPath + '/' + path }' cannot be found` );
else
parentProp[ prop ] = JSON.parse( fs.readFileSync( configPath + '/' + path, 'utf8' ) );
}
}
// Load and merge any sensitive json files
loadProp( config, 'adminUser', config.adminUser );
loadProp( config.remotes, 'google', config.remotes.google );
loadProp( config.remotes, 'local', config.remotes.local );
loadProp( config.mail, 'options', config.mail.options );
loadProp( config, 'database', config.database );
}
async function initialize() {
exports.browser = await puppeteer.launch( { headless: false } );
exports.page = await exports.browser.newPage();
exports.modepressConfig = JSON.parse( fs.readFileSync( './modepress.json' ) );
exports.config = JSON.parse( fs.readFileSync( args.config ) );
exports.host = `${ exports.modepressConfig.server.host }:${ exports.modepressConfig.server.port }`;
loadSensitiveProps( exports.config, path.dirname( args.config ) )
}
exports.initialize = initialize;
|
'use strict';
require('styles//SprintInformationPanel.scss');
import React from 'react';
import { connect } from "react-redux"
import {BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend} from 'Recharts';
const data = [
{name: 'Page A', uv: 10, pv: 0, amt: 0}
];
@connect((store) => {
return {
};
})
class SprintInformationPanelComponent extends React.Component {
propTypes: {
}
defaultProps: {
}
constructor(props) {
super(props);
}
render() {
return (
<div className="sprintinformationpanel-component">
<div>
<div>
Sprint 3
</div>
<div>
May 07 - May 18
</div>
<div>
<div>
<div>
39
</div>
<div>
<div></div>
</div>
</div>
<div>
of 42 h
</div>
</div>
<div>
Backlog items: 3 in progress
</div>
</div>
</div>
);
}
}
SprintInformationPanelComponent.displayName = 'SprintInformationPanelComponent';
export default SprintInformationPanelComponent;
|
var gulp = require('gulp');
var karma = require('karma').Server;
gulp.task('test', function(done) {
'use strict';
return new karma({
configFile: require('path').resolve('gulp/karma.conf.js'),
singleRun: true,
browserNoActivityTimeout: 15000,
browserDisconnectTolerance: 5
}, done).start();
});
|
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
var isString = function isString(s) {
return typeof s === 'string' || s instanceof String;
};
exports.isString = isString;
|
/**
* DEV WEBPACK CONFIGURATION
* - Merge into webpack.base.js
*/
const path = require('path');
const _ = require('lodash');
const webpack = require('webpack');
const CompressionPlugin = require('compression-webpack-plugin');
const {getConfig} = require('./../helpers.js');
/**
* Configs the devemplet webpack specific config
* @return {obj}
*/
const configProd = function () {
//configures prod output path, since the path needs to be configed beforhand
const prodDir = getConfig('webpack.production.output.path') || 'www';
const prodPath = path.join(process.cwd(), prodDir);
//default in the .cruzinrc.yml -> webpack.production Object config
const devConfig = _.defaultsDeep({
output: {path: prodPath}
}, _.omit(getConfig('webpack.production'), 'plugins') || {}, {
output: {
filename: '[name].[hash].js',
chunkFilename: '[name].[chunkhash].chunk.js'
}
});
/**
* Hardwire prod config the rest are preconfiged in the .cruzinrc.yml
*/
const prod = _.defaultsDeep(devConfig, {
// Add development plugins
plugins: [
// OccurrenceOrderPlugin is needed for long-term caching to work properly.
// See http://mxs.is/googmv
new webpack.optimize.OccurrenceOrderPlugin(true)
]
});
//check for Uglify
const uglifyPlugin = getConfig('webpack.production.plugins.UglifyJsPlugin');
if (_.isPlainObject(uglifyPlugin)) {
prod.plugins.push(new webpack.optimize.UglifyJsPlugin(uglifyPlugin));
}
//check for CompressionPlugin
const compressPlugin = getConfig('webpack.production.plugins.CompressionPlugin');
if (_.isPlainObject(compressPlugin)) {
prod.plugins.push(new CompressionPlugin(compressPlugin));
}
//NOTE: offline plugin configed in base
//>
return prod;
};
module.exports = require('./webpack.base.js')(configProd());
|
var helper = require("../../helper");
var Manager = require("../../../src/etl/fact-total-hutang-etl-manager");
var instanceManager = null;
var should = require("should");
var sqlHelper = require("../../sql-helper")
before("#00. connect db", function (done) {
Promise.all([helper, sqlHelper])
.then((result) => {
var db = result[0];
var sql = result[1];
db.getDb().then((db) => {
instanceManager = new Manager(db, {
username: "unit-test"
}, sql);
done();
})
.catch((e) => {
done(e);
});
});
});
it("#01. should success when create etl fact-total-hutang", function (done) {
instanceManager.run()
.then((a) => {
done();
})
.catch((e) => {
done(e);
});
});
it("#02. should success when transforming data for fact-total-hutang", function (done) {
var data = [{}, {}];
instanceManager.transform(data)
.then(() => {
done();
})
.catch((e) => {
done(e);
});
});
it("#03. should error when load empty data", function (done) {
instanceManager.load({})
.then(id => {
done("should error when create with empty data");
})
.catch(e => {
try {
done();
}
catch (ex) {
done(ex);
}
});
});
it("#04. should error when insert empty data", function (done) {
instanceManager.insertQuery(this.sql, "")
.then((id) => {
done("should error when create with empty data");
})
.catch((e) => {
try {
done();
}
catch (ex) {
done(ex);
}
});
});
it("#05. should success when joining URN to UPO", function (done) {
var data = [{}, {}];
instanceManager.joinUnitPaymentOrder(data)
.then(() => {
done();
})
.catch((e) => {
done(e);
});
});
// it("#05. should success when load data", function (done) {
// var data = [{
// unitPaymentOrderNo: null,
// unitPaymentOrderDate: null,
// supplierName: null,
// categoryType: null,
// invoicePrice: null,
// unitReceiptNoteQuantity: null,
// purchaseOrderExternalCurrencyRate: null,
// total: null,
// categoryName: null,
// divisionName: null,
// unitName: null,
// unitReceiptNoteNo: null,
// productName: null,
// productCode: null
// }]
// instanceManager.load(data)
// .then(() => {
// done();
// })
// .catch((e) => {
// done(e);
// });
// });
|
"use strict";
/// <reference path="./definitions/DefinitelyTyped/underscore/underscore.d.ts"/>
/// <reference path="./definitions/dummy-definitions/lastfm.d.ts"/>
/// <reference path="./definitions/typescript-node-definitions/winston.d.ts"/>
exports.__esModule = true;
var winston = require("winston");
var DummyLastFmDao = (function () {
function DummyLastFmDao() {
}
DummyLastFmDao.prototype.postNowPlaying = function (song, lastFmUsername, session, callback) {
callback = callback || (function () { });
if (song.Artist && song.Track) {
winston.info("Faking post now playing to user " + lastFmUsername + ", session " + session + " of song:", song);
callback(null, "OK");
}
else {
callback("Invalid song", null);
}
};
DummyLastFmDao.prototype.scrobble = function (song, lastFmUsername, session, callback) {
callback = callback || (function () { });
if (song.Artist && song.Track) {
winston.info("Faking scrobble to user " + lastFmUsername + ", session " + session + " of song:", song);
callback(null, "OK");
}
else {
callback("Invalid song", null);
}
};
return DummyLastFmDao;
}());
exports.DummyLastFmDao = DummyLastFmDao;
var LastFmDaoImpl = (function () {
function LastFmDaoImpl(lastfmNode, postNowPlayingLength) {
this.lastfmNode = lastfmNode;
this.postNowPlayingLength = postNowPlayingLength;
}
LastFmDaoImpl.prototype.postNowPlaying = function (song, lastFmUsername, sessionKey, callback) {
callback = callback || (function () { });
if (!song || !song.Artist || !song.Track || !lastFmUsername || !sessionKey) {
winston.error("postNowPlaying invalid parameters:", { song: song, lastFmUsername: lastFmUsername, sessionKey: sessionKey });
callback("Invalid parameters", null);
return;
}
var updateOptions = {
artist: song.Artist,
track: song.Track,
duration: this.postNowPlayingLength,
handlers: {
success: function (data) {
winston.info("Success posting now playing for " + lastFmUsername, song);
callback(null, "OK");
},
retry: function (result) {
winston.warn("Retrying post now playing for " + lastFmUsername, result);
},
error: function (error) {
winston.error("Error posting now playing for " + lastFmUsername, error.message);
callback(error, null);
}
}
};
var session = this.lastfmNode.session(lastFmUsername, sessionKey);
this.lastfmNode.update('nowplaying', session, updateOptions);
};
LastFmDaoImpl.prototype.scrobble = function (song, lastFmUsername, sessionKey, callback) {
callback = callback || (function () { });
if (!song || !song.Artist || !song.Track || !lastFmUsername || !sessionKey) {
winston.error("scrobble invalid parameters:", { song: song, lastFmUsername: lastFmUsername, sessionKey: sessionKey });
callback("Invalid parameters", null);
return;
}
var updateOptions = {
artist: song.Artist,
track: song.Track,
timestamp: Math.round(song.StartTime / 1000),
handlers: {
success: function (data) {
winston.info("Success posting scrobble for " + lastFmUsername, song);
callback(null, "OK");
},
retry: function (result) {
winston.warn("Retrying scrobble for " + lastFmUsername, result);
},
error: function (error) {
winston.error("Error posting scrobble for " + lastFmUsername, error.message);
callback(error, null);
}
}
};
var session = this.lastfmNode.session(lastFmUsername, sessionKey);
this.lastfmNode.update('scrobble', session, updateOptions);
};
return LastFmDaoImpl;
}());
exports.LastFmDaoImpl = LastFmDaoImpl;
//# sourceMappingURL=LastFmDao.js.map
|
/*
* Configuration File
*/
//URL from api to test api resources
var API_URL = 'http://validate.jsontest.com/';
//Send custom header in your request and response headers
//Used for example to send auth-cookies in headers
var USE_CUSTOM_HEADER = false;
var CUSTOM_HEADER = 'Accept-Language';
//To test login with facebook you need to setup krangular.com as your local virtualhost
//to obtain login responses , try it!
var LOGIN_FACEBOOK_REDIRECT_URI = "http://krangular.com:8080/auth/facebook/";
var LOGIN_FACEBOOK_CLIENT_ID = "723035201084388";
var LOGIN_FACEBOOK_SCOPE = ["email"];
|
define([ 'postal', 'module_base', 'text!./layout-full.html', 'text!./event-basics.html' ],
function (postal, mod_base, layout_full, form_basics) {
return mod_base.extend({
api_root: "/api/mod/event-form",
initialize: function (el, o, callback) {
var self = this;
_.bindAll(this, 'load_view_data');
self.base_initialize(el, o, function () {
self.load_view_data(function (data) {
self.manifest.options.view_data = data;
var event_form = $(layout_full);
var form_element = event_form.find("form");
form_element.append(form_basics);
var event_form_layout = event_form.html();
self.base_render(html_decode(event_form_layout), window.culture, function (self) {
if (callback) {
callback(self);
}
});
});
});
},
load_view_data: function (callback) {
var self = this;
var xhr = $.getJSON(self.api_root + '/event/');
xhr.done(function (data) {
callback(data);
}).fail(function () {
console.log("error");
});
},
events: {
"click #Save-Button": "save",
"click #Cancel-Button": "cancel",
"click #Delete-Button": "remove"
},
cancel: function () {
history.back();
},
save: function () {
// TODO: To be replaces with proper data binding.
var self = this;
var form_elements = self.$el.find("form :input");
for (var i = 0; i < form_elements.length; i++) {
var el = form_elements[i];
if (el.id) {
self.manifest.options.view_data.event_model[el.id] = el.value;
}
}
console.log(self.manifest.options.view_data.event_model);
$.ajax({
type: "POST",
//contentType: "application/json; charset=utf-8",
url: self.api_root + '/event/',
//dataType: "json",
data: self.manifest.options.view_data.event_model
})
.done(function (msg) {
console.log(self.manifest.options.view_data.event_model);
alert("Data Saved: " + msg);
}).fail(function (msg) {
alert("Save failed: " + msg);
});
// if (self.model.get("_is_dirty") === false) {
// alert('nothing to save');
// return;
// }
// self.model.validate(function(validationMessages){
// if(validationMessages.length){
// showValidationErrors(validationMessages);
// return;
// }
// var entityToSave;
// if(self.model.get("_is_address_validated") != true){
// var addressArray = [];
// addressArray.push(self.model.get("address1"));
// addressArray.push(self.model.get("city"));
// addressArray.push(self.model.get("state"));
// addressArray.push(self.model.get("postal_code"));
// addressArray.push(self.model.get("country"));
//
// var addressString = addressArray.join(' ');
// maps.codeAddress(addressString, function(geocode){
// if(geocode.results.length == 0){
// showAddressErrors();
// alert('invalid address' + addressString);
// console.log('no results');
// return;
// }
// if(geocode.results.length > 1){
// alert('Multiple results found. Show selector.');
// return;
// }
// if(geocode.status != 'OK'){
// showAddressErrors();
// alert('invalid address' + addressString);
// console.log("status: " + geocode.status);
// return;
// }
// if(geocode.results[0].partial_match == true){
// showAddressErrors();
// alert('invalid address' + addressString);
// console.log("partial_match: " + geocode.results[0].partial_match);
// return;
// }
// if(geocode.results.length == 1){
// self.model.set("_is_address_validated", true);
// clearAddressErrors();
// entity.save({address: geocode.results[0]}, {success: self.saveSuccess, error: self.saveFailure});
// // entityToSave = self.model.saveToEntity(self.model, geocode.results[0], self.saveEntity);
// }
// });
// } else {
// self.model.save(null, {success: self.saveSuccess, error: self.saveFailure});
// }
// });
},
saveEntity: function (entity) {
var self = this;
},
remove: function () {
window.location.href = "#/event/delete/" + this.entityId;
},
saveSuccess: function (model, response) {
console.log('MODEL: ' + model);
console.log('RESPONSE: ' + response);
this.model = model;
this.render();
alert('Event saved successfully!!');
var id = model.get("_id");
if (id) {
window.location.href = "#/event/" + model.get("_id");
} else {
window.location.href = "#/events/";
}
},
saveFailure: function (model, response) {
console.log('MODEL: ' + model);
console.log('RESPONSE: ' + response);
alert('Event saved failed!!');
}
});
function showValidationErrors(validationMessages) {
for (var v = 0; v < validationMessages.length; v++) {
var field = $('[data-bind-event="' + validationMessages[v][0] + '"]');
field.parent().parent().addClass("has-error");
}
}
function showAddressErrors() {
var fields = $('[data-bind-event^="location"]');
for (var v = 0; v < fields.length; v++) {
var field = fields[v];
$(field).parent().parent().addClass("has-error");
}
}
function clearAddressErrors() {
var fields = $('[data-bind-event^="location"]');
for (var v = 0; v < fields.length; v++) {
var field = fields[v];
$(field).parent().parent().removeClass("has-error");
}
}
});
function html_decode(str) {
return String(str)
.replace(/&/, '&')
.replace(/"/g, '\"')
.replace(/'/g, '\'')
.replace(/</g, '<')
.replace(/>/g, '>');
}
|
module.exports = {
"transform": {
"^.+\\.tsx?$": "ts-jest"
},
"testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
"moduleFileExtensions": [
"ts",
"tsx",
"js",
"jsx",
"json",
"node"
],
"globals": {
"ts-jest": {
"diagnostics": true
}
},
}
|
import React, {Component} from 'react';
import {message, Button} from 'antd';
import $ from 'jQuery';
const info = function() {
message.info('test');
};
export default class Caipiao123 extends Component {
componentDidMount() {
$.ajax({
url: '/app/api/data1.json',
method: 'GET',
success: function(data) {
message.info(data.retCode);
}
});
}
render() {
return(
<Button onClick={info}>点击test</Button>
)
}
}
|
(function () {
"use strict";
var PLAYER_HEIGHT = 1.82;
var vrDisplay = null;
var vrComponents = {display:null};
var projectionMat = mat4.create();
var viewMat = mat4.create();
var poseMat = mat4.create();
var standingPosition = vec3.create();
var orientation = [0, 0, 0];
var position = [0, 0, 0];
window.CARNIVAL = {};
var error = function (err) {
if (window.showError) {
window.showError(err);
}
else {
console.log(err);
}
}
/* Haptics actuators seem to operate all the way down to 0.00026 but aren't very noticeable at that level. */
var vrPresentButton = null;
var ROTY = 0;
var getCameraPos = function () {
var poseOut = mat4.create();
var standpos = vec3.create();
var PLAYER_HEIGHT = 1.82;
var pos = [0, 0, 0];
var rot = quat.create();
quat.rotateY(rot, rot, ROTY % (2*Math.PI));
ROTY+=0.01;
// var ori = [0, ((ROTY+=0.01)%Math.PI)-(Math.PI/2), 0, 1];
vec3.add(standpos, pos, [0, PLAYER_HEIGHT, 0]);
mat4.fromRotationTranslation(poseOut, rot, standpos);
// console.log(ROTY);
return poseOut;
}
var attachCameraToGamepad = function (gpIdx) {
var poseGet = function () {
var vrGamepads = FCUtil.getVRGamepads();
if (vrGamepads[gpIdx] && vrGamepads[gpIdx].pose && vrGamepads[gpIdx].pose.position) {
var myGp = vrGamepads[gpIdx];
var gPose = myGp.pose;
var cameraTranslate = vec3.create();
cameraTranslate[0] = numericValueOfElement('cameraTranslateX');
cameraTranslate[1] = numericValueOfElement('cameraTranslateY');
cameraTranslate[2] = numericValueOfElement('cameraTranslateZ');
var cameraPos = vec3.create();
vec3.add(cameraPos, cameraTranslate, gPose.position);
var gpMat = mat4.create();
// var orientation = gPose.orientation;
// var position = gPose.
if (window.vrDisplay.stageParameters) {
// mat4.fromRotationTranslation(gpMat, gPose.orientation, gPose.position);
mat4.fromRotationTranslation(gpMat, gPose.orientation, cameraPos);
mat4.multiply(gpMat, vrDisplay.stageParameters.sittingToStandingTransform, gpMat);
}
return gpMat;
}
else {
return getCameraPos();
}
}
return poseGet;
}
var attachSceneCamera = function (label) {
var poseGet = function () {
var scene = window.vrScene;
var camMat = mat4.create();
var myCam;
if (scene && scene.cameras && scene.cameras[label]) {
myCam = scene.cameras[label];
}
else {
myCam = {
position: {x:0.4, y:1, z:-1.6},
orientation: {x:0.0, y:Math.PI}
};
}
var pos = vec3.fromValues(myCam.position.x, myCam.position.y, myCam.position.z);
var rot = quat.create();
quat.rotateY(rot, rot, myCam.orientation.y || 0.0);
quat.rotateX(rot, rot, myCam.orientation.x || 0.0);
mat4.fromRotationTranslation(camMat, rot, pos);
return camMat;
}
return poseGet;
}
var numericValueOfElement = function (elemId, defaultValue) {
try {
return Number(document.getElementById(elemId).value);
}
catch (exc) {
return defaultValue || 0.0;
}
}
/* headsetBounds is left/top/width/height-down */
/* canvasBounds is left/bottom/width/height-up */
var doubleGridPorts = function (j) {
var port = {};
switch (j) {
/* Left eye */
case 0:
port.headsetBounds = [0.0, 0.0, 0.5, 1.0];
port.canvasBounds = [0.0, 0.0, 0.5, 1.0];
break;
/* Right eye */
case 1:
port.headsetBounds = [0.5, 0.0, 0.5, 1.0];
port.canvasBounds = [0.5, 0.0, 0.5, 1.0];
break;
}
return port;
}
var tripleGridPorts = function (j) {
var port = {};
switch (j) {
/* Left eye */
case 0:
port.headsetBounds = [0.0, 0.0, 0.5, 0.5];
port.canvasBounds = [0.0, 0.5, 0.5, 0.5];
break;
/* Right eye */
case 1:
port.headsetBounds = [0.5, 0.0, 0.5, 0.5];
port.canvasBounds = [0.5, 0.5, 0.5, 0.5];
break;
/* Camera */
case 2:
port.headsetBounds = null;
port.canvasBounds = [0.0, 0.0, 0.42, 0.5];
break;
}
return port;
}
var port = doubleGridPorts;
var viewports = {
/* headsetBounds are in a format that vrDisplay.requestPresent() understands ie. top-down */
/* canvasBounds are the same section but converted to canvas coords ie. bottom-up */
/* one could probably be inferred from the other but I CBF right now */
leftEye: {
povLabel: 'left_eye',
headsetBounds: port(0).headsetBounds,
canvasBounds: port(0).canvasBounds,
getEyeParameters: function () {return vrComponents.display && vrComponents.display.getEyeParameters('left');}
},
rightEye: {
povLabel: 'right_eye',
headsetBounds: port(1).headsetBounds,
canvasBounds: port(1).canvasBounds,
getEyeParameters: function () {return vrComponents.display && vrComponents.display.getEyeParameters('right');}
},
cam1: {
povLabel: 'cam_1',
headsetBounds: port(2).headsetBounds,
canvasBounds: port(2).canvasBounds,
getEyeParameters: function () {
return {
renderHeight: 1600,
renderWidth: 1512,
offset: [0,0,0],
fieldOfView: {
// upDegrees: 56.0,
// downDegrees: 56.0,
upDegrees: 40.0,
downDegrees: 40.0,
leftDegrees: 45.0,
rightDegrees: 45.0
}
};
},
// getPose: function () {return getCameraPos();}
getPose: attachSceneCamera('cam1')
},
cam2: {
povLabel: 'cam_2',
headsetBounds: port(2).headsetBounds,
canvasBounds: port(2).canvasBounds,
// canvasBounds: [0.0, 0.0, 1.0, 0.5],
getEyeParameters: function () {
return {
renderHeight: 1600,
renderWidth: 1512,
offset: [0,0,0],
fieldOfView: {
/// upDegrees: 56.0,
/// downDegrees: 56.0,
upDegrees: 32.0,
downDegrees: 32.0,
leftDegrees: 45.0,
rightDegrees: 45.0
// upDegrees: 32.0,
// downDegrees: 32.0,
// leftDegrees: 35.0,
// rightDegrees: 35.0
}
};
},
getPose: attachCameraToGamepad(1)
},
cam3: {
povLabel: 'cam_2',
headsetBounds: port(2).headsetBounds,
canvasBounds: port(2).canvasBounds,
// canvasBounds: [0.0, 0.0, 1.0, 0.5],
getEyeParameters: function () {
return {
renderHeight: 1600,
renderWidth: 1512,
offset: [0,0,0],
fieldOfView: {
/// upDegrees: 56.0,
/// downDegrees: 56.0,
upDegrees: numericValueOfElement('cameraUpDegrees'),
downDegrees: numericValueOfElement('cameraDownDegrees'),
leftDegrees: numericValueOfElement('cameraLeftDegrees'),
rightDegrees: numericValueOfElement('cameraRightDegrees')
// upDegrees: 32.0,
// downDegrees: 32.0,
// leftDegrees: 35.0,
// rightDegrees: 35.0
}
};
},
getPose: attachCameraToGamepad(1)
},
};
var activeViewports = [
viewports.leftEye,
viewports.rightEye
];
var webglCanvas = document.getElementById('webgl-canvas');
var gl = null;
var scene = null;
function initWebGL(preserveDrawingBuffer, stageParameters) {
var glAttribs = {
alpha: false,
antialias: true,
preserveDrawingBuffer: preserveDrawingBuffer
};
gl = webglCanvas.getContext("webgl", glAttribs);
gl.clearColor(0.1, 0.4, 0.2, 1.0);
gl.enable(gl.DEPTH_TEST);
gl.enable(gl.CULL_FACE);
var sceneClass = window.sceneClass || FCScene;
if (window.vrScene) {
window.vrScene.init(gl, stageParameters);
window.vrScene.setup();
window.vrScene.isRendering = true;
}
window.addEventListener('resize', onResize, false);
onResize();
window.requestAnimationFrame(onAnimationFrame);
}
// var presentingMessage = document.getElementById("presenting-message"); //
/* ---------------- */
function onVRRequestPresent () {
// This can only be called in response to a user gesture.
vrDisplay.requestPresent([{ source: webglCanvas }]).then(function () {
// Nothing to do because we're handling things in onVRPresentChange.
}, function () {
VRSamplesUtil.addError("requestPresent failed.", 2000);
});
}
function onVRExitPresent () {
vrDisplay.exitPresent().then(function () {
// Nothing to do because we're handling things in onVRPresentChange.
}, function () {
VRSamplesUtil.addError("exitPresent failed.", 2000);
});
}
function onVRPresentChange () {
// When we begin or end presenting, the canvas should be resized to the
// recommended dimensions for the display.
onResize();
if (vrDisplay.isPresenting) {
if (vrDisplay.capabilities.hasExternalDisplay) {
// Because we're not mirroring any images on an external screen will
// freeze while presenting. It's better to replace it with a message
// indicating that content is being shown on the VRDisplay.
// presentingMessage.style.display = "block";
// On devices with an external display the UA may not provide a way
// to exit VR presentation mode, so we should provide one ourselves.
// VRSamplesUtil.removeButton(vrPresentButton);
// vrPresentButton = VRSamplesUtil.addButton("Exit VR", "E", "../cardboard64.png", onVRExitPresent);
}
} else {
// If we have an external display take down the presenting message and
// change the button back to "Enter VR".
if (vrDisplay.capabilities.hasExternalDisplay) {
// presentingMessage.style.display = "";
// VRSamplesUtil.removeButton(vrPresentButton);
// vrPresentButton = VRSamplesUtil.addButton("Enter VR", "E", "../cardboard64.png", onVRRequestPresent);
}
}
}
function onResize () {
if (vrDisplay && vrDisplay.isPresenting) {
// If we're presenting we want to use the drawing buffer size
// recommended by the VRDevice, since that will ensure the best
// results post-distortion.
var leftEye = vrDisplay.getEyeParameters("left");
var rightEye = vrDisplay.getEyeParameters("right");
// For simplicity we're going to render both eyes at the same size,
// even if one eye needs less resolution. You can render each eye at
// the exact size it needs, but you'll need to adjust the viewports to
// account for that.
webglCanvas.width = Math.max(leftEye.renderWidth, rightEye.renderWidth) * 2;
webglCanvas.height = Math.max(leftEye.renderHeight, rightEye.renderHeight);
} else {
// We only want to change the size of the canvas drawing buffer to
// match the window dimensions when we're not presenting.
webglCanvas.width = webglCanvas.offsetWidth * window.devicePixelRatio;
webglCanvas.height = webglCanvas.offsetHeight * window.devicePixelRatio;
}
}
// window.addEventListener("resize", onResize, false);
// onResize();
function getPoseMatrix (out, pose) {
orientation = pose.orientation;
position = pose.position;
if (!orientation) { orientation = [0, 0, 0, 1]; }
if (!position) { position = [0, 0, 0]; }
if (vrDisplay.stageParameters) {
// If the headset provides stageParameters use the
// sittingToStandingTransform to transform the pose into a space where
// the floor in the center of the users play space is the origin.
mat4.fromRotationTranslation(out, orientation, position);
mat4.multiply(out, vrDisplay.stageParameters.sittingToStandingTransform, out);
} else {
// Otherwise you'll want to translate the view to compensate for the
// scene floor being at Y=0. Ideally this should match the user's
// height (you may want to make it configurable). For this demo we'll
// just assume all human beings are 1.65 meters (~5.4ft) tall.
vec3.add(standingPosition, position, [0, PLAYER_HEIGHT, 0]);
mat4.fromRotationTranslation(out, orientation, standingPosition);
}
}
function renderSceneView (poseInMat, eye, pov) {
if (eye) {
mat4.translate(viewMat, poseInMat, eye.offset);
mat4.perspectiveFromFieldOfView(projectionMat, eye.fieldOfView, 0.1, 1024.0);
mat4.invert(viewMat, viewMat);
} else {
mat4.perspective(projectionMat, Math.PI*0.4, webglCanvas.width / webglCanvas.height, 0.1, 1024.0);
mat4.invert(viewMat, poseInMat);
}
if (window.vrScene) window.vrScene.render(projectionMat, viewMat, pov);
}
var FC_SCENE_MISSING=null;
function onAnimationFrame (t) {
// stats.begin();
if (!gl) return;
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
if (!window.vrScene && FC_SCENE_MISSING === null) {
FC_SCENE_MISSING = true;
var err = 'No scene was found in window.vrScene';
error(err);
}
if (vrDisplay) {
// When presenting content to the VRDisplay we want to update at its
// refresh rate if it differs from the refresh rate of the main
// display. Calling VRDisplay.requestAnimationFrame ensures we render
// at the right speed for VR.
vrDisplay.requestAnimationFrame(onAnimationFrame);
// var vrGamepads = [];
// var gamepads = navigator.getGamepads();
// for (var i=0; i<gamepads.length; ++i) {
// var gamepad = gamepads[i];
// if (gamepad && gamepad.pose) {
// vrGamepads.push(gamepad);
// for (var j=0; j < gamepad.buttons.length; ++j) {
// if (gamepad.buttons[j].pressed) {
// console.log('Button '+j+' pressed');
// console.debug(gamepad);
// }
// }
// }
// }
// As a general rule you want to get the pose as late as possible
// and call VRDisplay.submitFrame as early as possible after
// retrieving the pose. Do any work for the frame that doesn't need
// to know the pose earlier to ensure the lowest latency possible.
// ^^ observe this
var pose = vrDisplay.getPose();
getPoseMatrix(poseMat, pose);
/* let's try relocating the player */
/* If scene.playerLocation is updated, here's how we notice it */
var ploc = window.vrScene && window.vrScene.playerLocation || {x:0, y:0, z:0};
var trans = vec3.fromValues(ploc.x, ploc.y, ploc.z);
var reloc = mat4.create();
mat4.fromTranslation(reloc, trans);
// console.debug(reloc);
mat4.mul(poseMat, reloc, poseMat);
/* ... */
if (vrDisplay.isPresenting) {
for (var i=0; i<activeViewports.length; i++) {
var myPort = activeViewports[i];
var cW = webglCanvas.width, cH = webglCanvas.height;
gl.viewport(myPort.canvasBounds[0]*cW, myPort.canvasBounds[1]*cH, myPort.canvasBounds[2]*cW, myPort.canvasBounds[3]*cH);
renderSceneView(myPort.getPose && myPort.getPose() || poseMat, myPort.getEyeParameters(), myPort.povLabel);
// if (myPort.pose) {console.log(myPort.pose);}
}
// When presenting render a stereo view.
//
//
// gl.viewport(0, 0, webglCanvas.width * 0.5, webglCanvas.height);
// renderSceneView(poseMat, vrDisplay.getEyeParameters("left"), 'left_eye');
//
// gl.viewport(webglCanvas.width * 0.5, 0, webglCanvas.width * 0.5, webglCanvas.height);
// renderSceneView(poseMat, vrDisplay.getEyeParameters("right"), 'right_eye');
//
// console.log(viewports.leftEye.getEyeParameters());
// If we're currently presenting to the VRDisplay we need to
// explicitly indicate we're done rendering and inform the
// display which pose was used to render the current frame.
vrDisplay.submitFrame(pose);
} else {
// When not presenting render a mono view that still takes pose into
// account.
gl.viewport(0, 0, webglCanvas.width, webglCanvas.height);
renderSceneView(poseMat, null);
// stats.renderOrtho();
}
} else {
window.requestAnimationFrame(onAnimationFrame);
// No VRDisplay found.
gl.viewport(0, 0, webglCanvas.width, webglCanvas.height);
mat4.perspective(projectionMat, Math.PI*0.4, webglCanvas.width / webglCanvas.height, 0.1, 1024.0);
mat4.identity(viewMat);
mat4.translate(viewMat, viewMat, [0, -PLAYER_HEIGHT, 0]);
scene.render(projectionMat, viewMat);
// stats.renderOrtho();
}
// stats.end();
}
if (navigator.getVRDisplays) {
navigator.getVRDisplays().then(function (displays) {
if (displays.length > 0) {
vrDisplay = displays[0];
window.vrDisplay = vrDisplay; /* TODO find a nicer way */
vrComponents.display = vrDisplay;
initWebGL(true, vrDisplay.stageParameters);
// if (vrDisplay.stageParameters &&
// vrDisplay.stageParameters.sizeX > 0 &&
// vrDisplay.stageParameters.sizeZ > 0) {
// scene.
// }
// VRSamplesUtil.addButton("Reset Pose", "R", null, function () { vrDisplay.resetPose(); });
// Generally, you want to wait until VR support is confirmed and
// you know the user has a VRDisplay capable of presenting connected
// before adding UI that advertises VR features.
if (vrDisplay.capabilities.canPresent) {}
// vrPresentButton = VRSamplesUtil.addButton("Enter VR", "E", "../cardboard64.png", onVRRequestPresent);
// The UA may kick us out of VR present mode for any reason, so to
// ensure we always know when we begin/end presenting we need to
// listen for vrdisplaypresentchange events.
window.addEventListener('vrdisplaypresentchange', onVRPresentChange, false);
/* Bounds are [leftOffset, topOffset, width, height] */
/* This could be useful for multiplexing, eg if we want to have cameras */
window.START_VR = function () {
vrDisplay.requestPresent([{ source: webglCanvas, leftBounds:viewports.leftEye.headsetBounds, rightBounds:viewports.rightEye.headsetBounds }]);
/* Check gamepads for pose */
var gamepads = FCUtil.getVRGamepads(true);
var poseMissing = false;
for (var i = 0; i < gamepads.length; i++) {
poseMissing = poseMissing || (gamepads[i].pose === undefined);
}
if (poseMissing) {
error('Gamepads were detected but are not reporting a pose. You probably need to enable Gamepad Extensions in about:flags . <a style="color:green;" href="http://meta4vr.net/setup/" target="_top">Click here for the solution</a>');
}
}
/* window.START_VR() needs to be called in response to a user gesture to activate */
// });
// console.debug(window.onload);
// console.log(viewports.rightEye.bounds);
/// [0.5,0.5,0.5,1.0]
/// [0.5,0.5,0.5,0.5]
} else {
// VRSamplesUtil.addInfo("WebVR supported, but no VRDisplays found.", 3000);
}
});
} else if (navigator.getVRDevices) {
// VRSamplesUtil.addError("Your browser supports WebVR but not the latest version. See <a href='http://webvr.info'>webvr.info</a> for more info.");
} else {
// VRSamplesUtil.addError("Your browser does not support WebVR. See <a href='http://webvr.info'>webvr.info</a> for assistance.");
}
window.requestAnimationFrame(onAnimationFrame);
})();
|
exports.render = function (input, out) {
var fs = require('fs');
var Finder = require('fs-finder');
var htmlparser = require("htmlparser");
var projectName = input.projectName;
var loadFilePath, hrefRoot;
if (projectName == "ax5ui") {
}
else {
loadFilePath = "_src_/" + projectName, hrefRoot = "_src_/";
}
if (loadFilePath) {
// find files and filter
var files = Finder.from(loadFilePath).findFiles('*.html').filter(function (path) {
return /html$/.test(path);
});
var url_replace = function (url) {
//return url.replace(process.cwd() + "/" + hrefRoot, "/");
return url.substring(url.indexOf("_src_") + 5);
};
var menus = [], trees = [];
(function () {
// Read file and parse 'tmpl-metadata' tag
files.forEach(function (src) {
var meta = (function () {
var
rawHtml = fs.readFileSync(src, 'utf8'),
handler = new htmlparser.DefaultHandler(function (error) {}, {verbose: false, ignoreWhitespace: true}),
parser = new htmlparser.Parser(handler)
;
parser.parseComplete(rawHtml);
var
obj = {}, i = handler.dom.length
;
while (i--) {
if (handler.dom[i].name == "tmpl-metadata") {
obj = handler.dom[i].attribs;
break;
}
}
return obj;
})();
var menu = {
url: url_replace(src)
};
// extend object
for (var k in meta) {
if (k == "sort") menu[k] = Number(meta[k]);
else menu[k] = meta[k];
}
if (menu.title) menus.push(menu);
});
// menus array sort
menus.sort(function (v1, v2) {
if (v1.sort == v2.sort) return 0;
else if (v1.sort > v2.sort) return 1;
else return -1;
});
menus.forEach(function (dn) {
if (!dn.parentId) {
trees.push(dn);
}
else {
var findMenuIndex = -1;
trees.forEach(function (mn, midx) {
if (mn.id == dn.parentId) {
findMenuIndex = midx;
return false;
}
});
if (findMenuIndex == -1) {
trees.push({title: dn.parentTitle, id: dn.parentId, child: [dn]});
}
else {
trees[findMenuIndex].child.push(dn);
}
}
});
})();
// console.log(trees);
var getUrl = function (url) {
return url;
};
var po = [];
for (var i = 0, l = trees.length, _item; i < l; i++) {
_item = trees[i];
po.push('<li ' + (function () {
return (input.activeId == _item.id) ? "class='active'" : "";
})() + '>');
if (!_item.url && _item.child && _item.child.length > 0) {
_item.url = _item.child[0].url;
}
po.push('<a href="' + getUrl(_item.url) + '">' + _item.title + '</a>');
po.push('</li>');
}
out.write(po.join(''));
}
else {
out.write('');
}
};
|
module.exports = {
name: 'AccountsDisplayDensity',
type: 'select',
default: false,
section: 'general',
title: 'Adjust Account Name Height',
description:
'Make the account names and their padding in the sidebar smaller allowing more accounts to fit on the screen.',
options: [
{ name: 'Compact', value: '1' },
{ name: 'Slim', value: '2' },
],
};
|
// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
// requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel
// MIT license
(function() {
var lastTime = 0;
var vendors = [ 'ms', 'moz', 'webkit', 'o' ];
for ( var x = 0; x < vendors.length && ! window.requestAnimationFrame; ++x )
{
window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
}
if ( ! window.requestAnimationFrame )
{
window.requestAnimationFrame = function( callback, element )
{
var currTime = new Date().getTime();
var timeToCall = Math.max( 0, 16 - ( currTime - lastTime ) );
var id = window.setTimeout( function() { callback(currTime + timeToCall); }, timeToCall );
lastTime = currTime + timeToCall;
return id;
};
}
if ( ! window.cancelAnimationFrame )
{
window.cancelAnimationFrame = function(id) { clearTimeout( id ); };
}
}());
|
//dui
name = "dui";
material = "grass";
//those attributes
addToCreative[0] = true;
hardness[0] = 0;
resistance[0] = 0;
hasTileEntity[0] = true;
tileEntity[0] = "Dummy";
stepSound[0] = "grass";
canPlaceOnWall[0] = false;
tickrate = 20;
//textures
textureFileFront[0] = "dui.png";
textureFileBack[0] = "dui.png";
textureFileSides[0] = "dui.png";
|
/* eslint-env mocha */
'use strict'
const expect = require('chai').expect
const obfuscateString = require('./../../lib/obfuscate-string')
describe('obfuscate-string', function () {
it('keeps the last n characters', function () {
const inp = '123456789'
const keep = 4
const exp = '*****6789'
expect(obfuscateString(inp, keep)).to.equal(exp)
})
it('keeps the last 3 characters by default', function () {
const inp = '123456789'
const exp = '******789'
expect(obfuscateString(inp)).to.equal(exp)
})
})
|
import React from 'react';
import classNames from 'classnames';
import PropTypes from 'prop-types';
export default function Teaser({
className,
itemType = 'http://schema.org/Article',
itemProp = 'article',
children,
publisher = 'The Economist',
author = 'The Economist',
classNameModifier = '',
}) {
return (
<article
aria-label="Article Teaser"
className={classNames(`teaser${ classNameModifier }`, className)}
itemScope itemType={itemType} itemProp={itemProp}
role="article"
>
<meta className="teaser__publisher" itemProp="publisher" content={publisher} />
<meta className="teaser__author" itemProp="author" content={author} />
{children}
</article>
);
}
if (process.env.NODE_ENV !== 'production') {
Teaser.propTypes = {
publisher: PropTypes.string,
author: PropTypes.string,
className: PropTypes.string,
classNameModifier: PropTypes.string,
itemType: PropTypes.string,
itemProp: PropTypes.string,
children: PropTypes.node,
};
}
|
search_result['1609']=["topic_00000000000003DD.html","tlece_PostVacancyVideos.UpdatedUtc Property",""];
|
const path = require('path');
module.exports = function(filename) {
return path.basename(filename, path.extname(filename));
}
|
function ChannelsCtrl($scope, apiService, UserData, $stateParams, startFromFilter) {
$scope.videos= [];
$scope.audios = [];
$scope.images = [];
$scope.channelStats = {};
$scope.playlists = [];
$scope.channelInfo = {};
$scope.numberOfThumbnailsToDisplay = 3;
$scope.isSubscribed = false;
$scope.init = function () {
apiService.apiCall(function(data, status) {
if(status == 200) {
$scope.channelInfo.username = data.username;
$scope.getUserSubscription();
$scope.getChannelStats();
$scope.getMultimedia();
$scope.getPlaylists();
$scope.updateViewCount();
} else {
}
}, 'GET', '/api/get-uploader-info', {id: $stateParams.id});
var initializeMediaPagingData = function() {
// hashes for each multimedia type to keep track of paging information
// videos hash
$scope.videosPagingHash = {
pageNumber: 1,
totalPages: Math.ceil($scope.videos.length / $scope.numberOfThumbnailsToDisplay),
startFrom: 0,
showPrevious: false,
showNext: ($scope.videos.length > $scope.numberOfThumbnailsToDisplay),
totalItems: $scope.videos.length
}
// images hash
$scope.imagesPagingHash = {
pageNumber: 1,
totalPages: Math.ceil($scope.images.length / $scope.numberOfThumbnailsToDisplay),
startFrom: 0,
showPrevious: false,
showNext: ($scope.images.length > $scope.numberOfThumbnailsToDisplay),
totalItems: $scope.images.length
}
// audio hash
$scope.audioPagingHash = {
pageNumber: 1,
totalPages: Math.ceil($scope.audios.length / $scope.numberOfThumbnailsToDisplay),
startFrom: 0,
showPrevious: false,
showNext: ($scope.audios.length > $scope.numberOfThumbnailsToDisplay),
totalItems: $scope.audios.length
}
};
var initializePlaylistPagingData = function() {
// playlist hash
$scope.playlistPagingHash = {
pageNumber: 1,
totalPages: Math.ceil($scope.playlists.length / $scope.numberOfThumbnailsToDisplay),
startFrom: 0,
showPrevious: false,
showNext: ($scope.playlists.length > $scope.numberOfThumbnailsToDisplay),
totalItems: $scope.playlists.length
}
}
$scope.getMultimedia = function () {
apiService.apiCall(function(data, status) {
if(status == 200) {
for(var i = 0; i < data.all_multimedia.length; i++) {
media = data.all_multimedia[i];
switch(media.mediaType) {
case 'video':
$scope.videos.push(media);
break;
case 'audio':
$scope.audios.push(media);
break;
case 'image':
$scope.images.push(media);
break;
}
initializeMediaPagingData();
}
} else {
}
}, 'GET', '/api/get-user-multimedia', {user_id: $stateParams.id});
};
$scope.getPlaylists = function () {
apiService.apiCall(function(data, status) {
if(status == 200) {
$scope.playlists = data.uploaded_playlists;
$scope.getPlaylistThumbnails();
}
}, 'GET', '/api/get-user-playlists', {user_id: $stateParams.id});
};
$scope.getPlaylistThumbnails = function() {
for(var i = 0; i < $scope.playlists.length; i++) {
//wrap call in function to save value of counter
(function (loopCounter) { apiService.apiCall(function(data,status){
if(status == 200) {
// load in default images if playlist is empty
if(data.thumbnail_media[0] === undefined) {
data.thumbnail_media[0] = {id: 0};
data.thumbnail_media[0].thumbnail_path = '/uploads/thumbnails/empty_playlist_thumbnail.png';
}
if(data.thumbnail_media[1] === undefined) {
data.thumbnail_media[1] = {id: 0};
data.thumbnail_media[1].thumbnail_path = '/uploads/thumbnails/empty_playlist_thumbnail.png';
}
$scope.playlists[loopCounter].media = data.thumbnail_media;
} else {
}
}, 'GET', '/api/get-playlist-thumbnails', {playlist_id: $scope.playlists[i].id});
})(i)
}
initializePlaylistPagingData();
};
$scope.getChannelStats = function() {
apiService.apiCall(function(data, status) {
if(status == 200) {
$scope.channelStats = data.channel_stats;
}
}, 'GET', '/api/get-channel-stats', {subscription_id: $stateParams.id});
};
$scope.getUserSubscription = function() {
apiService.apiCall(function(data,status) {
if(status == 200) {
$scope.isSubscribed = data.subscribed;
}
}, 'GET', '/api/is-user-subscribed', {user_id: UserData.userid, subscription_id: $stateParams.id});
};
$scope.updateViewCount = function() {
apiService.apiCall(function(data, status) {
if( status == 200) {} else {}
}, 'POST', '/api/update-channel-view-count', {subscription_id: $stateParams.id});
}
};
$scope.init();
//display previous 3 items in a multimedia array
$scope.previousPage = function(mediaHash){
if(mediaHash.showPrevious) {
mediaHash.pageNumber--;
if(mediaHash.pageNumber ==1){
mediaHash.showPrevious = false;
mediaHash.showNext = true;
}
mediaHash.startFrom = (mediaHash.pageNumber - 1) * $scope.numberOfThumbnailsToDisplay;
}
};
//display next 3 itms in multimedia array
$scope.nextPage = function(mediaHash){
if(mediaHash.showNext){
mediaHash.pageNumber++;
//see if another page is available
if(mediaHash.pageNumber == mediaHash.totalPages) {
mediaHash.showNext = false;
}
mediaHash.showPrevious = true;
mediaHash.startFrom = (mediaHash.pageNumber - 1) * $scope.numberOfThumbnailsToDisplay;
//make sure there are at least 3 to display
if(mediaHash.totalItems - mediaHash.startFrom < $scope.numberOfThumbnailsToDisplay ) {
mediaHash.startFrom--;
}
}
};
$scope.subscribe = function() {
apiService.apiCall(function(data, status) {
if(status == 200) {
$scope.isSubscribed = true;
}
}, 'POST', '/api/subscribe', {user_id: UserData.userid, subscription_id: $stateParams.id})
};
$scope.unsubscribe = function() {
apiService.apiCall(function(data, status) {
if(status == 200) {
$scope.isSubscribed = false;
}
}, 'POST', '/api/unsubscribe', {user_id: UserData.userid, subscription_id: $stateParams.id});
};
}
ChannelsCtrl.$inject = ['$scope', 'apiService', 'UserData', '$stateParams', 'startFromFilter'];
|
import EmberObject from '@ember/object';
import FooMixin from 'my-app/mixins/foo';
import { module, test } from 'qunit';
module('Unit | Mixin | foo', function () {
// TODO: Replace this with your real tests.
test('it works', function (assert) {
let FooObject = EmberObject.extend(FooMixin);
let subject = FooObject.create();
assert.ok(subject);
});
});
|
'use strict';
const url = require('url');
const qs = require('querystring');
const request = require('request');
const crypto = require('crypto');
var sortNumber = function (a,b) {
return a - b;
}
module.exports = {
getDorm: function(payload) {
console.log("in dorm " + payload);
switch (payload.toLowerCase())
{
case "111 brown st":
case "111 brown st.":
case "111 brown street" :
return 1429213;
case "125-127 waterman street":
case "125 waterman street":
case "127 waterman street":
case "125 127 waterman street":
case "125-127 waterman st":
case "125 waterman st":
case "127 waterman st":
case "125 127 waterman st.":
case "125-127 waterman st.":
case "125 waterman st.":
case "127 waterman st.":
case "125 127 waterman st." :
return 1429265;
case "315 thayer st":
case "315 thayer st.":
case "315 thayer street" :
return 1429240;
case "andrews e":
case "andrews east" :
return 4292350;
case "andrews west":
case "andrews w" :
return 1429250;
case "archibald-bronson":
case "archibald":
case "bronson":
case "archibald bronson":
return 1429212;
case "barbour apts":
case "barbour":
case "barbour apartments" :
return 1429231;
case "buxton house":
case "buxton" :
return 1429215;
case "caswell middle":
case "middle caswell hall" :
case "middle caswell":
return 1429216;
case "caswell north":
case "north caswell" :
case "north caswell hall" :
return 1429253;
case "champlin" :
case "champlin hall":
return 1429217;
case "chapin house":
case "chapin" :
return 1429218;
case "diman house rm028" :
case "diman rm028" :
case "diman 28" :
case "diman room 28":
return 142927;
case "diman house rm106" :
case "diman rm106":
case "diman 106" :
case "diman house 106" :
return 1429249;
case "everett-poland rme243" :
case "everett-poland 243":
case "everett poland 243" :
case "everett-poland room 243":
case "everett poland room 243" :
return 1429251;
case "everett-poland-rme166" :
case "everett-poland 166" :
case "everett poland 166" :
case "everett-poland room 166" :
case "everett poland room 166" :
return 1429267;
case "goddard house rm018" :
case "goddard house 18" :
case "goddard house room 18" :
case "goddard room 18" :
return 142928;
case "goddard house rm130" :
case "goddard house 130" :
case "goddard house 130" :
case "goddard house room 130" :
case "goddard room 130" :
return 142922;
case "grad center a":
case "grad a" :
return 1429221;
case "grad center b":
case "grad b" :
return 1429222;
case "grad center c":
case "grad c" :
return 1429220;
case "grad center d":
case "grad d" :
return 1429223;
case "harkness house rm023" :
case "harkness house 23" :
case "harkness 23" :
case "harkness room 23" :
case "harkness house room 23" :
return 142929;
case "harkness house rm106" :
case "harkness house 106" :
case "harkness house room 106" :
case "harkness room 106" :
case "harkness 106" :
return 1429245;
case "hedgeman" :
case "hegeman":
case "hedgeman a" :
case "hedgeman b" :
case "hedgeman c" :
case "hedgeman d" :
case "hedgeman e" :
return 1429224;
case "hope college" :
case "hope college" :
case "hope" :
return 1429225;
case "jamison-mead":
case "jamison mead":
case "jamison":
case "mead":
return 1429246;
case "king house":
case "king" :
return 1429226;
case "littlefield hall" :
case "littlefield" :
return 1429227;
case "machado house" :
case "machado" :
return 1429237;
case "marcy" :
case "marcy house" :
return 1429210;
case "metcalf hall" :
case "metcalf" :
return 1429229;
case "miller hall":
case "miller" :
return 1429230;
case "minden hall":
case "minden" :
return 1429257;
case "morriss 211a":
case "morriss 211" :
case "morriss room 211a":
case "morriss room 211" :
return 1429254;
case "morriss 311a" :
case "morriss 311" :
case "morriss room 311a" :
case "morriss room 311" :
return 1429255;
case "morriss 411a" :
case "morriss 411" :
case "morriss room 411a" :
case "morriss room 411" :
return 1429256;
case "new pembroke 2":
case "pembroke 2":
case "new pembroke 2 0":
case "pembroke 2 0" :
case "new pembroke 2 room 0":
case "pembroke 2 room 0" :
return 1429232;
case "new pembroke 3 0" :
case "pembroke 3 0" :
case "new pembroke 3 room 0" :
case "pembroke 3 room 0" :
return 1429233;
case "pembroke 3 20":
case "new pembroke 3 20" :
case "pembroke 3 room 20":
case "new pembroke 3 room 20" :
return 1429252;
case "new pembroke 4":
case "pembroke 4" :
case "new pembroke 4 117":
case "pembroke 4 117" :
case "new pembroke 4 room 117":
case "pembroke 4 room 117" :
return 1429234;
case "olney":
case "olney house" :
return 1429211;
case "perkins" :
case "perkins hall" :
case "perk" :
return 1429235;
case "plantations house":
case "plantations":
case "plantations house" :
return 1429236;
case "sears house 23" :
case "sears 23" :
case "sears house room 23" :
case "sears room 23" :
return 1429238;
case "sears house 106" :
case "sears 106" :
case "sears house room 106" :
case "sears room 106" :
return 1429263;
case "slater hall" :
case "slater":
return 1429239;
case "vgqa rm001" :
return 1429247;
case "vgqa rm007" :
return 1429288;
case "wayland house":
case "wayland" :
return 1429241;
case "west house":
case "west" :
return 1429214;
case "woolley 101a":
case "woolley 101" :
case "woolley 1" :
case "woolley room 101a":
case "woolley room 101" :
return 1429219;
case "woolley 201a" :
case "woolley 201":
case "woolley 2" :
case "woolley room 201a" :
case "woolley room 201":
return 1429258;
case "woolley 301" :
case "woolley 301a":
case "woolley 3" :
case "woolley room 301" :
case "woolley room 301a":
return 1429259;
case "woolley 401a":
case "woolley 401" :
case "woolley 4" :
case "woolley room 401a":
case "woolley room 401":
return 1429260;
case "yo10":
case "young o 10":
case "young orchard 10" :
return 1429242;
case "young orchard 2":
case "yo2":
case "young o 2" :
return 1429243;
case "yo4":
case "young o 4":
case "young orchard 4" :
return 1429244;
default:
return 0;
}
},
getLaundryInfo: function(dormId, cb) {
if (!cb) cb = Function.prototype;
request({
method: 'GET',
uri: `https://api.students.brown.edu/laundry/rooms/${dormId}/machines?client_id=${process.env.BROWN_API}&get_status=true`,
json: true
}, (err, res, body) => {
if (err) return cb(err)
if (body.error) return cb(body.error)
cb(null, body)
})
},
parseLaundry: function(laundryObject) {
console.log("preParse " + JSON.stringify(laundryObject));
console.log("type " + typeof(laundryObject));
var information = JSON.parse((JSON.stringify(laundryObject)));
var laundryOpen = [];
var dryerOpen = [];
for (var i in information.results) {
if ((information.results[i].avail === true))
if (information.results[i].type == "washFL")
laundryOpen.push(information.results[i].id);
if( (information.results[i].type == "dblDry") || (information.results[i].type == "dry"))
dryerOpen.push(information.results[i].id);
}
return "Washers " + laundryOpen.sort(sortNumber) + " are available. Dryers " + dryerOpen.sort(sortNumber) + " are available.";
}
};
|
'use strict'
import AudioAssetType from 'rpgmv-asset-manager-core/datas/audio-asset-type';
import path from 'path';
import fs from 'fs-extra';
/**
* Asset Manager MV
* 効果音アセットタイプデータ
*
* @since 2015/12/29
* @author RaTTiE
*/
export default class SEAssetType extends AudioAssetType {
/**
* コンストラクタ。
*/
constructor() {
super();
this.nameCode = 'asset.type.se';
this.path = 'audio/se';
}
/** クラス名 */
get className() {
return 'SEAssetType';
}
/**
* オブジェクトのシリアライズ処理。
*
* @return シリアライズしたオブジェクトデータ。
*/
serialize() {
var ret = super.serialize();
ret.className = 'SEAssetType';
return ret;
}
/**
* アセットタイプに該当する解析対象の一覧を取得する。
*
* @param projectPath プロジェクトパス。
*
* @return 解析対象の一覧。
*/
getAnalyseTargets(projectPath) {
var targets = super.getAnalyseTargets(projectPath);
targets.push({ type: 'SystemData', name:'System.json'});
targets.push({ type: 'AnimationData', name: 'Animations.json' });
this.pushMapAnalyseTargets(targets, projectPath);
targets.push({ type: 'CommonEventData', name: 'CommonEvents.json' });
return targets;
}
/**
* アセットの解析処理を実行する。
*
* @param target 解析対象情報。
* @param projectPath プロジェクトパス。
*/
analyse(target, projectPath) {
switch (target.type) {
case 'SystemData':
return this.analyseSingleDatabase(target, projectPath, this.analyseSystemData);
case 'AnimationData':
return this.analyseArrayDatabase(target, projectPath, this.analyseAnimationData);
case 'MapData':
return this.analyseSingleDatabase(target, projectPath, this.analyseMapData);
case 'CommonEventData':
return this.analyseCommonEvent(target, projectPath, this.analyseEventCommand);
case 'TroopData':
return this.analyseBattleEvent(target, projectPath, this.analyseEventCommand);
default:
return super.analyse(target, projectPath);
}
}
/**
* システムデータの解析処理を実行する。
*
* @param usingAssets 使用アセット一覧の配列。
* @param jsonData データベースのレコードデータ。
*/
analyseSystemData(usingAssets, jsonData) {
for (var i = 0; i < jsonData.sounds.length; i++) {
var sound = jsonData.sounds[i];
if (sound && sound.name && usingAssets.indexOf(sound.name) < 0) {
usingAssets.push(sound.name);
}
}
}
/**
* アニメーションデータの解析処理を実行する。
*
* @param usingAssets 使用アセット一覧の配列。
* @param jsonData データベースのレコードデータ。
*/
analyseAnimationData(usingAssets, jsonData) {
for (var i = 0; i < jsonData.timings.length; i++) {
var timing = jsonData.timings[i];
if (timing.se && timing.se.name && usingAssets.indexOf(timing.se.name) < 0) {
usingAssets.push(timing.se.name);
}
}
}
/**
* マップデータの解析処理を実行する。
*
* @param usingAssets 使用アセット一覧の配列。
* @param jsonData データベースのレコードデータ。
*/
analyseMapData(usingAssets, jsonData) {
this.analyseMapEvent(usingAssets, jsonData, this.analyseEventCommand);
}
/**
* イベントコマンドの解析処理を実行する。
*
* @param usingAssets 使用アセット一覧の配列。
* @param commandData イベントコマンドデータ。
*/
analyseEventCommand(usingAssets, commandData) {
switch (commandData.code) {
case 250:
if (commandData.parameters[0] && commandData.parameters[0].name && usingAssets.indexOf(commandData.parameters[0].name) < 0) {
usingAssets.push(commandData.parameters[0].name);
}
break;
}
}
}
|
var request = require('request');
var crypto = require('crypto');
var config = require('./config.js');
function Mail() {
this.appid = config.mailConfig.appid;
this.signtype = config.mailConfig.signtype;
this.appkey = config.mailConfig.appkey;
this.send = function(params) {
console.log(params);
var api = 'https://api.submail.cn/mail/send.json';
var requestParams = params;
requestParams['appid'] = this.appid;
var self = this;
request({
uri: 'https://api.submail.cn/service/timestamp.json',
method: 'GET'
}, function(error, response, body) {
var result = JSON.parse(body);
requestParams['timestamp'] = result["timestamp"];
requestParams['sign_type'] = self.signtype;
console.log(self.signtype);
requestParams['signature'] = self.createSignature(requestParams);
request.post({url: api, formData: requestParams}, function optionalCallback(err, httpResponse, body) {
if (err) {
return console.error('upload failed:', err);
}
console.log('Upload successful! Server responded with:', body);
});
});
};
this.xsend = function(params) {
console.log(params);
var api = 'https://api.submail.cn/mail/xsend.json';
var requestParams = params;
requestParams['appid'] = this.appid;
var self = this;
request({
uri: 'https://api.submail.cn/service/timestamp.json',
method: 'GET'
}, function(error, response, body) {
var result = JSON.parse(body);
requestParams['timestamp'] = result["timestamp"];
requestParams['sign_type'] = self.signtype;
console.log(self.signtype);
requestParams['signature'] = self.createSignature(requestParams);
request.post({url: api, formData: requestParams}, function optionalCallback(err, httpResponse, body) {
if (err) {
return console.error('upload failed:', err);
}
console.log('Upload successful! Server responded with:', body);
});
});
};
this.subscribe = function(params) {
console.log(params);
var api = 'https://api.submail.cn/addressbook/mail/subscribe.json';
var requestParams = params;
requestParams['appid'] = this.appid;
var self = this;
request({
uri: 'https://api.submail.cn/service/timestamp.json',
method: 'GET'
}, function(error, response, body) {
var result = JSON.parse(body);
requestParams['timestamp'] = result["timestamp"];
requestParams['sign_type'] = self.signtype;
console.log(self.signtype);
requestParams['signature'] = self.createSignature(requestParams);
request.post({url: api, formData: requestParams}, function optionalCallback(err, httpResponse, body) {
if (err) {
return console.error('upload failed:', err);
}
console.log('Upload successful! Server responded with:', body);
});
});
};
this.unsubscribe = function(params) {
console.log(params);
var api = 'https://api.submail.cn/addressbook/mail/unsubscribe.json';
var requestParams = params;
requestParams['appid'] = this.appid;
var self = this;
request({
uri: 'https://api.submail.cn/service/timestamp.json',
method: 'GET'
}, function(error, response, body) {
var result = JSON.parse(body);
requestParams['timestamp'] = result["timestamp"];
requestParams['sign_type'] = self.signtype;
console.log(self.signtype);
requestParams['signature'] = self.createSignature(requestParams);
request.post({url: api, formData: requestParams}, function optionalCallback(err, httpResponse, body) {
if (err) {
return console.error('upload failed:', err);
}
console.log('Upload successful! Server responded with:', body);
});
});
};
this.createSignature = function(params) {
if (this.signtype == 'normal') {
return this.appkey;
} else {
return this.buildSignature(params);
}
};
this.buildSignature = function(params) {
var sortedParams = this.sortOnKeys(params);
var signStr = "";
for(var key in sortedParams) {
signStr += key + '=' + sortedParams[key] + '&';
}
signStr = signStr.substring(0, signStr.length-1);
signStr = this.appid + this.appkey + signStr + this.appid + this.appkey;
if (this.signtype == 'md5') {
var md5sum = crypto.createHash('md5');
md5sum.update(signStr);
return md5sum.digest('hex');
}
if (this.signtype == 'sha1') {
var sha1sum = crypto.createHash('sha1');
sha1sum.update(signStr);
return sha1sum.digest('hex');
}
return '';
};
this.sortOnKeys = function(dict) {
var sorted = [];
for(var key in dict) {
if (key == 'attachments') {
continue;
}
sorted[sorted.length] = key;
}
sorted.sort();
var tempDict = {};
for(var i = 0; i < sorted.length; i++) {
tempDict[sorted[i]] = dict[sorted[i]];
}
return tempDict;
};
};
module.exports = Mail;
|
var express = require('express');
var path = require('path');
var ws = require('ws');
var DevToolsBackend = require('./backend');
var app = module.exports = express();
app.setupWebSocketServer = function(httpServer) {
var wsServer = ws.createServer({
server: httpServer,
path: app.path() + '/ws'
});
wsServer.on('connection', function onConnection(socket) {
new DevToolsBackend().serve(socket);
});
wsServer.on('error', function onError(err) {
console.warn('**warn** WebSocketServer error', err);
});
};
app.use(express.static(projectPath('custom')));
app.use(express.static(projectPath('prefixed')));
app.use(express.static(projectPath('frontend'), { index: 'inspector.html' }));
function projectPath() {
var args = Array.prototype.slice.call(arguments);
args.unshift('..');
args.unshift(__dirname);
return path.resolve.apply(path, args);
}
|
var Promise = require('bluebird')
var error = require('./error.js')
module.exports = doClose
function doClose(streamState) {
streamState.writablePromise._reject(
new Error('stream has been closed'))
// NON STANDARD - do not wrap onClose in try catch
// that's bullshit, if it needs to do error handling
// then pass this.[[error]] in as an argument
var closeResult = Promise.cast(streamState.onClose())
closeResult.then(onFulfill, onReject)
return streamState.closedPromise
function onFulfill() {
streamState.state = 'closed'
streamState.closedPromise._fulfill(undefined)
}
function onReject(err) {
error(streamState, err)
}
}
|
var levels = [screenStart,
level1_1, level1_2, level2_1,
screenEasy,
level2_2, level2_3, level2_4, level2_5,
screenTricky,
level3_1, level3_2, level3_3, level3_4,
screenWin, screenCredits,
levelbonus_1,
screenEnd];
var GameState = function(game){};
GameState.prototype.preload = function() {
};
function loadSolution(level) {
var solution = [];
if (level.solution !== undefined) {
var i;
for (i = 0; i < level.solution[0].length; i++) {
solution.push([]);
}
for (var row = 0; row < level.solution.length; row++) {
for (i = 0; i < level.solution[row].length; i++) {
var ch = level.solution[row].charAt(i);
if (ch !== " ") {
solution[i].push(level[ch].drum);
}
}
}
}
return solution;
}
GameState.prototype.addSolutionDrums = function(level) {
this.solutionBg.removeAll(true);
this.correctSolutionDrums.removeAll(true);
this.solutionRows = 1;
var i;
for (i = 0; i < this.correctSolution.length; i++) {
this.solutionRows = Math.max(this.solutionRows, this.correctSolution[i].length);
}
// Display background - big enough for solution plus one row
var sRect = getSolutionRect(this.solutionRows,
this.correctSolution.length);
var left = (GRID_SIZE - this.correctSolution.length) / 2;
var bg = this.solutionBg.add(new Phaser.Sprite(this.game,
sRect.x, sRect.y,
'black'));
bg.width = sRect.width;
bg.height = sRect.height;
// Add checkerboard to solution too
// Create checkerboard background
for (i = 0; i < this.correctSolution.length; i++) {
for (var j = 0; j < this.solutionRows + 1; j++) {
if (((i % 2) === 0) ^ ((j % 2) === 0)) {
var pixel = g2p({
x: left + i,
y: GRID_SIZE - this.solutionRows - 1 + j});
var check = this.solutionBg.add(
new Phaser.Sprite(this.game,
pixel.x, pixel.y,
'black2'));
check.width = PIXEL_SIZE;
check.height = PIXEL_SIZE;
}
}
}
if (level.solution !== undefined) {
for (var row = 0; row < level.solution.length; row++) {
var y = GRID_SIZE - this.solutionRows + row;
for (i = 0; i < level.solution[row].length; i++) {
var x = left + i;
var ch = level.solution[row].charAt(i);
if (ch !== " ") {
this.correctSolutionDrums.add(new Drum(this,
{x:x, y:y}, level[ch].drum,
null, null, null));
}
}
}
}
};
GameState.prototype.loadLevel = function(level) {
// Reset everything
this.solutionBg.removeAll(true);
this.correctSolutionDrums.removeAll(true);
this.solutionBeats.removeAll(true);
this.solutionDrums.removeAll(true);
this.beats.removeAll(true);
this.drums.removeAll(true);
this.indicators.removeAll(true);
this.draggedDrum = null;
this.solution = [];
this.correctSolution = [[]];
this.solutionRows = 1;
this.solutionBeat = 0;
this.BPM = 120;
// Load solution
if (level.solution !== undefined) {
this.correctSolution = loadSolution(level);
}
// Add pseudo-drums to display the solution
this.addSolutionDrums(level);
// Load the level
for (var y = 0; y < GRID_SIZE; y++) {
var row = level.cells[y];
for (var x = 0; x < GRID_SIZE; x++) {
var ch = row.charAt(x);
if (ch !== " ") {
var drumdef = level[ch].drum;
var bounce = null;
if (level[ch].bounce !== undefined) {
bounce = dir2vel(level[ch].bounce);
}
var beats = null;
if (level[ch].beat !== undefined) {
beats = [];
for (var i = 0; i < level[ch].beat.length; i++) {
var dir = level[ch].beat[i];
beats.push(dir2vel(dir));
}
}
this.drums.add(new Drum(this,
{x:x, y:y}, drumdef,
bounce, beats, level[ch].period));
}
}
}
this.solutionBeat = 0;
this.hasWon = false;
this.alwaysWin = level.alwaysWin;
if (level.BPM !== undefined) {
this.BPM = level.BPM;
}
};
GameState.prototype.create = function() {
this.game.stage.backgroundColor = 0x333333;
this.sounds = {
win: this.game.add.audio("yeah"),
newLevel: this.game.add.audio("mmhmm"),
rollover: this.game.add.audio("rollover"),
move: this.game.add.audio("move"),
place: this.game.add.audio("place")
};
this.timeAccumMS = 0;
this.bg = this.game.add.group();
this.solutionBg = this.game.add.group();
this.correctSolutionDrums = this.game.add.group();
this.solutionBeats = this.game.add.group();
this.solutionDrums = this.game.add.group();
this.indicators = this.game.add.group();
this.beats = this.game.add.group();
this.drums = this.game.add.group();
this.draggedDrum = null;
this.solution = [];
this.playAnyway = false;
// Create checkerboard background
for (var i = 0; i < GRID_SIZE; i++) {
for (var j = 0; j < GRID_SIZE; j++) {
if (((i % 2) === 0) ^ ((j % 2) === 0)) {
var pixel = g2p({x: i, y: j});
var check = this.bg.add(new Phaser.Sprite(this.game,
pixel.x, pixel.y,
'bg'));
check.width = PIXEL_SIZE;
check.height = PIXEL_SIZE;
}
}
}
// FPS timer
// Turn off in prod
/*this.game.time.advancedTiming = true;
this.fpsText = this.game.add.text(
20, 20, '', { font: '16px Arial', fill: '#ffffff' }
);*/
this.levelIndex = 0;
this.loadLevel(levels[this.levelIndex]);
};
GameState.prototype.dragAndInput = function() {
var getDrumAt = function(drums, grid) {
for (var i = 0; i < drums.length; i++) {
var drum = drums.getAt(i);
var drumGrid = p2g(drum);
if (drumGrid.x == grid.x &&
drumGrid.y == grid.y) {
return drum;
}
}
return null;
};
// Mouse overs: drum or solution
var mouseGrid = p2g(this.game.input);
var drum = getDrumAt(this.drums, mouseGrid);
// Can't drag drums that make beats
var canDragDrum = drum !== null && drum.beatDirs === null;
var sRect = getSolutionRect(this.solutionRows,
this.correctSolution.length);
var isOverSolution =
this.game.input.x >= sRect.x &&
this.game.input.x < sRect.x + sRect.width &&
this.game.input.y >= sRect.y &&
this.game.input.y < sRect.y + sRect.height;
if (canDragDrum || isOverSolution) {
this.game.canvas.style.cursor = "pointer";
} else {
this.game.canvas.style.cursor = "default";
}
if (this.solutionBeats.length === 0) {
if (this.game.input.activePointer.isDown) {
// Check if this is a solution click; if so add beats
if (isOverSolution &&
this.solutionBeats.length === 0) {
var dir = {x: 1, y: 0};
for (i = 0; i < this.solutionRows; i++) {
var pos = {
x: sRect.x,
y: (GRID_SIZE - this.solutionRows + i) * PIXEL_SIZE};
this.solutionBeats.add(new Beat(this.game, pos, dir));
}
this.playAnyway = true;
}
this.rolloverDrum = null;
mouseGrid = p2g(this.game.input);
// Find the drum under the mouse
if (this.draggedDrum === null) {
if (canDragDrum) {
this.draggedDrum = drum;
this.sounds.move.play();
}
}
if (this.draggedDrum) {
// Move drum around
if (getDrumAt(this.drums, mouseGrid) === null) {
var pixel = g2p(mouseGrid);
if (this.draggedDrum.x !== pixel.x || this.draggedDrum.y !== pixel.y) {
this.sounds.rollover.play();
}
this.draggedDrum.x = pixel.x;
this.draggedDrum.y = pixel.y;
}
}
} else {
if (this.draggedDrum !== null) {
this.sounds.place.play();
}
this.draggedDrum = null;
mouseGrid = p2g(this.game.input);
// play rollover sound if mouse over a drum
drum = getDrumAt(this.drums, mouseGrid);
// Can't drag drums that make beats
if (drum !== null && drum.beatDirs === null && drum !== this.rolloverDrum) {
this.sounds.rollover.play();
drum.beatLast = 0;
}
this.rolloverDrum = drum;
}
}
};
GameState.prototype.moveTheBeat = function(beats, drums) {
this.timeAccumMS += this.game.time.elapsedMS;
if (this.timeAccumMS > msPerMinibeat(this.BPM)) {
this.timeAccumMS = this.timeAccumMS % msPerMinibeat(this.BPM);
if (this.solutionBeat === 0) {
this.solutionDrums.removeAll(true);
}
var i;
for (i = 0; i < beats.length; i++) {
beats.getAt(i).updateBeat();
}
for (i = 0; i < drums.length; i++) {
var drum = drums.getAt(i);
drum.updateBeat();
}
return true;
}
return false;
};
GameState.prototype.moveBeatAndHitDrums = function(beats, drums) {
if (this.moveTheBeat(beats, drums) || this.playAnyway) {
var i;
var drum;
// Check collisions between beats and drums
// Activate drums that collide with beats
for (i = 0; i < drums.length; i++) {
drum = drums.getAt(i);
var drumGrid = p2g(drum);
for (var j = 0; j < beats.length; j++) {
var beat = beats.getAt(j);
var beatGrid = p2g(beat);
if (drumGrid.x == beatGrid.x && drumGrid.y == beatGrid.y) {
drum.hit = true;
// Check if this is a bouncy drum
// Change the beat direction
if (drum.bounceDir !== null) {
beat.vel = drum.bounceDir;
}
break;
}
}
}
// Hit drums that have been hit with beats, or beat themselves
for (i = 0; i < drums.length; i++) {
drum = drums.getAt(i);
if (drum.hit) {
drum.play(this.timeAccumMS);
}
}
this.playAnyway = false;
return true;
}
return false;
};
GameState.prototype.win = function() {
this.game.canvas.style.cursor = "pointer";
this.sounds.win.play('', 0, 0.3);
this.hasWon = true;
// Add win squares all around
var solutionXMin = Math.floor((GRID_SIZE - this.correctSolution.length) / 2);
var solutionXMax = solutionXMin + this.correctSolution.length;
for (var x = 0; x < GRID_SIZE; x++) {
for (var y = 0; y < GRID_SIZE; y++) {
if (x === 0 || y === 0 || x === GRID_SIZE - 1 ||
(y === GRID_SIZE - 1 && (x < solutionXMin || x >= solutionXMax))) {
var pixel = g2p({x:x, y:y});
var sd = this.solutionDrums.add(new Phaser.Sprite(
this.game, pixel.x, pixel.y, 'good'));
sd.width = PIXEL_SIZE;
sd.height = PIXEL_SIZE;
}
}
}
};
GameState.prototype.update = function() {
// Update FPS
/*if (this.game.time.fps !== 0) {
this.fpsText.setText(this.game.time.fps + ' FPS');
}*/
if (!this.hasWon) {
this.dragAndInput();
// If we're listening to solution, update those beats only
if (this.solutionBeats.length !== 0) {
this.moveBeatAndHitDrums(this.solutionBeats,
this.correctSolutionDrums);
// Special for solution:
// destroy beats if they are outside solution area
var sRect = getSolutionRect(this.solutionRows,
this.correctSolution.length);
if (this.solutionBeats.getAt(0).x >= sRect.x + sRect.width) {
this.solutionBeats.removeAll(true);
}
} else {
if (this.moveBeatAndHitDrums(this.beats, this.drums)) {
var i;
var j;
// Check solution too
var beats = [];
for (i = 0; i < this.drums.length; i++) {
drum = this.drums.getAt(i);
if (drum.hit) {
beats.push(drum.name);
}
}
// Add the drums beaten this beat
this.solution.push(beats);
// Check our solution so far
var ourBeats = this.solution[this.solutionBeat].sort();
var correctBeats = [];
var isCorrect = true;
for (j = 0; j < this.correctSolution[this.solutionBeat].length; j++) {
correctBeats.push(this.correctSolution[this.solutionBeat][j].basename);
}
correctBeats = correctBeats.sort();
if (ourBeats.length != correctBeats.length) {
isCorrect = false;
} else {
for (j = 0; j < correctBeats.length; j++) {
if (ourBeats[j] != correctBeats[j]) {
isCorrect = false;
}
}
}
// Add a sprite showing whether these beats are correct
var x = (GRID_SIZE - this.correctSolution.length) / 2 + this.solutionBeat;
var y = GRID_SIZE - this.solutionRows - 1;
var pixel = g2p({x:x, y:y});
var sd = this.solutionDrums.add(new Phaser.Sprite(
this.game, pixel.x, pixel.y, isCorrect ? 'good' : 'bad'));
sd.width = PIXEL_SIZE;
sd.height = PIXEL_SIZE;
if (!isCorrect) {
this.isCorrect = false;
}
this.solutionBeat++;
if (this.solutionBeat == this.correctSolution.length) {
if (this.alwaysWin) {
this.isCorrect = true;
}
if (this.isCorrect && !this.hasWon) {
this.win();
} else {
this.solution = [];
this.isCorrect = true;
this.solutionBeat = 0;
}
}
}
}
} else {
// keep the beat
this.moveBeatAndHitDrums(this.beats, this.drums);
// Move to next level
if (this.game.input.activePointer.justPressed()) {
this.levelIndex++;
console.log("Loading level " + this.levelIndex);
this.loadLevel(levels[this.levelIndex]);
this.sounds.newLevel.play('', 0, 0.3);
}
}
};
|
export default from './ChartMonitor';
|
/** _
* _ _ _| |_
* | | | |_ _|
* | |___ _ _ | | |_|
* | '_ \| | | || | | |
* | | | || |_| || | | |
* |_| |_|\___,_||_| |_|
*
* (c) Huli Inc
*/
/**
* Example controller that loads a component
open in your browser: http[s]://[your-app]/#index
*
*
* WARNING : proof of concept only, not a "good practices" guideline
* however, explanatory comments are reliable :p
*/
define([
'ju-mvc/controller',
'ju-example/modules/nihao-components/nihao-component'
],
function (
Controller,
NihaoComponent
) {
'use strict';
/**
* Handles routing to display a component
*
* The only requirement is to set the member `this.landCompClass`
* with a component definition (i.e. a class that extends component/base)
*/
var ControllerWithComponent = Controller.extend({
/*
init : function() {
this._super.apply(this);
this.landCompClass = NihaoComponent;
},
*/
/**
* Must be implemented in child classes
*/
handleRoute : function (alreadyInStack, routerParams, urlParams) {
this._super(alreadyInStack, routerParams, urlParams);
this.load.apply(this, urlParams);
},
setComponentClass : function (ComponentClass) {
this.ComponentClass = ComponentClass;
},
load : function () {
var $content = $("<div class='component-content'><div>Nihao Ju!</div><div>Pura vida Ju!</div><div>Hello Ju!</div><br/></div>");
this.setContent($content);
var ComponentClass = this.ComponentClass || NihaoComponent;
this.landCompInst = new ComponentClass();
this.landCompInst.isRootComponent = true;
this.landCompInst.load.apply(this.landCompInst, $.merge([$content], arguments));
}
});
return ControllerWithComponent;
});
|
app.directive("widgetweather",function(){
return{
restrict : "E",
replace : true,
scope: {},
templateUrl: "./app/widgets/widgetWeather/widgetWeatherView.html",
controller: 'widgetWeatherController'
}
});
|
import xs from 'xstream'
import streamAdapter from '@cycle/xstream-adapter'
import {mockDOMSource} from '@cycle/dom'
import delay from 'xstream/extra/delay'
import tween from 'xstream/extra/tween'
import fromDiagram from 'xstream/extra/fromDiagram'
import {assert} from 'chai'
import {prop} from 'ramda'
import intent from '../src/input/intent'
import model from '../src/input/model'
const assertion = (stream, fn, expected, done) => stream.addListener({
next: x => {
try {
fn(x, expected)
done && done()
} catch(error) {
done && done(error)
}
},
error: err => done ? done(err) : console.error(err),
complete: () => {}
})
const testInput = ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
describe('cycle-input', _ => {
describe('intent', _ => {
const domSource = mockDOMSource(streamAdapter, {
'.cycle-input': {
'input': xs.fromArray(testInput.map(val => ({ target: { value: val } })))
}
})
const actions = intent({DOM: domSource})
it('should return a stream of "h"', function(done) {
assertion(actions.input$.take(1), assert.strictEqual, 'h', done)
})
it('should return a stream of "e"', function(done) {
assertion(actions.input$.drop(1).take(1), assert.strictEqual, 'e', done)
})
it('should return a stream of "l"', function(done) {
assertion(actions.input$.drop(2).take(1), assert.strictEqual, 'l', done)
})
it('should return a stream of "l"', function(done) {
assertion(actions.input$.drop(3).take(1), assert.strictEqual, 'l', done)
})
it('should return a stream of "o"', function(done) {
assertion(actions.input$.drop(4).take(1), assert.strictEqual, 'o', done)
})
it('should return a stream of " "', function(done) {
assertion(actions.input$.drop(5).take(1), assert.strictEqual, ' ', done)
})
it('should return a stream of "w"', function(done) {
assertion(actions.input$.drop(6).take(1), assert.strictEqual, 'w', done)
})
it('should return a stream of "o"', function(done) {
assertion(actions.input$.drop(7).take(1), assert.strictEqual, 'o', done)
})
it('should return a stream of "r"', function(done) {
assertion(actions.input$.drop(8).take(1), assert.strictEqual, 'r', done)
})
it('should return a stream of "l"', function(done) {
assertion(actions.input$.drop(9).take(1), assert.strictEqual, 'l', done)
})
it('should return a stream of "d"', function(done) {
assertion(actions.input$.drop(10).take(1), assert.strictEqual, 'd', done)
})
})
describe('model', _ => {
const props = {
value: 'test',
placeholder: 'Placeholder',
visible: true,
duration: 1000,
className: 'hello',
easing: tween.linear.ease
}
const props$ = xs.of(props)
const state$ = model(props$, {input$: xs.empty()})
it('should return the initial value', function(done) {
const test$ = state$.map(prop('value'))
assertion(test$, assert.strictEqual, 'test', done)
})
it('should return the Placeholder', function(done) {
const test$ = state$.map(prop('placeholder'))
assertion(test$, assert.strictEqual, 'Placeholder', done)
})
it('should return "hello"', function(done) {
const test$ = state$.map(prop('className'))
assertion(test$, assert.strictEqual, 'hello', done)
})
it('should return transition: 100', function(done) {
const test$ = state$.map(prop('transition'))
assertion(test$, assert.strictEqual, 100, done)
})
})
})
|
/**
* This is a base class that stores common methods for both client & server implementation.
* It acts as a interface to the CustomProtocolCore class where the main logic happens.
*
* @abstract
* @category INTERNALS
* @type {CustomProtocolCommon}
*/
CustomProtocolCommon = class CustomProtocolCommon {
constructor() {
this._messages = [];
this._typeFieldName = null;
this._typeObject = {};
/**
* There are two types of protocols. Those with messages declared explicitly in the class
* constructor and those which allow to register messages dynamically at any time.
*
* @enum {number}
*/
this.protocolTypes = {
DECLARED_MESSAGES: 1,
DYNAMIC_MESSAGES: 2
};
this._options = {
messagesDefinition: this.protocolTypes.DECLARED_MESSAGES
};
}
/**
* For protocols with dynamic messages sets the field name that holds the message type.
*
* @param {string} name - Name of the field in the message object.
*/
setTypeFieldName(name) {
this._typeFieldName = name;
this._typeObject = {};
this._typeObject[name] = '';
}
/**
* Registers the protocol in core class.
*
* @param {string} name - Class name of the protocol.
* @param {Object} options - An object with the protocol config.
*/
registerProtocol(name, options = {}) {
if (!CustomProtocolsIndex[name]) {
throw new Error(`Protocol ${name} did not receive unique id. Check if the file name is `
+ 'in format `<name>.protocol.js` so that the indexer can assign an id to it.');
}
this._id = CustomProtocolsIndex[name].id;
if (this._id > 127) {
throw new Error('Custom protocol must have an this._id lower than 127');
}
_.extend(this._options, options);
CustomProtocolCore.registerProtocol(this._id, this._options, this);
this.registerMessages();
if (
options &&
options.messagesDefinition === this.protocolTypes.DYNAMIC_MESSAGES
) {
this.registerMessage(0);
}
}
/**
* Registers all the declared messages and their definitions in core class.
*/
registerMessages() {
if (this._messages.length > 0) {
// noinspection JSAnnotator
for (const [messageId, definition] of this._messages.entries()) {
if (definition !== undefined) {
CustomProtocolCore.registerMessage(this._id, messageId, definition);
}
}
}
}
/**
* Registers a single message.
*
* @param {number} messageId - Unique id of the message.
* @param {Object} definition - Object with the message definition.
*/
registerMessage(messageId, definition = {}) {
CustomProtocolCore.registerMessage(this._id, messageId, definition);
}
/**
* Registers a callback for a specified message.
*
* @param {number} messageId - Id of the message.
* @param {callback} callback - Function that will receive the message payload.
*/
on(messageId, callback) {
CustomProtocolCore.registerCallback(this._id, messageId, callback);
}
/**
* Removes a callback for a specified message.
*
* @param {number} messageId - Id of the message.
* @param {Function} callback - Reference of the function to call when a message arrives.
*/
removeCallback(messageId, callback = Function.prototype) {
CustomProtocolCore.removeCallback(this._id, messageId, callback);
}
/**
* Removes all callbacks for a specified message.
*
* @param {number} messageId - Id of the message.
*/
removeAllCallbacks(messageId) {
CustomProtocolCore.removeAllCallbacks(this._id, messageId);
}
/**
* Computes the message string by concatenating header and encoded message payload.
*
* @param {number} messageId - Id of the message.
* @param {Array} payload - An array with message payload.
* @returns {string}
*/
getEncodedMessage(messageId, payload = []) {
let message = null;
// Get the 16 bit header.
message = CustomProtocolCore.getHeader(this._id, messageId);
message += this.encode(
messageId,
CustomProtocolCore.getDefinition(this._id, messageId),
...(!Array.isArray(payload) ? [payload] : payload)
);
return message;
}
};
|
import { moduleForComponent, test } from 'ember-qunit';
import hbs from 'htmlbars-inline-precompile';
moduleForComponent('bs-popover/element', 'Integration | Component | bs-popover/element', {
integration: true
});
test('it has correct markup', function(assert) {
// Template block usage:
this.render(hbs`
{{#bs-popover/element fade=true in=true title="dummy title"}}
template block text
{{/bs-popover/element}}
`);
assert.ok(this.$(':first-child').hasClass('popover'), 'has popover class');
assert.ok(this.$(':first-child').hasClass('top'), 'has top class');
assert.ok(this.$(':first-child').hasClass('fade'), 'has fade class');
assert.ok(this.$(':first-child').hasClass('in'), 'has in class');
assert.equal(this.$('.arrow').length, 1, 'has arrow');
assert.equal(this.$('.popover-title').text().trim(), 'dummy title', 'shows title');
assert.equal(this.$('.popover-content').text().trim(), 'template block text', 'shows content');
});
test('it supports different placements', function(assert) {
let placements = ['top', 'left', 'bottom', 'right'];
this.render(hbs`
{{#bs-popover/element placement=placement title="dummy title"}}
template block text
{{/bs-popover/element}}
`);
placements.forEach((placement) => {
this.set('placement', placement);
assert.ok(this.$(':first-child').hasClass(placement), `has ${placement} class`);
});
});
test('it passes along class attribute', function(assert) {
this.render(hbs`
{{#bs-popover/element placement=placement title="dummy title" class="wide"}}
template block text
{{/bs-popover/element}}
`);
assert.equal(this.$('.popover.wide').length, 1);
});
|
var searchData=
[
['file',['File',['../namespace_file.html',1,'']]],
['file_2ecpp',['file.cpp',['../file_8cpp.html',1,'']]],
['file_2eh',['file.h',['../file_8h.html',1,'']]],
['find',['Find',['../struct_tree.html#af493df2ec0c091368a1718caf3e3b89a',1,'Tree']]],
['finishread',['FinishRead',['../class_byte_buffer.html#a0ced0b1d5cb4530944d1ba465ac3d031',1,'ByteBuffer']]],
['flushbits',['FlushBits',['../class_byte_buffer.html#acbe19e2860ed3a66531215697880d038',1,'ByteBuffer']]],
['frequency',['Frequency',['../struct_tree_1_1_node.html#a427d1b6802ab57e7ed33d2918fcc107c',1,'Tree::Node']]],
['fwd',['fwd',['../struct_reverser.html#abde59a83b7f0d0ddb9c8f46d6cb63a0e',1,'Reverser']]]
];
|
// MPL 2.0 License
import Joint from "jointjs";
Joint.shapes.DefaultOutput = Joint.shapes.basic.Rect.extend({
markup: '<g class="rotatable"><g class="scalable"><rect /></g><text class="text1" /><text class="text2" /></g>',
defaults: Joint.util.deepSupplement({
type: "DefaultOutput"
}, Joint.shapes.basic.Rect.prototype.defaults)
});
export default Joint.shapes.DefaultOutput;
|
'use strict';
var React = require('react');
var SvgIcon = require('../../svg-icon');
var CommunicationChatBubbleOutline = React.createClass({
displayName: 'CommunicationChatBubbleOutline',
render: function render() {
return React.createElement(
SvgIcon,
this.props,
React.createElement('path', { d: "M20 2H4c-1.1 0-2 .9-2 2v18l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 14H6l-2 2V4h16v12z" })
);
}
});
module.exports = CommunicationChatBubbleOutline;
|
'use strict';
var grunt = require('grunt');
exports.makedeb = {
setUp: function(done) {
done();
},
simple: function(test) {
test.expect(1);
var debFile = grunt.file.read('tmp/simple-1.2.3.deb');
test.ok(debFile);
test.done();
}
};
|
function TaskByUserCtrl ($scope, $routeParams, tasks, session, socket) {
session.auth();
var userId = $routeParams.id || localStorage.id;
var userActive = localStorage.id;
var overActive;
socket.emit('get tasks by user', userId);
socket.on('return tasks by user', function (response) {
if (response[0].userAssigned == userId) {
$scope.tasks = response;
}
});
// Drag&Drop
if (userActive === userId) {
$('[data-state]').on('dragend', '[draggable]', function(event) {
var taskList = []; // creamos un array vacío
var stateName = $(this).parent().attr('data-state'); // obtenemos el stateName de la columna inicial
var index = $(this).attr('data-index'); // obtenemos la posición de la tarea dentro de la columna
var targetState = $(overActive).attr('data-state'); // obtenemos el stateName objetivo
// recorremos todas las tareas para buscar las que tengan el stateName inicial
for (task in $scope.tasks) {
if ($scope.tasks[task].stateName === stateName) {
taskList.push($scope.tasks[task]);
};
};
// obtenemos los datos de la tarea
var targetTask = taskList[index];
var targetTaskId = targetTask['id'];
if (targetTask.stateName === 'to do' && targetTask.userAssigned === null) {
targetTask.userAssigned = userId;
}
// le cambiamos el stateName y el userAsigned
targetTask.stateName = targetState;
// obtenemos el state como número
targetTask.state = tasks.getStateNumber(targetState);
socket.emit('edit task', targetTask);
setTimeout(function () {
socket.emit('get tasks by user', userId);
}, 100);
});
$('[data-state]').on('dragover', function(event) {
$(this).addClass('active');
overActive = $(this);
});
$('[data-state]').on('dragleave', function(event) {
$(this).removeClass('active');
});
}
};
|
export default src => new Promise((resolve, reject) => {
const img = new Image();
img.onerror = reject;
img.onload = () => resolve(img);
img.src = src;
});
|
var dbContext = require('./../../db/DbContext');
var _ = require('lodash');
var EventDao = function () {
this.context = dbContext.entities;
};
_.extend(EventDao.prototype, {
getAll: function (callback) {
return this.context.Event.findAll({include: [{ model: this.context.EventCategory}]});
},
getAllOfDay: function(like, callback){
return this.context.Event.findAll({where: ['start like ?', like+'%']});
},
getFiveLast: function (callback) {
return this.context.Event.findAll({limit: 5, include: [{ model: this.context.EventCategory}]});
},
get: function (id, callback) {
return this.context.Event.find(id);
},
save: function(properties, callback){
this.context.Event.create(properties)
.success(function (event) {
callback(null, event);
})
.error(function (error) {
callback(error, null);
});
},
update: function (properties, callback) {
this.get(properties.id).success(function (event) {
if(event){
event.updateAttributes(properties).success(function (event) {
callback(null, event);
}).error(function (error) {
callback(error, event);
});
}else{
callback('Aucun événement avec l\'id :' + properties.id, null);
}
});
},
delete: function (id, callback) {
this.context.Event.find(id).success(function (event) {
if(event){
event.destroy().success(callback);
}
else{
callback('Aucun événement avec l\'id :' + id);
}
})
.error(callback);
}
});
module.exports = EventDao;
|
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _react = __webpack_require__(1);
var _react2 = _interopRequireDefault(_react);
var _reactDom = __webpack_require__(158);
var _reactDom2 = _interopRequireDefault(_reactDom);
var _Navigation = __webpack_require__(159);
var _Navigation2 = _interopRequireDefault(_Navigation);
__webpack_require__(160);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var ITEMS = ['React', 'Angular', 'Vue', 'Ember', 'Knockout', 'Vanilla'];
window.onload = function () {
_reactDom2.default.render(_react2.default.createElement(_Navigation2.default, { items: ITEMS }), document.querySelector('#container'));
};
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
module.exports = __webpack_require__(2);
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule React
*/
'use strict';
var ReactDOM = __webpack_require__(3);
var ReactDOMServer = __webpack_require__(148);
var ReactIsomorphic = __webpack_require__(152);
var assign = __webpack_require__(39);
var deprecated = __webpack_require__(157);
// `version` will be added here by ReactIsomorphic.
var React = {};
assign(React, ReactIsomorphic);
assign(React, {
// ReactDOM
findDOMNode: deprecated('findDOMNode', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.findDOMNode),
render: deprecated('render', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.render),
unmountComponentAtNode: deprecated('unmountComponentAtNode', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.unmountComponentAtNode),
// ReactDOMServer
renderToString: deprecated('renderToString', 'ReactDOMServer', 'react-dom/server', ReactDOMServer, ReactDOMServer.renderToString),
renderToStaticMarkup: deprecated('renderToStaticMarkup', 'ReactDOMServer', 'react-dom/server', ReactDOMServer, ReactDOMServer.renderToStaticMarkup)
});
React.__SECRET_DOM_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactDOM;
React.__SECRET_DOM_SERVER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactDOMServer;
module.exports = React;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOM
*/
/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/
'use strict';
var ReactCurrentOwner = __webpack_require__(5);
var ReactDOMTextComponent = __webpack_require__(6);
var ReactDefaultInjection = __webpack_require__(71);
var ReactInstanceHandles = __webpack_require__(45);
var ReactMount = __webpack_require__(28);
var ReactPerf = __webpack_require__(18);
var ReactReconciler = __webpack_require__(50);
var ReactUpdates = __webpack_require__(54);
var ReactVersion = __webpack_require__(146);
var findDOMNode = __webpack_require__(91);
var renderSubtreeIntoContainer = __webpack_require__(147);
var warning = __webpack_require__(25);
ReactDefaultInjection.inject();
var render = ReactPerf.measure('React', 'render', ReactMount.render);
var React = {
findDOMNode: findDOMNode,
render: render,
unmountComponentAtNode: ReactMount.unmountComponentAtNode,
version: ReactVersion,
/* eslint-disable camelcase */
unstable_batchedUpdates: ReactUpdates.batchedUpdates,
unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer
};
// Inject the runtime into a devtools global hook regardless of browser.
// Allows for debugging when the hook is injected on the page.
/* eslint-enable camelcase */
if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {
__REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
CurrentOwner: ReactCurrentOwner,
InstanceHandles: ReactInstanceHandles,
Mount: ReactMount,
Reconciler: ReactReconciler,
TextComponent: ReactDOMTextComponent
});
}
if (process.env.NODE_ENV !== 'production') {
var ExecutionEnvironment = __webpack_require__(9);
if (ExecutionEnvironment.canUseDOM && window.top === window.self) {
// First check if devtools is not installed
if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
// If we're in Chrome or Firefox, provide a download link if not installed.
if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) {
console.debug('Download the React DevTools for a better development experience: ' + 'https://fb.me/react-devtools');
}
}
// If we're in IE8, check to see if we are in compatibility mode and provide
// information on preventing compatibility mode
var ieCompatibilityMode = document.documentMode && document.documentMode < 8;
process.env.NODE_ENV !== 'production' ? warning(!ieCompatibilityMode, 'Internet Explorer is running in compatibility mode; please add the ' + 'following tag to your HTML to prevent this from happening: ' + '<meta http-equiv="X-UA-Compatible" content="IE=edge" />') : undefined;
var expectedFeatures = [
// shims
Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.split, String.prototype.trim,
// shams
Object.create, Object.freeze];
for (var i = 0; i < expectedFeatures.length; i++) {
if (!expectedFeatures[i]) {
console.error('One or more ES5 shim/shams expected by React are not available: ' + 'https://fb.me/react-warning-polyfills');
break;
}
}
}
}
module.exports = React;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 4 */
/***/ function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = setTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
clearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
setTimeout(drainQueue, 0);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ },
/* 5 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactCurrentOwner
*/
'use strict';
/**
* Keeps track of the current owner.
*
* The current owner is the component who should own any components that are
* currently being constructed.
*/
var ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/
current: null
};
module.exports = ReactCurrentOwner;
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMTextComponent
* @typechecks static-only
*/
'use strict';
var DOMChildrenOperations = __webpack_require__(7);
var DOMPropertyOperations = __webpack_require__(22);
var ReactComponentBrowserEnvironment = __webpack_require__(26);
var ReactMount = __webpack_require__(28);
var assign = __webpack_require__(39);
var escapeTextContentForBrowser = __webpack_require__(21);
var setTextContent = __webpack_require__(20);
var validateDOMNesting = __webpack_require__(70);
/**
* Text nodes violate a couple assumptions that React makes about components:
*
* - When mounting text into the DOM, adjacent text nodes are merged.
* - Text nodes cannot be assigned a React root ID.
*
* This component is used to wrap strings in elements so that they can undergo
* the same reconciliation that is applied to elements.
*
* TODO: Investigate representing React components in the DOM with text nodes.
*
* @class ReactDOMTextComponent
* @extends ReactComponent
* @internal
*/
var ReactDOMTextComponent = function (props) {
// This constructor and its argument is currently used by mocks.
};
assign(ReactDOMTextComponent.prototype, {
/**
* @param {ReactText} text
* @internal
*/
construct: function (text) {
// TODO: This is really a ReactText (ReactNode), not a ReactElement
this._currentElement = text;
this._stringText = '' + text;
// Properties
this._rootNodeID = null;
this._mountIndex = 0;
},
/**
* Creates the markup for this text node. This node is not intended to have
* any features besides containing text content.
*
* @param {string} rootID DOM ID of the root node.
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @return {string} Markup for this text node.
* @internal
*/
mountComponent: function (rootID, transaction, context) {
if (process.env.NODE_ENV !== 'production') {
if (context[validateDOMNesting.ancestorInfoContextKey]) {
validateDOMNesting('span', null, context[validateDOMNesting.ancestorInfoContextKey]);
}
}
this._rootNodeID = rootID;
if (transaction.useCreateElement) {
var ownerDocument = context[ReactMount.ownerDocumentContextKey];
var el = ownerDocument.createElement('span');
DOMPropertyOperations.setAttributeForID(el, rootID);
// Populate node cache
ReactMount.getID(el);
setTextContent(el, this._stringText);
return el;
} else {
var escapedText = escapeTextContentForBrowser(this._stringText);
if (transaction.renderToStaticMarkup) {
// Normally we'd wrap this in a `span` for the reasons stated above, but
// since this is a situation where React won't take over (static pages),
// we can simply return the text as it is.
return escapedText;
}
return '<span ' + DOMPropertyOperations.createMarkupForID(rootID) + '>' + escapedText + '</span>';
}
},
/**
* Updates this component by updating the text content.
*
* @param {ReactText} nextText The next text content
* @param {ReactReconcileTransaction} transaction
* @internal
*/
receiveComponent: function (nextText, transaction) {
if (nextText !== this._currentElement) {
this._currentElement = nextText;
var nextStringText = '' + nextText;
if (nextStringText !== this._stringText) {
// TODO: Save this as pending props and use performUpdateIfNecessary
// and/or updateComponent to do the actual update for consistency with
// other component types?
this._stringText = nextStringText;
var node = ReactMount.getNode(this._rootNodeID);
DOMChildrenOperations.updateTextContent(node, nextStringText);
}
}
},
unmountComponent: function () {
ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);
}
});
module.exports = ReactDOMTextComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule DOMChildrenOperations
* @typechecks static-only
*/
'use strict';
var Danger = __webpack_require__(8);
var ReactMultiChildUpdateTypes = __webpack_require__(16);
var ReactPerf = __webpack_require__(18);
var setInnerHTML = __webpack_require__(19);
var setTextContent = __webpack_require__(20);
var invariant = __webpack_require__(13);
/**
* Inserts `childNode` as a child of `parentNode` at the `index`.
*
* @param {DOMElement} parentNode Parent node in which to insert.
* @param {DOMElement} childNode Child node to insert.
* @param {number} index Index at which to insert the child.
* @internal
*/
function insertChildAt(parentNode, childNode, index) {
// By exploiting arrays returning `undefined` for an undefined index, we can
// rely exclusively on `insertBefore(node, null)` instead of also using
// `appendChild(node)`. However, using `undefined` is not allowed by all
// browsers so we must replace it with `null`.
// fix render order error in safari
// IE8 will throw error when index out of list size.
var beforeChild = index >= parentNode.childNodes.length ? null : parentNode.childNodes.item(index);
parentNode.insertBefore(childNode, beforeChild);
}
/**
* Operations for updating with DOM children.
*/
var DOMChildrenOperations = {
dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup,
updateTextContent: setTextContent,
/**
* Updates a component's children by processing a series of updates. The
* update configurations are each expected to have a `parentNode` property.
*
* @param {array<object>} updates List of update configurations.
* @param {array<string>} markupList List of markup strings.
* @internal
*/
processUpdates: function (updates, markupList) {
var update;
// Mapping from parent IDs to initial child orderings.
var initialChildren = null;
// List of children that will be moved or removed.
var updatedChildren = null;
for (var i = 0; i < updates.length; i++) {
update = updates[i];
if (update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING || update.type === ReactMultiChildUpdateTypes.REMOVE_NODE) {
var updatedIndex = update.fromIndex;
var updatedChild = update.parentNode.childNodes[updatedIndex];
var parentID = update.parentID;
!updatedChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processUpdates(): Unable to find child %s of element. This ' + 'probably means the DOM was unexpectedly mutated (e.g., by the ' + 'browser), usually due to forgetting a <tbody> when using tables, ' + 'nesting tags like <form>, <p>, or <a>, or using non-SVG elements ' + 'in an <svg> parent. Try inspecting the child nodes of the element ' + 'with React ID `%s`.', updatedIndex, parentID) : invariant(false) : undefined;
initialChildren = initialChildren || {};
initialChildren[parentID] = initialChildren[parentID] || [];
initialChildren[parentID][updatedIndex] = updatedChild;
updatedChildren = updatedChildren || [];
updatedChildren.push(updatedChild);
}
}
var renderedMarkup;
// markupList is either a list of markup or just a list of elements
if (markupList.length && typeof markupList[0] === 'string') {
renderedMarkup = Danger.dangerouslyRenderMarkup(markupList);
} else {
renderedMarkup = markupList;
}
// Remove updated children first so that `toIndex` is consistent.
if (updatedChildren) {
for (var j = 0; j < updatedChildren.length; j++) {
updatedChildren[j].parentNode.removeChild(updatedChildren[j]);
}
}
for (var k = 0; k < updates.length; k++) {
update = updates[k];
switch (update.type) {
case ReactMultiChildUpdateTypes.INSERT_MARKUP:
insertChildAt(update.parentNode, renderedMarkup[update.markupIndex], update.toIndex);
break;
case ReactMultiChildUpdateTypes.MOVE_EXISTING:
insertChildAt(update.parentNode, initialChildren[update.parentID][update.fromIndex], update.toIndex);
break;
case ReactMultiChildUpdateTypes.SET_MARKUP:
setInnerHTML(update.parentNode, update.content);
break;
case ReactMultiChildUpdateTypes.TEXT_CONTENT:
setTextContent(update.parentNode, update.content);
break;
case ReactMultiChildUpdateTypes.REMOVE_NODE:
// Already removed by the for-loop above.
break;
}
}
}
};
ReactPerf.measureMethods(DOMChildrenOperations, 'DOMChildrenOperations', {
updateTextContent: 'updateTextContent'
});
module.exports = DOMChildrenOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule Danger
* @typechecks static-only
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var createNodesFromMarkup = __webpack_require__(10);
var emptyFunction = __webpack_require__(15);
var getMarkupWrap = __webpack_require__(14);
var invariant = __webpack_require__(13);
var OPEN_TAG_NAME_EXP = /^(<[^ \/>]+)/;
var RESULT_INDEX_ATTR = 'data-danger-index';
/**
* Extracts the `nodeName` from a string of markup.
*
* NOTE: Extracting the `nodeName` does not require a regular expression match
* because we make assumptions about React-generated markup (i.e. there are no
* spaces surrounding the opening tag and there is at least one attribute).
*
* @param {string} markup String of markup.
* @return {string} Node name of the supplied markup.
* @see http://jsperf.com/extract-nodename
*/
function getNodeName(markup) {
return markup.substring(1, markup.indexOf(' '));
}
var Danger = {
/**
* Renders markup into an array of nodes. The markup is expected to render
* into a list of root nodes. Also, the length of `resultList` and
* `markupList` should be the same.
*
* @param {array<string>} markupList List of markup strings to render.
* @return {array<DOMElement>} List of rendered nodes.
* @internal
*/
dangerouslyRenderMarkup: function (markupList) {
!ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' + 'thread. Make sure `window` and `document` are available globally ' + 'before requiring React when unit testing or use ' + 'ReactDOMServer.renderToString for server rendering.') : invariant(false) : undefined;
var nodeName;
var markupByNodeName = {};
// Group markup by `nodeName` if a wrap is necessary, else by '*'.
for (var i = 0; i < markupList.length; i++) {
!markupList[i] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyRenderMarkup(...): Missing markup.') : invariant(false) : undefined;
nodeName = getNodeName(markupList[i]);
nodeName = getMarkupWrap(nodeName) ? nodeName : '*';
markupByNodeName[nodeName] = markupByNodeName[nodeName] || [];
markupByNodeName[nodeName][i] = markupList[i];
}
var resultList = [];
var resultListAssignmentCount = 0;
for (nodeName in markupByNodeName) {
if (!markupByNodeName.hasOwnProperty(nodeName)) {
continue;
}
var markupListByNodeName = markupByNodeName[nodeName];
// This for-in loop skips the holes of the sparse array. The order of
// iteration should follow the order of assignment, which happens to match
// numerical index order, but we don't rely on that.
var resultIndex;
for (resultIndex in markupListByNodeName) {
if (markupListByNodeName.hasOwnProperty(resultIndex)) {
var markup = markupListByNodeName[resultIndex];
// Push the requested markup with an additional RESULT_INDEX_ATTR
// attribute. If the markup does not start with a < character, it
// will be discarded below (with an appropriate console.error).
markupListByNodeName[resultIndex] = markup.replace(OPEN_TAG_NAME_EXP,
// This index will be parsed back out below.
'$1 ' + RESULT_INDEX_ATTR + '="' + resultIndex + '" ');
}
}
// Render each group of markup with similar wrapping `nodeName`.
var renderNodes = createNodesFromMarkup(markupListByNodeName.join(''), emptyFunction // Do nothing special with <script> tags.
);
for (var j = 0; j < renderNodes.length; ++j) {
var renderNode = renderNodes[j];
if (renderNode.hasAttribute && renderNode.hasAttribute(RESULT_INDEX_ATTR)) {
resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR);
renderNode.removeAttribute(RESULT_INDEX_ATTR);
!!resultList.hasOwnProperty(resultIndex) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Danger: Assigning to an already-occupied result index.') : invariant(false) : undefined;
resultList[resultIndex] = renderNode;
// This should match resultList.length and markupList.length when
// we're done.
resultListAssignmentCount += 1;
} else if (process.env.NODE_ENV !== 'production') {
console.error('Danger: Discarding unexpected node:', renderNode);
}
}
}
// Although resultList was populated out of order, it should now be a dense
// array.
!(resultListAssignmentCount === resultList.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Danger: Did not assign to every index of resultList.') : invariant(false) : undefined;
!(resultList.length === markupList.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Danger: Expected markup to render %s nodes, but rendered %s.', markupList.length, resultList.length) : invariant(false) : undefined;
return resultList;
},
/**
* Replaces a node with a string of markup at its current position within its
* parent. The markup must render into a single root node.
*
* @param {DOMElement} oldChild Child node to replace.
* @param {string} markup Markup to render in place of the child node.
* @internal
*/
dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) {
!ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a ' + 'worker thread. Make sure `window` and `document` are available ' + 'globally before requiring React when unit testing or use ' + 'ReactDOMServer.renderToString() for server rendering.') : invariant(false) : undefined;
!markup ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : invariant(false) : undefined;
!(oldChild.tagName.toLowerCase() !== 'html') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the ' + '<html> node. This is because browser quirks make this unreliable ' + 'and/or slow. If you want to render to the root you must use ' + 'server rendering. See ReactDOMServer.renderToString().') : invariant(false) : undefined;
var newChild;
if (typeof markup === 'string') {
newChild = createNodesFromMarkup(markup, emptyFunction)[0];
} else {
newChild = markup;
}
oldChild.parentNode.replaceChild(newChild, oldChild);
}
};
module.exports = Danger;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 9 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ExecutionEnvironment
*/
'use strict';
var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
/**
* Simple, lightweight module assisting with the detection and context of
* Worker. Helps avoid circular dependencies and allows code to reason about
* whether or not they are in a Worker, even if they never include the main
* `ReactWorker` dependency.
*/
var ExecutionEnvironment = {
canUseDOM: canUseDOM,
canUseWorkers: typeof Worker !== 'undefined',
canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
canUseViewport: canUseDOM && !!window.screen,
isInWorker: !canUseDOM // For now, this is true - might change in the future.
};
module.exports = ExecutionEnvironment;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule createNodesFromMarkup
* @typechecks
*/
/*eslint-disable fb-www/unsafe-html*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var createArrayFromMixed = __webpack_require__(11);
var getMarkupWrap = __webpack_require__(14);
var invariant = __webpack_require__(13);
/**
* Dummy container used to render all markup.
*/
var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;
/**
* Pattern used by `getNodeName`.
*/
var nodeNamePattern = /^\s*<(\w+)/;
/**
* Extracts the `nodeName` of the first element in a string of markup.
*
* @param {string} markup String of markup.
* @return {?string} Node name of the supplied markup.
*/
function getNodeName(markup) {
var nodeNameMatch = markup.match(nodeNamePattern);
return nodeNameMatch && nodeNameMatch[1].toLowerCase();
}
/**
* Creates an array containing the nodes rendered from the supplied markup. The
* optionally supplied `handleScript` function will be invoked once for each
* <script> element that is rendered. If no `handleScript` function is supplied,
* an exception is thrown if any <script> elements are rendered.
*
* @param {string} markup A string of valid HTML markup.
* @param {?function} handleScript Invoked once for each rendered <script>.
* @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.
*/
function createNodesFromMarkup(markup, handleScript) {
var node = dummyNode;
!!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : undefined;
var nodeName = getNodeName(markup);
var wrap = nodeName && getMarkupWrap(nodeName);
if (wrap) {
node.innerHTML = wrap[1] + markup + wrap[2];
var wrapDepth = wrap[0];
while (wrapDepth--) {
node = node.lastChild;
}
} else {
node.innerHTML = markup;
}
var scripts = node.getElementsByTagName('script');
if (scripts.length) {
!handleScript ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : undefined;
createArrayFromMixed(scripts).forEach(handleScript);
}
var nodes = createArrayFromMixed(node.childNodes);
while (node.lastChild) {
node.removeChild(node.lastChild);
}
return nodes;
}
module.exports = createNodesFromMarkup;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule createArrayFromMixed
* @typechecks
*/
'use strict';
var toArray = __webpack_require__(12);
/**
* Perform a heuristic test to determine if an object is "array-like".
*
* A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"
* Joshu replied: "Mu."
*
* This function determines if its argument has "array nature": it returns
* true if the argument is an actual array, an `arguments' object, or an
* HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).
*
* It will return false for other array-like objects like Filelist.
*
* @param {*} obj
* @return {boolean}
*/
function hasArrayNature(obj) {
return(
// not null/false
!!obj && (
// arrays are objects, NodeLists are functions in Safari
typeof obj == 'object' || typeof obj == 'function') &&
// quacks like an array
'length' in obj &&
// not window
!('setInterval' in obj) &&
// no DOM node should be considered an array-like
// a 'select' element has 'length' and 'item' properties on IE8
typeof obj.nodeType != 'number' && (
// a real array
Array.isArray(obj) ||
// arguments
'callee' in obj ||
// HTMLCollection/NodeList
'item' in obj)
);
}
/**
* Ensure that the argument is an array by wrapping it in an array if it is not.
* Creates a copy of the argument if it is already an array.
*
* This is mostly useful idiomatically:
*
* var createArrayFromMixed = require('createArrayFromMixed');
*
* function takesOneOrMoreThings(things) {
* things = createArrayFromMixed(things);
* ...
* }
*
* This allows you to treat `things' as an array, but accept scalars in the API.
*
* If you need to convert an array-like object, like `arguments`, into an array
* use toArray instead.
*
* @param {*} obj
* @return {array}
*/
function createArrayFromMixed(obj) {
if (!hasArrayNature(obj)) {
return [obj];
} else if (Array.isArray(obj)) {
return obj.slice();
} else {
return toArray(obj);
}
}
module.exports = createArrayFromMixed;
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule toArray
* @typechecks
*/
'use strict';
var invariant = __webpack_require__(13);
/**
* Convert array-like objects to arrays.
*
* This API assumes the caller knows the contents of the data type. For less
* well defined inputs use createArrayFromMixed.
*
* @param {object|function|filelist} obj
* @return {array}
*/
function toArray(obj) {
var length = obj.length;
// Some browse builtin objects can report typeof 'function' (e.g. NodeList in
// old versions of Safari).
!(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : undefined;
!(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : undefined;
!(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : undefined;
// Old IE doesn't give collections access to hasOwnProperty. Assume inputs
// without method will throw during the slice call and skip straight to the
// fallback.
if (obj.hasOwnProperty) {
try {
return Array.prototype.slice.call(obj);
} catch (e) {
// IE < 9 does not support Array#slice on collections objects
}
}
// Fall back to copying key by key. This assumes all keys have a value,
// so will not preserve sparsely populated inputs.
var ret = Array(length);
for (var ii = 0; ii < length; ii++) {
ret[ii] = obj[ii];
}
return ret;
}
module.exports = toArray;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule invariant
*/
'use strict';
/**
* Use invariant() to assert state which your program assumes to be true.
*
* Provide sprintf-style format (only %s is supported) and arguments
* to provide information about what broke and what you were
* expecting.
*
* The invariant message will be stripped in production, but the invariant
* will remain to ensure logic does not differ in production.
*/
function invariant(condition, format, a, b, c, d, e, f) {
if (process.env.NODE_ENV !== 'production') {
if (format === undefined) {
throw new Error('invariant requires an error message argument');
}
}
if (!condition) {
var error;
if (format === undefined) {
error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
} else {
var args = [a, b, c, d, e, f];
var argIndex = 0;
error = new Error(format.replace(/%s/g, function () {
return args[argIndex++];
}));
error.name = 'Invariant Violation';
}
error.framesToPop = 1; // we don't care about invariant's own frame
throw error;
}
}
module.exports = invariant;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getMarkupWrap
*/
/*eslint-disable fb-www/unsafe-html */
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var invariant = __webpack_require__(13);
/**
* Dummy container used to detect which wraps are necessary.
*/
var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;
/**
* Some browsers cannot use `innerHTML` to render certain elements standalone,
* so we wrap them, render the wrapped nodes, then extract the desired node.
*
* In IE8, certain elements cannot render alone, so wrap all elements ('*').
*/
var shouldWrap = {};
var selectWrap = [1, '<select multiple="true">', '</select>'];
var tableWrap = [1, '<table>', '</table>'];
var trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
var svgWrap = [1, '<svg xmlns="http://www.w3.org/2000/svg">', '</svg>'];
var markupWrap = {
'*': [1, '?<div>', '</div>'],
'area': [1, '<map>', '</map>'],
'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
'legend': [1, '<fieldset>', '</fieldset>'],
'param': [1, '<object>', '</object>'],
'tr': [2, '<table><tbody>', '</tbody></table>'],
'optgroup': selectWrap,
'option': selectWrap,
'caption': tableWrap,
'colgroup': tableWrap,
'tbody': tableWrap,
'tfoot': tableWrap,
'thead': tableWrap,
'td': trWrap,
'th': trWrap
};
// Initialize the SVG elements since we know they'll always need to be wrapped
// consistently. If they are created inside a <div> they will be initialized in
// the wrong namespace (and will not display).
var svgElements = ['circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'text', 'tspan'];
svgElements.forEach(function (nodeName) {
markupWrap[nodeName] = svgWrap;
shouldWrap[nodeName] = true;
});
/**
* Gets the markup wrap configuration for the supplied `nodeName`.
*
* NOTE: This lazily detects which wraps are necessary for the current browser.
*
* @param {string} nodeName Lowercase `nodeName`.
* @return {?array} Markup wrap configuration, if applicable.
*/
function getMarkupWrap(nodeName) {
!!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : undefined;
if (!markupWrap.hasOwnProperty(nodeName)) {
nodeName = '*';
}
if (!shouldWrap.hasOwnProperty(nodeName)) {
if (nodeName === '*') {
dummyNode.innerHTML = '<link />';
} else {
dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
}
shouldWrap[nodeName] = !dummyNode.firstChild;
}
return shouldWrap[nodeName] ? markupWrap[nodeName] : null;
}
module.exports = getMarkupWrap;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 15 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule emptyFunction
*/
"use strict";
function makeEmptyFunction(arg) {
return function () {
return arg;
};
}
/**
* This function accepts and discards inputs; it has no side effects. This is
* primarily useful idiomatically for overridable function endpoints which
* always need to be callable, since JS lacks a null-call idiom ala Cocoa.
*/
function emptyFunction() {}
emptyFunction.thatReturns = makeEmptyFunction;
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
emptyFunction.thatReturnsThis = function () {
return this;
};
emptyFunction.thatReturnsArgument = function (arg) {
return arg;
};
module.exports = emptyFunction;
/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactMultiChildUpdateTypes
*/
'use strict';
var keyMirror = __webpack_require__(17);
/**
* When a component's children are updated, a series of update configuration
* objects are created in order to batch and serialize the required changes.
*
* Enumerates all the possible types of update configurations.
*
* @internal
*/
var ReactMultiChildUpdateTypes = keyMirror({
INSERT_MARKUP: null,
MOVE_EXISTING: null,
REMOVE_NODE: null,
SET_MARKUP: null,
TEXT_CONTENT: null
});
module.exports = ReactMultiChildUpdateTypes;
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule keyMirror
* @typechecks static-only
*/
'use strict';
var invariant = __webpack_require__(13);
/**
* Constructs an enumeration with keys equal to their value.
*
* For example:
*
* var COLORS = keyMirror({blue: null, red: null});
* var myColor = COLORS.blue;
* var isColorValid = !!COLORS[myColor];
*
* The last line could not be performed if the values of the generated enum were
* not equal to their keys.
*
* Input: {key1: val1, key2: val2}
* Output: {key1: key1, key2: key2}
*
* @param {object} obj
* @return {object}
*/
var keyMirror = function (obj) {
var ret = {};
var key;
!(obj instanceof Object && !Array.isArray(obj)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : undefined;
for (key in obj) {
if (!obj.hasOwnProperty(key)) {
continue;
}
ret[key] = key;
}
return ret;
};
module.exports = keyMirror;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactPerf
* @typechecks static-only
*/
'use strict';
/**
* ReactPerf is a general AOP system designed to measure performance. This
* module only has the hooks: see ReactDefaultPerf for the analysis tool.
*/
var ReactPerf = {
/**
* Boolean to enable/disable measurement. Set to false by default to prevent
* accidental logging and perf loss.
*/
enableMeasure: false,
/**
* Holds onto the measure function in use. By default, don't measure
* anything, but we'll override this if we inject a measure function.
*/
storedMeasure: _noMeasure,
/**
* @param {object} object
* @param {string} objectName
* @param {object<string>} methodNames
*/
measureMethods: function (object, objectName, methodNames) {
if (process.env.NODE_ENV !== 'production') {
for (var key in methodNames) {
if (!methodNames.hasOwnProperty(key)) {
continue;
}
object[key] = ReactPerf.measure(objectName, methodNames[key], object[key]);
}
}
},
/**
* Use this to wrap methods you want to measure. Zero overhead in production.
*
* @param {string} objName
* @param {string} fnName
* @param {function} func
* @return {function}
*/
measure: function (objName, fnName, func) {
if (process.env.NODE_ENV !== 'production') {
var measuredFunc = null;
var wrapper = function () {
if (ReactPerf.enableMeasure) {
if (!measuredFunc) {
measuredFunc = ReactPerf.storedMeasure(objName, fnName, func);
}
return measuredFunc.apply(this, arguments);
}
return func.apply(this, arguments);
};
wrapper.displayName = objName + '_' + fnName;
return wrapper;
}
return func;
},
injection: {
/**
* @param {function} measure
*/
injectMeasure: function (measure) {
ReactPerf.storedMeasure = measure;
}
}
};
/**
* Simply passes through the measured function, without measuring it.
*
* @param {string} objName
* @param {string} fnName
* @param {function} func
* @return {function}
*/
function _noMeasure(objName, fnName, func) {
return func;
}
module.exports = ReactPerf;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule setInnerHTML
*/
/* globals MSApp */
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var WHITESPACE_TEST = /^[ \r\n\t\f]/;
var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;
/**
* Set the innerHTML property of a node, ensuring that whitespace is preserved
* even in IE8.
*
* @param {DOMElement} node
* @param {string} html
* @internal
*/
var setInnerHTML = function (node, html) {
node.innerHTML = html;
};
// Win8 apps: Allow all html to be inserted
if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
setInnerHTML = function (node, html) {
MSApp.execUnsafeLocalFunction(function () {
node.innerHTML = html;
});
};
}
if (ExecutionEnvironment.canUseDOM) {
// IE8: When updating a just created node with innerHTML only leading
// whitespace is removed. When updating an existing node with innerHTML
// whitespace in root TextNodes is also collapsed.
// @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
// Feature detection; only IE8 is known to behave improperly like this.
var testElement = document.createElement('div');
testElement.innerHTML = ' ';
if (testElement.innerHTML === '') {
setInnerHTML = function (node, html) {
// Magic theory: IE8 supposedly differentiates between added and updated
// nodes when processing innerHTML, innerHTML on updated nodes suffers
// from worse whitespace behavior. Re-adding a node like this triggers
// the initial and more favorable whitespace behavior.
// TODO: What to do on a detached node?
if (node.parentNode) {
node.parentNode.replaceChild(node, node);
}
// We also implement a workaround for non-visible tags disappearing into
// thin air on IE8, this only happens if there is no visible text
// in-front of the non-visible tags. Piggyback on the whitespace fix
// and simply check if any non-visible tags appear in the source.
if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) {
// Recover leading whitespace by temporarily prepending any character.
// \uFEFF has the potential advantage of being zero-width/invisible.
// UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode
// in hopes that this is preserved even if "\uFEFF" is transformed to
// the actual Unicode character (by Babel, for example).
// https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216
node.innerHTML = String.fromCharCode(0xFEFF) + html;
// deleteData leaves an empty `TextNode` which offsets the index of all
// children. Definitely want to avoid this.
var textNode = node.firstChild;
if (textNode.data.length === 1) {
node.removeChild(textNode);
} else {
textNode.deleteData(0, 1);
}
} else {
node.innerHTML = html;
}
};
}
}
module.exports = setInnerHTML;
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule setTextContent
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var escapeTextContentForBrowser = __webpack_require__(21);
var setInnerHTML = __webpack_require__(19);
/**
* Set the textContent property of a node, ensuring that whitespace is preserved
* even in IE8. innerText is a poor substitute for textContent and, among many
* issues, inserts <br> instead of the literal newline chars. innerHTML behaves
* as it should.
*
* @param {DOMElement} node
* @param {string} text
* @internal
*/
var setTextContent = function (node, text) {
node.textContent = text;
};
if (ExecutionEnvironment.canUseDOM) {
if (!('textContent' in document.documentElement)) {
setTextContent = function (node, text) {
setInnerHTML(node, escapeTextContentForBrowser(text));
};
}
}
module.exports = setTextContent;
/***/ },
/* 21 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule escapeTextContentForBrowser
*/
'use strict';
var ESCAPE_LOOKUP = {
'&': '&',
'>': '>',
'<': '<',
'"': '"',
'\'': '''
};
var ESCAPE_REGEX = /[&><"']/g;
function escaper(match) {
return ESCAPE_LOOKUP[match];
}
/**
* Escapes text to prevent scripting attacks.
*
* @param {*} text Text value to escape.
* @return {string} An escaped string.
*/
function escapeTextContentForBrowser(text) {
return ('' + text).replace(ESCAPE_REGEX, escaper);
}
module.exports = escapeTextContentForBrowser;
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule DOMPropertyOperations
* @typechecks static-only
*/
'use strict';
var DOMProperty = __webpack_require__(23);
var ReactPerf = __webpack_require__(18);
var quoteAttributeValueForBrowser = __webpack_require__(24);
var warning = __webpack_require__(25);
// Simplified subset
var VALID_ATTRIBUTE_NAME_REGEX = /^[a-zA-Z_][\w\.\-]*$/;
var illegalAttributeNameCache = {};
var validatedAttributeNameCache = {};
function isAttributeNameSafe(attributeName) {
if (validatedAttributeNameCache.hasOwnProperty(attributeName)) {
return true;
}
if (illegalAttributeNameCache.hasOwnProperty(attributeName)) {
return false;
}
if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
validatedAttributeNameCache[attributeName] = true;
return true;
}
illegalAttributeNameCache[attributeName] = true;
process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid attribute name: `%s`', attributeName) : undefined;
return false;
}
function shouldIgnoreValue(propertyInfo, value) {
return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;
}
if (process.env.NODE_ENV !== 'production') {
var reactProps = {
children: true,
dangerouslySetInnerHTML: true,
key: true,
ref: true
};
var warnedProperties = {};
var warnUnknownProperty = function (name) {
if (reactProps.hasOwnProperty(name) && reactProps[name] || warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {
return;
}
warnedProperties[name] = true;
var lowerCasedName = name.toLowerCase();
// data-* attributes should be lowercase; suggest the lowercase version
var standardName = DOMProperty.isCustomAttribute(lowerCasedName) ? lowerCasedName : DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ? DOMProperty.getPossibleStandardName[lowerCasedName] : null;
// For now, only warn when we have a suggested correction. This prevents
// logging too much when using transferPropsTo.
process.env.NODE_ENV !== 'production' ? warning(standardName == null, 'Unknown DOM property %s. Did you mean %s?', name, standardName) : undefined;
};
}
/**
* Operations for dealing with DOM properties.
*/
var DOMPropertyOperations = {
/**
* Creates markup for the ID property.
*
* @param {string} id Unescaped ID.
* @return {string} Markup string.
*/
createMarkupForID: function (id) {
return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id);
},
setAttributeForID: function (node, id) {
node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id);
},
/**
* Creates markup for a property.
*
* @param {string} name
* @param {*} value
* @return {?string} Markup string, or null if the property was invalid.
*/
createMarkupForProperty: function (name, value) {
var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
if (propertyInfo) {
if (shouldIgnoreValue(propertyInfo, value)) {
return '';
}
var attributeName = propertyInfo.attributeName;
if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
return attributeName + '=""';
}
return attributeName + '=' + quoteAttributeValueForBrowser(value);
} else if (DOMProperty.isCustomAttribute(name)) {
if (value == null) {
return '';
}
return name + '=' + quoteAttributeValueForBrowser(value);
} else if (process.env.NODE_ENV !== 'production') {
warnUnknownProperty(name);
}
return null;
},
/**
* Creates markup for a custom property.
*
* @param {string} name
* @param {*} value
* @return {string} Markup string, or empty string if the property was invalid.
*/
createMarkupForCustomAttribute: function (name, value) {
if (!isAttributeNameSafe(name) || value == null) {
return '';
}
return name + '=' + quoteAttributeValueForBrowser(value);
},
/**
* Sets the value for a property on a node.
*
* @param {DOMElement} node
* @param {string} name
* @param {*} value
*/
setValueForProperty: function (node, name, value) {
var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
if (propertyInfo) {
var mutationMethod = propertyInfo.mutationMethod;
if (mutationMethod) {
mutationMethod(node, value);
} else if (shouldIgnoreValue(propertyInfo, value)) {
this.deleteValueForProperty(node, name);
} else if (propertyInfo.mustUseAttribute) {
var attributeName = propertyInfo.attributeName;
var namespace = propertyInfo.attributeNamespace;
// `setAttribute` with objects becomes only `[object]` in IE8/9,
// ('' + value) makes it output the correct toString()-value.
if (namespace) {
node.setAttributeNS(namespace, attributeName, '' + value);
} else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
node.setAttribute(attributeName, '');
} else {
node.setAttribute(attributeName, '' + value);
}
} else {
var propName = propertyInfo.propertyName;
// Must explicitly cast values for HAS_SIDE_EFFECTS-properties to the
// property type before comparing; only `value` does and is string.
if (!propertyInfo.hasSideEffects || '' + node[propName] !== '' + value) {
// Contrary to `setAttribute`, object properties are properly
// `toString`ed by IE8/9.
node[propName] = value;
}
}
} else if (DOMProperty.isCustomAttribute(name)) {
DOMPropertyOperations.setValueForAttribute(node, name, value);
} else if (process.env.NODE_ENV !== 'production') {
warnUnknownProperty(name);
}
},
setValueForAttribute: function (node, name, value) {
if (!isAttributeNameSafe(name)) {
return;
}
if (value == null) {
node.removeAttribute(name);
} else {
node.setAttribute(name, '' + value);
}
},
/**
* Deletes the value for a property on a node.
*
* @param {DOMElement} node
* @param {string} name
*/
deleteValueForProperty: function (node, name) {
var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
if (propertyInfo) {
var mutationMethod = propertyInfo.mutationMethod;
if (mutationMethod) {
mutationMethod(node, undefined);
} else if (propertyInfo.mustUseAttribute) {
node.removeAttribute(propertyInfo.attributeName);
} else {
var propName = propertyInfo.propertyName;
var defaultValue = DOMProperty.getDefaultValueForProperty(node.nodeName, propName);
if (!propertyInfo.hasSideEffects || '' + node[propName] !== defaultValue) {
node[propName] = defaultValue;
}
}
} else if (DOMProperty.isCustomAttribute(name)) {
node.removeAttribute(name);
} else if (process.env.NODE_ENV !== 'production') {
warnUnknownProperty(name);
}
}
};
ReactPerf.measureMethods(DOMPropertyOperations, 'DOMPropertyOperations', {
setValueForProperty: 'setValueForProperty',
setValueForAttribute: 'setValueForAttribute',
deleteValueForProperty: 'deleteValueForProperty'
});
module.exports = DOMPropertyOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule DOMProperty
* @typechecks static-only
*/
'use strict';
var invariant = __webpack_require__(13);
function checkMask(value, bitmask) {
return (value & bitmask) === bitmask;
}
var DOMPropertyInjection = {
/**
* Mapping from normalized, camelcased property names to a configuration that
* specifies how the associated DOM property should be accessed or rendered.
*/
MUST_USE_ATTRIBUTE: 0x1,
MUST_USE_PROPERTY: 0x2,
HAS_SIDE_EFFECTS: 0x4,
HAS_BOOLEAN_VALUE: 0x8,
HAS_NUMERIC_VALUE: 0x10,
HAS_POSITIVE_NUMERIC_VALUE: 0x20 | 0x10,
HAS_OVERLOADED_BOOLEAN_VALUE: 0x40,
/**
* Inject some specialized knowledge about the DOM. This takes a config object
* with the following properties:
*
* isCustomAttribute: function that given an attribute name will return true
* if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
* attributes where it's impossible to enumerate all of the possible
* attribute names,
*
* Properties: object mapping DOM property name to one of the
* DOMPropertyInjection constants or null. If your attribute isn't in here,
* it won't get written to the DOM.
*
* DOMAttributeNames: object mapping React attribute name to the DOM
* attribute name. Attribute names not specified use the **lowercase**
* normalized name.
*
* DOMAttributeNamespaces: object mapping React attribute name to the DOM
* attribute namespace URL. (Attribute names not specified use no namespace.)
*
* DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
* Property names not specified use the normalized name.
*
* DOMMutationMethods: Properties that require special mutation methods. If
* `value` is undefined, the mutation method should unset the property.
*
* @param {object} domPropertyConfig the config as described above.
*/
injectDOMPropertyConfig: function (domPropertyConfig) {
var Injection = DOMPropertyInjection;
var Properties = domPropertyConfig.Properties || {};
var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
if (domPropertyConfig.isCustomAttribute) {
DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
}
for (var propName in Properties) {
!!DOMProperty.properties.hasOwnProperty(propName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property ' + '\'%s\' which has already been injected. You may be accidentally ' + 'injecting the same DOM property config twice, or you may be ' + 'injecting two configs that have conflicting property names.', propName) : invariant(false) : undefined;
var lowerCased = propName.toLowerCase();
var propConfig = Properties[propName];
var propertyInfo = {
attributeName: lowerCased,
attributeNamespace: null,
propertyName: propName,
mutationMethod: null,
mustUseAttribute: checkMask(propConfig, Injection.MUST_USE_ATTRIBUTE),
mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
hasSideEffects: checkMask(propConfig, Injection.HAS_SIDE_EFFECTS),
hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
};
!(!propertyInfo.mustUseAttribute || !propertyInfo.mustUseProperty) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Cannot require using both attribute and property: %s', propName) : invariant(false) : undefined;
!(propertyInfo.mustUseProperty || !propertyInfo.hasSideEffects) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Properties that have side effects must use property: %s', propName) : invariant(false) : undefined;
!(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or ' + 'numeric value, but not a combination: %s', propName) : invariant(false) : undefined;
if (process.env.NODE_ENV !== 'production') {
DOMProperty.getPossibleStandardName[lowerCased] = propName;
}
if (DOMAttributeNames.hasOwnProperty(propName)) {
var attributeName = DOMAttributeNames[propName];
propertyInfo.attributeName = attributeName;
if (process.env.NODE_ENV !== 'production') {
DOMProperty.getPossibleStandardName[attributeName] = propName;
}
}
if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
}
if (DOMPropertyNames.hasOwnProperty(propName)) {
propertyInfo.propertyName = DOMPropertyNames[propName];
}
if (DOMMutationMethods.hasOwnProperty(propName)) {
propertyInfo.mutationMethod = DOMMutationMethods[propName];
}
DOMProperty.properties[propName] = propertyInfo;
}
}
};
var defaultValueCache = {};
/**
* DOMProperty exports lookup objects that can be used like functions:
*
* > DOMProperty.isValid['id']
* true
* > DOMProperty.isValid['foobar']
* undefined
*
* Although this may be confusing, it performs better in general.
*
* @see http://jsperf.com/key-exists
* @see http://jsperf.com/key-missing
*/
var DOMProperty = {
ID_ATTRIBUTE_NAME: 'data-reactid',
/**
* Map from property "standard name" to an object with info about how to set
* the property in the DOM. Each object contains:
*
* attributeName:
* Used when rendering markup or with `*Attribute()`.
* attributeNamespace
* propertyName:
* Used on DOM node instances. (This includes properties that mutate due to
* external factors.)
* mutationMethod:
* If non-null, used instead of the property or `setAttribute()` after
* initial render.
* mustUseAttribute:
* Whether the property must be accessed and mutated using `*Attribute()`.
* (This includes anything that fails `<propName> in <element>`.)
* mustUseProperty:
* Whether the property must be accessed and mutated as an object property.
* hasSideEffects:
* Whether or not setting a value causes side effects such as triggering
* resources to be loaded or text selection changes. If true, we read from
* the DOM before updating to ensure that the value is only set if it has
* changed.
* hasBooleanValue:
* Whether the property should be removed when set to a falsey value.
* hasNumericValue:
* Whether the property must be numeric or parse as a numeric and should be
* removed when set to a falsey value.
* hasPositiveNumericValue:
* Whether the property must be positive numeric or parse as a positive
* numeric and should be removed when set to a falsey value.
* hasOverloadedBooleanValue:
* Whether the property can be used as a flag as well as with a value.
* Removed when strictly equal to false; present without a value when
* strictly equal to true; present with a value otherwise.
*/
properties: {},
/**
* Mapping from lowercase property names to the properly cased version, used
* to warn in the case of missing properties. Available only in __DEV__.
* @type {Object}
*/
getPossibleStandardName: process.env.NODE_ENV !== 'production' ? {} : null,
/**
* All of the isCustomAttribute() functions that have been injected.
*/
_isCustomAttributeFunctions: [],
/**
* Checks whether a property name is a custom attribute.
* @method
*/
isCustomAttribute: function (attributeName) {
for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
if (isCustomAttributeFn(attributeName)) {
return true;
}
}
return false;
},
/**
* Returns the default property value for a DOM property (i.e., not an
* attribute). Most default values are '' or false, but not all. Worse yet,
* some (in particular, `type`) vary depending on the type of element.
*
* TODO: Is it better to grab all the possible properties when creating an
* element to avoid having to create the same element twice?
*/
getDefaultValueForProperty: function (nodeName, prop) {
var nodeDefaults = defaultValueCache[nodeName];
var testElement;
if (!nodeDefaults) {
defaultValueCache[nodeName] = nodeDefaults = {};
}
if (!(prop in nodeDefaults)) {
testElement = document.createElement(nodeName);
nodeDefaults[prop] = testElement[prop];
}
return nodeDefaults[prop];
},
injection: DOMPropertyInjection
};
module.exports = DOMProperty;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule quoteAttributeValueForBrowser
*/
'use strict';
var escapeTextContentForBrowser = __webpack_require__(21);
/**
* Escapes attribute value to prevent scripting attacks.
*
* @param {*} value Value to escape.
* @return {string} An escaped string.
*/
function quoteAttributeValueForBrowser(value) {
return '"' + escapeTextContentForBrowser(value) + '"';
}
module.exports = quoteAttributeValueForBrowser;
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule warning
*/
'use strict';
var emptyFunction = __webpack_require__(15);
/**
* Similar to invariant but only logs a warning if the condition is not met.
* This can be used to log issues in development environments in critical
* paths. Removing the logging code for production environments will keep the
* same logic and follow the same code paths.
*/
var warning = emptyFunction;
if (process.env.NODE_ENV !== 'production') {
warning = function (condition, format) {
for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
args[_key - 2] = arguments[_key];
}
if (format === undefined) {
throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
}
if (format.indexOf('Failed Composite propType: ') === 0) {
return; // Ignore CompositeComponent proptype check.
}
if (!condition) {
var argIndex = 0;
var message = 'Warning: ' + format.replace(/%s/g, function () {
return args[argIndex++];
});
if (typeof console !== 'undefined') {
console.error(message);
}
try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
throw new Error(message);
} catch (x) {}
}
};
}
module.exports = warning;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactComponentBrowserEnvironment
*/
'use strict';
var ReactDOMIDOperations = __webpack_require__(27);
var ReactMount = __webpack_require__(28);
/**
* Abstracts away all functionality of the reconciler that requires knowledge of
* the browser context. TODO: These callers should be refactored to avoid the
* need for this injection.
*/
var ReactComponentBrowserEnvironment = {
processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,
replaceNodeWithMarkupByID: ReactDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID,
/**
* If a particular environment requires that some resources be cleaned up,
* specify this in the injected Mixin. In the DOM, we would likely want to
* purge any cached node ID lookups.
*
* @private
*/
unmountIDFromEnvironment: function (rootNodeID) {
ReactMount.purgeID(rootNodeID);
}
};
module.exports = ReactComponentBrowserEnvironment;
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMIDOperations
* @typechecks static-only
*/
'use strict';
var DOMChildrenOperations = __webpack_require__(7);
var DOMPropertyOperations = __webpack_require__(22);
var ReactMount = __webpack_require__(28);
var ReactPerf = __webpack_require__(18);
var invariant = __webpack_require__(13);
/**
* Errors for properties that should not be updated with `updatePropertyByID()`.
*
* @type {object}
* @private
*/
var INVALID_PROPERTY_ERRORS = {
dangerouslySetInnerHTML: '`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.',
style: '`style` must be set using `updateStylesByID()`.'
};
/**
* Operations used to process updates to DOM nodes.
*/
var ReactDOMIDOperations = {
/**
* Updates a DOM node with new property values. This should only be used to
* update DOM properties in `DOMProperty`.
*
* @param {string} id ID of the node to update.
* @param {string} name A valid property name, see `DOMProperty`.
* @param {*} value New value of the property.
* @internal
*/
updatePropertyByID: function (id, name, value) {
var node = ReactMount.getNode(id);
!!INVALID_PROPERTY_ERRORS.hasOwnProperty(name) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updatePropertyByID(...): %s', INVALID_PROPERTY_ERRORS[name]) : invariant(false) : undefined;
// If we're updating to null or undefined, we should remove the property
// from the DOM node instead of inadvertantly setting to a string. This
// brings us in line with the same behavior we have on initial render.
if (value != null) {
DOMPropertyOperations.setValueForProperty(node, name, value);
} else {
DOMPropertyOperations.deleteValueForProperty(node, name);
}
},
/**
* Replaces a DOM node that exists in the document with markup.
*
* @param {string} id ID of child to be replaced.
* @param {string} markup Dangerous markup to inject in place of child.
* @internal
* @see {Danger.dangerouslyReplaceNodeWithMarkup}
*/
dangerouslyReplaceNodeWithMarkupByID: function (id, markup) {
var node = ReactMount.getNode(id);
DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);
},
/**
* Updates a component's children by processing a series of updates.
*
* @param {array<object>} updates List of update configurations.
* @param {array<string>} markup List of markup strings.
* @internal
*/
dangerouslyProcessChildrenUpdates: function (updates, markup) {
for (var i = 0; i < updates.length; i++) {
updates[i].parentNode = ReactMount.getNode(updates[i].parentID);
}
DOMChildrenOperations.processUpdates(updates, markup);
}
};
ReactPerf.measureMethods(ReactDOMIDOperations, 'ReactDOMIDOperations', {
dangerouslyReplaceNodeWithMarkupByID: 'dangerouslyReplaceNodeWithMarkupByID',
dangerouslyProcessChildrenUpdates: 'dangerouslyProcessChildrenUpdates'
});
module.exports = ReactDOMIDOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactMount
*/
'use strict';
var DOMProperty = __webpack_require__(23);
var ReactBrowserEventEmitter = __webpack_require__(29);
var ReactCurrentOwner = __webpack_require__(5);
var ReactDOMFeatureFlags = __webpack_require__(41);
var ReactElement = __webpack_require__(42);
var ReactEmptyComponentRegistry = __webpack_require__(44);
var ReactInstanceHandles = __webpack_require__(45);
var ReactInstanceMap = __webpack_require__(47);
var ReactMarkupChecksum = __webpack_require__(48);
var ReactPerf = __webpack_require__(18);
var ReactReconciler = __webpack_require__(50);
var ReactUpdateQueue = __webpack_require__(53);
var ReactUpdates = __webpack_require__(54);
var assign = __webpack_require__(39);
var emptyObject = __webpack_require__(58);
var containsNode = __webpack_require__(59);
var instantiateReactComponent = __webpack_require__(62);
var invariant = __webpack_require__(13);
var setInnerHTML = __webpack_require__(19);
var shouldUpdateReactComponent = __webpack_require__(67);
var validateDOMNesting = __webpack_require__(70);
var warning = __webpack_require__(25);
var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
var nodeCache = {};
var ELEMENT_NODE_TYPE = 1;
var DOC_NODE_TYPE = 9;
var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
var ownerDocumentContextKey = '__ReactMount_ownerDocument$' + Math.random().toString(36).slice(2);
/** Mapping from reactRootID to React component instance. */
var instancesByReactRootID = {};
/** Mapping from reactRootID to `container` nodes. */
var containersByReactRootID = {};
if (process.env.NODE_ENV !== 'production') {
/** __DEV__-only mapping from reactRootID to root elements. */
var rootElementsByReactRootID = {};
}
// Used to store breadth-first search state in findComponentRoot.
var findComponentRootReusableArray = [];
/**
* Finds the index of the first character
* that's not common between the two given strings.
*
* @return {number} the index of the character where the strings diverge
*/
function firstDifferenceIndex(string1, string2) {
var minLen = Math.min(string1.length, string2.length);
for (var i = 0; i < minLen; i++) {
if (string1.charAt(i) !== string2.charAt(i)) {
return i;
}
}
return string1.length === string2.length ? -1 : minLen;
}
/**
* @param {DOMElement|DOMDocument} container DOM element that may contain
* a React component
* @return {?*} DOM element that may have the reactRoot ID, or null.
*/
function getReactRootElementInContainer(container) {
if (!container) {
return null;
}
if (container.nodeType === DOC_NODE_TYPE) {
return container.documentElement;
} else {
return container.firstChild;
}
}
/**
* @param {DOMElement} container DOM element that may contain a React component.
* @return {?string} A "reactRoot" ID, if a React component is rendered.
*/
function getReactRootID(container) {
var rootElement = getReactRootElementInContainer(container);
return rootElement && ReactMount.getID(rootElement);
}
/**
* Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form
* element can return its control whose name or ID equals ATTR_NAME. All
* DOM nodes support `getAttributeNode` but this can also get called on
* other objects so just return '' if we're given something other than a
* DOM node (such as window).
*
* @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.
* @return {string} ID of the supplied `domNode`.
*/
function getID(node) {
var id = internalGetID(node);
if (id) {
if (nodeCache.hasOwnProperty(id)) {
var cached = nodeCache[id];
if (cached !== node) {
!!isValid(cached, id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactMount: Two valid but unequal nodes with the same `%s`: %s', ATTR_NAME, id) : invariant(false) : undefined;
nodeCache[id] = node;
}
} else {
nodeCache[id] = node;
}
}
return id;
}
function internalGetID(node) {
// If node is something like a window, document, or text node, none of
// which support attributes or a .getAttribute method, gracefully return
// the empty string, as if the attribute were missing.
return node && node.getAttribute && node.getAttribute(ATTR_NAME) || '';
}
/**
* Sets the React-specific ID of the given node.
*
* @param {DOMElement} node The DOM node whose ID will be set.
* @param {string} id The value of the ID attribute.
*/
function setID(node, id) {
var oldID = internalGetID(node);
if (oldID !== id) {
delete nodeCache[oldID];
}
node.setAttribute(ATTR_NAME, id);
nodeCache[id] = node;
}
/**
* Finds the node with the supplied React-generated DOM ID.
*
* @param {string} id A React-generated DOM ID.
* @return {DOMElement} DOM node with the suppled `id`.
* @internal
*/
function getNode(id) {
if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {
nodeCache[id] = ReactMount.findReactNodeByID(id);
}
return nodeCache[id];
}
/**
* Finds the node with the supplied public React instance.
*
* @param {*} instance A public React instance.
* @return {?DOMElement} DOM node with the suppled `id`.
* @internal
*/
function getNodeFromInstance(instance) {
var id = ReactInstanceMap.get(instance)._rootNodeID;
if (ReactEmptyComponentRegistry.isNullComponentID(id)) {
return null;
}
if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {
nodeCache[id] = ReactMount.findReactNodeByID(id);
}
return nodeCache[id];
}
/**
* A node is "valid" if it is contained by a currently mounted container.
*
* This means that the node does not have to be contained by a document in
* order to be considered valid.
*
* @param {?DOMElement} node The candidate DOM node.
* @param {string} id The expected ID of the node.
* @return {boolean} Whether the node is contained by a mounted container.
*/
function isValid(node, id) {
if (node) {
!(internalGetID(node) === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactMount: Unexpected modification of `%s`', ATTR_NAME) : invariant(false) : undefined;
var container = ReactMount.findReactContainerForID(id);
if (container && containsNode(container, node)) {
return true;
}
}
return false;
}
/**
* Causes the cache to forget about one React-specific ID.
*
* @param {string} id The ID to forget.
*/
function purgeID(id) {
delete nodeCache[id];
}
var deepestNodeSoFar = null;
function findDeepestCachedAncestorImpl(ancestorID) {
var ancestor = nodeCache[ancestorID];
if (ancestor && isValid(ancestor, ancestorID)) {
deepestNodeSoFar = ancestor;
} else {
// This node isn't populated in the cache, so presumably none of its
// descendants are. Break out of the loop.
return false;
}
}
/**
* Return the deepest cached node whose ID is a prefix of `targetID`.
*/
function findDeepestCachedAncestor(targetID) {
deepestNodeSoFar = null;
ReactInstanceHandles.traverseAncestors(targetID, findDeepestCachedAncestorImpl);
var foundNode = deepestNodeSoFar;
deepestNodeSoFar = null;
return foundNode;
}
/**
* Mounts this component and inserts it into the DOM.
*
* @param {ReactComponent} componentInstance The instance to mount.
* @param {string} rootID DOM ID of the root node.
* @param {DOMElement} container DOM element to mount into.
* @param {ReactReconcileTransaction} transaction
* @param {boolean} shouldReuseMarkup If true, do not insert markup
*/
function mountComponentIntoNode(componentInstance, rootID, container, transaction, shouldReuseMarkup, context) {
if (ReactDOMFeatureFlags.useCreateElement) {
context = assign({}, context);
if (container.nodeType === DOC_NODE_TYPE) {
context[ownerDocumentContextKey] = container;
} else {
context[ownerDocumentContextKey] = container.ownerDocument;
}
}
if (process.env.NODE_ENV !== 'production') {
if (context === emptyObject) {
context = {};
}
var tag = container.nodeName.toLowerCase();
context[validateDOMNesting.ancestorInfoContextKey] = validateDOMNesting.updatedAncestorInfo(null, tag, null);
}
var markup = ReactReconciler.mountComponent(componentInstance, rootID, transaction, context);
componentInstance._renderedComponent._topLevelWrapper = componentInstance;
ReactMount._mountImageIntoNode(markup, container, shouldReuseMarkup, transaction);
}
/**
* Batched mount.
*
* @param {ReactComponent} componentInstance The instance to mount.
* @param {string} rootID DOM ID of the root node.
* @param {DOMElement} container DOM element to mount into.
* @param {boolean} shouldReuseMarkup If true, do not insert markup
*/
function batchedMountComponentIntoNode(componentInstance, rootID, container, shouldReuseMarkup, context) {
var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(
/* forceHTML */shouldReuseMarkup);
transaction.perform(mountComponentIntoNode, null, componentInstance, rootID, container, transaction, shouldReuseMarkup, context);
ReactUpdates.ReactReconcileTransaction.release(transaction);
}
/**
* Unmounts a component and removes it from the DOM.
*
* @param {ReactComponent} instance React component instance.
* @param {DOMElement} container DOM element to unmount from.
* @final
* @internal
* @see {ReactMount.unmountComponentAtNode}
*/
function unmountComponentFromNode(instance, container) {
ReactReconciler.unmountComponent(instance);
if (container.nodeType === DOC_NODE_TYPE) {
container = container.documentElement;
}
// http://jsperf.com/emptying-a-node
while (container.lastChild) {
container.removeChild(container.lastChild);
}
}
/**
* True if the supplied DOM node has a direct React-rendered child that is
* not a React root element. Useful for warning in `render`,
* `unmountComponentAtNode`, etc.
*
* @param {?DOMElement} node The candidate DOM node.
* @return {boolean} True if the DOM element contains a direct child that was
* rendered by React but is not a root element.
* @internal
*/
function hasNonRootReactChild(node) {
var reactRootID = getReactRootID(node);
return reactRootID ? reactRootID !== ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID) : false;
}
/**
* Returns the first (deepest) ancestor of a node which is rendered by this copy
* of React.
*/
function findFirstReactDOMImpl(node) {
// This node might be from another React instance, so we make sure not to
// examine the node cache here
for (; node && node.parentNode !== node; node = node.parentNode) {
if (node.nodeType !== 1) {
// Not a DOMElement, therefore not a React component
continue;
}
var nodeID = internalGetID(node);
if (!nodeID) {
continue;
}
var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(nodeID);
// If containersByReactRootID contains the container we find by crawling up
// the tree, we know that this instance of React rendered the node.
// nb. isValid's strategy (with containsNode) does not work because render
// trees may be nested and we don't want a false positive in that case.
var current = node;
var lastID;
do {
lastID = internalGetID(current);
current = current.parentNode;
if (current == null) {
// The passed-in node has been detached from the container it was
// originally rendered into.
return null;
}
} while (lastID !== reactRootID);
if (current === containersByReactRootID[reactRootID]) {
return node;
}
}
return null;
}
/**
* Temporary (?) hack so that we can store all top-level pending updates on
* composites instead of having to worry about different types of components
* here.
*/
var TopLevelWrapper = function () {};
TopLevelWrapper.prototype.isReactComponent = {};
if (process.env.NODE_ENV !== 'production') {
TopLevelWrapper.displayName = 'TopLevelWrapper';
}
TopLevelWrapper.prototype.render = function () {
// this.props is actually a ReactElement
return this.props;
};
/**
* Mounting is the process of initializing a React component by creating its
* representative DOM elements and inserting them into a supplied `container`.
* Any prior content inside `container` is destroyed in the process.
*
* ReactMount.render(
* component,
* document.getElementById('container')
* );
*
* <div id="container"> <-- Supplied `container`.
* <div data-reactid=".3"> <-- Rendered reactRoot of React
* // ... component.
* </div>
* </div>
*
* Inside of `container`, the first element rendered is the "reactRoot".
*/
var ReactMount = {
TopLevelWrapper: TopLevelWrapper,
/** Exposed for debugging purposes **/
_instancesByReactRootID: instancesByReactRootID,
/**
* This is a hook provided to support rendering React components while
* ensuring that the apparent scroll position of its `container` does not
* change.
*
* @param {DOMElement} container The `container` being rendered into.
* @param {function} renderCallback This must be called once to do the render.
*/
scrollMonitor: function (container, renderCallback) {
renderCallback();
},
/**
* Take a component that's already mounted into the DOM and replace its props
* @param {ReactComponent} prevComponent component instance already in the DOM
* @param {ReactElement} nextElement component instance to render
* @param {DOMElement} container container to render into
* @param {?function} callback function triggered on completion
*/
_updateRootComponent: function (prevComponent, nextElement, container, callback) {
ReactMount.scrollMonitor(container, function () {
ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement);
if (callback) {
ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);
}
});
if (process.env.NODE_ENV !== 'production') {
// Record the root element in case it later gets transplanted.
rootElementsByReactRootID[getReactRootID(container)] = getReactRootElementInContainer(container);
}
return prevComponent;
},
/**
* Register a component into the instance map and starts scroll value
* monitoring
* @param {ReactComponent} nextComponent component instance to render
* @param {DOMElement} container container to render into
* @return {string} reactRoot ID prefix
*/
_registerComponent: function (nextComponent, container) {
!(container && (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE || container.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : invariant(false) : undefined;
ReactBrowserEventEmitter.ensureScrollValueMonitoring();
var reactRootID = ReactMount.registerContainer(container);
instancesByReactRootID[reactRootID] = nextComponent;
return reactRootID;
},
/**
* Render a new component into the DOM.
* @param {ReactElement} nextElement element to render
* @param {DOMElement} container container to render into
* @param {boolean} shouldReuseMarkup if we should skip the markup insertion
* @return {ReactComponent} nextComponent
*/
_renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case.
process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : undefined;
var componentInstance = instantiateReactComponent(nextElement, null);
var reactRootID = ReactMount._registerComponent(componentInstance, container);
// The initial render is synchronous but any updates that happen during
// rendering, in componentWillMount or componentDidMount, will be batched
// according to the current batching strategy.
ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, reactRootID, container, shouldReuseMarkup, context);
if (process.env.NODE_ENV !== 'production') {
// Record the root element in case it later gets transplanted.
rootElementsByReactRootID[reactRootID] = getReactRootElementInContainer(container);
}
return componentInstance;
},
/**
* Renders a React component into the DOM in the supplied `container`.
*
* If the React component was previously rendered into `container`, this will
* perform an update on it and only mutate the DOM as necessary to reflect the
* latest React component.
*
* @param {ReactComponent} parentComponent The conceptual parent of this render tree.
* @param {ReactElement} nextElement Component element to render.
* @param {DOMElement} container DOM element to render into.
* @param {?function} callback function triggered on completion
* @return {ReactComponent} Component instance rendered in `container`.
*/
renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
!(parentComponent != null && parentComponent._reactInternalInstance != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : invariant(false) : undefined;
return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback);
},
_renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
!ReactElement.isValidElement(nextElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? ' Instead of passing an element string, make sure to instantiate ' + 'it by passing it to React.createElement.' : typeof nextElement === 'function' ? ' Instead of passing a component class, make sure to instantiate ' + 'it by passing it to React.createElement.' :
// Check if it quacks like an element
nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : invariant(false) : undefined;
process.env.NODE_ENV !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : undefined;
var nextWrappedElement = new ReactElement(TopLevelWrapper, null, null, null, null, null, nextElement);
var prevComponent = instancesByReactRootID[getReactRootID(container)];
if (prevComponent) {
var prevWrappedElement = prevComponent._currentElement;
var prevElement = prevWrappedElement.props;
if (shouldUpdateReactComponent(prevElement, nextElement)) {
var publicInst = prevComponent._renderedComponent.getPublicInstance();
var updatedCallback = callback && function () {
callback.call(publicInst);
};
ReactMount._updateRootComponent(prevComponent, nextWrappedElement, container, updatedCallback);
return publicInst;
} else {
ReactMount.unmountComponentAtNode(container);
}
}
var reactRootElement = getReactRootElementInContainer(container);
var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement);
var containerHasNonRootReactChild = hasNonRootReactChild(container);
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : undefined;
if (!containerHasReactMarkup || reactRootElement.nextSibling) {
var rootElementSibling = reactRootElement;
while (rootElementSibling) {
if (internalGetID(rootElementSibling)) {
process.env.NODE_ENV !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : undefined;
break;
}
rootElementSibling = rootElementSibling.nextSibling;
}
}
}
var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild;
var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, parentComponent != null ? parentComponent._reactInternalInstance._processChildContext(parentComponent._reactInternalInstance._context) : emptyObject)._renderedComponent.getPublicInstance();
if (callback) {
callback.call(component);
}
return component;
},
/**
* Renders a React component into the DOM in the supplied `container`.
*
* If the React component was previously rendered into `container`, this will
* perform an update on it and only mutate the DOM as necessary to reflect the
* latest React component.
*
* @param {ReactElement} nextElement Component element to render.
* @param {DOMElement} container DOM element to render into.
* @param {?function} callback function triggered on completion
* @return {ReactComponent} Component instance rendered in `container`.
*/
render: function (nextElement, container, callback) {
return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);
},
/**
* Registers a container node into which React components will be rendered.
* This also creates the "reactRoot" ID that will be assigned to the element
* rendered within.
*
* @param {DOMElement} container DOM element to register as a container.
* @return {string} The "reactRoot" ID of elements rendered within.
*/
registerContainer: function (container) {
var reactRootID = getReactRootID(container);
if (reactRootID) {
// If one exists, make sure it is a valid "reactRoot" ID.
reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID);
}
if (!reactRootID) {
// No valid "reactRoot" ID found, create one.
reactRootID = ReactInstanceHandles.createReactRootID();
}
containersByReactRootID[reactRootID] = container;
return reactRootID;
},
/**
* Unmounts and destroys the React component rendered in the `container`.
*
* @param {DOMElement} container DOM element containing a React component.
* @return {boolean} True if a component was found in and unmounted from
* `container`
*/
unmountComponentAtNode: function (container) {
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case. (Strictly speaking, unmounting won't cause a
// render but we still don't expect to be in a render call here.)
process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : undefined;
!(container && (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE || container.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : invariant(false) : undefined;
var reactRootID = getReactRootID(container);
var component = instancesByReactRootID[reactRootID];
if (!component) {
// Check if the node being unmounted was rendered by React, but isn't a
// root node.
var containerHasNonRootReactChild = hasNonRootReactChild(container);
// Check if the container itself is a React root node.
var containerID = internalGetID(container);
var isContainerReactRoot = containerID && containerID === ReactInstanceHandles.getReactRootIDFromNodeID(containerID);
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : undefined;
}
return false;
}
ReactUpdates.batchedUpdates(unmountComponentFromNode, component, container);
delete instancesByReactRootID[reactRootID];
delete containersByReactRootID[reactRootID];
if (process.env.NODE_ENV !== 'production') {
delete rootElementsByReactRootID[reactRootID];
}
return true;
},
/**
* Finds the container DOM element that contains React component to which the
* supplied DOM `id` belongs.
*
* @param {string} id The ID of an element rendered by a React component.
* @return {?DOMElement} DOM element that contains the `id`.
*/
findReactContainerForID: function (id) {
var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(id);
var container = containersByReactRootID[reactRootID];
if (process.env.NODE_ENV !== 'production') {
var rootElement = rootElementsByReactRootID[reactRootID];
if (rootElement && rootElement.parentNode !== container) {
process.env.NODE_ENV !== 'production' ? warning(
// Call internalGetID here because getID calls isValid which calls
// findReactContainerForID (this function).
internalGetID(rootElement) === reactRootID, 'ReactMount: Root element ID differed from reactRootID.') : undefined;
var containerChild = container.firstChild;
if (containerChild && reactRootID === internalGetID(containerChild)) {
// If the container has a new child with the same ID as the old
// root element, then rootElementsByReactRootID[reactRootID] is
// just stale and needs to be updated. The case that deserves a
// warning is when the container is empty.
rootElementsByReactRootID[reactRootID] = containerChild;
} else {
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactMount: Root element has been removed from its original ' + 'container. New container: %s', rootElement.parentNode) : undefined;
}
}
}
return container;
},
/**
* Finds an element rendered by React with the supplied ID.
*
* @param {string} id ID of a DOM node in the React component.
* @return {DOMElement} Root DOM node of the React component.
*/
findReactNodeByID: function (id) {
var reactRoot = ReactMount.findReactContainerForID(id);
return ReactMount.findComponentRoot(reactRoot, id);
},
/**
* Traverses up the ancestors of the supplied node to find a node that is a
* DOM representation of a React component rendered by this copy of React.
*
* @param {*} node
* @return {?DOMEventTarget}
* @internal
*/
getFirstReactDOM: function (node) {
return findFirstReactDOMImpl(node);
},
/**
* Finds a node with the supplied `targetID` inside of the supplied
* `ancestorNode`. Exploits the ID naming scheme to perform the search
* quickly.
*
* @param {DOMEventTarget} ancestorNode Search from this root.
* @pararm {string} targetID ID of the DOM representation of the component.
* @return {DOMEventTarget} DOM node with the supplied `targetID`.
* @internal
*/
findComponentRoot: function (ancestorNode, targetID) {
var firstChildren = findComponentRootReusableArray;
var childIndex = 0;
var deepestAncestor = findDeepestCachedAncestor(targetID) || ancestorNode;
if (process.env.NODE_ENV !== 'production') {
// This will throw on the next line; give an early warning
process.env.NODE_ENV !== 'production' ? warning(deepestAncestor != null, 'React can\'t find the root component node for data-reactid value ' + '`%s`. If you\'re seeing this message, it probably means that ' + 'you\'ve loaded two copies of React on the page. At this time, only ' + 'a single copy of React can be loaded at a time.', targetID) : undefined;
}
firstChildren[0] = deepestAncestor.firstChild;
firstChildren.length = 1;
while (childIndex < firstChildren.length) {
var child = firstChildren[childIndex++];
var targetChild;
while (child) {
var childID = ReactMount.getID(child);
if (childID) {
// Even if we find the node we're looking for, we finish looping
// through its siblings to ensure they're cached so that we don't have
// to revisit this node again. Otherwise, we make n^2 calls to getID
// when visiting the many children of a single node in order.
if (targetID === childID) {
targetChild = child;
} else if (ReactInstanceHandles.isAncestorIDOf(childID, targetID)) {
// If we find a child whose ID is an ancestor of the given ID,
// then we can be sure that we only want to search the subtree
// rooted at this child, so we can throw out the rest of the
// search state.
firstChildren.length = childIndex = 0;
firstChildren.push(child.firstChild);
}
} else {
// If this child had no ID, then there's a chance that it was
// injected automatically by the browser, as when a `<table>`
// element sprouts an extra `<tbody>` child as a side effect of
// `.innerHTML` parsing. Optimistically continue down this
// branch, but not before examining the other siblings.
firstChildren.push(child.firstChild);
}
child = child.nextSibling;
}
if (targetChild) {
// Emptying firstChildren/findComponentRootReusableArray is
// not necessary for correctness, but it helps the GC reclaim
// any nodes that were left at the end of the search.
firstChildren.length = 0;
return targetChild;
}
}
firstChildren.length = 0;
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'findComponentRoot(..., %s): Unable to find element. This probably ' + 'means the DOM was unexpectedly mutated (e.g., by the browser), ' + 'usually due to forgetting a <tbody> when using tables, nesting tags ' + 'like <form>, <p>, or <a>, or using non-SVG elements in an <svg> ' + 'parent. ' + 'Try inspecting the child nodes of the element with React ID `%s`.', targetID, ReactMount.getID(ancestorNode)) : invariant(false) : undefined;
},
_mountImageIntoNode: function (markup, container, shouldReuseMarkup, transaction) {
!(container && (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE || container.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : invariant(false) : undefined;
if (shouldReuseMarkup) {
var rootElement = getReactRootElementInContainer(container);
if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {
return;
} else {
var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
var rootMarkup = rootElement.outerHTML;
rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);
var normalizedMarkup = markup;
if (process.env.NODE_ENV !== 'production') {
// because rootMarkup is retrieved from the DOM, various normalizations
// will have occurred which will not be present in `markup`. Here,
// insert markup into a <div> or <iframe> depending on the container
// type to perform the same normalizations before comparing.
var normalizer;
if (container.nodeType === ELEMENT_NODE_TYPE) {
normalizer = document.createElement('div');
normalizer.innerHTML = markup;
normalizedMarkup = normalizer.innerHTML;
} else {
normalizer = document.createElement('iframe');
document.body.appendChild(normalizer);
normalizer.contentDocument.write(markup);
normalizedMarkup = normalizer.contentDocument.documentElement.outerHTML;
document.body.removeChild(normalizer);
}
}
var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);
var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);
!(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document using ' + 'server rendering but the checksum was invalid. This usually ' + 'means you rendered a different component type or props on ' + 'the client from the one on the server, or your render() ' + 'methods are impure. React cannot handle this case due to ' + 'cross-browser quirks by rendering at the document root. You ' + 'should look for environment dependent code in your components ' + 'and ensure the props are the same client and server side:\n%s', difference) : invariant(false) : undefined;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\n%s', difference) : undefined;
}
}
}
!(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document but ' + 'you didn\'t use server rendering. We can\'t do this ' + 'without using server rendering due to cross-browser quirks. ' + 'See ReactDOMServer.renderToString() for server rendering.') : invariant(false) : undefined;
if (transaction.useCreateElement) {
while (container.lastChild) {
container.removeChild(container.lastChild);
}
container.appendChild(markup);
} else {
setInnerHTML(container, markup);
}
},
ownerDocumentContextKey: ownerDocumentContextKey,
/**
* React ID utilities.
*/
getReactRootID: getReactRootID,
getID: getID,
setID: setID,
getNode: getNode,
getNodeFromInstance: getNodeFromInstance,
isValid: isValid,
purgeID: purgeID
};
ReactPerf.measureMethods(ReactMount, 'ReactMount', {
_renderNewRootComponent: '_renderNewRootComponent',
_mountImageIntoNode: '_mountImageIntoNode'
});
module.exports = ReactMount;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactBrowserEventEmitter
* @typechecks static-only
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventPluginHub = __webpack_require__(31);
var EventPluginRegistry = __webpack_require__(32);
var ReactEventEmitterMixin = __webpack_require__(37);
var ReactPerf = __webpack_require__(18);
var ViewportMetrics = __webpack_require__(38);
var assign = __webpack_require__(39);
var isEventSupported = __webpack_require__(40);
/**
* Summary of `ReactBrowserEventEmitter` event handling:
*
* - Top-level delegation is used to trap most native browser events. This
* may only occur in the main thread and is the responsibility of
* ReactEventListener, which is injected and can therefore support pluggable
* event sources. This is the only work that occurs in the main thread.
*
* - We normalize and de-duplicate events to account for browser quirks. This
* may be done in the worker thread.
*
* - Forward these native events (with the associated top-level type used to
* trap it) to `EventPluginHub`, which in turn will ask plugins if they want
* to extract any synthetic events.
*
* - The `EventPluginHub` will then process each event by annotating them with
* "dispatches", a sequence of listeners and IDs that care about that event.
*
* - The `EventPluginHub` then dispatches the events.
*
* Overview of React and the event system:
*
* +------------+ .
* | DOM | .
* +------------+ .
* | .
* v .
* +------------+ .
* | ReactEvent | .
* | Listener | .
* +------------+ . +-----------+
* | . +--------+|SimpleEvent|
* | . | |Plugin |
* +-----|------+ . v +-----------+
* | | | . +--------------+ +------------+
* | +-----------.--->|EventPluginHub| | Event |
* | | . | | +-----------+ | Propagators|
* | ReactEvent | . | | |TapEvent | |------------|
* | Emitter | . | |<---+|Plugin | |other plugin|
* | | . | | +-----------+ | utilities |
* | +-----------.--->| | +------------+
* | | | . +--------------+
* +-----|------+ . ^ +-----------+
* | . | |Enter/Leave|
* + . +-------+|Plugin |
* +-------------+ . +-----------+
* | application | .
* |-------------| .
* | | .
* | | .
* +-------------+ .
* .
* React Core . General Purpose Event Plugin System
*/
var alreadyListeningTo = {};
var isMonitoringScrollValue = false;
var reactTopListenersCounter = 0;
// For events like 'submit' which don't consistently bubble (which we trap at a
// lower node than `document`), binding at `document` would cause duplicate
// events so we don't include them here
var topEventMapping = {
topAbort: 'abort',
topBlur: 'blur',
topCanPlay: 'canplay',
topCanPlayThrough: 'canplaythrough',
topChange: 'change',
topClick: 'click',
topCompositionEnd: 'compositionend',
topCompositionStart: 'compositionstart',
topCompositionUpdate: 'compositionupdate',
topContextMenu: 'contextmenu',
topCopy: 'copy',
topCut: 'cut',
topDoubleClick: 'dblclick',
topDrag: 'drag',
topDragEnd: 'dragend',
topDragEnter: 'dragenter',
topDragExit: 'dragexit',
topDragLeave: 'dragleave',
topDragOver: 'dragover',
topDragStart: 'dragstart',
topDrop: 'drop',
topDurationChange: 'durationchange',
topEmptied: 'emptied',
topEncrypted: 'encrypted',
topEnded: 'ended',
topError: 'error',
topFocus: 'focus',
topInput: 'input',
topKeyDown: 'keydown',
topKeyPress: 'keypress',
topKeyUp: 'keyup',
topLoadedData: 'loadeddata',
topLoadedMetadata: 'loadedmetadata',
topLoadStart: 'loadstart',
topMouseDown: 'mousedown',
topMouseMove: 'mousemove',
topMouseOut: 'mouseout',
topMouseOver: 'mouseover',
topMouseUp: 'mouseup',
topPaste: 'paste',
topPause: 'pause',
topPlay: 'play',
topPlaying: 'playing',
topProgress: 'progress',
topRateChange: 'ratechange',
topScroll: 'scroll',
topSeeked: 'seeked',
topSeeking: 'seeking',
topSelectionChange: 'selectionchange',
topStalled: 'stalled',
topSuspend: 'suspend',
topTextInput: 'textInput',
topTimeUpdate: 'timeupdate',
topTouchCancel: 'touchcancel',
topTouchEnd: 'touchend',
topTouchMove: 'touchmove',
topTouchStart: 'touchstart',
topVolumeChange: 'volumechange',
topWaiting: 'waiting',
topWheel: 'wheel'
};
/**
* To ensure no conflicts with other potential React instances on the page
*/
var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);
function getListeningForDocument(mountAt) {
// In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`
// directly.
if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {
mountAt[topListenersIDKey] = reactTopListenersCounter++;
alreadyListeningTo[mountAt[topListenersIDKey]] = {};
}
return alreadyListeningTo[mountAt[topListenersIDKey]];
}
/**
* `ReactBrowserEventEmitter` is used to attach top-level event listeners. For
* example:
*
* ReactBrowserEventEmitter.putListener('myID', 'onClick', myFunction);
*
* This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.
*
* @internal
*/
var ReactBrowserEventEmitter = assign({}, ReactEventEmitterMixin, {
/**
* Injectable event backend
*/
ReactEventListener: null,
injection: {
/**
* @param {object} ReactEventListener
*/
injectReactEventListener: function (ReactEventListener) {
ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel);
ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;
}
},
/**
* Sets whether or not any created callbacks should be enabled.
*
* @param {boolean} enabled True if callbacks should be enabled.
*/
setEnabled: function (enabled) {
if (ReactBrowserEventEmitter.ReactEventListener) {
ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);
}
},
/**
* @return {boolean} True if callbacks are enabled.
*/
isEnabled: function () {
return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled());
},
/**
* We listen for bubbled touch events on the document object.
*
* Firefox v8.01 (and possibly others) exhibited strange behavior when
* mounting `onmousemove` events at some node that was not the document
* element. The symptoms were that if your mouse is not moving over something
* contained within that mount point (for example on the background) the
* top-level listeners for `onmousemove` won't be called. However, if you
* register the `mousemove` on the document object, then it will of course
* catch all `mousemove`s. This along with iOS quirks, justifies restricting
* top-level listeners to the document object only, at least for these
* movement types of events and possibly all events.
*
* @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
*
* Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but
* they bubble to document.
*
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @param {object} contentDocumentHandle Document which owns the container
*/
listenTo: function (registrationName, contentDocumentHandle) {
var mountAt = contentDocumentHandle;
var isListening = getListeningForDocument(mountAt);
var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];
var topLevelTypes = EventConstants.topLevelTypes;
for (var i = 0; i < dependencies.length; i++) {
var dependency = dependencies[i];
if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {
if (dependency === topLevelTypes.topWheel) {
if (isEventSupported('wheel')) {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topWheel, 'wheel', mountAt);
} else if (isEventSupported('mousewheel')) {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topWheel, 'mousewheel', mountAt);
} else {
// Firefox needs to capture a different mouse scroll event.
// @see http://www.quirksmode.org/dom/events/tests/scroll.html
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topWheel, 'DOMMouseScroll', mountAt);
}
} else if (dependency === topLevelTypes.topScroll) {
if (isEventSupported('scroll', true)) {
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topScroll, 'scroll', mountAt);
} else {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topScroll, 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);
}
} else if (dependency === topLevelTypes.topFocus || dependency === topLevelTypes.topBlur) {
if (isEventSupported('focus', true)) {
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topFocus, 'focus', mountAt);
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topBlur, 'blur', mountAt);
} else if (isEventSupported('focusin')) {
// IE has `focusin` and `focusout` events which bubble.
// @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topFocus, 'focusin', mountAt);
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topBlur, 'focusout', mountAt);
}
// to make sure blur and focus event listeners are only attached once
isListening[topLevelTypes.topBlur] = true;
isListening[topLevelTypes.topFocus] = true;
} else if (topEventMapping.hasOwnProperty(dependency)) {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt);
}
isListening[dependency] = true;
}
}
},
trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle);
},
trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle);
},
/**
* Listens to window scroll and resize events. We cache scroll values so that
* application code can access them without triggering reflows.
*
* NOTE: Scroll events do not bubble.
*
* @see http://www.quirksmode.org/dom/events/scroll.html
*/
ensureScrollValueMonitoring: function () {
if (!isMonitoringScrollValue) {
var refresh = ViewportMetrics.refreshScrollValues;
ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
isMonitoringScrollValue = true;
}
},
eventNameDispatchConfigs: EventPluginHub.eventNameDispatchConfigs,
registrationNameModules: EventPluginHub.registrationNameModules,
putListener: EventPluginHub.putListener,
getListener: EventPluginHub.getListener,
deleteListener: EventPluginHub.deleteListener,
deleteAllListeners: EventPluginHub.deleteAllListeners
});
ReactPerf.measureMethods(ReactBrowserEventEmitter, 'ReactBrowserEventEmitter', {
putListener: 'putListener',
deleteListener: 'deleteListener'
});
module.exports = ReactBrowserEventEmitter;
/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule EventConstants
*/
'use strict';
var keyMirror = __webpack_require__(17);
var PropagationPhases = keyMirror({ bubbled: null, captured: null });
/**
* Types of raw signals from the browser caught at the top level.
*/
var topLevelTypes = keyMirror({
topAbort: null,
topBlur: null,
topCanPlay: null,
topCanPlayThrough: null,
topChange: null,
topClick: null,
topCompositionEnd: null,
topCompositionStart: null,
topCompositionUpdate: null,
topContextMenu: null,
topCopy: null,
topCut: null,
topDoubleClick: null,
topDrag: null,
topDragEnd: null,
topDragEnter: null,
topDragExit: null,
topDragLeave: null,
topDragOver: null,
topDragStart: null,
topDrop: null,
topDurationChange: null,
topEmptied: null,
topEncrypted: null,
topEnded: null,
topError: null,
topFocus: null,
topInput: null,
topKeyDown: null,
topKeyPress: null,
topKeyUp: null,
topLoad: null,
topLoadedData: null,
topLoadedMetadata: null,
topLoadStart: null,
topMouseDown: null,
topMouseMove: null,
topMouseOut: null,
topMouseOver: null,
topMouseUp: null,
topPaste: null,
topPause: null,
topPlay: null,
topPlaying: null,
topProgress: null,
topRateChange: null,
topReset: null,
topScroll: null,
topSeeked: null,
topSeeking: null,
topSelectionChange: null,
topStalled: null,
topSubmit: null,
topSuspend: null,
topTextInput: null,
topTimeUpdate: null,
topTouchCancel: null,
topTouchEnd: null,
topTouchMove: null,
topTouchStart: null,
topVolumeChange: null,
topWaiting: null,
topWheel: null
});
var EventConstants = {
topLevelTypes: topLevelTypes,
PropagationPhases: PropagationPhases
};
module.exports = EventConstants;
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule EventPluginHub
*/
'use strict';
var EventPluginRegistry = __webpack_require__(32);
var EventPluginUtils = __webpack_require__(33);
var ReactErrorUtils = __webpack_require__(34);
var accumulateInto = __webpack_require__(35);
var forEachAccumulated = __webpack_require__(36);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
/**
* Internal store for event listeners
*/
var listenerBank = {};
/**
* Internal queue of events that have accumulated their dispatches and are
* waiting to have their dispatches executed.
*/
var eventQueue = null;
/**
* Dispatches an event and releases it back into the pool, unless persistent.
*
* @param {?object} event Synthetic event to be dispatched.
* @param {boolean} simulated If the event is simulated (changes exn behavior)
* @private
*/
var executeDispatchesAndRelease = function (event, simulated) {
if (event) {
EventPluginUtils.executeDispatchesInOrder(event, simulated);
if (!event.isPersistent()) {
event.constructor.release(event);
}
}
};
var executeDispatchesAndReleaseSimulated = function (e) {
return executeDispatchesAndRelease(e, true);
};
var executeDispatchesAndReleaseTopLevel = function (e) {
return executeDispatchesAndRelease(e, false);
};
/**
* - `InstanceHandle`: [required] Module that performs logical traversals of DOM
* hierarchy given ids of the logical DOM elements involved.
*/
var InstanceHandle = null;
function validateInstanceHandle() {
var valid = InstanceHandle && InstanceHandle.traverseTwoPhase && InstanceHandle.traverseEnterLeave;
process.env.NODE_ENV !== 'production' ? warning(valid, 'InstanceHandle not injected before use!') : undefined;
}
/**
* This is a unified interface for event plugins to be installed and configured.
*
* Event plugins can implement the following properties:
*
* `extractEvents` {function(string, DOMEventTarget, string, object): *}
* Required. When a top-level event is fired, this method is expected to
* extract synthetic events that will in turn be queued and dispatched.
*
* `eventTypes` {object}
* Optional, plugins that fire events must publish a mapping of registration
* names that are used to register listeners. Values of this mapping must
* be objects that contain `registrationName` or `phasedRegistrationNames`.
*
* `executeDispatch` {function(object, function, string)}
* Optional, allows plugins to override how an event gets dispatched. By
* default, the listener is simply invoked.
*
* Each plugin that is injected into `EventsPluginHub` is immediately operable.
*
* @public
*/
var EventPluginHub = {
/**
* Methods for injecting dependencies.
*/
injection: {
/**
* @param {object} InjectedMount
* @public
*/
injectMount: EventPluginUtils.injection.injectMount,
/**
* @param {object} InjectedInstanceHandle
* @public
*/
injectInstanceHandle: function (InjectedInstanceHandle) {
InstanceHandle = InjectedInstanceHandle;
if (process.env.NODE_ENV !== 'production') {
validateInstanceHandle();
}
},
getInstanceHandle: function () {
if (process.env.NODE_ENV !== 'production') {
validateInstanceHandle();
}
return InstanceHandle;
},
/**
* @param {array} InjectedEventPluginOrder
* @public
*/
injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,
/**
* @param {object} injectedNamesToPlugins Map from names to plugin modules.
*/
injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName
},
eventNameDispatchConfigs: EventPluginRegistry.eventNameDispatchConfigs,
registrationNameModules: EventPluginRegistry.registrationNameModules,
/**
* Stores `listener` at `listenerBank[registrationName][id]`. Is idempotent.
*
* @param {string} id ID of the DOM element.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @param {?function} listener The callback to store.
*/
putListener: function (id, registrationName, listener) {
!(typeof listener === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : invariant(false) : undefined;
var bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {});
bankForRegistrationName[id] = listener;
var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
if (PluginModule && PluginModule.didPutListener) {
PluginModule.didPutListener(id, registrationName, listener);
}
},
/**
* @param {string} id ID of the DOM element.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @return {?function} The stored callback.
*/
getListener: function (id, registrationName) {
var bankForRegistrationName = listenerBank[registrationName];
return bankForRegistrationName && bankForRegistrationName[id];
},
/**
* Deletes a listener from the registration bank.
*
* @param {string} id ID of the DOM element.
* @param {string} registrationName Name of listener (e.g. `onClick`).
*/
deleteListener: function (id, registrationName) {
var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
if (PluginModule && PluginModule.willDeleteListener) {
PluginModule.willDeleteListener(id, registrationName);
}
var bankForRegistrationName = listenerBank[registrationName];
// TODO: This should never be null -- when is it?
if (bankForRegistrationName) {
delete bankForRegistrationName[id];
}
},
/**
* Deletes all listeners for the DOM element with the supplied ID.
*
* @param {string} id ID of the DOM element.
*/
deleteAllListeners: function (id) {
for (var registrationName in listenerBank) {
if (!listenerBank[registrationName][id]) {
continue;
}
var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
if (PluginModule && PluginModule.willDeleteListener) {
PluginModule.willDeleteListener(id, registrationName);
}
delete listenerBank[registrationName][id];
}
},
/**
* Allows registered plugins an opportunity to extract events from top-level
* native browser events.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {*} An accumulation of synthetic events.
* @internal
*/
extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
var events;
var plugins = EventPluginRegistry.plugins;
for (var i = 0; i < plugins.length; i++) {
// Not every plugin in the ordering may be loaded at runtime.
var possiblePlugin = plugins[i];
if (possiblePlugin) {
var extractedEvents = possiblePlugin.extractEvents(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget);
if (extractedEvents) {
events = accumulateInto(events, extractedEvents);
}
}
}
return events;
},
/**
* Enqueues a synthetic event that should be dispatched when
* `processEventQueue` is invoked.
*
* @param {*} events An accumulation of synthetic events.
* @internal
*/
enqueueEvents: function (events) {
if (events) {
eventQueue = accumulateInto(eventQueue, events);
}
},
/**
* Dispatches all synthetic events on the event queue.
*
* @internal
*/
processEventQueue: function (simulated) {
// Set `eventQueue` to null before processing it so that we can tell if more
// events get enqueued while processing.
var processingEventQueue = eventQueue;
eventQueue = null;
if (simulated) {
forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
} else {
forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
}
!!eventQueue ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing ' + 'an event queue. Support for this has not yet been implemented.') : invariant(false) : undefined;
// This would be a good time to rethrow if any of the event handlers threw.
ReactErrorUtils.rethrowCaughtError();
},
/**
* These are needed for tests only. Do not use!
*/
__purge: function () {
listenerBank = {};
},
__getListenerBank: function () {
return listenerBank;
}
};
module.exports = EventPluginHub;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule EventPluginRegistry
* @typechecks static-only
*/
'use strict';
var invariant = __webpack_require__(13);
/**
* Injectable ordering of event plugins.
*/
var EventPluginOrder = null;
/**
* Injectable mapping from names to event plugin modules.
*/
var namesToPlugins = {};
/**
* Recomputes the plugin list using the injected plugins and plugin ordering.
*
* @private
*/
function recomputePluginOrdering() {
if (!EventPluginOrder) {
// Wait until an `EventPluginOrder` is injected.
return;
}
for (var pluginName in namesToPlugins) {
var PluginModule = namesToPlugins[pluginName];
var pluginIndex = EventPluginOrder.indexOf(pluginName);
!(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in ' + 'the plugin ordering, `%s`.', pluginName) : invariant(false) : undefined;
if (EventPluginRegistry.plugins[pluginIndex]) {
continue;
}
!PluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` ' + 'method, but `%s` does not.', pluginName) : invariant(false) : undefined;
EventPluginRegistry.plugins[pluginIndex] = PluginModule;
var publishedEvents = PluginModule.eventTypes;
for (var eventName in publishedEvents) {
!publishEventForPlugin(publishedEvents[eventName], PluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : invariant(false) : undefined;
}
}
}
/**
* Publishes an event so that it can be dispatched by the supplied plugin.
*
* @param {object} dispatchConfig Dispatch configuration for the event.
* @param {object} PluginModule Plugin publishing the event.
* @return {boolean} True if the event was successfully published.
* @private
*/
function publishEventForPlugin(dispatchConfig, PluginModule, eventName) {
!!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same ' + 'event name, `%s`.', eventName) : invariant(false) : undefined;
EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
if (phasedRegistrationNames) {
for (var phaseName in phasedRegistrationNames) {
if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
var phasedRegistrationName = phasedRegistrationNames[phaseName];
publishRegistrationName(phasedRegistrationName, PluginModule, eventName);
}
}
return true;
} else if (dispatchConfig.registrationName) {
publishRegistrationName(dispatchConfig.registrationName, PluginModule, eventName);
return true;
}
return false;
}
/**
* Publishes a registration name that is used to identify dispatched events and
* can be used with `EventPluginHub.putListener` to register listeners.
*
* @param {string} registrationName Registration name to add.
* @param {object} PluginModule Plugin publishing the event.
* @private
*/
function publishRegistrationName(registrationName, PluginModule, eventName) {
!!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same ' + 'registration name, `%s`.', registrationName) : invariant(false) : undefined;
EventPluginRegistry.registrationNameModules[registrationName] = PluginModule;
EventPluginRegistry.registrationNameDependencies[registrationName] = PluginModule.eventTypes[eventName].dependencies;
}
/**
* Registers plugins so that they can extract and dispatch events.
*
* @see {EventPluginHub}
*/
var EventPluginRegistry = {
/**
* Ordered list of injected plugins.
*/
plugins: [],
/**
* Mapping from event name to dispatch config
*/
eventNameDispatchConfigs: {},
/**
* Mapping from registration name to plugin module
*/
registrationNameModules: {},
/**
* Mapping from registration name to event name
*/
registrationNameDependencies: {},
/**
* Injects an ordering of plugins (by plugin name). This allows the ordering
* to be decoupled from injection of the actual plugins so that ordering is
* always deterministic regardless of packaging, on-the-fly injection, etc.
*
* @param {array} InjectedEventPluginOrder
* @internal
* @see {EventPluginHub.injection.injectEventPluginOrder}
*/
injectEventPluginOrder: function (InjectedEventPluginOrder) {
!!EventPluginOrder ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than ' + 'once. You are likely trying to load more than one copy of React.') : invariant(false) : undefined;
// Clone the ordering so it cannot be dynamically mutated.
EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder);
recomputePluginOrdering();
},
/**
* Injects plugins to be used by `EventPluginHub`. The plugin names must be
* in the ordering injected by `injectEventPluginOrder`.
*
* Plugins can be injected as part of page initialization or on-the-fly.
*
* @param {object} injectedNamesToPlugins Map from names to plugin modules.
* @internal
* @see {EventPluginHub.injection.injectEventPluginsByName}
*/
injectEventPluginsByName: function (injectedNamesToPlugins) {
var isOrderingDirty = false;
for (var pluginName in injectedNamesToPlugins) {
if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
continue;
}
var PluginModule = injectedNamesToPlugins[pluginName];
if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== PluginModule) {
!!namesToPlugins[pluginName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins ' + 'using the same name, `%s`.', pluginName) : invariant(false) : undefined;
namesToPlugins[pluginName] = PluginModule;
isOrderingDirty = true;
}
}
if (isOrderingDirty) {
recomputePluginOrdering();
}
},
/**
* Looks up the plugin for the supplied event.
*
* @param {object} event A synthetic event.
* @return {?object} The plugin that created the supplied event.
* @internal
*/
getPluginModuleForEvent: function (event) {
var dispatchConfig = event.dispatchConfig;
if (dispatchConfig.registrationName) {
return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;
}
for (var phase in dispatchConfig.phasedRegistrationNames) {
if (!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)) {
continue;
}
var PluginModule = EventPluginRegistry.registrationNameModules[dispatchConfig.phasedRegistrationNames[phase]];
if (PluginModule) {
return PluginModule;
}
}
return null;
},
/**
* Exposed for unit testing.
* @private
*/
_resetEventPlugins: function () {
EventPluginOrder = null;
for (var pluginName in namesToPlugins) {
if (namesToPlugins.hasOwnProperty(pluginName)) {
delete namesToPlugins[pluginName];
}
}
EventPluginRegistry.plugins.length = 0;
var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
for (var eventName in eventNameDispatchConfigs) {
if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
delete eventNameDispatchConfigs[eventName];
}
}
var registrationNameModules = EventPluginRegistry.registrationNameModules;
for (var registrationName in registrationNameModules) {
if (registrationNameModules.hasOwnProperty(registrationName)) {
delete registrationNameModules[registrationName];
}
}
}
};
module.exports = EventPluginRegistry;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule EventPluginUtils
*/
'use strict';
var EventConstants = __webpack_require__(30);
var ReactErrorUtils = __webpack_require__(34);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
/**
* Injected dependencies:
*/
/**
* - `Mount`: [required] Module that can convert between React dom IDs and
* actual node references.
*/
var injection = {
Mount: null,
injectMount: function (InjectedMount) {
injection.Mount = InjectedMount;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(InjectedMount && InjectedMount.getNode && InjectedMount.getID, 'EventPluginUtils.injection.injectMount(...): Injected Mount ' + 'module is missing getNode or getID.') : undefined;
}
}
};
var topLevelTypes = EventConstants.topLevelTypes;
function isEndish(topLevelType) {
return topLevelType === topLevelTypes.topMouseUp || topLevelType === topLevelTypes.topTouchEnd || topLevelType === topLevelTypes.topTouchCancel;
}
function isMoveish(topLevelType) {
return topLevelType === topLevelTypes.topMouseMove || topLevelType === topLevelTypes.topTouchMove;
}
function isStartish(topLevelType) {
return topLevelType === topLevelTypes.topMouseDown || topLevelType === topLevelTypes.topTouchStart;
}
var validateEventDispatches;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches = function (event) {
var dispatchListeners = event._dispatchListeners;
var dispatchIDs = event._dispatchIDs;
var listenersIsArr = Array.isArray(dispatchListeners);
var idsIsArr = Array.isArray(dispatchIDs);
var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0;
var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
process.env.NODE_ENV !== 'production' ? warning(idsIsArr === listenersIsArr && IDsLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : undefined;
};
}
/**
* Dispatch the event to the listener.
* @param {SyntheticEvent} event SyntheticEvent to handle
* @param {boolean} simulated If the event is simulated (changes exn behavior)
* @param {function} listener Application-level callback
* @param {string} domID DOM id to pass to the callback.
*/
function executeDispatch(event, simulated, listener, domID) {
var type = event.type || 'unknown-event';
event.currentTarget = injection.Mount.getNode(domID);
if (simulated) {
ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event, domID);
} else {
ReactErrorUtils.invokeGuardedCallback(type, listener, event, domID);
}
event.currentTarget = null;
}
/**
* Standard/simple iteration through an event's collected dispatches.
*/
function executeDispatchesInOrder(event, simulated) {
var dispatchListeners = event._dispatchListeners;
var dispatchIDs = event._dispatchIDs;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
}
// Listeners and IDs are two parallel arrays that are always in sync.
executeDispatch(event, simulated, dispatchListeners[i], dispatchIDs[i]);
}
} else if (dispatchListeners) {
executeDispatch(event, simulated, dispatchListeners, dispatchIDs);
}
event._dispatchListeners = null;
event._dispatchIDs = null;
}
/**
* Standard/simple iteration through an event's collected dispatches, but stops
* at the first dispatch execution returning true, and returns that id.
*
* @return {?string} id of the first dispatch execution who's listener returns
* true, or null if no listener returned true.
*/
function executeDispatchesInOrderStopAtTrueImpl(event) {
var dispatchListeners = event._dispatchListeners;
var dispatchIDs = event._dispatchIDs;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
}
// Listeners and IDs are two parallel arrays that are always in sync.
if (dispatchListeners[i](event, dispatchIDs[i])) {
return dispatchIDs[i];
}
}
} else if (dispatchListeners) {
if (dispatchListeners(event, dispatchIDs)) {
return dispatchIDs;
}
}
return null;
}
/**
* @see executeDispatchesInOrderStopAtTrueImpl
*/
function executeDispatchesInOrderStopAtTrue(event) {
var ret = executeDispatchesInOrderStopAtTrueImpl(event);
event._dispatchIDs = null;
event._dispatchListeners = null;
return ret;
}
/**
* Execution of a "direct" dispatch - there must be at most one dispatch
* accumulated on the event or it is considered an error. It doesn't really make
* sense for an event with multiple dispatches (bubbled) to keep track of the
* return values at each dispatch execution, but it does tend to make sense when
* dealing with "direct" dispatches.
*
* @return {*} The return value of executing the single dispatch.
*/
function executeDirectDispatch(event) {
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
var dispatchListener = event._dispatchListeners;
var dispatchID = event._dispatchIDs;
!!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : invariant(false) : undefined;
var res = dispatchListener ? dispatchListener(event, dispatchID) : null;
event._dispatchListeners = null;
event._dispatchIDs = null;
return res;
}
/**
* @param {SyntheticEvent} event
* @return {boolean} True iff number of dispatches accumulated is greater than 0.
*/
function hasDispatches(event) {
return !!event._dispatchListeners;
}
/**
* General utilities that are useful in creating custom Event Plugins.
*/
var EventPluginUtils = {
isEndish: isEndish,
isMoveish: isMoveish,
isStartish: isStartish,
executeDirectDispatch: executeDirectDispatch,
executeDispatchesInOrder: executeDispatchesInOrder,
executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
hasDispatches: hasDispatches,
getNode: function (id) {
return injection.Mount.getNode(id);
},
getID: function (node) {
return injection.Mount.getID(node);
},
injection: injection
};
module.exports = EventPluginUtils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactErrorUtils
* @typechecks
*/
'use strict';
var caughtError = null;
/**
* Call a function while guarding against errors that happens within it.
*
* @param {?String} name of the guard to use for logging or debugging
* @param {Function} func The function to invoke
* @param {*} a First argument
* @param {*} b Second argument
*/
function invokeGuardedCallback(name, func, a, b) {
try {
return func(a, b);
} catch (x) {
if (caughtError === null) {
caughtError = x;
}
return undefined;
}
}
var ReactErrorUtils = {
invokeGuardedCallback: invokeGuardedCallback,
/**
* Invoked by ReactTestUtils.Simulate so that any errors thrown by the event
* handler are sure to be rethrown by rethrowCaughtError.
*/
invokeGuardedCallbackWithCatch: invokeGuardedCallback,
/**
* During execution of guarded functions we will capture the first error which
* we will rethrow to be handled by the top level error handler.
*/
rethrowCaughtError: function () {
if (caughtError) {
var error = caughtError;
caughtError = null;
throw error;
}
}
};
if (process.env.NODE_ENV !== 'production') {
/**
* To help development we can get better devtools integration by simulating a
* real browser event.
*/
if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {
var fakeNode = document.createElement('react');
ReactErrorUtils.invokeGuardedCallback = function (name, func, a, b) {
var boundFunc = func.bind(null, a, b);
var evtType = 'react-' + name;
fakeNode.addEventListener(evtType, boundFunc, false);
var evt = document.createEvent('Event');
evt.initEvent(evtType, false, false);
fakeNode.dispatchEvent(evt);
fakeNode.removeEventListener(evtType, boundFunc, false);
};
}
}
module.exports = ReactErrorUtils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule accumulateInto
*/
'use strict';
var invariant = __webpack_require__(13);
/**
*
* Accumulates items that must not be null or undefined into the first one. This
* is used to conserve memory by avoiding array allocations, and thus sacrifices
* API cleanness. Since `current` can be null before being passed in and not
* null after this function, make sure to assign it back to `current`:
*
* `a = accumulateInto(a, b);`
*
* This API should be sparingly used. Try `accumulate` for something cleaner.
*
* @return {*|array<*>} An accumulation of items.
*/
function accumulateInto(current, next) {
!(next != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : invariant(false) : undefined;
if (current == null) {
return next;
}
// Both are not empty. Warning: Never call x.concat(y) when you are not
// certain that x is an Array (x could be a string with concat method).
var currentIsArray = Array.isArray(current);
var nextIsArray = Array.isArray(next);
if (currentIsArray && nextIsArray) {
current.push.apply(current, next);
return current;
}
if (currentIsArray) {
current.push(next);
return current;
}
if (nextIsArray) {
// A bit too dangerous to mutate `next`.
return [current].concat(next);
}
return [current, next];
}
module.exports = accumulateInto;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 36 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule forEachAccumulated
*/
'use strict';
/**
* @param {array} arr an "accumulation" of items which is either an Array or
* a single item. Useful when paired with the `accumulate` module. This is a
* simple utility that allows us to reason about a collection of items, but
* handling the case when there is exactly one item (and we do not need to
* allocate an array).
*/
var forEachAccumulated = function (arr, cb, scope) {
if (Array.isArray(arr)) {
arr.forEach(cb, scope);
} else if (arr) {
cb.call(scope, arr);
}
};
module.exports = forEachAccumulated;
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactEventEmitterMixin
*/
'use strict';
var EventPluginHub = __webpack_require__(31);
function runEventQueueInBatch(events) {
EventPluginHub.enqueueEvents(events);
EventPluginHub.processEventQueue(false);
}
var ReactEventEmitterMixin = {
/**
* Streams a fired top-level event to `EventPluginHub` where plugins have the
* opportunity to create `ReactEvent`s to be dispatched.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {object} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native environment event.
*/
handleTopLevel: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
var events = EventPluginHub.extractEvents(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget);
runEventQueueInBatch(events);
}
};
module.exports = ReactEventEmitterMixin;
/***/ },
/* 38 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ViewportMetrics
*/
'use strict';
var ViewportMetrics = {
currentScrollLeft: 0,
currentScrollTop: 0,
refreshScrollValues: function (scrollPosition) {
ViewportMetrics.currentScrollLeft = scrollPosition.x;
ViewportMetrics.currentScrollTop = scrollPosition.y;
}
};
module.exports = ViewportMetrics;
/***/ },
/* 39 */
/***/ function(module, exports) {
/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule Object.assign
*/
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign
'use strict';
function assign(target, sources) {
if (target == null) {
throw new TypeError('Object.assign target cannot be null or undefined');
}
var to = Object(target);
var hasOwnProperty = Object.prototype.hasOwnProperty;
for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {
var nextSource = arguments[nextIndex];
if (nextSource == null) {
continue;
}
var from = Object(nextSource);
// We don't currently support accessors nor proxies. Therefore this
// copy cannot throw. If we ever supported this then we must handle
// exceptions and side-effects. We don't support symbols so they won't
// be transferred.
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
}
return to;
}
module.exports = assign;
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule isEventSupported
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var useHasFeature;
if (ExecutionEnvironment.canUseDOM) {
useHasFeature = document.implementation && document.implementation.hasFeature &&
// always returns true in newer browsers as per the standard.
// @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
document.implementation.hasFeature('', '') !== true;
}
/**
* Checks if an event is supported in the current execution environment.
*
* NOTE: This will not work correctly for non-generic events such as `change`,
* `reset`, `load`, `error`, and `select`.
*
* Borrows from Modernizr.
*
* @param {string} eventNameSuffix Event name, e.g. "click".
* @param {?boolean} capture Check if the capture phase is supported.
* @return {boolean} True if the event is supported.
* @internal
* @license Modernizr 3.0.0pre (Custom Build) | MIT
*/
function isEventSupported(eventNameSuffix, capture) {
if (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {
return false;
}
var eventName = 'on' + eventNameSuffix;
var isSupported = (eventName in document);
if (!isSupported) {
var element = document.createElement('div');
element.setAttribute(eventName, 'return;');
isSupported = typeof element[eventName] === 'function';
}
if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {
// This is the only way to test support for the `wheel` event in IE9+.
isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
}
return isSupported;
}
module.exports = isEventSupported;
/***/ },
/* 41 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMFeatureFlags
*/
'use strict';
var ReactDOMFeatureFlags = {
useCreateElement: false
};
module.exports = ReactDOMFeatureFlags;
/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactElement
*/
'use strict';
var ReactCurrentOwner = __webpack_require__(5);
var assign = __webpack_require__(39);
var canDefineProperty = __webpack_require__(43);
// The Symbol used to tag the ReactElement type. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true
};
/**
* Base constructor for all React elements. This is only used to make this
* work with a dynamic instanceof check. Nothing should live on this prototype.
*
* @param {*} type
* @param {*} key
* @param {string|object} ref
* @param {*} self A *temporary* helper to detect places where `this` is
* different from the `owner` when React.createElement is called, so that we
* can warn. We want to get rid of owner and replace string `ref`s with arrow
* functions, and as long as `this` and owner are the same, there will be no
* change in behavior.
* @param {*} source An annotation object (added by a transpiler or otherwise)
* indicating filename, line number, and/or other information.
* @param {*} owner
* @param {*} props
* @internal
*/
var ReactElement = function (type, key, ref, self, source, owner, props) {
var element = {
// This tag allow us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type: type,
key: key,
ref: ref,
props: props,
// Record the component responsible for creating this element.
_owner: owner
};
if (process.env.NODE_ENV !== 'production') {
// The validation flag is currently mutative. We put it on
// an external backing store so that we can freeze the whole object.
// This can be replaced with a WeakMap once they are implemented in
// commonly used development environments.
element._store = {};
// To make comparing ReactElements easier for testing purposes, we make
// the validation flag non-enumerable (where possible, which should
// include every environment we run tests in), so the test framework
// ignores it.
if (canDefineProperty) {
Object.defineProperty(element._store, 'validated', {
configurable: false,
enumerable: false,
writable: true,
value: false
});
// self and source are DEV only properties.
Object.defineProperty(element, '_self', {
configurable: false,
enumerable: false,
writable: false,
value: self
});
// Two elements created in two different places should be considered
// equal for testing purposes and therefore we hide it from enumeration.
Object.defineProperty(element, '_source', {
configurable: false,
enumerable: false,
writable: false,
value: source
});
} else {
element._store.validated = false;
element._self = self;
element._source = source;
}
Object.freeze(element.props);
Object.freeze(element);
}
return element;
};
ReactElement.createElement = function (type, config, children) {
var propName;
// Reserved names are extracted
var props = {};
var key = null;
var ref = null;
var self = null;
var source = null;
if (config != null) {
ref = config.ref === undefined ? null : config.ref;
key = config.key === undefined ? null : '' + config.key;
self = config.__self === undefined ? null : config.__self;
source = config.__source === undefined ? null : config.__source;
// Remaining properties are added to a new props object
for (propName in config) {
if (config.hasOwnProperty(propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
props[propName] = config[propName];
}
}
}
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
props.children = childArray;
}
// Resolve default props
if (type && type.defaultProps) {
var defaultProps = type.defaultProps;
for (propName in defaultProps) {
if (typeof props[propName] === 'undefined') {
props[propName] = defaultProps[propName];
}
}
}
return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
};
ReactElement.createFactory = function (type) {
var factory = ReactElement.createElement.bind(null, type);
// Expose the type on the factory and the prototype so that it can be
// easily accessed on elements. E.g. `<Foo />.type === Foo`.
// This should not be named `constructor` since this may not be the function
// that created the element, and it may not even be a constructor.
// Legacy hook TODO: Warn if this is accessed
factory.type = type;
return factory;
};
ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
return newElement;
};
ReactElement.cloneAndReplaceProps = function (oldElement, newProps) {
var newElement = ReactElement(oldElement.type, oldElement.key, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, newProps);
if (process.env.NODE_ENV !== 'production') {
// If the key on the original is valid, then the clone is valid
newElement._store.validated = oldElement._store.validated;
}
return newElement;
};
ReactElement.cloneElement = function (element, config, children) {
var propName;
// Original props are copied
var props = assign({}, element.props);
// Reserved names are extracted
var key = element.key;
var ref = element.ref;
// Self is preserved since the owner is preserved.
var self = element._self;
// Source is preserved since cloneElement is unlikely to be targeted by a
// transpiler, and the original source is probably a better indicator of the
// true owner.
var source = element._source;
// Owner will be preserved, unless ref is overridden
var owner = element._owner;
if (config != null) {
if (config.ref !== undefined) {
// Silently steal the ref from the parent.
ref = config.ref;
owner = ReactCurrentOwner.current;
}
if (config.key !== undefined) {
key = '' + config.key;
}
// Remaining properties override existing props
for (propName in config) {
if (config.hasOwnProperty(propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
props[propName] = config[propName];
}
}
}
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
props.children = childArray;
}
return ReactElement(element.type, key, ref, self, source, owner, props);
};
/**
* @param {?object} object
* @return {boolean} True if `object` is a valid component.
* @final
*/
ReactElement.isValidElement = function (object) {
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
};
module.exports = ReactElement;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule canDefineProperty
*/
'use strict';
var canDefineProperty = false;
if (process.env.NODE_ENV !== 'production') {
try {
Object.defineProperty({}, 'x', { get: function () {} });
canDefineProperty = true;
} catch (x) {
// IE will fail on defineProperty
}
}
module.exports = canDefineProperty;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 44 */
/***/ function(module, exports) {
/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactEmptyComponentRegistry
*/
'use strict';
// This registry keeps track of the React IDs of the components that rendered to
// `null` (in reality a placeholder such as `noscript`)
var nullComponentIDsRegistry = {};
/**
* @param {string} id Component's `_rootNodeID`.
* @return {boolean} True if the component is rendered to null.
*/
function isNullComponentID(id) {
return !!nullComponentIDsRegistry[id];
}
/**
* Mark the component as having rendered to null.
* @param {string} id Component's `_rootNodeID`.
*/
function registerNullComponentID(id) {
nullComponentIDsRegistry[id] = true;
}
/**
* Unmark the component as having rendered to null: it renders to something now.
* @param {string} id Component's `_rootNodeID`.
*/
function deregisterNullComponentID(id) {
delete nullComponentIDsRegistry[id];
}
var ReactEmptyComponentRegistry = {
isNullComponentID: isNullComponentID,
registerNullComponentID: registerNullComponentID,
deregisterNullComponentID: deregisterNullComponentID
};
module.exports = ReactEmptyComponentRegistry;
/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactInstanceHandles
* @typechecks static-only
*/
'use strict';
var ReactRootIndex = __webpack_require__(46);
var invariant = __webpack_require__(13);
var SEPARATOR = '.';
var SEPARATOR_LENGTH = SEPARATOR.length;
/**
* Maximum depth of traversals before we consider the possibility of a bad ID.
*/
var MAX_TREE_DEPTH = 10000;
/**
* Creates a DOM ID prefix to use when mounting React components.
*
* @param {number} index A unique integer
* @return {string} React root ID.
* @internal
*/
function getReactRootIDString(index) {
return SEPARATOR + index.toString(36);
}
/**
* Checks if a character in the supplied ID is a separator or the end.
*
* @param {string} id A React DOM ID.
* @param {number} index Index of the character to check.
* @return {boolean} True if the character is a separator or end of the ID.
* @private
*/
function isBoundary(id, index) {
return id.charAt(index) === SEPARATOR || index === id.length;
}
/**
* Checks if the supplied string is a valid React DOM ID.
*
* @param {string} id A React DOM ID, maybe.
* @return {boolean} True if the string is a valid React DOM ID.
* @private
*/
function isValidID(id) {
return id === '' || id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR;
}
/**
* Checks if the first ID is an ancestor of or equal to the second ID.
*
* @param {string} ancestorID
* @param {string} descendantID
* @return {boolean} True if `ancestorID` is an ancestor of `descendantID`.
* @internal
*/
function isAncestorIDOf(ancestorID, descendantID) {
return descendantID.indexOf(ancestorID) === 0 && isBoundary(descendantID, ancestorID.length);
}
/**
* Gets the parent ID of the supplied React DOM ID, `id`.
*
* @param {string} id ID of a component.
* @return {string} ID of the parent, or an empty string.
* @private
*/
function getParentID(id) {
return id ? id.substr(0, id.lastIndexOf(SEPARATOR)) : '';
}
/**
* Gets the next DOM ID on the tree path from the supplied `ancestorID` to the
* supplied `destinationID`. If they are equal, the ID is returned.
*
* @param {string} ancestorID ID of an ancestor node of `destinationID`.
* @param {string} destinationID ID of the destination node.
* @return {string} Next ID on the path from `ancestorID` to `destinationID`.
* @private
*/
function getNextDescendantID(ancestorID, destinationID) {
!(isValidID(ancestorID) && isValidID(destinationID)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNextDescendantID(%s, %s): Received an invalid React DOM ID.', ancestorID, destinationID) : invariant(false) : undefined;
!isAncestorIDOf(ancestorID, destinationID) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNextDescendantID(...): React has made an invalid assumption about ' + 'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.', ancestorID, destinationID) : invariant(false) : undefined;
if (ancestorID === destinationID) {
return ancestorID;
}
// Skip over the ancestor and the immediate separator. Traverse until we hit
// another separator or we reach the end of `destinationID`.
var start = ancestorID.length + SEPARATOR_LENGTH;
var i;
for (i = start; i < destinationID.length; i++) {
if (isBoundary(destinationID, i)) {
break;
}
}
return destinationID.substr(0, i);
}
/**
* Gets the nearest common ancestor ID of two IDs.
*
* Using this ID scheme, the nearest common ancestor ID is the longest common
* prefix of the two IDs that immediately preceded a "marker" in both strings.
*
* @param {string} oneID
* @param {string} twoID
* @return {string} Nearest common ancestor ID, or the empty string if none.
* @private
*/
function getFirstCommonAncestorID(oneID, twoID) {
var minLength = Math.min(oneID.length, twoID.length);
if (minLength === 0) {
return '';
}
var lastCommonMarkerIndex = 0;
// Use `<=` to traverse until the "EOL" of the shorter string.
for (var i = 0; i <= minLength; i++) {
if (isBoundary(oneID, i) && isBoundary(twoID, i)) {
lastCommonMarkerIndex = i;
} else if (oneID.charAt(i) !== twoID.charAt(i)) {
break;
}
}
var longestCommonID = oneID.substr(0, lastCommonMarkerIndex);
!isValidID(longestCommonID) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s', oneID, twoID, longestCommonID) : invariant(false) : undefined;
return longestCommonID;
}
/**
* Traverses the parent path between two IDs (either up or down). The IDs must
* not be the same, and there must exist a parent path between them. If the
* callback returns `false`, traversal is stopped.
*
* @param {?string} start ID at which to start traversal.
* @param {?string} stop ID at which to end traversal.
* @param {function} cb Callback to invoke each ID with.
* @param {*} arg Argument to invoke the callback with.
* @param {?boolean} skipFirst Whether or not to skip the first node.
* @param {?boolean} skipLast Whether or not to skip the last node.
* @private
*/
function traverseParentPath(start, stop, cb, arg, skipFirst, skipLast) {
start = start || '';
stop = stop || '';
!(start !== stop) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.', start) : invariant(false) : undefined;
var traverseUp = isAncestorIDOf(stop, start);
!(traverseUp || isAncestorIDOf(start, stop)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' + 'not have a parent path.', start, stop) : invariant(false) : undefined;
// Traverse from `start` to `stop` one depth at a time.
var depth = 0;
var traverse = traverseUp ? getParentID : getNextDescendantID;
for (var id = start;; /* until break */id = traverse(id, stop)) {
var ret;
if ((!skipFirst || id !== start) && (!skipLast || id !== stop)) {
ret = cb(id, traverseUp, arg);
}
if (ret === false || id === stop) {
// Only break //after// visiting `stop`.
break;
}
!(depth++ < MAX_TREE_DEPTH) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' + 'traversing the React DOM ID tree. This may be due to malformed IDs: %s', start, stop, id) : invariant(false) : undefined;
}
}
/**
* Manages the IDs assigned to DOM representations of React components. This
* uses a specific scheme in order to traverse the DOM efficiently (e.g. in
* order to simulate events).
*
* @internal
*/
var ReactInstanceHandles = {
/**
* Constructs a React root ID
* @return {string} A React root ID.
*/
createReactRootID: function () {
return getReactRootIDString(ReactRootIndex.createReactRootIndex());
},
/**
* Constructs a React ID by joining a root ID with a name.
*
* @param {string} rootID Root ID of a parent component.
* @param {string} name A component's name (as flattened children).
* @return {string} A React ID.
* @internal
*/
createReactID: function (rootID, name) {
return rootID + name;
},
/**
* Gets the DOM ID of the React component that is the root of the tree that
* contains the React component with the supplied DOM ID.
*
* @param {string} id DOM ID of a React component.
* @return {?string} DOM ID of the React component that is the root.
* @internal
*/
getReactRootIDFromNodeID: function (id) {
if (id && id.charAt(0) === SEPARATOR && id.length > 1) {
var index = id.indexOf(SEPARATOR, 1);
return index > -1 ? id.substr(0, index) : id;
}
return null;
},
/**
* Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that
* should would receive a `mouseEnter` or `mouseLeave` event.
*
* NOTE: Does not invoke the callback on the nearest common ancestor because
* nothing "entered" or "left" that element.
*
* @param {string} leaveID ID being left.
* @param {string} enterID ID being entered.
* @param {function} cb Callback to invoke on each entered/left ID.
* @param {*} upArg Argument to invoke the callback with on left IDs.
* @param {*} downArg Argument to invoke the callback with on entered IDs.
* @internal
*/
traverseEnterLeave: function (leaveID, enterID, cb, upArg, downArg) {
var ancestorID = getFirstCommonAncestorID(leaveID, enterID);
if (ancestorID !== leaveID) {
traverseParentPath(leaveID, ancestorID, cb, upArg, false, true);
}
if (ancestorID !== enterID) {
traverseParentPath(ancestorID, enterID, cb, downArg, true, false);
}
},
/**
* Simulates the traversal of a two-phase, capture/bubble event dispatch.
*
* NOTE: This traversal happens on IDs without touching the DOM.
*
* @param {string} targetID ID of the target node.
* @param {function} cb Callback to invoke.
* @param {*} arg Argument to invoke the callback with.
* @internal
*/
traverseTwoPhase: function (targetID, cb, arg) {
if (targetID) {
traverseParentPath('', targetID, cb, arg, true, false);
traverseParentPath(targetID, '', cb, arg, false, true);
}
},
/**
* Same as `traverseTwoPhase` but skips the `targetID`.
*/
traverseTwoPhaseSkipTarget: function (targetID, cb, arg) {
if (targetID) {
traverseParentPath('', targetID, cb, arg, true, true);
traverseParentPath(targetID, '', cb, arg, true, true);
}
},
/**
* Traverse a node ID, calling the supplied `cb` for each ancestor ID. For
* example, passing `.0.$row-0.1` would result in `cb` getting called
* with `.0`, `.0.$row-0`, and `.0.$row-0.1`.
*
* NOTE: This traversal happens on IDs without touching the DOM.
*
* @param {string} targetID ID of the target node.
* @param {function} cb Callback to invoke.
* @param {*} arg Argument to invoke the callback with.
* @internal
*/
traverseAncestors: function (targetID, cb, arg) {
traverseParentPath('', targetID, cb, arg, true, false);
},
getFirstCommonAncestorID: getFirstCommonAncestorID,
/**
* Exposed for unit testing.
* @private
*/
_getNextDescendantID: getNextDescendantID,
isAncestorIDOf: isAncestorIDOf,
SEPARATOR: SEPARATOR
};
module.exports = ReactInstanceHandles;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 46 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactRootIndex
* @typechecks
*/
'use strict';
var ReactRootIndexInjection = {
/**
* @param {function} _createReactRootIndex
*/
injectCreateReactRootIndex: function (_createReactRootIndex) {
ReactRootIndex.createReactRootIndex = _createReactRootIndex;
}
};
var ReactRootIndex = {
createReactRootIndex: null,
injection: ReactRootIndexInjection
};
module.exports = ReactRootIndex;
/***/ },
/* 47 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactInstanceMap
*/
'use strict';
/**
* `ReactInstanceMap` maintains a mapping from a public facing stateful
* instance (key) and the internal representation (value). This allows public
* methods to accept the user facing instance as an argument and map them back
* to internal methods.
*/
// TODO: Replace this with ES6: var ReactInstanceMap = new Map();
var ReactInstanceMap = {
/**
* This API should be called `delete` but we'd have to make sure to always
* transform these to strings for IE support. When this transform is fully
* supported we can rename it.
*/
remove: function (key) {
key._reactInternalInstance = undefined;
},
get: function (key) {
return key._reactInternalInstance;
},
has: function (key) {
return key._reactInternalInstance !== undefined;
},
set: function (key, value) {
key._reactInternalInstance = value;
}
};
module.exports = ReactInstanceMap;
/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactMarkupChecksum
*/
'use strict';
var adler32 = __webpack_require__(49);
var TAG_END = /\/?>/;
var ReactMarkupChecksum = {
CHECKSUM_ATTR_NAME: 'data-react-checksum',
/**
* @param {string} markup Markup string
* @return {string} Markup string with checksum attribute attached
*/
addChecksumToMarkup: function (markup) {
var checksum = adler32(markup);
// Add checksum (handle both parent tags and self-closing tags)
return markup.replace(TAG_END, ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '"$&');
},
/**
* @param {string} markup to use
* @param {DOMElement} element root React element
* @returns {boolean} whether or not the markup is the same
*/
canReuseMarkup: function (markup, element) {
var existingChecksum = element.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
existingChecksum = existingChecksum && parseInt(existingChecksum, 10);
var markupChecksum = adler32(markup);
return markupChecksum === existingChecksum;
}
};
module.exports = ReactMarkupChecksum;
/***/ },
/* 49 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule adler32
*/
'use strict';
var MOD = 65521;
// adler32 is not cryptographically strong, and is only used to sanity check that
// markup generated on the server matches the markup generated on the client.
// This implementation (a modified version of the SheetJS version) has been optimized
// for our use case, at the expense of conforming to the adler32 specification
// for non-ascii inputs.
function adler32(data) {
var a = 1;
var b = 0;
var i = 0;
var l = data.length;
var m = l & ~0x3;
while (i < m) {
for (; i < Math.min(i + 4096, m); i += 4) {
b += (a += data.charCodeAt(i)) + (a += data.charCodeAt(i + 1)) + (a += data.charCodeAt(i + 2)) + (a += data.charCodeAt(i + 3));
}
a %= MOD;
b %= MOD;
}
for (; i < l; i++) {
b += a += data.charCodeAt(i);
}
a %= MOD;
b %= MOD;
return a | b << 16;
}
module.exports = adler32;
/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactReconciler
*/
'use strict';
var ReactRef = __webpack_require__(51);
/**
* Helper to call ReactRef.attachRefs with this composite component, split out
* to avoid allocations in the transaction mount-ready queue.
*/
function attachRefs() {
ReactRef.attachRefs(this, this._currentElement);
}
var ReactReconciler = {
/**
* Initializes the component, renders markup, and registers event listeners.
*
* @param {ReactComponent} internalInstance
* @param {string} rootID DOM ID of the root node.
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @return {?string} Rendered markup to be inserted into the DOM.
* @final
* @internal
*/
mountComponent: function (internalInstance, rootID, transaction, context) {
var markup = internalInstance.mountComponent(rootID, transaction, context);
if (internalInstance._currentElement && internalInstance._currentElement.ref != null) {
transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
}
return markup;
},
/**
* Releases any resources allocated by `mountComponent`.
*
* @final
* @internal
*/
unmountComponent: function (internalInstance) {
ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
internalInstance.unmountComponent();
},
/**
* Update a component using a new element.
*
* @param {ReactComponent} internalInstance
* @param {ReactElement} nextElement
* @param {ReactReconcileTransaction} transaction
* @param {object} context
* @internal
*/
receiveComponent: function (internalInstance, nextElement, transaction, context) {
var prevElement = internalInstance._currentElement;
if (nextElement === prevElement && context === internalInstance._context) {
// Since elements are immutable after the owner is rendered,
// we can do a cheap identity compare here to determine if this is a
// superfluous reconcile. It's possible for state to be mutable but such
// change should trigger an update of the owner which would recreate
// the element. We explicitly check for the existence of an owner since
// it's possible for an element created outside a composite to be
// deeply mutated and reused.
// TODO: Bailing out early is just a perf optimization right?
// TODO: Removing the return statement should affect correctness?
return;
}
var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
if (refsChanged) {
ReactRef.detachRefs(internalInstance, prevElement);
}
internalInstance.receiveComponent(nextElement, transaction, context);
if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) {
transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
}
},
/**
* Flush any dirty changes in a component.
*
* @param {ReactComponent} internalInstance
* @param {ReactReconcileTransaction} transaction
* @internal
*/
performUpdateIfNecessary: function (internalInstance, transaction) {
internalInstance.performUpdateIfNecessary(transaction);
}
};
module.exports = ReactReconciler;
/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactRef
*/
'use strict';
var ReactOwner = __webpack_require__(52);
var ReactRef = {};
function attachRef(ref, component, owner) {
if (typeof ref === 'function') {
ref(component.getPublicInstance());
} else {
// Legacy ref
ReactOwner.addComponentAsRefTo(component, ref, owner);
}
}
function detachRef(ref, component, owner) {
if (typeof ref === 'function') {
ref(null);
} else {
// Legacy ref
ReactOwner.removeComponentAsRefFrom(component, ref, owner);
}
}
ReactRef.attachRefs = function (instance, element) {
if (element === null || element === false) {
return;
}
var ref = element.ref;
if (ref != null) {
attachRef(ref, instance, element._owner);
}
};
ReactRef.shouldUpdateRefs = function (prevElement, nextElement) {
// If either the owner or a `ref` has changed, make sure the newest owner
// has stored a reference to `this`, and the previous owner (if different)
// has forgotten the reference to `this`. We use the element instead
// of the public this.props because the post processing cannot determine
// a ref. The ref conceptually lives on the element.
// TODO: Should this even be possible? The owner cannot change because
// it's forbidden by shouldUpdateReactComponent. The ref can change
// if you swap the keys of but not the refs. Reconsider where this check
// is made. It probably belongs where the key checking and
// instantiateReactComponent is done.
var prevEmpty = prevElement === null || prevElement === false;
var nextEmpty = nextElement === null || nextElement === false;
return(
// This has a few false positives w/r/t empty components.
prevEmpty || nextEmpty || nextElement._owner !== prevElement._owner || nextElement.ref !== prevElement.ref
);
};
ReactRef.detachRefs = function (instance, element) {
if (element === null || element === false) {
return;
}
var ref = element.ref;
if (ref != null) {
detachRef(ref, instance, element._owner);
}
};
module.exports = ReactRef;
/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactOwner
*/
'use strict';
var invariant = __webpack_require__(13);
/**
* ReactOwners are capable of storing references to owned components.
*
* All components are capable of //being// referenced by owner components, but
* only ReactOwner components are capable of //referencing// owned components.
* The named reference is known as a "ref".
*
* Refs are available when mounted and updated during reconciliation.
*
* var MyComponent = React.createClass({
* render: function() {
* return (
* <div onClick={this.handleClick}>
* <CustomComponent ref="custom" />
* </div>
* );
* },
* handleClick: function() {
* this.refs.custom.handleClick();
* },
* componentDidMount: function() {
* this.refs.custom.initialize();
* }
* });
*
* Refs should rarely be used. When refs are used, they should only be done to
* control data that is not handled by React's data flow.
*
* @class ReactOwner
*/
var ReactOwner = {
/**
* @param {?object} object
* @return {boolean} True if `object` is a valid owner.
* @final
*/
isValidOwner: function (object) {
return !!(object && typeof object.attachRef === 'function' && typeof object.detachRef === 'function');
},
/**
* Adds a component by ref to an owner component.
*
* @param {ReactComponent} component Component to reference.
* @param {string} ref Name by which to refer to the component.
* @param {ReactOwner} owner Component on which to record the ref.
* @final
* @internal
*/
addComponentAsRefTo: function (component, ref, owner) {
!ReactOwner.isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'addComponentAsRefTo(...): Only a ReactOwner can have refs. You might ' + 'be adding a ref to a component that was not created inside a component\'s ' + '`render` method, or you have multiple copies of React loaded ' + '(details: https://fb.me/react-refs-must-have-owner).') : invariant(false) : undefined;
owner.attachRef(ref, component);
},
/**
* Removes a component by ref from an owner component.
*
* @param {ReactComponent} component Component to dereference.
* @param {string} ref Name of the ref to remove.
* @param {ReactOwner} owner Component on which the ref is recorded.
* @final
* @internal
*/
removeComponentAsRefFrom: function (component, ref, owner) {
!ReactOwner.isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might ' + 'be removing a ref to a component that was not created inside a component\'s ' + '`render` method, or you have multiple copies of React loaded ' + '(details: https://fb.me/react-refs-must-have-owner).') : invariant(false) : undefined;
// Check that `component` is still the current ref because we do not want to
// detach the ref if another component stole it.
if (owner.getPublicInstance().refs[ref] === component.getPublicInstance()) {
owner.detachRef(ref);
}
}
};
module.exports = ReactOwner;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactUpdateQueue
*/
'use strict';
var ReactCurrentOwner = __webpack_require__(5);
var ReactElement = __webpack_require__(42);
var ReactInstanceMap = __webpack_require__(47);
var ReactUpdates = __webpack_require__(54);
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
function enqueueUpdate(internalInstance) {
ReactUpdates.enqueueUpdate(internalInstance);
}
function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
var internalInstance = ReactInstanceMap.get(publicInstance);
if (!internalInstance) {
if (process.env.NODE_ENV !== 'production') {
// Only warn when we have a callerName. Otherwise we should be silent.
// We're probably calling from enqueueCallback. We don't want to warn
// there because we already warned for the corresponding lifecycle method.
process.env.NODE_ENV !== 'production' ? warning(!callerName, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, publicInstance.constructor.displayName) : undefined;
}
return null;
}
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '%s(...): Cannot update during an existing state transition ' + '(such as within `render`). Render methods should be a pure function ' + 'of props and state.', callerName) : undefined;
}
return internalInstance;
}
/**
* ReactUpdateQueue allows for state updates to be scheduled into a later
* reconciliation step.
*/
var ReactUpdateQueue = {
/**
* Checks whether or not this composite component is mounted.
* @param {ReactClass} publicInstance The instance we want to test.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/
isMounted: function (publicInstance) {
if (process.env.NODE_ENV !== 'production') {
var owner = ReactCurrentOwner.current;
if (owner !== null) {
process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : undefined;
owner._warnedAboutRefsInRender = true;
}
}
var internalInstance = ReactInstanceMap.get(publicInstance);
if (internalInstance) {
// During componentWillMount and render this will still be null but after
// that will always render to something. At least for now. So we can use
// this hack.
return !!internalInstance._renderedComponent;
} else {
return false;
}
},
/**
* Enqueue a callback that will be executed after all the pending updates
* have processed.
*
* @param {ReactClass} publicInstance The instance to use as `this` context.
* @param {?function} callback Called after state is updated.
* @internal
*/
enqueueCallback: function (publicInstance, callback) {
!(typeof callback === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn\'t callable.') : invariant(false) : undefined;
var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
// Previously we would throw an error if we didn't have an internal
// instance. Since we want to make it a no-op instead, we mirror the same
// behavior we have in other enqueue* methods.
// We also need to ignore callbacks in componentWillMount. See
// enqueueUpdates.
if (!internalInstance) {
return null;
}
if (internalInstance._pendingCallbacks) {
internalInstance._pendingCallbacks.push(callback);
} else {
internalInstance._pendingCallbacks = [callback];
}
// TODO: The callback here is ignored when setState is called from
// componentWillMount. Either fix it or disallow doing so completely in
// favor of getInitialState. Alternatively, we can disallow
// componentWillMount during server-side rendering.
enqueueUpdate(internalInstance);
},
enqueueCallbackInternal: function (internalInstance, callback) {
!(typeof callback === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn\'t callable.') : invariant(false) : undefined;
if (internalInstance._pendingCallbacks) {
internalInstance._pendingCallbacks.push(callback);
} else {
internalInstance._pendingCallbacks = [callback];
}
enqueueUpdate(internalInstance);
},
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @internal
*/
enqueueForceUpdate: function (publicInstance) {
var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'forceUpdate');
if (!internalInstance) {
return;
}
internalInstance._pendingForceUpdate = true;
enqueueUpdate(internalInstance);
},
/**
* Replaces all of the state. Always use this or `setState` to mutate state.
* You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} completeState Next state.
* @internal
*/
enqueueReplaceState: function (publicInstance, completeState) {
var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceState');
if (!internalInstance) {
return;
}
internalInstance._pendingStateQueue = [completeState];
internalInstance._pendingReplaceState = true;
enqueueUpdate(internalInstance);
},
/**
* Sets a subset of the state. This only exists because _pendingState is
* internal. This provides a merging strategy that is not available to deep
* properties which is confusing. TODO: Expose pendingState or don't use it
* during the merge.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialState Next partial state to be merged with state.
* @internal
*/
enqueueSetState: function (publicInstance, partialState) {
var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setState');
if (!internalInstance) {
return;
}
var queue = internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = []);
queue.push(partialState);
enqueueUpdate(internalInstance);
},
/**
* Sets a subset of the props.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialProps Subset of the next props.
* @internal
*/
enqueueSetProps: function (publicInstance, partialProps) {
var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setProps');
if (!internalInstance) {
return;
}
ReactUpdateQueue.enqueueSetPropsInternal(internalInstance, partialProps);
},
enqueueSetPropsInternal: function (internalInstance, partialProps) {
var topLevelWrapper = internalInstance._topLevelWrapper;
!topLevelWrapper ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setProps(...): You called `setProps` on a ' + 'component with a parent. This is an anti-pattern since props will ' + 'get reactively updated when rendered. Instead, change the owner\'s ' + '`render` method to pass the correct value as props to the component ' + 'where it is created.') : invariant(false) : undefined;
// Merge with the pending element if it exists, otherwise with existing
// element props.
var wrapElement = topLevelWrapper._pendingElement || topLevelWrapper._currentElement;
var element = wrapElement.props;
var props = assign({}, element.props, partialProps);
topLevelWrapper._pendingElement = ReactElement.cloneAndReplaceProps(wrapElement, ReactElement.cloneAndReplaceProps(element, props));
enqueueUpdate(topLevelWrapper);
},
/**
* Replaces all of the props.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} props New props.
* @internal
*/
enqueueReplaceProps: function (publicInstance, props) {
var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceProps');
if (!internalInstance) {
return;
}
ReactUpdateQueue.enqueueReplacePropsInternal(internalInstance, props);
},
enqueueReplacePropsInternal: function (internalInstance, props) {
var topLevelWrapper = internalInstance._topLevelWrapper;
!topLevelWrapper ? process.env.NODE_ENV !== 'production' ? invariant(false, 'replaceProps(...): You called `replaceProps` on a ' + 'component with a parent. This is an anti-pattern since props will ' + 'get reactively updated when rendered. Instead, change the owner\'s ' + '`render` method to pass the correct value as props to the component ' + 'where it is created.') : invariant(false) : undefined;
// Merge with the pending element if it exists, otherwise with existing
// element props.
var wrapElement = topLevelWrapper._pendingElement || topLevelWrapper._currentElement;
var element = wrapElement.props;
topLevelWrapper._pendingElement = ReactElement.cloneAndReplaceProps(wrapElement, ReactElement.cloneAndReplaceProps(element, props));
enqueueUpdate(topLevelWrapper);
},
enqueueElementInternal: function (internalInstance, newElement) {
internalInstance._pendingElement = newElement;
enqueueUpdate(internalInstance);
}
};
module.exports = ReactUpdateQueue;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactUpdates
*/
'use strict';
var CallbackQueue = __webpack_require__(55);
var PooledClass = __webpack_require__(56);
var ReactPerf = __webpack_require__(18);
var ReactReconciler = __webpack_require__(50);
var Transaction = __webpack_require__(57);
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
var dirtyComponents = [];
var asapCallbackQueue = CallbackQueue.getPooled();
var asapEnqueued = false;
var batchingStrategy = null;
function ensureInjected() {
!(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching ' + 'strategy') : invariant(false) : undefined;
}
var NESTED_UPDATES = {
initialize: function () {
this.dirtyComponentsLength = dirtyComponents.length;
},
close: function () {
if (this.dirtyComponentsLength !== dirtyComponents.length) {
// Additional updates were enqueued by componentDidUpdate handlers or
// similar; before our own UPDATE_QUEUEING wrapper closes, we want to run
// these new updates so that if A's componentDidUpdate calls setState on
// B, B will update before the callback A's updater provided when calling
// setState.
dirtyComponents.splice(0, this.dirtyComponentsLength);
flushBatchedUpdates();
} else {
dirtyComponents.length = 0;
}
}
};
var UPDATE_QUEUEING = {
initialize: function () {
this.callbackQueue.reset();
},
close: function () {
this.callbackQueue.notifyAll();
}
};
var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];
function ReactUpdatesFlushTransaction() {
this.reinitializeTransaction();
this.dirtyComponentsLength = null;
this.callbackQueue = CallbackQueue.getPooled();
this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled( /* forceHTML */false);
}
assign(ReactUpdatesFlushTransaction.prototype, Transaction.Mixin, {
getTransactionWrappers: function () {
return TRANSACTION_WRAPPERS;
},
destructor: function () {
this.dirtyComponentsLength = null;
CallbackQueue.release(this.callbackQueue);
this.callbackQueue = null;
ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
this.reconcileTransaction = null;
},
perform: function (method, scope, a) {
// Essentially calls `this.reconcileTransaction.perform(method, scope, a)`
// with this transaction's wrappers around it.
return Transaction.Mixin.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
}
});
PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);
function batchedUpdates(callback, a, b, c, d, e) {
ensureInjected();
batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
}
/**
* Array comparator for ReactComponents by mount ordering.
*
* @param {ReactComponent} c1 first component you're comparing
* @param {ReactComponent} c2 second component you're comparing
* @return {number} Return value usable by Array.prototype.sort().
*/
function mountOrderComparator(c1, c2) {
return c1._mountOrder - c2._mountOrder;
}
function runBatchedUpdates(transaction) {
var len = transaction.dirtyComponentsLength;
!(len === dirtyComponents.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to ' + 'match dirty-components array length (%s).', len, dirtyComponents.length) : invariant(false) : undefined;
// Since reconciling a component higher in the owner hierarchy usually (not
// always -- see shouldComponentUpdate()) will reconcile children, reconcile
// them before their children by sorting the array.
dirtyComponents.sort(mountOrderComparator);
for (var i = 0; i < len; i++) {
// If a component is unmounted before pending changes apply, it will still
// be here, but we assume that it has cleared its _pendingCallbacks and
// that performUpdateIfNecessary is a noop.
var component = dirtyComponents[i];
// If performUpdateIfNecessary happens to enqueue any new updates, we
// shouldn't execute the callbacks until the next render happens, so
// stash the callbacks first
var callbacks = component._pendingCallbacks;
component._pendingCallbacks = null;
ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction);
if (callbacks) {
for (var j = 0; j < callbacks.length; j++) {
transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance());
}
}
}
}
var flushBatchedUpdates = function () {
// ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
// array and perform any updates enqueued by mount-ready handlers (i.e.,
// componentDidUpdate) but we need to check here too in order to catch
// updates enqueued by setState callbacks and asap calls.
while (dirtyComponents.length || asapEnqueued) {
if (dirtyComponents.length) {
var transaction = ReactUpdatesFlushTransaction.getPooled();
transaction.perform(runBatchedUpdates, null, transaction);
ReactUpdatesFlushTransaction.release(transaction);
}
if (asapEnqueued) {
asapEnqueued = false;
var queue = asapCallbackQueue;
asapCallbackQueue = CallbackQueue.getPooled();
queue.notifyAll();
CallbackQueue.release(queue);
}
}
};
flushBatchedUpdates = ReactPerf.measure('ReactUpdates', 'flushBatchedUpdates', flushBatchedUpdates);
/**
* Mark a component as needing a rerender, adding an optional callback to a
* list of functions which will be executed once the rerender occurs.
*/
function enqueueUpdate(component) {
ensureInjected();
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case. (This is called by each top-level update
// function, like setProps, setState, forceUpdate, etc.; creation and
// destruction of top-level components is guarded in ReactMount.)
if (!batchingStrategy.isBatchingUpdates) {
batchingStrategy.batchedUpdates(enqueueUpdate, component);
return;
}
dirtyComponents.push(component);
}
/**
* Enqueue a callback to be run at the end of the current batching cycle. Throws
* if no updates are currently being performed.
*/
function asap(callback, context) {
!batchingStrategy.isBatchingUpdates ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' + 'updates are not being batched.') : invariant(false) : undefined;
asapCallbackQueue.enqueue(callback, context);
asapEnqueued = true;
}
var ReactUpdatesInjection = {
injectReconcileTransaction: function (ReconcileTransaction) {
!ReconcileTransaction ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : invariant(false) : undefined;
ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
},
injectBatchingStrategy: function (_batchingStrategy) {
!_batchingStrategy ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : invariant(false) : undefined;
!(typeof _batchingStrategy.batchedUpdates === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : invariant(false) : undefined;
!(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : invariant(false) : undefined;
batchingStrategy = _batchingStrategy;
}
};
var ReactUpdates = {
/**
* React references `ReactReconcileTransaction` using this property in order
* to allow dependency injection.
*
* @internal
*/
ReactReconcileTransaction: null,
batchedUpdates: batchedUpdates,
enqueueUpdate: enqueueUpdate,
flushBatchedUpdates: flushBatchedUpdates,
injection: ReactUpdatesInjection,
asap: asap
};
module.exports = ReactUpdates;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule CallbackQueue
*/
'use strict';
var PooledClass = __webpack_require__(56);
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
/**
* A specialized pseudo-event module to help keep track of components waiting to
* be notified when their DOM representations are available for use.
*
* This implements `PooledClass`, so you should never need to instantiate this.
* Instead, use `CallbackQueue.getPooled()`.
*
* @class ReactMountReady
* @implements PooledClass
* @internal
*/
function CallbackQueue() {
this._callbacks = null;
this._contexts = null;
}
assign(CallbackQueue.prototype, {
/**
* Enqueues a callback to be invoked when `notifyAll` is invoked.
*
* @param {function} callback Invoked when `notifyAll` is invoked.
* @param {?object} context Context to call `callback` with.
* @internal
*/
enqueue: function (callback, context) {
this._callbacks = this._callbacks || [];
this._contexts = this._contexts || [];
this._callbacks.push(callback);
this._contexts.push(context);
},
/**
* Invokes all enqueued callbacks and clears the queue. This is invoked after
* the DOM representation of a component has been created or updated.
*
* @internal
*/
notifyAll: function () {
var callbacks = this._callbacks;
var contexts = this._contexts;
if (callbacks) {
!(callbacks.length === contexts.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : invariant(false) : undefined;
this._callbacks = null;
this._contexts = null;
for (var i = 0; i < callbacks.length; i++) {
callbacks[i].call(contexts[i]);
}
callbacks.length = 0;
contexts.length = 0;
}
},
/**
* Resets the internal queue.
*
* @internal
*/
reset: function () {
this._callbacks = null;
this._contexts = null;
},
/**
* `PooledClass` looks for this.
*/
destructor: function () {
this.reset();
}
});
PooledClass.addPoolingTo(CallbackQueue);
module.exports = CallbackQueue;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule PooledClass
*/
'use strict';
var invariant = __webpack_require__(13);
/**
* Static poolers. Several custom versions for each potential number of
* arguments. A completely generic pooler is easy to implement, but would
* require accessing the `arguments` object. In each of these, `this` refers to
* the Class itself, not an instance. If any others are needed, simply add them
* here, or in their own files.
*/
var oneArgumentPooler = function (copyFieldsFrom) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, copyFieldsFrom);
return instance;
} else {
return new Klass(copyFieldsFrom);
}
};
var twoArgumentPooler = function (a1, a2) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2);
return instance;
} else {
return new Klass(a1, a2);
}
};
var threeArgumentPooler = function (a1, a2, a3) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3);
return instance;
} else {
return new Klass(a1, a2, a3);
}
};
var fourArgumentPooler = function (a1, a2, a3, a4) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3, a4);
return instance;
} else {
return new Klass(a1, a2, a3, a4);
}
};
var fiveArgumentPooler = function (a1, a2, a3, a4, a5) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3, a4, a5);
return instance;
} else {
return new Klass(a1, a2, a3, a4, a5);
}
};
var standardReleaser = function (instance) {
var Klass = this;
!(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : invariant(false) : undefined;
instance.destructor();
if (Klass.instancePool.length < Klass.poolSize) {
Klass.instancePool.push(instance);
}
};
var DEFAULT_POOL_SIZE = 10;
var DEFAULT_POOLER = oneArgumentPooler;
/**
* Augments `CopyConstructor` to be a poolable class, augmenting only the class
* itself (statically) not adding any prototypical fields. Any CopyConstructor
* you give this may have a `poolSize` property, and will look for a
* prototypical `destructor` on instances (optional).
*
* @param {Function} CopyConstructor Constructor that can be used to reset.
* @param {Function} pooler Customizable pooler.
*/
var addPoolingTo = function (CopyConstructor, pooler) {
var NewKlass = CopyConstructor;
NewKlass.instancePool = [];
NewKlass.getPooled = pooler || DEFAULT_POOLER;
if (!NewKlass.poolSize) {
NewKlass.poolSize = DEFAULT_POOL_SIZE;
}
NewKlass.release = standardReleaser;
return NewKlass;
};
var PooledClass = {
addPoolingTo: addPoolingTo,
oneArgumentPooler: oneArgumentPooler,
twoArgumentPooler: twoArgumentPooler,
threeArgumentPooler: threeArgumentPooler,
fourArgumentPooler: fourArgumentPooler,
fiveArgumentPooler: fiveArgumentPooler
};
module.exports = PooledClass;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule Transaction
*/
'use strict';
var invariant = __webpack_require__(13);
/**
* `Transaction` creates a black box that is able to wrap any method such that
* certain invariants are maintained before and after the method is invoked
* (Even if an exception is thrown while invoking the wrapped method). Whoever
* instantiates a transaction can provide enforcers of the invariants at
* creation time. The `Transaction` class itself will supply one additional
* automatic invariant for you - the invariant that any transaction instance
* should not be run while it is already being run. You would typically create a
* single instance of a `Transaction` for reuse multiple times, that potentially
* is used to wrap several different methods. Wrappers are extremely simple -
* they only require implementing two methods.
*
* <pre>
* wrappers (injected at creation time)
* + +
* | |
* +-----------------|--------|--------------+
* | v | |
* | +---------------+ | |
* | +--| wrapper1 |---|----+ |
* | | +---------------+ v | |
* | | +-------------+ | |
* | | +----| wrapper2 |--------+ |
* | | | +-------------+ | | |
* | | | | | |
* | v v v v | wrapper
* | +---+ +---+ +---------+ +---+ +---+ | invariants
* perform(anyMethod) | | | | | | | | | | | | maintained
* +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->
* | | | | | | | | | | | |
* | | | | | | | | | | | |
* | | | | | | | | | | | |
* | +---+ +---+ +---------+ +---+ +---+ |
* | initialize close |
* +-----------------------------------------+
* </pre>
*
* Use cases:
* - Preserving the input selection ranges before/after reconciliation.
* Restoring selection even in the event of an unexpected error.
* - Deactivating events while rearranging the DOM, preventing blurs/focuses,
* while guaranteeing that afterwards, the event system is reactivated.
* - Flushing a queue of collected DOM mutations to the main UI thread after a
* reconciliation takes place in a worker thread.
* - Invoking any collected `componentDidUpdate` callbacks after rendering new
* content.
* - (Future use case): Wrapping particular flushes of the `ReactWorker` queue
* to preserve the `scrollTop` (an automatic scroll aware DOM).
* - (Future use case): Layout calculations before and after DOM updates.
*
* Transactional plugin API:
* - A module that has an `initialize` method that returns any precomputation.
* - and a `close` method that accepts the precomputation. `close` is invoked
* when the wrapped process is completed, or has failed.
*
* @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules
* that implement `initialize` and `close`.
* @return {Transaction} Single transaction for reuse in thread.
*
* @class Transaction
*/
var Mixin = {
/**
* Sets up this instance so that it is prepared for collecting metrics. Does
* so such that this setup method may be used on an instance that is already
* initialized, in a way that does not consume additional memory upon reuse.
* That can be useful if you decide to make your subclass of this mixin a
* "PooledClass".
*/
reinitializeTransaction: function () {
this.transactionWrappers = this.getTransactionWrappers();
if (this.wrapperInitData) {
this.wrapperInitData.length = 0;
} else {
this.wrapperInitData = [];
}
this._isInTransaction = false;
},
_isInTransaction: false,
/**
* @abstract
* @return {Array<TransactionWrapper>} Array of transaction wrappers.
*/
getTransactionWrappers: null,
isInTransaction: function () {
return !!this._isInTransaction;
},
/**
* Executes the function within a safety window. Use this for the top level
* methods that result in large amounts of computation/mutations that would
* need to be safety checked. The optional arguments helps prevent the need
* to bind in many cases.
*
* @param {function} method Member of scope to call.
* @param {Object} scope Scope to invoke from.
* @param {Object?=} a Argument to pass to the method.
* @param {Object?=} b Argument to pass to the method.
* @param {Object?=} c Argument to pass to the method.
* @param {Object?=} d Argument to pass to the method.
* @param {Object?=} e Argument to pass to the method.
* @param {Object?=} f Argument to pass to the method.
*
* @return {*} Return value from `method`.
*/
perform: function (method, scope, a, b, c, d, e, f) {
!!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there ' + 'is already an outstanding transaction.') : invariant(false) : undefined;
var errorThrown;
var ret;
try {
this._isInTransaction = true;
// Catching errors makes debugging more difficult, so we start with
// errorThrown set to true before setting it to false after calling
// close -- if it's still set to true in the finally block, it means
// one of these calls threw.
errorThrown = true;
this.initializeAll(0);
ret = method.call(scope, a, b, c, d, e, f);
errorThrown = false;
} finally {
try {
if (errorThrown) {
// If `method` throws, prefer to show that stack trace over any thrown
// by invoking `closeAll`.
try {
this.closeAll(0);
} catch (err) {}
} else {
// Since `method` didn't throw, we don't want to silence the exception
// here.
this.closeAll(0);
}
} finally {
this._isInTransaction = false;
}
}
return ret;
},
initializeAll: function (startIndex) {
var transactionWrappers = this.transactionWrappers;
for (var i = startIndex; i < transactionWrappers.length; i++) {
var wrapper = transactionWrappers[i];
try {
// Catching errors makes debugging more difficult, so we start with the
// OBSERVED_ERROR state before overwriting it with the real return value
// of initialize -- if it's still set to OBSERVED_ERROR in the finally
// block, it means wrapper.initialize threw.
this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;
this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
} finally {
if (this.wrapperInitData[i] === Transaction.OBSERVED_ERROR) {
// The initializer for wrapper i threw an error; initialize the
// remaining wrappers but silence any exceptions from them to ensure
// that the first error is the one to bubble up.
try {
this.initializeAll(i + 1);
} catch (err) {}
}
}
}
},
/**
* Invokes each of `this.transactionWrappers.close[i]` functions, passing into
* them the respective return values of `this.transactionWrappers.init[i]`
* (`close`rs that correspond to initializers that failed will not be
* invoked).
*/
closeAll: function (startIndex) {
!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : invariant(false) : undefined;
var transactionWrappers = this.transactionWrappers;
for (var i = startIndex; i < transactionWrappers.length; i++) {
var wrapper = transactionWrappers[i];
var initData = this.wrapperInitData[i];
var errorThrown;
try {
// Catching errors makes debugging more difficult, so we start with
// errorThrown set to true before setting it to false after calling
// close -- if it's still set to true in the finally block, it means
// wrapper.close threw.
errorThrown = true;
if (initData !== Transaction.OBSERVED_ERROR && wrapper.close) {
wrapper.close.call(this, initData);
}
errorThrown = false;
} finally {
if (errorThrown) {
// The closer for wrapper i threw an error; close the remaining
// wrappers but silence any exceptions from them to ensure that the
// first error is the one to bubble up.
try {
this.closeAll(i + 1);
} catch (e) {}
}
}
}
this.wrapperInitData.length = 0;
}
};
var Transaction = {
Mixin: Mixin,
/**
* Token to look for to determine if an error occurred.
*/
OBSERVED_ERROR: {}
};
module.exports = Transaction;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule emptyObject
*/
'use strict';
var emptyObject = {};
if (process.env.NODE_ENV !== 'production') {
Object.freeze(emptyObject);
}
module.exports = emptyObject;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule containsNode
* @typechecks
*/
'use strict';
var isTextNode = __webpack_require__(60);
/*eslint-disable no-bitwise */
/**
* Checks if a given DOM node contains or is another DOM node.
*
* @param {?DOMNode} outerNode Outer DOM node.
* @param {?DOMNode} innerNode Inner DOM node.
* @return {boolean} True if `outerNode` contains or is `innerNode`.
*/
function containsNode(_x, _x2) {
var _again = true;
_function: while (_again) {
var outerNode = _x,
innerNode = _x2;
_again = false;
if (!outerNode || !innerNode) {
return false;
} else if (outerNode === innerNode) {
return true;
} else if (isTextNode(outerNode)) {
return false;
} else if (isTextNode(innerNode)) {
_x = outerNode;
_x2 = innerNode.parentNode;
_again = true;
continue _function;
} else if (outerNode.contains) {
return outerNode.contains(innerNode);
} else if (outerNode.compareDocumentPosition) {
return !!(outerNode.compareDocumentPosition(innerNode) & 16);
} else {
return false;
}
}
}
module.exports = containsNode;
/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule isTextNode
* @typechecks
*/
'use strict';
var isNode = __webpack_require__(61);
/**
* @param {*} object The object to check.
* @return {boolean} Whether or not the object is a DOM text node.
*/
function isTextNode(object) {
return isNode(object) && object.nodeType == 3;
}
module.exports = isTextNode;
/***/ },
/* 61 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule isNode
* @typechecks
*/
/**
* @param {*} object The object to check.
* @return {boolean} Whether or not the object is a DOM node.
*/
'use strict';
function isNode(object) {
return !!(object && (typeof Node === 'function' ? object instanceof Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
}
module.exports = isNode;
/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule instantiateReactComponent
* @typechecks static-only
*/
'use strict';
var ReactCompositeComponent = __webpack_require__(63);
var ReactEmptyComponent = __webpack_require__(68);
var ReactNativeComponent = __webpack_require__(69);
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
// To avoid a cyclic dependency, we create the final class in this module
var ReactCompositeComponentWrapper = function () {};
assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent.Mixin, {
_instantiateReactComponent: instantiateReactComponent
});
function getDeclarationErrorAddendum(owner) {
if (owner) {
var name = owner.getName();
if (name) {
return ' Check the render method of `' + name + '`.';
}
}
return '';
}
/**
* Check if the type reference is a known internal type. I.e. not a user
* provided composite type.
*
* @param {function} type
* @return {boolean} Returns true if this is a valid internal type.
*/
function isInternalComponentType(type) {
return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';
}
/**
* Given a ReactNode, create an instance that will actually be mounted.
*
* @param {ReactNode} node
* @return {object} A new instance of the element's constructor.
* @protected
*/
function instantiateReactComponent(node) {
var instance;
if (node === null || node === false) {
instance = new ReactEmptyComponent(instantiateReactComponent);
} else if (typeof node === 'object') {
var element = node;
!(element && (typeof element.type === 'function' || typeof element.type === 'string')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) ' + 'or a class/function (for composite components) but got: %s.%s', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : invariant(false) : undefined;
// Special case string values
if (typeof element.type === 'string') {
instance = ReactNativeComponent.createInternalComponent(element);
} else if (isInternalComponentType(element.type)) {
// This is temporarily available for custom components that are not string
// representations. I.e. ART. Once those are updated to use the string
// representation, we can drop this code path.
instance = new element.type(element);
} else {
instance = new ReactCompositeComponentWrapper();
}
} else if (typeof node === 'string' || typeof node === 'number') {
instance = ReactNativeComponent.createInstanceForText(node);
} else {
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : invariant(false) : undefined;
}
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(typeof instance.construct === 'function' && typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : undefined;
}
// Sets up the instance. This can probably just move into the constructor now.
instance.construct(node);
// These two fields are used by the DOM and ART diffing algorithms
// respectively. Instead of using expandos on components, we should be
// storing the state needed by the diffing algorithms elsewhere.
instance._mountIndex = 0;
instance._mountImage = null;
if (process.env.NODE_ENV !== 'production') {
instance._isOwnerNecessary = false;
instance._warnedAboutRefsInRender = false;
}
// Internal instances should fully constructed at this point, so they should
// not get any new fields added to them at this point.
if (process.env.NODE_ENV !== 'production') {
if (Object.preventExtensions) {
Object.preventExtensions(instance);
}
}
return instance;
}
module.exports = instantiateReactComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactCompositeComponent
*/
'use strict';
var ReactComponentEnvironment = __webpack_require__(64);
var ReactCurrentOwner = __webpack_require__(5);
var ReactElement = __webpack_require__(42);
var ReactInstanceMap = __webpack_require__(47);
var ReactPerf = __webpack_require__(18);
var ReactPropTypeLocations = __webpack_require__(65);
var ReactPropTypeLocationNames = __webpack_require__(66);
var ReactReconciler = __webpack_require__(50);
var ReactUpdateQueue = __webpack_require__(53);
var assign = __webpack_require__(39);
var emptyObject = __webpack_require__(58);
var invariant = __webpack_require__(13);
var shouldUpdateReactComponent = __webpack_require__(67);
var warning = __webpack_require__(25);
function getDeclarationErrorAddendum(component) {
var owner = component._currentElement._owner || null;
if (owner) {
var name = owner.getName();
if (name) {
return ' Check the render method of `' + name + '`.';
}
}
return '';
}
function StatelessComponent(Component) {}
StatelessComponent.prototype.render = function () {
var Component = ReactInstanceMap.get(this)._currentElement.type;
return Component(this.props, this.context, this.updater);
};
/**
* ------------------ The Life-Cycle of a Composite Component ------------------
*
* - constructor: Initialization of state. The instance is now retained.
* - componentWillMount
* - render
* - [children's constructors]
* - [children's componentWillMount and render]
* - [children's componentDidMount]
* - componentDidMount
*
* Update Phases:
* - componentWillReceiveProps (only called if parent updated)
* - shouldComponentUpdate
* - componentWillUpdate
* - render
* - [children's constructors or receive props phases]
* - componentDidUpdate
*
* - componentWillUnmount
* - [children's componentWillUnmount]
* - [children destroyed]
* - (destroyed): The instance is now blank, released by React and ready for GC.
*
* -----------------------------------------------------------------------------
*/
/**
* An incrementing ID assigned to each component when it is mounted. This is
* used to enforce the order in which `ReactUpdates` updates dirty components.
*
* @private
*/
var nextMountID = 1;
/**
* @lends {ReactCompositeComponent.prototype}
*/
var ReactCompositeComponentMixin = {
/**
* Base constructor for all composite component.
*
* @param {ReactElement} element
* @final
* @internal
*/
construct: function (element) {
this._currentElement = element;
this._rootNodeID = null;
this._instance = null;
// See ReactUpdateQueue
this._pendingElement = null;
this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;
this._renderedComponent = null;
this._context = null;
this._mountOrder = 0;
this._topLevelWrapper = null;
// See ReactUpdates and ReactUpdateQueue.
this._pendingCallbacks = null;
},
/**
* Initializes the component, renders markup, and registers event listeners.
*
* @param {string} rootID DOM ID of the root node.
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @return {?string} Rendered markup to be inserted into the DOM.
* @final
* @internal
*/
mountComponent: function (rootID, transaction, context) {
this._context = context;
this._mountOrder = nextMountID++;
this._rootNodeID = rootID;
var publicProps = this._processProps(this._currentElement.props);
var publicContext = this._processContext(context);
var Component = this._currentElement.type;
// Initialize the public class
var inst;
var renderedElement;
// This is a way to detect if Component is a stateless arrow function
// component, which is not newable. It might not be 100% reliable but is
// something we can do until we start detecting that Component extends
// React.Component. We already assume that typeof Component === 'function'.
var canInstantiate = ('prototype' in Component);
if (canInstantiate) {
if (process.env.NODE_ENV !== 'production') {
ReactCurrentOwner.current = this;
try {
inst = new Component(publicProps, publicContext, ReactUpdateQueue);
} finally {
ReactCurrentOwner.current = null;
}
} else {
inst = new Component(publicProps, publicContext, ReactUpdateQueue);
}
}
if (!canInstantiate || inst === null || inst === false || ReactElement.isValidElement(inst)) {
renderedElement = inst;
inst = new StatelessComponent(Component);
}
if (process.env.NODE_ENV !== 'production') {
// This will throw later in _renderValidatedComponent, but add an early
// warning now to help debugging
if (inst.render == null) {
process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`, returned ' + 'null/false from a stateless component, or tried to render an ' + 'element whose type is a function that isn\'t a React component.', Component.displayName || Component.name || 'Component') : undefined;
} else {
// We support ES6 inheriting from React.Component, the module pattern,
// and stateless components, but not ES6 classes that don't extend
process.env.NODE_ENV !== 'production' ? warning(Component.prototype && Component.prototype.isReactComponent || !canInstantiate || !(inst instanceof Component), '%s(...): React component classes must extend React.Component.', Component.displayName || Component.name || 'Component') : undefined;
}
}
// These should be set up in the constructor, but as a convenience for
// simpler class abstractions, we set them up after the fact.
inst.props = publicProps;
inst.context = publicContext;
inst.refs = emptyObject;
inst.updater = ReactUpdateQueue;
this._instance = inst;
// Store a reference from the instance back to the internal representation
ReactInstanceMap.set(inst, this);
if (process.env.NODE_ENV !== 'production') {
// Since plain JS classes are defined without any special initialization
// logic, we can not catch common errors early. Therefore, we have to
// catch them here, at initialization time, instead.
process.env.NODE_ENV !== 'production' ? warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', this.getName() || 'a component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', this.getName() || 'a component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(!inst.propTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', this.getName() || 'a component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(!inst.contextTypes, 'contextTypes was defined as an instance property on %s. Use a ' + 'static property to define contextTypes instead.', this.getName() || 'a component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentShouldUpdate !== 'function', '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', this.getName() || 'A component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentDidUnmount !== 'function', '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', this.getName() || 'A component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentWillRecieveProps !== 'function', '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', this.getName() || 'A component') : undefined;
}
var initialState = inst.state;
if (initialState === undefined) {
inst.state = initialState = null;
}
!(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.state: must be set to an object or null', this.getName() || 'ReactCompositeComponent') : invariant(false) : undefined;
this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;
if (inst.componentWillMount) {
inst.componentWillMount();
// When mounting, calls to `setState` by `componentWillMount` will set
// `this._pendingStateQueue` without triggering a re-render.
if (this._pendingStateQueue) {
inst.state = this._processPendingState(inst.props, inst.context);
}
}
// If not a stateless component, we now render
if (renderedElement === undefined) {
renderedElement = this._renderValidatedComponent();
}
this._renderedComponent = this._instantiateReactComponent(renderedElement);
var markup = ReactReconciler.mountComponent(this._renderedComponent, rootID, transaction, this._processChildContext(context));
if (inst.componentDidMount) {
transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);
}
return markup;
},
/**
* Releases any resources allocated by `mountComponent`.
*
* @final
* @internal
*/
unmountComponent: function () {
var inst = this._instance;
if (inst.componentWillUnmount) {
inst.componentWillUnmount();
}
ReactReconciler.unmountComponent(this._renderedComponent);
this._renderedComponent = null;
this._instance = null;
// Reset pending fields
// Even if this component is scheduled for another update in ReactUpdates,
// it would still be ignored because these fields are reset.
this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;
this._pendingCallbacks = null;
this._pendingElement = null;
// These fields do not really need to be reset since this object is no
// longer accessible.
this._context = null;
this._rootNodeID = null;
this._topLevelWrapper = null;
// Delete the reference from the instance to this internal representation
// which allow the internals to be properly cleaned up even if the user
// leaks a reference to the public instance.
ReactInstanceMap.remove(inst);
// Some existing components rely on inst.props even after they've been
// destroyed (in event handlers).
// TODO: inst.props = null;
// TODO: inst.state = null;
// TODO: inst.context = null;
},
/**
* Filters the context object to only contain keys specified in
* `contextTypes`
*
* @param {object} context
* @return {?object}
* @private
*/
_maskContext: function (context) {
var maskedContext = null;
var Component = this._currentElement.type;
var contextTypes = Component.contextTypes;
if (!contextTypes) {
return emptyObject;
}
maskedContext = {};
for (var contextName in contextTypes) {
maskedContext[contextName] = context[contextName];
}
return maskedContext;
},
/**
* Filters the context object to only contain keys specified in
* `contextTypes`, and asserts that they are valid.
*
* @param {object} context
* @return {?object}
* @private
*/
_processContext: function (context) {
var maskedContext = this._maskContext(context);
if (process.env.NODE_ENV !== 'production') {
var Component = this._currentElement.type;
if (Component.contextTypes) {
this._checkPropTypes(Component.contextTypes, maskedContext, ReactPropTypeLocations.context);
}
}
return maskedContext;
},
/**
* @param {object} currentContext
* @return {object}
* @private
*/
_processChildContext: function (currentContext) {
var Component = this._currentElement.type;
var inst = this._instance;
var childContext = inst.getChildContext && inst.getChildContext();
if (childContext) {
!(typeof Component.childContextTypes === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): childContextTypes must be defined in order to ' + 'use getChildContext().', this.getName() || 'ReactCompositeComponent') : invariant(false) : undefined;
if (process.env.NODE_ENV !== 'production') {
this._checkPropTypes(Component.childContextTypes, childContext, ReactPropTypeLocations.childContext);
}
for (var name in childContext) {
!(name in Component.childContextTypes) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || 'ReactCompositeComponent', name) : invariant(false) : undefined;
}
return assign({}, currentContext, childContext);
}
return currentContext;
},
/**
* Processes props by setting default values for unspecified props and
* asserting that the props are valid. Does not mutate its argument; returns
* a new props object with defaults merged in.
*
* @param {object} newProps
* @return {object}
* @private
*/
_processProps: function (newProps) {
if (process.env.NODE_ENV !== 'production') {
var Component = this._currentElement.type;
if (Component.propTypes) {
this._checkPropTypes(Component.propTypes, newProps, ReactPropTypeLocations.prop);
}
}
return newProps;
},
/**
* Assert that the props are valid
*
* @param {object} propTypes Map of prop name to a ReactPropType
* @param {object} props
* @param {string} location e.g. "prop", "context", "child context"
* @private
*/
_checkPropTypes: function (propTypes, props, location) {
// TODO: Stop validating prop types here and only use the element
// validation.
var componentName = this.getName();
for (var propName in propTypes) {
if (propTypes.hasOwnProperty(propName)) {
var error;
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
!(typeof propTypes[propName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually ' + 'from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], propName) : invariant(false) : undefined;
error = propTypes[propName](props, propName, componentName, location);
} catch (ex) {
error = ex;
}
if (error instanceof Error) {
// We may want to extend this logic for similar errors in
// top-level render calls, so I'm abstracting it away into
// a function to minimize refactoring in the future
var addendum = getDeclarationErrorAddendum(this);
if (location === ReactPropTypeLocations.prop) {
// Preface gives us something to blacklist in warning module
process.env.NODE_ENV !== 'production' ? warning(false, 'Failed Composite propType: %s%s', error.message, addendum) : undefined;
} else {
process.env.NODE_ENV !== 'production' ? warning(false, 'Failed Context Types: %s%s', error.message, addendum) : undefined;
}
}
}
}
},
receiveComponent: function (nextElement, transaction, nextContext) {
var prevElement = this._currentElement;
var prevContext = this._context;
this._pendingElement = null;
this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);
},
/**
* If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`
* is set, update the component.
*
* @param {ReactReconcileTransaction} transaction
* @internal
*/
performUpdateIfNecessary: function (transaction) {
if (this._pendingElement != null) {
ReactReconciler.receiveComponent(this, this._pendingElement || this._currentElement, transaction, this._context);
}
if (this._pendingStateQueue !== null || this._pendingForceUpdate) {
this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context);
}
},
/**
* Perform an update to a mounted component. The componentWillReceiveProps and
* shouldComponentUpdate methods are called, then (assuming the update isn't
* skipped) the remaining update lifecycle methods are called and the DOM
* representation is updated.
*
* By default, this implements React's rendering and reconciliation algorithm.
* Sophisticated clients may wish to override this.
*
* @param {ReactReconcileTransaction} transaction
* @param {ReactElement} prevParentElement
* @param {ReactElement} nextParentElement
* @internal
* @overridable
*/
updateComponent: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
var inst = this._instance;
var nextContext = this._context === nextUnmaskedContext ? inst.context : this._processContext(nextUnmaskedContext);
var nextProps;
// Distinguish between a props update versus a simple state update
if (prevParentElement === nextParentElement) {
// Skip checking prop types again -- we don't read inst.props to avoid
// warning for DOM component props in this upgrade
nextProps = nextParentElement.props;
} else {
nextProps = this._processProps(nextParentElement.props);
// An update here will schedule an update but immediately set
// _pendingStateQueue which will ensure that any state updates gets
// immediately reconciled instead of waiting for the next batch.
if (inst.componentWillReceiveProps) {
inst.componentWillReceiveProps(nextProps, nextContext);
}
}
var nextState = this._processPendingState(nextProps, nextContext);
var shouldUpdate = this._pendingForceUpdate || !inst.shouldComponentUpdate || inst.shouldComponentUpdate(nextProps, nextState, nextContext);
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(typeof shouldUpdate !== 'undefined', '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : undefined;
}
if (shouldUpdate) {
this._pendingForceUpdate = false;
// Will set `this.props`, `this.state` and `this.context`.
this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext);
} else {
// If it's determined that a component should not update, we still want
// to set props and state but we shortcut the rest of the update.
this._currentElement = nextParentElement;
this._context = nextUnmaskedContext;
inst.props = nextProps;
inst.state = nextState;
inst.context = nextContext;
}
},
_processPendingState: function (props, context) {
var inst = this._instance;
var queue = this._pendingStateQueue;
var replace = this._pendingReplaceState;
this._pendingReplaceState = false;
this._pendingStateQueue = null;
if (!queue) {
return inst.state;
}
if (replace && queue.length === 1) {
return queue[0];
}
var nextState = assign({}, replace ? queue[0] : inst.state);
for (var i = replace ? 1 : 0; i < queue.length; i++) {
var partial = queue[i];
assign(nextState, typeof partial === 'function' ? partial.call(inst, nextState, props, context) : partial);
}
return nextState;
},
/**
* Merges new props and state, notifies delegate methods of update and
* performs update.
*
* @param {ReactElement} nextElement Next element
* @param {object} nextProps Next public object to set as properties.
* @param {?object} nextState Next object to set as state.
* @param {?object} nextContext Next public object to set as context.
* @param {ReactReconcileTransaction} transaction
* @param {?object} unmaskedContext
* @private
*/
_performComponentUpdate: function (nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {
var inst = this._instance;
var hasComponentDidUpdate = Boolean(inst.componentDidUpdate);
var prevProps;
var prevState;
var prevContext;
if (hasComponentDidUpdate) {
prevProps = inst.props;
prevState = inst.state;
prevContext = inst.context;
}
if (inst.componentWillUpdate) {
inst.componentWillUpdate(nextProps, nextState, nextContext);
}
this._currentElement = nextElement;
this._context = unmaskedContext;
inst.props = nextProps;
inst.state = nextState;
inst.context = nextContext;
this._updateRenderedComponent(transaction, unmaskedContext);
if (hasComponentDidUpdate) {
transaction.getReactMountReady().enqueue(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), inst);
}
},
/**
* Call the component's `render` method and update the DOM accordingly.
*
* @param {ReactReconcileTransaction} transaction
* @internal
*/
_updateRenderedComponent: function (transaction, context) {
var prevComponentInstance = this._renderedComponent;
var prevRenderedElement = prevComponentInstance._currentElement;
var nextRenderedElement = this._renderValidatedComponent();
if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {
ReactReconciler.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context));
} else {
// These two IDs are actually the same! But nothing should rely on that.
var thisID = this._rootNodeID;
var prevComponentID = prevComponentInstance._rootNodeID;
ReactReconciler.unmountComponent(prevComponentInstance);
this._renderedComponent = this._instantiateReactComponent(nextRenderedElement);
var nextMarkup = ReactReconciler.mountComponent(this._renderedComponent, thisID, transaction, this._processChildContext(context));
this._replaceNodeWithMarkupByID(prevComponentID, nextMarkup);
}
},
/**
* @protected
*/
_replaceNodeWithMarkupByID: function (prevComponentID, nextMarkup) {
ReactComponentEnvironment.replaceNodeWithMarkupByID(prevComponentID, nextMarkup);
},
/**
* @protected
*/
_renderValidatedComponentWithoutOwnerOrContext: function () {
var inst = this._instance;
var renderedComponent = inst.render();
if (process.env.NODE_ENV !== 'production') {
// We allow auto-mocks to proceed as if they're returning null.
if (typeof renderedComponent === 'undefined' && inst.render._isMockFunction) {
// This is probably bad practice. Consider warning here and
// deprecating this convenience.
renderedComponent = null;
}
}
return renderedComponent;
},
/**
* @private
*/
_renderValidatedComponent: function () {
var renderedComponent;
ReactCurrentOwner.current = this;
try {
renderedComponent = this._renderValidatedComponentWithoutOwnerOrContext();
} finally {
ReactCurrentOwner.current = null;
}
!(
// TODO: An `isValidNode` function would probably be more appropriate
renderedComponent === null || renderedComponent === false || ReactElement.isValidElement(renderedComponent)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.render(): A valid ReactComponent must be returned. You may have ' + 'returned undefined, an array or some other invalid object.', this.getName() || 'ReactCompositeComponent') : invariant(false) : undefined;
return renderedComponent;
},
/**
* Lazily allocates the refs object and stores `component` as `ref`.
*
* @param {string} ref Reference name.
* @param {component} component Component to store as `ref`.
* @final
* @private
*/
attachRef: function (ref, component) {
var inst = this.getPublicInstance();
!(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Stateless function components cannot have refs.') : invariant(false) : undefined;
var publicComponentInstance = component.getPublicInstance();
if (process.env.NODE_ENV !== 'production') {
var componentName = component && component.getName ? component.getName() : 'a component';
process.env.NODE_ENV !== 'production' ? warning(publicComponentInstance != null, 'Stateless function components cannot be given refs ' + '(See ref "%s" in %s created by %s). ' + 'Attempts to access this ref will fail.', ref, componentName, this.getName()) : undefined;
}
var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
refs[ref] = publicComponentInstance;
},
/**
* Detaches a reference name.
*
* @param {string} ref Name to dereference.
* @final
* @private
*/
detachRef: function (ref) {
var refs = this.getPublicInstance().refs;
delete refs[ref];
},
/**
* Get a text description of the component that can be used to identify it
* in error messages.
* @return {string} The name or null.
* @internal
*/
getName: function () {
var type = this._currentElement.type;
var constructor = this._instance && this._instance.constructor;
return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null;
},
/**
* Get the publicly accessible representation of this component - i.e. what
* is exposed by refs and returned by render. Can be null for stateless
* components.
*
* @return {ReactComponent} the public component instance.
* @internal
*/
getPublicInstance: function () {
var inst = this._instance;
if (inst instanceof StatelessComponent) {
return null;
}
return inst;
},
// Stub
_instantiateReactComponent: null
};
ReactPerf.measureMethods(ReactCompositeComponentMixin, 'ReactCompositeComponent', {
mountComponent: 'mountComponent',
updateComponent: 'updateComponent',
_renderValidatedComponent: '_renderValidatedComponent'
});
var ReactCompositeComponent = {
Mixin: ReactCompositeComponentMixin
};
module.exports = ReactCompositeComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactComponentEnvironment
*/
'use strict';
var invariant = __webpack_require__(13);
var injected = false;
var ReactComponentEnvironment = {
/**
* Optionally injectable environment dependent cleanup hook. (server vs.
* browser etc). Example: A browser system caches DOM nodes based on component
* ID and must remove that cache entry when this instance is unmounted.
*/
unmountIDFromEnvironment: null,
/**
* Optionally injectable hook for swapping out mount images in the middle of
* the tree.
*/
replaceNodeWithMarkupByID: null,
/**
* Optionally injectable hook for processing a queue of child updates. Will
* later move into MultiChildComponents.
*/
processChildrenUpdates: null,
injection: {
injectEnvironment: function (environment) {
!!injected ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : invariant(false) : undefined;
ReactComponentEnvironment.unmountIDFromEnvironment = environment.unmountIDFromEnvironment;
ReactComponentEnvironment.replaceNodeWithMarkupByID = environment.replaceNodeWithMarkupByID;
ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;
injected = true;
}
}
};
module.exports = ReactComponentEnvironment;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactPropTypeLocations
*/
'use strict';
var keyMirror = __webpack_require__(17);
var ReactPropTypeLocations = keyMirror({
prop: null,
context: null,
childContext: null
});
module.exports = ReactPropTypeLocations;
/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactPropTypeLocationNames
*/
'use strict';
var ReactPropTypeLocationNames = {};
if (process.env.NODE_ENV !== 'production') {
ReactPropTypeLocationNames = {
prop: 'prop',
context: 'context',
childContext: 'child context'
};
}
module.exports = ReactPropTypeLocationNames;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 67 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule shouldUpdateReactComponent
* @typechecks static-only
*/
'use strict';
/**
* Given a `prevElement` and `nextElement`, determines if the existing
* instance should be updated as opposed to being destroyed or replaced by a new
* instance. Both arguments are elements. This ensures that this logic can
* operate on stateless trees without any backing instance.
*
* @param {?object} prevElement
* @param {?object} nextElement
* @return {boolean} True if the existing instance should be updated.
* @protected
*/
function shouldUpdateReactComponent(prevElement, nextElement) {
var prevEmpty = prevElement === null || prevElement === false;
var nextEmpty = nextElement === null || nextElement === false;
if (prevEmpty || nextEmpty) {
return prevEmpty === nextEmpty;
}
var prevType = typeof prevElement;
var nextType = typeof nextElement;
if (prevType === 'string' || prevType === 'number') {
return nextType === 'string' || nextType === 'number';
} else {
return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
}
return false;
}
module.exports = shouldUpdateReactComponent;
/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactEmptyComponent
*/
'use strict';
var ReactElement = __webpack_require__(42);
var ReactEmptyComponentRegistry = __webpack_require__(44);
var ReactReconciler = __webpack_require__(50);
var assign = __webpack_require__(39);
var placeholderElement;
var ReactEmptyComponentInjection = {
injectEmptyComponent: function (component) {
placeholderElement = ReactElement.createElement(component);
}
};
var ReactEmptyComponent = function (instantiate) {
this._currentElement = null;
this._rootNodeID = null;
this._renderedComponent = instantiate(placeholderElement);
};
assign(ReactEmptyComponent.prototype, {
construct: function (element) {},
mountComponent: function (rootID, transaction, context) {
ReactEmptyComponentRegistry.registerNullComponentID(rootID);
this._rootNodeID = rootID;
return ReactReconciler.mountComponent(this._renderedComponent, rootID, transaction, context);
},
receiveComponent: function () {},
unmountComponent: function (rootID, transaction, context) {
ReactReconciler.unmountComponent(this._renderedComponent);
ReactEmptyComponentRegistry.deregisterNullComponentID(this._rootNodeID);
this._rootNodeID = null;
this._renderedComponent = null;
}
});
ReactEmptyComponent.injection = ReactEmptyComponentInjection;
module.exports = ReactEmptyComponent;
/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactNativeComponent
*/
'use strict';
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
var autoGenerateWrapperClass = null;
var genericComponentClass = null;
// This registry keeps track of wrapper classes around native tags.
var tagToComponentClass = {};
var textComponentClass = null;
var ReactNativeComponentInjection = {
// This accepts a class that receives the tag string. This is a catch all
// that can render any kind of tag.
injectGenericComponentClass: function (componentClass) {
genericComponentClass = componentClass;
},
// This accepts a text component class that takes the text string to be
// rendered as props.
injectTextComponentClass: function (componentClass) {
textComponentClass = componentClass;
},
// This accepts a keyed object with classes as values. Each key represents a
// tag. That particular tag will use this class instead of the generic one.
injectComponentClasses: function (componentClasses) {
assign(tagToComponentClass, componentClasses);
}
};
/**
* Get a composite component wrapper class for a specific tag.
*
* @param {ReactElement} element The tag for which to get the class.
* @return {function} The React class constructor function.
*/
function getComponentClassForElement(element) {
if (typeof element.type === 'function') {
return element.type;
}
var tag = element.type;
var componentClass = tagToComponentClass[tag];
if (componentClass == null) {
tagToComponentClass[tag] = componentClass = autoGenerateWrapperClass(tag);
}
return componentClass;
}
/**
* Get a native internal component class for a specific tag.
*
* @param {ReactElement} element The element to create.
* @return {function} The internal class constructor function.
*/
function createInternalComponent(element) {
!genericComponentClass ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : invariant(false) : undefined;
return new genericComponentClass(element.type, element.props);
}
/**
* @param {ReactText} text
* @return {ReactComponent}
*/
function createInstanceForText(text) {
return new textComponentClass(text);
}
/**
* @param {ReactComponent} component
* @return {boolean}
*/
function isTextComponent(component) {
return component instanceof textComponentClass;
}
var ReactNativeComponent = {
getComponentClassForElement: getComponentClassForElement,
createInternalComponent: createInternalComponent,
createInstanceForText: createInstanceForText,
isTextComponent: isTextComponent,
injection: ReactNativeComponentInjection
};
module.exports = ReactNativeComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule validateDOMNesting
*/
'use strict';
var assign = __webpack_require__(39);
var emptyFunction = __webpack_require__(15);
var warning = __webpack_require__(25);
var validateDOMNesting = emptyFunction;
if (process.env.NODE_ENV !== 'production') {
// This validation code was written based on the HTML5 parsing spec:
// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
//
// Note: this does not catch all invalid nesting, nor does it try to (as it's
// not clear what practical benefit doing so provides); instead, we warn only
// for cases where the parser will give a parse tree differing from what React
// intended. For example, <b><div></div></b> is invalid but we don't warn
// because it still parses correctly; we do warn for other cases like nested
// <p> tags where the beginning of the second element implicitly closes the
// first, causing a confusing mess.
// https://html.spec.whatwg.org/multipage/syntax.html#special
var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp'];
// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template',
// https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
// TODO: Distinguish by namespace here -- for <title>, including it here
// errs on the side of fewer warnings
'foreignObject', 'desc', 'title'];
// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
var buttonScopeTags = inScopeTags.concat(['button']);
// https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'];
var emptyAncestorInfo = {
parentTag: null,
formTag: null,
aTagInScope: null,
buttonTagInScope: null,
nobrTagInScope: null,
pTagInButtonScope: null,
listItemTagAutoclosing: null,
dlItemTagAutoclosing: null
};
var updatedAncestorInfo = function (oldInfo, tag, instance) {
var ancestorInfo = assign({}, oldInfo || emptyAncestorInfo);
var info = { tag: tag, instance: instance };
if (inScopeTags.indexOf(tag) !== -1) {
ancestorInfo.aTagInScope = null;
ancestorInfo.buttonTagInScope = null;
ancestorInfo.nobrTagInScope = null;
}
if (buttonScopeTags.indexOf(tag) !== -1) {
ancestorInfo.pTagInButtonScope = null;
}
// See rules for 'li', 'dd', 'dt' start tags in
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') {
ancestorInfo.listItemTagAutoclosing = null;
ancestorInfo.dlItemTagAutoclosing = null;
}
ancestorInfo.parentTag = info;
if (tag === 'form') {
ancestorInfo.formTag = info;
}
if (tag === 'a') {
ancestorInfo.aTagInScope = info;
}
if (tag === 'button') {
ancestorInfo.buttonTagInScope = info;
}
if (tag === 'nobr') {
ancestorInfo.nobrTagInScope = info;
}
if (tag === 'p') {
ancestorInfo.pTagInButtonScope = info;
}
if (tag === 'li') {
ancestorInfo.listItemTagAutoclosing = info;
}
if (tag === 'dd' || tag === 'dt') {
ancestorInfo.dlItemTagAutoclosing = info;
}
return ancestorInfo;
};
/**
* Returns whether
*/
var isTagValidWithParent = function (tag, parentTag) {
// First, let's check if we're in an unusual parsing mode...
switch (parentTag) {
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
case 'select':
return tag === 'option' || tag === 'optgroup' || tag === '#text';
case 'optgroup':
return tag === 'option' || tag === '#text';
// Strictly speaking, seeing an <option> doesn't mean we're in a <select>
// but
case 'option':
return tag === '#text';
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
// No special behavior since these rules fall back to "in body" mode for
// all except special table nodes which cause bad parsing behavior anyway.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
case 'tr':
return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template';
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
case 'tbody':
case 'thead':
case 'tfoot':
return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template';
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
case 'colgroup':
return tag === 'col' || tag === 'template';
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
case 'table':
return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template';
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
case 'head':
return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template';
// https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
case 'html':
return tag === 'head' || tag === 'body';
}
// Probably in the "in body" parsing mode, so we outlaw only tag combos
// where the parsing rules cause implicit opens or closes to be added.
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
switch (tag) {
case 'h1':
case 'h2':
case 'h3':
case 'h4':
case 'h5':
case 'h6':
return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6';
case 'rp':
case 'rt':
return impliedEndTags.indexOf(parentTag) === -1;
case 'caption':
case 'col':
case 'colgroup':
case 'frame':
case 'head':
case 'tbody':
case 'td':
case 'tfoot':
case 'th':
case 'thead':
case 'tr':
// These tags are only valid with a few parents that have special child
// parsing rules -- if we're down here, then none of those matched and
// so we allow it only if we don't know what the parent is, as all other
// cases are invalid.
return parentTag == null;
}
return true;
};
/**
* Returns whether
*/
var findInvalidAncestorForTag = function (tag, ancestorInfo) {
switch (tag) {
case 'address':
case 'article':
case 'aside':
case 'blockquote':
case 'center':
case 'details':
case 'dialog':
case 'dir':
case 'div':
case 'dl':
case 'fieldset':
case 'figcaption':
case 'figure':
case 'footer':
case 'header':
case 'hgroup':
case 'main':
case 'menu':
case 'nav':
case 'ol':
case 'p':
case 'section':
case 'summary':
case 'ul':
case 'pre':
case 'listing':
case 'table':
case 'hr':
case 'xmp':
case 'h1':
case 'h2':
case 'h3':
case 'h4':
case 'h5':
case 'h6':
return ancestorInfo.pTagInButtonScope;
case 'form':
return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
case 'li':
return ancestorInfo.listItemTagAutoclosing;
case 'dd':
case 'dt':
return ancestorInfo.dlItemTagAutoclosing;
case 'button':
return ancestorInfo.buttonTagInScope;
case 'a':
// Spec says something about storing a list of markers, but it sounds
// equivalent to this check.
return ancestorInfo.aTagInScope;
case 'nobr':
return ancestorInfo.nobrTagInScope;
}
return null;
};
/**
* Given a ReactCompositeComponent instance, return a list of its recursive
* owners, starting at the root and ending with the instance itself.
*/
var findOwnerStack = function (instance) {
if (!instance) {
return [];
}
var stack = [];
/*eslint-disable space-after-keywords */
do {
/*eslint-enable space-after-keywords */
stack.push(instance);
} while (instance = instance._currentElement._owner);
stack.reverse();
return stack;
};
var didWarn = {};
validateDOMNesting = function (childTag, childInstance, ancestorInfo) {
ancestorInfo = ancestorInfo || emptyAncestorInfo;
var parentInfo = ancestorInfo.parentTag;
var parentTag = parentInfo && parentInfo.tag;
var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo;
var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo);
var problematic = invalidParent || invalidAncestor;
if (problematic) {
var ancestorTag = problematic.tag;
var ancestorInstance = problematic.instance;
var childOwner = childInstance && childInstance._currentElement._owner;
var ancestorOwner = ancestorInstance && ancestorInstance._currentElement._owner;
var childOwners = findOwnerStack(childOwner);
var ancestorOwners = findOwnerStack(ancestorOwner);
var minStackLen = Math.min(childOwners.length, ancestorOwners.length);
var i;
var deepestCommon = -1;
for (i = 0; i < minStackLen; i++) {
if (childOwners[i] === ancestorOwners[i]) {
deepestCommon = i;
} else {
break;
}
}
var UNKNOWN = '(unknown)';
var childOwnerNames = childOwners.slice(deepestCommon + 1).map(function (inst) {
return inst.getName() || UNKNOWN;
});
var ancestorOwnerNames = ancestorOwners.slice(deepestCommon + 1).map(function (inst) {
return inst.getName() || UNKNOWN;
});
var ownerInfo = [].concat(
// If the parent and child instances have a common owner ancestor, start
// with that -- otherwise we just start with the parent's owners.
deepestCommon !== -1 ? childOwners[deepestCommon].getName() || UNKNOWN : [], ancestorOwnerNames, ancestorTag,
// If we're warning about an invalid (non-parent) ancestry, add '...'
invalidAncestor ? ['...'] : [], childOwnerNames, childTag).join(' > ');
var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + ownerInfo;
if (didWarn[warnKey]) {
return;
}
didWarn[warnKey] = true;
if (invalidParent) {
var info = '';
if (ancestorTag === 'table' && childTag === 'tr') {
info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.';
}
process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): <%s> cannot appear as a child of <%s>. ' + 'See %s.%s', childTag, ancestorTag, ownerInfo, info) : undefined;
} else {
process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): <%s> cannot appear as a descendant of ' + '<%s>. See %s.', childTag, ancestorTag, ownerInfo) : undefined;
}
}
};
validateDOMNesting.ancestorInfoContextKey = '__validateDOMNesting_ancestorInfo$' + Math.random().toString(36).slice(2);
validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo;
// For testing
validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) {
ancestorInfo = ancestorInfo || emptyAncestorInfo;
var parentInfo = ancestorInfo.parentTag;
var parentTag = parentInfo && parentInfo.tag;
return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo);
};
}
module.exports = validateDOMNesting;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDefaultInjection
*/
'use strict';
var BeforeInputEventPlugin = __webpack_require__(72);
var ChangeEventPlugin = __webpack_require__(80);
var ClientReactRootIndex = __webpack_require__(83);
var DefaultEventPluginOrder = __webpack_require__(84);
var EnterLeaveEventPlugin = __webpack_require__(85);
var ExecutionEnvironment = __webpack_require__(9);
var HTMLDOMPropertyConfig = __webpack_require__(89);
var ReactBrowserComponentMixin = __webpack_require__(90);
var ReactComponentBrowserEnvironment = __webpack_require__(26);
var ReactDefaultBatchingStrategy = __webpack_require__(92);
var ReactDOMComponent = __webpack_require__(93);
var ReactDOMTextComponent = __webpack_require__(6);
var ReactEventListener = __webpack_require__(118);
var ReactInjection = __webpack_require__(121);
var ReactInstanceHandles = __webpack_require__(45);
var ReactMount = __webpack_require__(28);
var ReactReconcileTransaction = __webpack_require__(125);
var SelectEventPlugin = __webpack_require__(130);
var ServerReactRootIndex = __webpack_require__(131);
var SimpleEventPlugin = __webpack_require__(132);
var SVGDOMPropertyConfig = __webpack_require__(141);
var alreadyInjected = false;
function inject() {
if (alreadyInjected) {
// TODO: This is currently true because these injections are shared between
// the client and the server package. They should be built independently
// and not share any injection state. Then this problem will be solved.
return;
}
alreadyInjected = true;
ReactInjection.EventEmitter.injectReactEventListener(ReactEventListener);
/**
* Inject modules for resolving DOM hierarchy and plugin ordering.
*/
ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder);
ReactInjection.EventPluginHub.injectInstanceHandle(ReactInstanceHandles);
ReactInjection.EventPluginHub.injectMount(ReactMount);
/**
* Some important event plugins included by default (without having to require
* them).
*/
ReactInjection.EventPluginHub.injectEventPluginsByName({
SimpleEventPlugin: SimpleEventPlugin,
EnterLeaveEventPlugin: EnterLeaveEventPlugin,
ChangeEventPlugin: ChangeEventPlugin,
SelectEventPlugin: SelectEventPlugin,
BeforeInputEventPlugin: BeforeInputEventPlugin
});
ReactInjection.NativeComponent.injectGenericComponentClass(ReactDOMComponent);
ReactInjection.NativeComponent.injectTextComponentClass(ReactDOMTextComponent);
ReactInjection.Class.injectMixin(ReactBrowserComponentMixin);
ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig);
ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig);
ReactInjection.EmptyComponent.injectEmptyComponent('noscript');
ReactInjection.Updates.injectReconcileTransaction(ReactReconcileTransaction);
ReactInjection.Updates.injectBatchingStrategy(ReactDefaultBatchingStrategy);
ReactInjection.RootIndex.injectCreateReactRootIndex(ExecutionEnvironment.canUseDOM ? ClientReactRootIndex.createReactRootIndex : ServerReactRootIndex.createReactRootIndex);
ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment);
if (process.env.NODE_ENV !== 'production') {
var url = ExecutionEnvironment.canUseDOM && window.location.href || '';
if (/[?&]react_perf\b/.test(url)) {
var ReactDefaultPerf = __webpack_require__(142);
ReactDefaultPerf.start();
}
}
}
module.exports = {
inject: inject
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015 Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule BeforeInputEventPlugin
* @typechecks static-only
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventPropagators = __webpack_require__(73);
var ExecutionEnvironment = __webpack_require__(9);
var FallbackCompositionState = __webpack_require__(74);
var SyntheticCompositionEvent = __webpack_require__(76);
var SyntheticInputEvent = __webpack_require__(78);
var keyOf = __webpack_require__(79);
var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
var START_KEYCODE = 229;
var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;
var documentMode = null;
if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {
documentMode = document.documentMode;
}
// Webkit offers a very useful `textInput` event that can be used to
// directly represent `beforeInput`. The IE `textinput` event is not as
// useful, so we don't use it.
var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();
// In IE9+, we have access to composition events, but the data supplied
// by the native compositionend event may be incorrect. Japanese ideographic
// spaces, for instance (\u3000) are not recorded correctly.
var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
/**
* Opera <= 12 includes TextEvent in window, but does not fire
* text input events. Rely on keypress instead.
*/
function isPresto() {
var opera = window.opera;
return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;
}
var SPACEBAR_CODE = 32;
var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
var topLevelTypes = EventConstants.topLevelTypes;
// Events and their corresponding property names.
var eventTypes = {
beforeInput: {
phasedRegistrationNames: {
bubbled: keyOf({ onBeforeInput: null }),
captured: keyOf({ onBeforeInputCapture: null })
},
dependencies: [topLevelTypes.topCompositionEnd, topLevelTypes.topKeyPress, topLevelTypes.topTextInput, topLevelTypes.topPaste]
},
compositionEnd: {
phasedRegistrationNames: {
bubbled: keyOf({ onCompositionEnd: null }),
captured: keyOf({ onCompositionEndCapture: null })
},
dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionEnd, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]
},
compositionStart: {
phasedRegistrationNames: {
bubbled: keyOf({ onCompositionStart: null }),
captured: keyOf({ onCompositionStartCapture: null })
},
dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionStart, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]
},
compositionUpdate: {
phasedRegistrationNames: {
bubbled: keyOf({ onCompositionUpdate: null }),
captured: keyOf({ onCompositionUpdateCapture: null })
},
dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionUpdate, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]
}
};
// Track whether we've ever handled a keypress on the space key.
var hasSpaceKeypress = false;
/**
* Return whether a native keypress event is assumed to be a command.
* This is required because Firefox fires `keypress` events for key commands
* (cut, copy, select-all, etc.) even though no character is inserted.
*/
function isKeypressCommand(nativeEvent) {
return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
// ctrlKey && altKey is equivalent to AltGr, and is not a command.
!(nativeEvent.ctrlKey && nativeEvent.altKey);
}
/**
* Translate native top level events into event types.
*
* @param {string} topLevelType
* @return {object}
*/
function getCompositionEventType(topLevelType) {
switch (topLevelType) {
case topLevelTypes.topCompositionStart:
return eventTypes.compositionStart;
case topLevelTypes.topCompositionEnd:
return eventTypes.compositionEnd;
case topLevelTypes.topCompositionUpdate:
return eventTypes.compositionUpdate;
}
}
/**
* Does our fallback best-guess model think this event signifies that
* composition has begun?
*
* @param {string} topLevelType
* @param {object} nativeEvent
* @return {boolean}
*/
function isFallbackCompositionStart(topLevelType, nativeEvent) {
return topLevelType === topLevelTypes.topKeyDown && nativeEvent.keyCode === START_KEYCODE;
}
/**
* Does our fallback mode think that this event is the end of composition?
*
* @param {string} topLevelType
* @param {object} nativeEvent
* @return {boolean}
*/
function isFallbackCompositionEnd(topLevelType, nativeEvent) {
switch (topLevelType) {
case topLevelTypes.topKeyUp:
// Command keys insert or clear IME input.
return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
case topLevelTypes.topKeyDown:
// Expect IME keyCode on each keydown. If we get any other
// code we must have exited earlier.
return nativeEvent.keyCode !== START_KEYCODE;
case topLevelTypes.topKeyPress:
case topLevelTypes.topMouseDown:
case topLevelTypes.topBlur:
// Events are not possible without cancelling IME.
return true;
default:
return false;
}
}
/**
* Google Input Tools provides composition data via a CustomEvent,
* with the `data` property populated in the `detail` object. If this
* is available on the event object, use it. If not, this is a plain
* composition event and we have nothing special to extract.
*
* @param {object} nativeEvent
* @return {?string}
*/
function getDataFromCustomEvent(nativeEvent) {
var detail = nativeEvent.detail;
if (typeof detail === 'object' && 'data' in detail) {
return detail.data;
}
return null;
}
// Track the current IME composition fallback object, if any.
var currentComposition = null;
/**
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {?object} A SyntheticCompositionEvent.
*/
function extractCompositionEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
var eventType;
var fallbackData;
if (canUseCompositionEvent) {
eventType = getCompositionEventType(topLevelType);
} else if (!currentComposition) {
if (isFallbackCompositionStart(topLevelType, nativeEvent)) {
eventType = eventTypes.compositionStart;
}
} else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {
eventType = eventTypes.compositionEnd;
}
if (!eventType) {
return null;
}
if (useFallbackCompositionData) {
// The current composition is stored statically and must not be
// overwritten while composition continues.
if (!currentComposition && eventType === eventTypes.compositionStart) {
currentComposition = FallbackCompositionState.getPooled(topLevelTarget);
} else if (eventType === eventTypes.compositionEnd) {
if (currentComposition) {
fallbackData = currentComposition.getData();
}
}
}
var event = SyntheticCompositionEvent.getPooled(eventType, topLevelTargetID, nativeEvent, nativeEventTarget);
if (fallbackData) {
// Inject data generated from fallback path into the synthetic event.
// This matches the property of native CompositionEventInterface.
event.data = fallbackData;
} else {
var customData = getDataFromCustomEvent(nativeEvent);
if (customData !== null) {
event.data = customData;
}
}
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
}
/**
* @param {string} topLevelType Record from `EventConstants`.
* @param {object} nativeEvent Native browser event.
* @return {?string} The string corresponding to this `beforeInput` event.
*/
function getNativeBeforeInputChars(topLevelType, nativeEvent) {
switch (topLevelType) {
case topLevelTypes.topCompositionEnd:
return getDataFromCustomEvent(nativeEvent);
case topLevelTypes.topKeyPress:
/**
* If native `textInput` events are available, our goal is to make
* use of them. However, there is a special case: the spacebar key.
* In Webkit, preventing default on a spacebar `textInput` event
* cancels character insertion, but it *also* causes the browser
* to fall back to its default spacebar behavior of scrolling the
* page.
*
* Tracking at:
* https://code.google.com/p/chromium/issues/detail?id=355103
*
* To avoid this issue, use the keypress event as if no `textInput`
* event is available.
*/
var which = nativeEvent.which;
if (which !== SPACEBAR_CODE) {
return null;
}
hasSpaceKeypress = true;
return SPACEBAR_CHAR;
case topLevelTypes.topTextInput:
// Record the characters to be added to the DOM.
var chars = nativeEvent.data;
// If it's a spacebar character, assume that we have already handled
// it at the keypress level and bail immediately. Android Chrome
// doesn't give us keycodes, so we need to blacklist it.
if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
return null;
}
return chars;
default:
// For other native event types, do nothing.
return null;
}
}
/**
* For browsers that do not provide the `textInput` event, extract the
* appropriate string to use for SyntheticInputEvent.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {object} nativeEvent Native browser event.
* @return {?string} The fallback string for this `beforeInput` event.
*/
function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
// If we are currently composing (IME) and using a fallback to do so,
// try to extract the composed characters from the fallback object.
if (currentComposition) {
if (topLevelType === topLevelTypes.topCompositionEnd || isFallbackCompositionEnd(topLevelType, nativeEvent)) {
var chars = currentComposition.getData();
FallbackCompositionState.release(currentComposition);
currentComposition = null;
return chars;
}
return null;
}
switch (topLevelType) {
case topLevelTypes.topPaste:
// If a paste event occurs after a keypress, throw out the input
// chars. Paste events should not lead to BeforeInput events.
return null;
case topLevelTypes.topKeyPress:
/**
* As of v27, Firefox may fire keypress events even when no character
* will be inserted. A few possibilities:
*
* - `which` is `0`. Arrow keys, Esc key, etc.
*
* - `which` is the pressed key code, but no char is available.
* Ex: 'AltGr + d` in Polish. There is no modified character for
* this key combination and no character is inserted into the
* document, but FF fires the keypress for char code `100` anyway.
* No `input` event will occur.
*
* - `which` is the pressed key code, but a command combination is
* being used. Ex: `Cmd+C`. No character is inserted, and no
* `input` event will occur.
*/
if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
return String.fromCharCode(nativeEvent.which);
}
return null;
case topLevelTypes.topCompositionEnd:
return useFallbackCompositionData ? null : nativeEvent.data;
default:
return null;
}
}
/**
* Extract a SyntheticInputEvent for `beforeInput`, based on either native
* `textInput` or fallback behavior.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {?object} A SyntheticInputEvent.
*/
function extractBeforeInputEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
var chars;
if (canUseTextInputEvent) {
chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
} else {
chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
}
// If no characters are being inserted, no BeforeInput event should
// be fired.
if (!chars) {
return null;
}
var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, topLevelTargetID, nativeEvent, nativeEventTarget);
event.data = chars;
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
}
/**
* Create an `onBeforeInput` event to match
* http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
*
* This event plugin is based on the native `textInput` event
* available in Chrome, Safari, Opera, and IE. This event fires after
* `onKeyPress` and `onCompositionEnd`, but before `onInput`.
*
* `beforeInput` is spec'd but not implemented in any browsers, and
* the `input` event does not provide any useful information about what has
* actually been added, contrary to the spec. Thus, `textInput` is the best
* available event to identify the characters that have actually been inserted
* into the target node.
*
* This plugin is also responsible for emitting `composition` events, thus
* allowing us to share composition fallback code for both `beforeInput` and
* `composition` event types.
*/
var BeforeInputEventPlugin = {
eventTypes: eventTypes,
/**
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {*} An accumulation of synthetic events.
* @see {EventPluginHub.extractEvents}
*/
extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
return [extractCompositionEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget)];
}
};
module.exports = BeforeInputEventPlugin;
/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule EventPropagators
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventPluginHub = __webpack_require__(31);
var warning = __webpack_require__(25);
var accumulateInto = __webpack_require__(35);
var forEachAccumulated = __webpack_require__(36);
var PropagationPhases = EventConstants.PropagationPhases;
var getListener = EventPluginHub.getListener;
/**
* Some event types have a notion of different registration names for different
* "phases" of propagation. This finds listeners by a given phase.
*/
function listenerAtPhase(id, event, propagationPhase) {
var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
return getListener(id, registrationName);
}
/**
* Tags a `SyntheticEvent` with dispatched listeners. Creating this function
* here, allows us to not have to bind or create functions for each event.
* Mutating the event's members allows us to not have to create a wrapping
* "dispatch" object that pairs the event with the listener.
*/
function accumulateDirectionalDispatches(domID, upwards, event) {
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(domID, 'Dispatching id must not be null') : undefined;
}
var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;
var listener = listenerAtPhase(domID, event, phase);
if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
event._dispatchIDs = accumulateInto(event._dispatchIDs, domID);
}
}
/**
* Collect dispatches (must be entirely collected before dispatching - see unit
* tests). Lazily allocate the array to conserve memory. We must loop through
* each event and perform the traversal for each one. We cannot perform a
* single traversal for the entire collection of events because each event may
* have a different target.
*/
function accumulateTwoPhaseDispatchesSingle(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
EventPluginHub.injection.getInstanceHandle().traverseTwoPhase(event.dispatchMarker, accumulateDirectionalDispatches, event);
}
}
/**
* Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
*/
function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
EventPluginHub.injection.getInstanceHandle().traverseTwoPhaseSkipTarget(event.dispatchMarker, accumulateDirectionalDispatches, event);
}
}
/**
* Accumulates without regard to direction, does not look for phased
* registration names. Same as `accumulateDirectDispatchesSingle` but without
* requiring that the `dispatchMarker` be the same as the dispatched ID.
*/
function accumulateDispatches(id, ignoredDirection, event) {
if (event && event.dispatchConfig.registrationName) {
var registrationName = event.dispatchConfig.registrationName;
var listener = getListener(id, registrationName);
if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
event._dispatchIDs = accumulateInto(event._dispatchIDs, id);
}
}
}
/**
* Accumulates dispatches on an `SyntheticEvent`, but only for the
* `dispatchMarker`.
* @param {SyntheticEvent} event
*/
function accumulateDirectDispatchesSingle(event) {
if (event && event.dispatchConfig.registrationName) {
accumulateDispatches(event.dispatchMarker, null, event);
}
}
function accumulateTwoPhaseDispatches(events) {
forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
}
function accumulateTwoPhaseDispatchesSkipTarget(events) {
forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
}
function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {
EventPluginHub.injection.getInstanceHandle().traverseEnterLeave(fromID, toID, accumulateDispatches, leave, enter);
}
function accumulateDirectDispatches(events) {
forEachAccumulated(events, accumulateDirectDispatchesSingle);
}
/**
* A small set of propagation patterns, each of which will accept a small amount
* of information, and generate a set of "dispatch ready event objects" - which
* are sets of events that have already been annotated with a set of dispatched
* listener functions/ids. The API is designed this way to discourage these
* propagation strategies from actually executing the dispatches, since we
* always want to collect the entire set of dispatches before executing event a
* single one.
*
* @constructor EventPropagators
*/
var EventPropagators = {
accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
accumulateDirectDispatches: accumulateDirectDispatches,
accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
};
module.exports = EventPropagators;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule FallbackCompositionState
* @typechecks static-only
*/
'use strict';
var PooledClass = __webpack_require__(56);
var assign = __webpack_require__(39);
var getTextContentAccessor = __webpack_require__(75);
/**
* This helper class stores information about text content of a target node,
* allowing comparison of content before and after a given event.
*
* Identify the node where selection currently begins, then observe
* both its text content and its current position in the DOM. Since the
* browser may natively replace the target node during composition, we can
* use its position to find its replacement.
*
* @param {DOMEventTarget} root
*/
function FallbackCompositionState(root) {
this._root = root;
this._startText = this.getText();
this._fallbackText = null;
}
assign(FallbackCompositionState.prototype, {
destructor: function () {
this._root = null;
this._startText = null;
this._fallbackText = null;
},
/**
* Get current text of input.
*
* @return {string}
*/
getText: function () {
if ('value' in this._root) {
return this._root.value;
}
return this._root[getTextContentAccessor()];
},
/**
* Determine the differing substring between the initially stored
* text content and the current content.
*
* @return {string}
*/
getData: function () {
if (this._fallbackText) {
return this._fallbackText;
}
var start;
var startValue = this._startText;
var startLength = startValue.length;
var end;
var endValue = this.getText();
var endLength = endValue.length;
for (start = 0; start < startLength; start++) {
if (startValue[start] !== endValue[start]) {
break;
}
}
var minEnd = startLength - start;
for (end = 1; end <= minEnd; end++) {
if (startValue[startLength - end] !== endValue[endLength - end]) {
break;
}
}
var sliceTail = end > 1 ? 1 - end : undefined;
this._fallbackText = endValue.slice(start, sliceTail);
return this._fallbackText;
}
});
PooledClass.addPoolingTo(FallbackCompositionState);
module.exports = FallbackCompositionState;
/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getTextContentAccessor
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var contentKey = null;
/**
* Gets the key used to access text content on a DOM node.
*
* @return {?string} Key used to access text content.
* @internal
*/
function getTextContentAccessor() {
if (!contentKey && ExecutionEnvironment.canUseDOM) {
// Prefer textContent to innerText because many browsers support both but
// SVG <text> elements don't support innerText even when <div> does.
contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';
}
return contentKey;
}
module.exports = getTextContentAccessor;
/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticCompositionEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = __webpack_require__(77);
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
*/
var CompositionEventInterface = {
data: null
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface);
module.exports = SyntheticCompositionEvent;
/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticEvent
* @typechecks static-only
*/
'use strict';
var PooledClass = __webpack_require__(56);
var assign = __webpack_require__(39);
var emptyFunction = __webpack_require__(15);
var warning = __webpack_require__(25);
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var EventInterface = {
type: null,
target: null,
// currentTarget is set when dispatching; no use in copying it here
currentTarget: emptyFunction.thatReturnsNull,
eventPhase: null,
bubbles: null,
cancelable: null,
timeStamp: function (event) {
return event.timeStamp || Date.now();
},
defaultPrevented: null,
isTrusted: null
};
/**
* Synthetic events are dispatched by event plugins, typically in response to a
* top-level event delegation handler.
*
* These systems should generally use pooling to reduce the frequency of garbage
* collection. The system should check `isPersistent` to determine whether the
* event should be released into the pool after being dispatched. Users that
* need a persisted event should invoke `persist`.
*
* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
* normalizing browser quirks. Subclasses do not necessarily have to implement a
* DOM interface; custom application-specific events can also subclass this.
*
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
*/
function SyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
this.dispatchConfig = dispatchConfig;
this.dispatchMarker = dispatchMarker;
this.nativeEvent = nativeEvent;
var Interface = this.constructor.Interface;
for (var propName in Interface) {
if (!Interface.hasOwnProperty(propName)) {
continue;
}
var normalize = Interface[propName];
if (normalize) {
this[propName] = normalize(nativeEvent);
} else {
if (propName === 'target') {
this.target = nativeEventTarget;
} else {
this[propName] = nativeEvent[propName];
}
}
}
var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
if (defaultPrevented) {
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
} else {
this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
}
this.isPropagationStopped = emptyFunction.thatReturnsFalse;
}
assign(SyntheticEvent.prototype, {
preventDefault: function () {
this.defaultPrevented = true;
var event = this.nativeEvent;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(event, 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re calling `preventDefault` on a ' + 'released/nullified synthetic event. This is a no-op. See ' + 'https://fb.me/react-event-pooling for more information.') : undefined;
}
if (!event) {
return;
}
if (event.preventDefault) {
event.preventDefault();
} else {
event.returnValue = false;
}
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
},
stopPropagation: function () {
var event = this.nativeEvent;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(event, 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re calling `stopPropagation` on a ' + 'released/nullified synthetic event. This is a no-op. See ' + 'https://fb.me/react-event-pooling for more information.') : undefined;
}
if (!event) {
return;
}
if (event.stopPropagation) {
event.stopPropagation();
} else {
event.cancelBubble = true;
}
this.isPropagationStopped = emptyFunction.thatReturnsTrue;
},
/**
* We release all dispatched `SyntheticEvent`s after each event loop, adding
* them back into the pool. This allows a way to hold onto a reference that
* won't be added back into the pool.
*/
persist: function () {
this.isPersistent = emptyFunction.thatReturnsTrue;
},
/**
* Checks if this event should be released back into the pool.
*
* @return {boolean} True if this should not be released, false otherwise.
*/
isPersistent: emptyFunction.thatReturnsFalse,
/**
* `PooledClass` looks for `destructor` on each instance it releases.
*/
destructor: function () {
var Interface = this.constructor.Interface;
for (var propName in Interface) {
this[propName] = null;
}
this.dispatchConfig = null;
this.dispatchMarker = null;
this.nativeEvent = null;
}
});
SyntheticEvent.Interface = EventInterface;
/**
* Helper to reduce boilerplate when creating subclasses.
*
* @param {function} Class
* @param {?object} Interface
*/
SyntheticEvent.augmentClass = function (Class, Interface) {
var Super = this;
var prototype = Object.create(Super.prototype);
assign(prototype, Class.prototype);
Class.prototype = prototype;
Class.prototype.constructor = Class;
Class.Interface = assign({}, Super.Interface, Interface);
Class.augmentClass = Super.augmentClass;
PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler);
};
PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler);
module.exports = SyntheticEvent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticInputEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = __webpack_require__(77);
/**
* @interface Event
* @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
* /#events-inputevents
*/
var InputEventInterface = {
data: null
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticEvent.augmentClass(SyntheticInputEvent, InputEventInterface);
module.exports = SyntheticInputEvent;
/***/ },
/* 79 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule keyOf
*/
/**
* Allows extraction of a minified key. Let's the build system minify keys
* without losing the ability to dynamically use key strings as values
* themselves. Pass in an object with a single key/val pair and it will return
* you the string key of that single record. Suppose you want to grab the
* value for a key 'className' inside of an object. Key/val minification may
* have aliased that key to be 'xa12'. keyOf({className: null}) will return
* 'xa12' in that case. Resolve keys you want to use once at startup time, then
* reuse those resolutions.
*/
"use strict";
var keyOf = function (oneKeyObj) {
var key;
for (key in oneKeyObj) {
if (!oneKeyObj.hasOwnProperty(key)) {
continue;
}
return key;
}
return null;
};
module.exports = keyOf;
/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ChangeEventPlugin
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventPluginHub = __webpack_require__(31);
var EventPropagators = __webpack_require__(73);
var ExecutionEnvironment = __webpack_require__(9);
var ReactUpdates = __webpack_require__(54);
var SyntheticEvent = __webpack_require__(77);
var getEventTarget = __webpack_require__(81);
var isEventSupported = __webpack_require__(40);
var isTextInputElement = __webpack_require__(82);
var keyOf = __webpack_require__(79);
var topLevelTypes = EventConstants.topLevelTypes;
var eventTypes = {
change: {
phasedRegistrationNames: {
bubbled: keyOf({ onChange: null }),
captured: keyOf({ onChangeCapture: null })
},
dependencies: [topLevelTypes.topBlur, topLevelTypes.topChange, topLevelTypes.topClick, topLevelTypes.topFocus, topLevelTypes.topInput, topLevelTypes.topKeyDown, topLevelTypes.topKeyUp, topLevelTypes.topSelectionChange]
}
};
/**
* For IE shims
*/
var activeElement = null;
var activeElementID = null;
var activeElementValue = null;
var activeElementValueProp = null;
/**
* SECTION: handle `change` event
*/
function shouldUseChangeEvent(elem) {
var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
}
var doesChangeEventBubble = false;
if (ExecutionEnvironment.canUseDOM) {
// See `handleChange` comment below
doesChangeEventBubble = isEventSupported('change') && (!('documentMode' in document) || document.documentMode > 8);
}
function manualDispatchChangeEvent(nativeEvent) {
var event = SyntheticEvent.getPooled(eventTypes.change, activeElementID, nativeEvent, getEventTarget(nativeEvent));
EventPropagators.accumulateTwoPhaseDispatches(event);
// If change and propertychange bubbled, we'd just bind to it like all the
// other events and have it go through ReactBrowserEventEmitter. Since it
// doesn't, we manually listen for the events and so we have to enqueue and
// process the abstract event manually.
//
// Batching is necessary here in order to ensure that all event handlers run
// before the next rerender (including event handlers attached to ancestor
// elements instead of directly on the input). Without this, controlled
// components don't work properly in conjunction with event bubbling because
// the component is rerendered and the value reverted before all the event
// handlers can run. See https://github.com/facebook/react/issues/708.
ReactUpdates.batchedUpdates(runEventInBatch, event);
}
function runEventInBatch(event) {
EventPluginHub.enqueueEvents(event);
EventPluginHub.processEventQueue(false);
}
function startWatchingForChangeEventIE8(target, targetID) {
activeElement = target;
activeElementID = targetID;
activeElement.attachEvent('onchange', manualDispatchChangeEvent);
}
function stopWatchingForChangeEventIE8() {
if (!activeElement) {
return;
}
activeElement.detachEvent('onchange', manualDispatchChangeEvent);
activeElement = null;
activeElementID = null;
}
function getTargetIDForChangeEvent(topLevelType, topLevelTarget, topLevelTargetID) {
if (topLevelType === topLevelTypes.topChange) {
return topLevelTargetID;
}
}
function handleEventsForChangeEventIE8(topLevelType, topLevelTarget, topLevelTargetID) {
if (topLevelType === topLevelTypes.topFocus) {
// stopWatching() should be a noop here but we call it just in case we
// missed a blur event somehow.
stopWatchingForChangeEventIE8();
startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID);
} else if (topLevelType === topLevelTypes.topBlur) {
stopWatchingForChangeEventIE8();
}
}
/**
* SECTION: handle `input` event
*/
var isInputEventSupported = false;
if (ExecutionEnvironment.canUseDOM) {
// IE9 claims to support the input event but fails to trigger it when
// deleting text, so we ignore its input events
isInputEventSupported = isEventSupported('input') && (!('documentMode' in document) || document.documentMode > 9);
}
/**
* (For old IE.) Replacement getter/setter for the `value` property that gets
* set on the active element.
*/
var newValueProp = {
get: function () {
return activeElementValueProp.get.call(this);
},
set: function (val) {
// Cast to a string so we can do equality checks.
activeElementValue = '' + val;
activeElementValueProp.set.call(this, val);
}
};
/**
* (For old IE.) Starts tracking propertychange events on the passed-in element
* and override the value property so that we can distinguish user events from
* value changes in JS.
*/
function startWatchingForValueChange(target, targetID) {
activeElement = target;
activeElementID = targetID;
activeElementValue = target.value;
activeElementValueProp = Object.getOwnPropertyDescriptor(target.constructor.prototype, 'value');
// Not guarded in a canDefineProperty check: IE8 supports defineProperty only
// on DOM elements
Object.defineProperty(activeElement, 'value', newValueProp);
activeElement.attachEvent('onpropertychange', handlePropertyChange);
}
/**
* (For old IE.) Removes the event listeners from the currently-tracked element,
* if any exists.
*/
function stopWatchingForValueChange() {
if (!activeElement) {
return;
}
// delete restores the original property definition
delete activeElement.value;
activeElement.detachEvent('onpropertychange', handlePropertyChange);
activeElement = null;
activeElementID = null;
activeElementValue = null;
activeElementValueProp = null;
}
/**
* (For old IE.) Handles a propertychange event, sending a `change` event if
* the value of the active element has changed.
*/
function handlePropertyChange(nativeEvent) {
if (nativeEvent.propertyName !== 'value') {
return;
}
var value = nativeEvent.srcElement.value;
if (value === activeElementValue) {
return;
}
activeElementValue = value;
manualDispatchChangeEvent(nativeEvent);
}
/**
* If a `change` event should be fired, returns the target's ID.
*/
function getTargetIDForInputEvent(topLevelType, topLevelTarget, topLevelTargetID) {
if (topLevelType === topLevelTypes.topInput) {
// In modern browsers (i.e., not IE8 or IE9), the input event is exactly
// what we want so fall through here and trigger an abstract event
return topLevelTargetID;
}
}
// For IE8 and IE9.
function handleEventsForInputEventIE(topLevelType, topLevelTarget, topLevelTargetID) {
if (topLevelType === topLevelTypes.topFocus) {
// In IE8, we can capture almost all .value changes by adding a
// propertychange handler and looking for events with propertyName
// equal to 'value'
// In IE9, propertychange fires for most input events but is buggy and
// doesn't fire when text is deleted, but conveniently, selectionchange
// appears to fire in all of the remaining cases so we catch those and
// forward the event if the value has changed
// In either case, we don't want to call the event handler if the value
// is changed from JS so we redefine a setter for `.value` that updates
// our activeElementValue variable, allowing us to ignore those changes
//
// stopWatching() should be a noop here but we call it just in case we
// missed a blur event somehow.
stopWatchingForValueChange();
startWatchingForValueChange(topLevelTarget, topLevelTargetID);
} else if (topLevelType === topLevelTypes.topBlur) {
stopWatchingForValueChange();
}
}
// For IE8 and IE9.
function getTargetIDForInputEventIE(topLevelType, topLevelTarget, topLevelTargetID) {
if (topLevelType === topLevelTypes.topSelectionChange || topLevelType === topLevelTypes.topKeyUp || topLevelType === topLevelTypes.topKeyDown) {
// On the selectionchange event, the target is just document which isn't
// helpful for us so just check activeElement instead.
//
// 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
// propertychange on the first input event after setting `value` from a
// script and fires only keydown, keypress, keyup. Catching keyup usually
// gets it and catching keydown lets us fire an event for the first
// keystroke if user does a key repeat (it'll be a little delayed: right
// before the second keystroke). Other input methods (e.g., paste) seem to
// fire selectionchange normally.
if (activeElement && activeElement.value !== activeElementValue) {
activeElementValue = activeElement.value;
return activeElementID;
}
}
}
/**
* SECTION: handle `click` event
*/
function shouldUseClickEvent(elem) {
// Use the `click` event to detect changes to checkbox and radio inputs.
// This approach works across all browsers, whereas `change` does not fire
// until `blur` in IE8.
return elem.nodeName && elem.nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
}
function getTargetIDForClickEvent(topLevelType, topLevelTarget, topLevelTargetID) {
if (topLevelType === topLevelTypes.topClick) {
return topLevelTargetID;
}
}
/**
* This plugin creates an `onChange` event that normalizes change events
* across form elements. This event fires at a time when it's possible to
* change the element's value without seeing a flicker.
*
* Supported elements are:
* - input (see `isTextInputElement`)
* - textarea
* - select
*/
var ChangeEventPlugin = {
eventTypes: eventTypes,
/**
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {*} An accumulation of synthetic events.
* @see {EventPluginHub.extractEvents}
*/
extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
var getTargetIDFunc, handleEventFunc;
if (shouldUseChangeEvent(topLevelTarget)) {
if (doesChangeEventBubble) {
getTargetIDFunc = getTargetIDForChangeEvent;
} else {
handleEventFunc = handleEventsForChangeEventIE8;
}
} else if (isTextInputElement(topLevelTarget)) {
if (isInputEventSupported) {
getTargetIDFunc = getTargetIDForInputEvent;
} else {
getTargetIDFunc = getTargetIDForInputEventIE;
handleEventFunc = handleEventsForInputEventIE;
}
} else if (shouldUseClickEvent(topLevelTarget)) {
getTargetIDFunc = getTargetIDForClickEvent;
}
if (getTargetIDFunc) {
var targetID = getTargetIDFunc(topLevelType, topLevelTarget, topLevelTargetID);
if (targetID) {
var event = SyntheticEvent.getPooled(eventTypes.change, targetID, nativeEvent, nativeEventTarget);
event.type = 'change';
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
}
}
if (handleEventFunc) {
handleEventFunc(topLevelType, topLevelTarget, topLevelTargetID);
}
}
};
module.exports = ChangeEventPlugin;
/***/ },
/* 81 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getEventTarget
* @typechecks static-only
*/
'use strict';
/**
* Gets the target node from a native browser event by accounting for
* inconsistencies in browser DOM APIs.
*
* @param {object} nativeEvent Native browser event.
* @return {DOMEventTarget} Target node.
*/
function getEventTarget(nativeEvent) {
var target = nativeEvent.target || nativeEvent.srcElement || window;
// Safari may fire events on text nodes (Node.TEXT_NODE is 3).
// @see http://www.quirksmode.org/js/events_properties.html
return target.nodeType === 3 ? target.parentNode : target;
}
module.exports = getEventTarget;
/***/ },
/* 82 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule isTextInputElement
*/
'use strict';
/**
* @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
*/
var supportedInputTypes = {
'color': true,
'date': true,
'datetime': true,
'datetime-local': true,
'email': true,
'month': true,
'number': true,
'password': true,
'range': true,
'search': true,
'tel': true,
'text': true,
'time': true,
'url': true,
'week': true
};
function isTextInputElement(elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
return nodeName && (nodeName === 'input' && supportedInputTypes[elem.type] || nodeName === 'textarea');
}
module.exports = isTextInputElement;
/***/ },
/* 83 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ClientReactRootIndex
* @typechecks
*/
'use strict';
var nextReactRootIndex = 0;
var ClientReactRootIndex = {
createReactRootIndex: function () {
return nextReactRootIndex++;
}
};
module.exports = ClientReactRootIndex;
/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule DefaultEventPluginOrder
*/
'use strict';
var keyOf = __webpack_require__(79);
/**
* Module that is injectable into `EventPluginHub`, that specifies a
* deterministic ordering of `EventPlugin`s. A convenient way to reason about
* plugins, without having to package every one of them. This is better than
* having plugins be ordered in the same order that they are injected because
* that ordering would be influenced by the packaging order.
* `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that
* preventing default on events is convenient in `SimpleEventPlugin` handlers.
*/
var DefaultEventPluginOrder = [keyOf({ ResponderEventPlugin: null }), keyOf({ SimpleEventPlugin: null }), keyOf({ TapEventPlugin: null }), keyOf({ EnterLeaveEventPlugin: null }), keyOf({ ChangeEventPlugin: null }), keyOf({ SelectEventPlugin: null }), keyOf({ BeforeInputEventPlugin: null })];
module.exports = DefaultEventPluginOrder;
/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule EnterLeaveEventPlugin
* @typechecks static-only
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventPropagators = __webpack_require__(73);
var SyntheticMouseEvent = __webpack_require__(86);
var ReactMount = __webpack_require__(28);
var keyOf = __webpack_require__(79);
var topLevelTypes = EventConstants.topLevelTypes;
var getFirstReactDOM = ReactMount.getFirstReactDOM;
var eventTypes = {
mouseEnter: {
registrationName: keyOf({ onMouseEnter: null }),
dependencies: [topLevelTypes.topMouseOut, topLevelTypes.topMouseOver]
},
mouseLeave: {
registrationName: keyOf({ onMouseLeave: null }),
dependencies: [topLevelTypes.topMouseOut, topLevelTypes.topMouseOver]
}
};
var extractedEvents = [null, null];
var EnterLeaveEventPlugin = {
eventTypes: eventTypes,
/**
* For almost every interaction we care about, there will be both a top-level
* `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
* we do not extract duplicate events. However, moving the mouse into the
* browser from outside will not fire a `mouseout` event. In this case, we use
* the `mouseover` top-level event.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {*} An accumulation of synthetic events.
* @see {EventPluginHub.extractEvents}
*/
extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
if (topLevelType === topLevelTypes.topMouseOver && (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
return null;
}
if (topLevelType !== topLevelTypes.topMouseOut && topLevelType !== topLevelTypes.topMouseOver) {
// Must not be a mouse in or mouse out - ignoring.
return null;
}
var win;
if (topLevelTarget.window === topLevelTarget) {
// `topLevelTarget` is probably a window object.
win = topLevelTarget;
} else {
// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
var doc = topLevelTarget.ownerDocument;
if (doc) {
win = doc.defaultView || doc.parentWindow;
} else {
win = window;
}
}
var from;
var to;
var fromID = '';
var toID = '';
if (topLevelType === topLevelTypes.topMouseOut) {
from = topLevelTarget;
fromID = topLevelTargetID;
to = getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement);
if (to) {
toID = ReactMount.getID(to);
} else {
to = win;
}
to = to || win;
} else {
from = win;
to = topLevelTarget;
toID = topLevelTargetID;
}
if (from === to) {
// Nothing pertains to our managed components.
return null;
}
var leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, fromID, nativeEvent, nativeEventTarget);
leave.type = 'mouseleave';
leave.target = from;
leave.relatedTarget = to;
var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, toID, nativeEvent, nativeEventTarget);
enter.type = 'mouseenter';
enter.target = to;
enter.relatedTarget = from;
EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);
extractedEvents[0] = leave;
extractedEvents[1] = enter;
return extractedEvents;
}
};
module.exports = EnterLeaveEventPlugin;
/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticMouseEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = __webpack_require__(87);
var ViewportMetrics = __webpack_require__(38);
var getEventModifierState = __webpack_require__(88);
/**
* @interface MouseEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var MouseEventInterface = {
screenX: null,
screenY: null,
clientX: null,
clientY: null,
ctrlKey: null,
shiftKey: null,
altKey: null,
metaKey: null,
getModifierState: getEventModifierState,
button: function (event) {
// Webkit, Firefox, IE9+
// which: 1 2 3
// button: 0 1 2 (standard)
var button = event.button;
if ('which' in event) {
return button;
}
// IE<9
// which: undefined
// button: 0 0 0
// button: 1 4 2 (onmouseup)
return button === 2 ? 2 : button === 4 ? 1 : 0;
},
buttons: null,
relatedTarget: function (event) {
return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement);
},
// "Proprietary" Interface.
pageX: function (event) {
return 'pageX' in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft;
},
pageY: function (event) {
return 'pageY' in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop;
}
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);
module.exports = SyntheticMouseEvent;
/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticUIEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = __webpack_require__(77);
var getEventTarget = __webpack_require__(81);
/**
* @interface UIEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var UIEventInterface = {
view: function (event) {
if (event.view) {
return event.view;
}
var target = getEventTarget(event);
if (target != null && target.window === target) {
// target is a window object
return target;
}
var doc = target.ownerDocument;
// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
if (doc) {
return doc.defaultView || doc.parentWindow;
} else {
return window;
}
},
detail: function (event) {
return event.detail || 0;
}
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticEvent}
*/
function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);
module.exports = SyntheticUIEvent;
/***/ },
/* 88 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getEventModifierState
* @typechecks static-only
*/
'use strict';
/**
* Translation from modifier key to the associated property in the event.
* @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
*/
var modifierKeyToProp = {
'Alt': 'altKey',
'Control': 'ctrlKey',
'Meta': 'metaKey',
'Shift': 'shiftKey'
};
// IE8 does not implement getModifierState so we simply map it to the only
// modifier keys exposed by the event itself, does not support Lock-keys.
// Currently, all major browsers except Chrome seems to support Lock-keys.
function modifierStateGetter(keyArg) {
var syntheticEvent = this;
var nativeEvent = syntheticEvent.nativeEvent;
if (nativeEvent.getModifierState) {
return nativeEvent.getModifierState(keyArg);
}
var keyProp = modifierKeyToProp[keyArg];
return keyProp ? !!nativeEvent[keyProp] : false;
}
function getEventModifierState(nativeEvent) {
return modifierStateGetter;
}
module.exports = getEventModifierState;
/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule HTMLDOMPropertyConfig
*/
'use strict';
var DOMProperty = __webpack_require__(23);
var ExecutionEnvironment = __webpack_require__(9);
var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
var HAS_SIDE_EFFECTS = DOMProperty.injection.HAS_SIDE_EFFECTS;
var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;
var HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;
var HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;
var hasSVG;
if (ExecutionEnvironment.canUseDOM) {
var implementation = document.implementation;
hasSVG = implementation && implementation.hasFeature && implementation.hasFeature('http://www.w3.org/TR/SVG11/feature#BasicStructure', '1.1');
}
var HTMLDOMPropertyConfig = {
isCustomAttribute: RegExp.prototype.test.bind(/^(data|aria)-[a-z_][a-z\d_.\-]*$/),
Properties: {
/**
* Standard Properties
*/
accept: null,
acceptCharset: null,
accessKey: null,
action: null,
allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
allowTransparency: MUST_USE_ATTRIBUTE,
alt: null,
async: HAS_BOOLEAN_VALUE,
autoComplete: null,
// autoFocus is polyfilled/normalized by AutoFocusUtils
// autoFocus: HAS_BOOLEAN_VALUE,
autoPlay: HAS_BOOLEAN_VALUE,
capture: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
cellPadding: null,
cellSpacing: null,
charSet: MUST_USE_ATTRIBUTE,
challenge: MUST_USE_ATTRIBUTE,
checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
classID: MUST_USE_ATTRIBUTE,
// To set className on SVG elements, it's necessary to use .setAttribute;
// this works on HTML elements too in all browsers except IE8. Conveniently,
// IE8 doesn't support SVG and so we can simply use the attribute in
// browsers that support SVG and the property in browsers that don't,
// regardless of whether the element is HTML or SVG.
className: hasSVG ? MUST_USE_ATTRIBUTE : MUST_USE_PROPERTY,
cols: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
colSpan: null,
content: null,
contentEditable: null,
contextMenu: MUST_USE_ATTRIBUTE,
controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
coords: null,
crossOrigin: null,
data: null, // For `<object />` acts as `src`.
dateTime: MUST_USE_ATTRIBUTE,
'default': HAS_BOOLEAN_VALUE,
defer: HAS_BOOLEAN_VALUE,
dir: null,
disabled: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
download: HAS_OVERLOADED_BOOLEAN_VALUE,
draggable: null,
encType: null,
form: MUST_USE_ATTRIBUTE,
formAction: MUST_USE_ATTRIBUTE,
formEncType: MUST_USE_ATTRIBUTE,
formMethod: MUST_USE_ATTRIBUTE,
formNoValidate: HAS_BOOLEAN_VALUE,
formTarget: MUST_USE_ATTRIBUTE,
frameBorder: MUST_USE_ATTRIBUTE,
headers: null,
height: MUST_USE_ATTRIBUTE,
hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
high: null,
href: null,
hrefLang: null,
htmlFor: null,
httpEquiv: null,
icon: null,
id: MUST_USE_PROPERTY,
inputMode: MUST_USE_ATTRIBUTE,
integrity: null,
is: MUST_USE_ATTRIBUTE,
keyParams: MUST_USE_ATTRIBUTE,
keyType: MUST_USE_ATTRIBUTE,
kind: null,
label: null,
lang: null,
list: MUST_USE_ATTRIBUTE,
loop: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
low: null,
manifest: MUST_USE_ATTRIBUTE,
marginHeight: null,
marginWidth: null,
max: null,
maxLength: MUST_USE_ATTRIBUTE,
media: MUST_USE_ATTRIBUTE,
mediaGroup: null,
method: null,
min: null,
minLength: MUST_USE_ATTRIBUTE,
multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
name: null,
nonce: MUST_USE_ATTRIBUTE,
noValidate: HAS_BOOLEAN_VALUE,
open: HAS_BOOLEAN_VALUE,
optimum: null,
pattern: null,
placeholder: null,
poster: null,
preload: null,
radioGroup: null,
readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
rel: null,
required: HAS_BOOLEAN_VALUE,
reversed: HAS_BOOLEAN_VALUE,
role: MUST_USE_ATTRIBUTE,
rows: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
rowSpan: null,
sandbox: null,
scope: null,
scoped: HAS_BOOLEAN_VALUE,
scrolling: null,
seamless: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
shape: null,
size: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
sizes: MUST_USE_ATTRIBUTE,
span: HAS_POSITIVE_NUMERIC_VALUE,
spellCheck: null,
src: null,
srcDoc: MUST_USE_PROPERTY,
srcLang: null,
srcSet: MUST_USE_ATTRIBUTE,
start: HAS_NUMERIC_VALUE,
step: null,
style: null,
summary: null,
tabIndex: null,
target: null,
title: null,
type: null,
useMap: null,
value: MUST_USE_PROPERTY | HAS_SIDE_EFFECTS,
width: MUST_USE_ATTRIBUTE,
wmode: MUST_USE_ATTRIBUTE,
wrap: null,
/**
* RDFa Properties
*/
about: MUST_USE_ATTRIBUTE,
datatype: MUST_USE_ATTRIBUTE,
inlist: MUST_USE_ATTRIBUTE,
prefix: MUST_USE_ATTRIBUTE,
// property is also supported for OpenGraph in meta tags.
property: MUST_USE_ATTRIBUTE,
resource: MUST_USE_ATTRIBUTE,
'typeof': MUST_USE_ATTRIBUTE,
vocab: MUST_USE_ATTRIBUTE,
/**
* Non-standard Properties
*/
// autoCapitalize and autoCorrect are supported in Mobile Safari for
// keyboard hints.
autoCapitalize: MUST_USE_ATTRIBUTE,
autoCorrect: MUST_USE_ATTRIBUTE,
// autoSave allows WebKit/Blink to persist values of input fields on page reloads
autoSave: null,
// color is for Safari mask-icon link
color: null,
// itemProp, itemScope, itemType are for
// Microdata support. See http://schema.org/docs/gs.html
itemProp: MUST_USE_ATTRIBUTE,
itemScope: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
itemType: MUST_USE_ATTRIBUTE,
// itemID and itemRef are for Microdata support as well but
// only specified in the the WHATWG spec document. See
// https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api
itemID: MUST_USE_ATTRIBUTE,
itemRef: MUST_USE_ATTRIBUTE,
// results show looking glass icon and recent searches on input
// search fields in WebKit/Blink
results: null,
// IE-only attribute that specifies security restrictions on an iframe
// as an alternative to the sandbox attribute on IE<10
security: MUST_USE_ATTRIBUTE,
// IE-only attribute that controls focus behavior
unselectable: MUST_USE_ATTRIBUTE
},
DOMAttributeNames: {
acceptCharset: 'accept-charset',
className: 'class',
htmlFor: 'for',
httpEquiv: 'http-equiv'
},
DOMPropertyNames: {
autoComplete: 'autocomplete',
autoFocus: 'autofocus',
autoPlay: 'autoplay',
autoSave: 'autosave',
// `encoding` is equivalent to `enctype`, IE8 lacks an `enctype` setter.
// http://www.w3.org/TR/html5/forms.html#dom-fs-encoding
encType: 'encoding',
hrefLang: 'hreflang',
radioGroup: 'radiogroup',
spellCheck: 'spellcheck',
srcDoc: 'srcdoc',
srcSet: 'srcset'
}
};
module.exports = HTMLDOMPropertyConfig;
/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactBrowserComponentMixin
*/
'use strict';
var ReactInstanceMap = __webpack_require__(47);
var findDOMNode = __webpack_require__(91);
var warning = __webpack_require__(25);
var didWarnKey = '_getDOMNodeDidWarn';
var ReactBrowserComponentMixin = {
/**
* Returns the DOM node rendered by this component.
*
* @return {DOMElement} The root node of this component.
* @final
* @protected
*/
getDOMNode: function () {
process.env.NODE_ENV !== 'production' ? warning(this.constructor[didWarnKey], '%s.getDOMNode(...) is deprecated. Please use ' + 'ReactDOM.findDOMNode(instance) instead.', ReactInstanceMap.get(this).getName() || this.tagName || 'Unknown') : undefined;
this.constructor[didWarnKey] = true;
return findDOMNode(this);
}
};
module.exports = ReactBrowserComponentMixin;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule findDOMNode
* @typechecks static-only
*/
'use strict';
var ReactCurrentOwner = __webpack_require__(5);
var ReactInstanceMap = __webpack_require__(47);
var ReactMount = __webpack_require__(28);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
/**
* Returns the DOM node rendered by this element.
*
* @param {ReactComponent|DOMElement} componentOrElement
* @return {?DOMElement} The root node of this element.
*/
function findDOMNode(componentOrElement) {
if (process.env.NODE_ENV !== 'production') {
var owner = ReactCurrentOwner.current;
if (owner !== null) {
process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing getDOMNode or findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : undefined;
owner._warnedAboutRefsInRender = true;
}
}
if (componentOrElement == null) {
return null;
}
if (componentOrElement.nodeType === 1) {
return componentOrElement;
}
if (ReactInstanceMap.has(componentOrElement)) {
return ReactMount.getNodeFromInstance(componentOrElement);
}
!(componentOrElement.render == null || typeof componentOrElement.render !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : invariant(false) : undefined;
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)', Object.keys(componentOrElement)) : invariant(false) : undefined;
}
module.exports = findDOMNode;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDefaultBatchingStrategy
*/
'use strict';
var ReactUpdates = __webpack_require__(54);
var Transaction = __webpack_require__(57);
var assign = __webpack_require__(39);
var emptyFunction = __webpack_require__(15);
var RESET_BATCHED_UPDATES = {
initialize: emptyFunction,
close: function () {
ReactDefaultBatchingStrategy.isBatchingUpdates = false;
}
};
var FLUSH_BATCHED_UPDATES = {
initialize: emptyFunction,
close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)
};
var TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES];
function ReactDefaultBatchingStrategyTransaction() {
this.reinitializeTransaction();
}
assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction.Mixin, {
getTransactionWrappers: function () {
return TRANSACTION_WRAPPERS;
}
});
var transaction = new ReactDefaultBatchingStrategyTransaction();
var ReactDefaultBatchingStrategy = {
isBatchingUpdates: false,
/**
* Call the provided function in a context within which calls to `setState`
* and friends are batched such that components aren't updated unnecessarily.
*/
batchedUpdates: function (callback, a, b, c, d, e) {
var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
ReactDefaultBatchingStrategy.isBatchingUpdates = true;
// The code is written this way to avoid extra allocations
if (alreadyBatchingUpdates) {
callback(a, b, c, d, e);
} else {
transaction.perform(callback, null, a, b, c, d, e);
}
}
};
module.exports = ReactDefaultBatchingStrategy;
/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMComponent
* @typechecks static-only
*/
/* global hasOwnProperty:true */
'use strict';
var AutoFocusUtils = __webpack_require__(94);
var CSSPropertyOperations = __webpack_require__(96);
var DOMProperty = __webpack_require__(23);
var DOMPropertyOperations = __webpack_require__(22);
var EventConstants = __webpack_require__(30);
var ReactBrowserEventEmitter = __webpack_require__(29);
var ReactComponentBrowserEnvironment = __webpack_require__(26);
var ReactDOMButton = __webpack_require__(104);
var ReactDOMInput = __webpack_require__(105);
var ReactDOMOption = __webpack_require__(109);
var ReactDOMSelect = __webpack_require__(112);
var ReactDOMTextarea = __webpack_require__(113);
var ReactMount = __webpack_require__(28);
var ReactMultiChild = __webpack_require__(114);
var ReactPerf = __webpack_require__(18);
var ReactUpdateQueue = __webpack_require__(53);
var assign = __webpack_require__(39);
var canDefineProperty = __webpack_require__(43);
var escapeTextContentForBrowser = __webpack_require__(21);
var invariant = __webpack_require__(13);
var isEventSupported = __webpack_require__(40);
var keyOf = __webpack_require__(79);
var setInnerHTML = __webpack_require__(19);
var setTextContent = __webpack_require__(20);
var shallowEqual = __webpack_require__(117);
var validateDOMNesting = __webpack_require__(70);
var warning = __webpack_require__(25);
var deleteListener = ReactBrowserEventEmitter.deleteListener;
var listenTo = ReactBrowserEventEmitter.listenTo;
var registrationNameModules = ReactBrowserEventEmitter.registrationNameModules;
// For quickly matching children type, to test if can be treated as content.
var CONTENT_TYPES = { 'string': true, 'number': true };
var CHILDREN = keyOf({ children: null });
var STYLE = keyOf({ style: null });
var HTML = keyOf({ __html: null });
var ELEMENT_NODE_TYPE = 1;
function getDeclarationErrorAddendum(internalInstance) {
if (internalInstance) {
var owner = internalInstance._currentElement._owner || null;
if (owner) {
var name = owner.getName();
if (name) {
return ' This DOM node was rendered by `' + name + '`.';
}
}
}
return '';
}
var legacyPropsDescriptor;
if (process.env.NODE_ENV !== 'production') {
legacyPropsDescriptor = {
props: {
enumerable: false,
get: function () {
var component = this._reactInternalComponent;
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .props of a DOM node; instead, ' + 'recreate the props as `render` did originally or read the DOM ' + 'properties/attributes directly from this node (e.g., ' + 'this.refs.box.className).%s', getDeclarationErrorAddendum(component)) : undefined;
return component._currentElement.props;
}
}
};
}
function legacyGetDOMNode() {
if (process.env.NODE_ENV !== 'production') {
var component = this._reactInternalComponent;
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .getDOMNode() of a DOM node; ' + 'instead, use the node directly.%s', getDeclarationErrorAddendum(component)) : undefined;
}
return this;
}
function legacyIsMounted() {
var component = this._reactInternalComponent;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .isMounted() of a DOM node.%s', getDeclarationErrorAddendum(component)) : undefined;
}
return !!component;
}
function legacySetStateEtc() {
if (process.env.NODE_ENV !== 'production') {
var component = this._reactInternalComponent;
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .setState(), .replaceState(), or ' + '.forceUpdate() of a DOM node. This is a no-op.%s', getDeclarationErrorAddendum(component)) : undefined;
}
}
function legacySetProps(partialProps, callback) {
var component = this._reactInternalComponent;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .setProps() of a DOM node. ' + 'Instead, call ReactDOM.render again at the top level.%s', getDeclarationErrorAddendum(component)) : undefined;
}
if (!component) {
return;
}
ReactUpdateQueue.enqueueSetPropsInternal(component, partialProps);
if (callback) {
ReactUpdateQueue.enqueueCallbackInternal(component, callback);
}
}
function legacyReplaceProps(partialProps, callback) {
var component = this._reactInternalComponent;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .replaceProps() of a DOM node. ' + 'Instead, call ReactDOM.render again at the top level.%s', getDeclarationErrorAddendum(component)) : undefined;
}
if (!component) {
return;
}
ReactUpdateQueue.enqueueReplacePropsInternal(component, partialProps);
if (callback) {
ReactUpdateQueue.enqueueCallbackInternal(component, callback);
}
}
function friendlyStringify(obj) {
if (typeof obj === 'object') {
if (Array.isArray(obj)) {
return '[' + obj.map(friendlyStringify).join(', ') + ']';
} else {
var pairs = [];
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
var keyEscaped = /^[a-z$_][\w$_]*$/i.test(key) ? key : JSON.stringify(key);
pairs.push(keyEscaped + ': ' + friendlyStringify(obj[key]));
}
}
return '{' + pairs.join(', ') + '}';
}
} else if (typeof obj === 'string') {
return JSON.stringify(obj);
} else if (typeof obj === 'function') {
return '[function object]';
}
// Differs from JSON.stringify in that undefined becauses undefined and that
// inf and nan don't become null
return String(obj);
}
var styleMutationWarning = {};
function checkAndWarnForMutatedStyle(style1, style2, component) {
if (style1 == null || style2 == null) {
return;
}
if (shallowEqual(style1, style2)) {
return;
}
var componentName = component._tag;
var owner = component._currentElement._owner;
var ownerName;
if (owner) {
ownerName = owner.getName();
}
var hash = ownerName + '|' + componentName;
if (styleMutationWarning.hasOwnProperty(hash)) {
return;
}
styleMutationWarning[hash] = true;
process.env.NODE_ENV !== 'production' ? warning(false, '`%s` was passed a style object that has previously been mutated. ' + 'Mutating `style` is deprecated. Consider cloning it beforehand. Check ' + 'the `render` %s. Previous style: %s. Mutated style: %s.', componentName, owner ? 'of `' + ownerName + '`' : 'using <' + componentName + '>', friendlyStringify(style1), friendlyStringify(style2)) : undefined;
}
/**
* @param {object} component
* @param {?object} props
*/
function assertValidProps(component, props) {
if (!props) {
return;
}
// Note the use of `==` which checks for null or undefined.
if (process.env.NODE_ENV !== 'production') {
if (voidElementTags[component._tag]) {
process.env.NODE_ENV !== 'production' ? warning(props.children == null && props.dangerouslySetInnerHTML == null, '%s is a void element tag and must not have `children` or ' + 'use `props.dangerouslySetInnerHTML`.%s', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : undefined;
}
}
if (props.dangerouslySetInnerHTML != null) {
!(props.children == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : invariant(false) : undefined;
!(typeof props.dangerouslySetInnerHTML === 'object' && HTML in props.dangerouslySetInnerHTML) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' + 'Please visit https://fb.me/react-invariant-dangerously-set-inner-html ' + 'for more information.') : invariant(false) : undefined;
}
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(props.innerHTML == null, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.') : undefined;
process.env.NODE_ENV !== 'production' ? warning(!props.contentEditable || props.children == null, 'A component is `contentEditable` and contains `children` managed by ' + 'React. It is now your responsibility to guarantee that none of ' + 'those nodes are unexpectedly modified or duplicated. This is ' + 'probably not intentional.') : undefined;
}
!(props.style == null || typeof props.style === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'The `style` prop expects a mapping from style properties to values, ' + 'not a string. For example, style={{marginRight: spacing + \'em\'}} when ' + 'using JSX.%s', getDeclarationErrorAddendum(component)) : invariant(false) : undefined;
}
function enqueuePutListener(id, registrationName, listener, transaction) {
if (process.env.NODE_ENV !== 'production') {
// IE8 has no API for event capturing and the `onScroll` event doesn't
// bubble.
process.env.NODE_ENV !== 'production' ? warning(registrationName !== 'onScroll' || isEventSupported('scroll', true), 'This browser doesn\'t support the `onScroll` event') : undefined;
}
var container = ReactMount.findReactContainerForID(id);
if (container) {
var doc = container.nodeType === ELEMENT_NODE_TYPE ? container.ownerDocument : container;
listenTo(registrationName, doc);
}
transaction.getReactMountReady().enqueue(putListener, {
id: id,
registrationName: registrationName,
listener: listener
});
}
function putListener() {
var listenerToPut = this;
ReactBrowserEventEmitter.putListener(listenerToPut.id, listenerToPut.registrationName, listenerToPut.listener);
}
// There are so many media events, it makes sense to just
// maintain a list rather than create a `trapBubbledEvent` for each
var mediaEvents = {
topAbort: 'abort',
topCanPlay: 'canplay',
topCanPlayThrough: 'canplaythrough',
topDurationChange: 'durationchange',
topEmptied: 'emptied',
topEncrypted: 'encrypted',
topEnded: 'ended',
topError: 'error',
topLoadedData: 'loadeddata',
topLoadedMetadata: 'loadedmetadata',
topLoadStart: 'loadstart',
topPause: 'pause',
topPlay: 'play',
topPlaying: 'playing',
topProgress: 'progress',
topRateChange: 'ratechange',
topSeeked: 'seeked',
topSeeking: 'seeking',
topStalled: 'stalled',
topSuspend: 'suspend',
topTimeUpdate: 'timeupdate',
topVolumeChange: 'volumechange',
topWaiting: 'waiting'
};
function trapBubbledEventsLocal() {
var inst = this;
// If a component renders to null or if another component fatals and causes
// the state of the tree to be corrupted, `node` here can be null.
!inst._rootNodeID ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Must be mounted to trap events') : invariant(false) : undefined;
var node = ReactMount.getNode(inst._rootNodeID);
!node ? process.env.NODE_ENV !== 'production' ? invariant(false, 'trapBubbledEvent(...): Requires node to be rendered.') : invariant(false) : undefined;
switch (inst._tag) {
case 'iframe':
inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load', node)];
break;
case 'video':
case 'audio':
inst._wrapperState.listeners = [];
// create listener for each media event
for (var event in mediaEvents) {
if (mediaEvents.hasOwnProperty(event)) {
inst._wrapperState.listeners.push(ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes[event], mediaEvents[event], node));
}
}
break;
case 'img':
inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topError, 'error', node), ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load', node)];
break;
case 'form':
inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topReset, 'reset', node), ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topSubmit, 'submit', node)];
break;
}
}
function mountReadyInputWrapper() {
ReactDOMInput.mountReadyWrapper(this);
}
function postUpdateSelectWrapper() {
ReactDOMSelect.postUpdateWrapper(this);
}
// For HTML, certain tags should omit their close tag. We keep a whitelist for
// those special cased tags.
var omittedCloseTags = {
'area': true,
'base': true,
'br': true,
'col': true,
'embed': true,
'hr': true,
'img': true,
'input': true,
'keygen': true,
'link': true,
'meta': true,
'param': true,
'source': true,
'track': true,
'wbr': true
};
// NOTE: menuitem's close tag should be omitted, but that causes problems.
var newlineEatingTags = {
'listing': true,
'pre': true,
'textarea': true
};
// For HTML, certain tags cannot have children. This has the same purpose as
// `omittedCloseTags` except that `menuitem` should still have its closing tag.
var voidElementTags = assign({
'menuitem': true
}, omittedCloseTags);
// We accept any tag to be rendered but since this gets injected into arbitrary
// HTML, we want to make sure that it's a safe tag.
// http://www.w3.org/TR/REC-xml/#NT-Name
var VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
var validatedTagCache = {};
var hasOwnProperty = ({}).hasOwnProperty;
function validateDangerousTag(tag) {
if (!hasOwnProperty.call(validatedTagCache, tag)) {
!VALID_TAG_REGEX.test(tag) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid tag: %s', tag) : invariant(false) : undefined;
validatedTagCache[tag] = true;
}
}
function processChildContextDev(context, inst) {
// Pass down our tag name to child components for validation purposes
context = assign({}, context);
var info = context[validateDOMNesting.ancestorInfoContextKey];
context[validateDOMNesting.ancestorInfoContextKey] = validateDOMNesting.updatedAncestorInfo(info, inst._tag, inst);
return context;
}
function isCustomComponent(tagName, props) {
return tagName.indexOf('-') >= 0 || props.is != null;
}
/**
* Creates a new React class that is idempotent and capable of containing other
* React components. It accepts event listeners and DOM properties that are
* valid according to `DOMProperty`.
*
* - Event listeners: `onClick`, `onMouseDown`, etc.
* - DOM properties: `className`, `name`, `title`, etc.
*
* The `style` property functions differently from the DOM API. It accepts an
* object mapping of style properties to values.
*
* @constructor ReactDOMComponent
* @extends ReactMultiChild
*/
function ReactDOMComponent(tag) {
validateDangerousTag(tag);
this._tag = tag.toLowerCase();
this._renderedChildren = null;
this._previousStyle = null;
this._previousStyleCopy = null;
this._rootNodeID = null;
this._wrapperState = null;
this._topLevelWrapper = null;
this._nodeWithLegacyProperties = null;
if (process.env.NODE_ENV !== 'production') {
this._unprocessedContextDev = null;
this._processedContextDev = null;
}
}
ReactDOMComponent.displayName = 'ReactDOMComponent';
ReactDOMComponent.Mixin = {
construct: function (element) {
this._currentElement = element;
},
/**
* Generates root tag markup then recurses. This method has side effects and
* is not idempotent.
*
* @internal
* @param {string} rootID The root DOM ID for this node.
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @param {object} context
* @return {string} The computed markup.
*/
mountComponent: function (rootID, transaction, context) {
this._rootNodeID = rootID;
var props = this._currentElement.props;
switch (this._tag) {
case 'iframe':
case 'img':
case 'form':
case 'video':
case 'audio':
this._wrapperState = {
listeners: null
};
transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
break;
case 'button':
props = ReactDOMButton.getNativeProps(this, props, context);
break;
case 'input':
ReactDOMInput.mountWrapper(this, props, context);
props = ReactDOMInput.getNativeProps(this, props, context);
break;
case 'option':
ReactDOMOption.mountWrapper(this, props, context);
props = ReactDOMOption.getNativeProps(this, props, context);
break;
case 'select':
ReactDOMSelect.mountWrapper(this, props, context);
props = ReactDOMSelect.getNativeProps(this, props, context);
context = ReactDOMSelect.processChildContext(this, props, context);
break;
case 'textarea':
ReactDOMTextarea.mountWrapper(this, props, context);
props = ReactDOMTextarea.getNativeProps(this, props, context);
break;
}
assertValidProps(this, props);
if (process.env.NODE_ENV !== 'production') {
if (context[validateDOMNesting.ancestorInfoContextKey]) {
validateDOMNesting(this._tag, this, context[validateDOMNesting.ancestorInfoContextKey]);
}
}
if (process.env.NODE_ENV !== 'production') {
this._unprocessedContextDev = context;
this._processedContextDev = processChildContextDev(context, this);
context = this._processedContextDev;
}
var mountImage;
if (transaction.useCreateElement) {
var ownerDocument = context[ReactMount.ownerDocumentContextKey];
var el = ownerDocument.createElement(this._currentElement.type);
DOMPropertyOperations.setAttributeForID(el, this._rootNodeID);
// Populate node cache
ReactMount.getID(el);
this._updateDOMProperties({}, props, transaction, el);
this._createInitialChildren(transaction, props, context, el);
mountImage = el;
} else {
var tagOpen = this._createOpenTagMarkupAndPutListeners(transaction, props);
var tagContent = this._createContentMarkup(transaction, props, context);
if (!tagContent && omittedCloseTags[this._tag]) {
mountImage = tagOpen + '/>';
} else {
mountImage = tagOpen + '>' + tagContent + '</' + this._currentElement.type + '>';
}
}
switch (this._tag) {
case 'input':
transaction.getReactMountReady().enqueue(mountReadyInputWrapper, this);
// falls through
case 'button':
case 'select':
case 'textarea':
if (props.autoFocus) {
transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
}
break;
}
return mountImage;
},
/**
* Creates markup for the open tag and all attributes.
*
* This method has side effects because events get registered.
*
* Iterating over object properties is faster than iterating over arrays.
* @see http://jsperf.com/obj-vs-arr-iteration
*
* @private
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @param {object} props
* @return {string} Markup of opening tag.
*/
_createOpenTagMarkupAndPutListeners: function (transaction, props) {
var ret = '<' + this._currentElement.type;
for (var propKey in props) {
if (!props.hasOwnProperty(propKey)) {
continue;
}
var propValue = props[propKey];
if (propValue == null) {
continue;
}
if (registrationNameModules.hasOwnProperty(propKey)) {
if (propValue) {
enqueuePutListener(this._rootNodeID, propKey, propValue, transaction);
}
} else {
if (propKey === STYLE) {
if (propValue) {
if (process.env.NODE_ENV !== 'production') {
// See `_updateDOMProperties`. style block
this._previousStyle = propValue;
}
propValue = this._previousStyleCopy = assign({}, props.style);
}
propValue = CSSPropertyOperations.createMarkupForStyles(propValue);
}
var markup = null;
if (this._tag != null && isCustomComponent(this._tag, props)) {
if (propKey !== CHILDREN) {
markup = DOMPropertyOperations.createMarkupForCustomAttribute(propKey, propValue);
}
} else {
markup = DOMPropertyOperations.createMarkupForProperty(propKey, propValue);
}
if (markup) {
ret += ' ' + markup;
}
}
}
// For static pages, no need to put React ID and checksum. Saves lots of
// bytes.
if (transaction.renderToStaticMarkup) {
return ret;
}
var markupForID = DOMPropertyOperations.createMarkupForID(this._rootNodeID);
return ret + ' ' + markupForID;
},
/**
* Creates markup for the content between the tags.
*
* @private
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @param {object} props
* @param {object} context
* @return {string} Content markup.
*/
_createContentMarkup: function (transaction, props, context) {
var ret = '';
// Intentional use of != to avoid catching zero/false.
var innerHTML = props.dangerouslySetInnerHTML;
if (innerHTML != null) {
if (innerHTML.__html != null) {
ret = innerHTML.__html;
}
} else {
var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;
var childrenToUse = contentToUse != null ? null : props.children;
if (contentToUse != null) {
// TODO: Validate that text is allowed as a child of this node
ret = escapeTextContentForBrowser(contentToUse);
} else if (childrenToUse != null) {
var mountImages = this.mountChildren(childrenToUse, transaction, context);
ret = mountImages.join('');
}
}
if (newlineEatingTags[this._tag] && ret.charAt(0) === '\n') {
// text/html ignores the first character in these tags if it's a newline
// Prefer to break application/xml over text/html (for now) by adding
// a newline specifically to get eaten by the parser. (Alternately for
// textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
// \r is normalized out by HTMLTextAreaElement#value.)
// See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
// See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
// See: <http://www.w3.org/TR/html5/syntax.html#newlines>
// See: Parsing of "textarea" "listing" and "pre" elements
// from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
return '\n' + ret;
} else {
return ret;
}
},
_createInitialChildren: function (transaction, props, context, el) {
// Intentional use of != to avoid catching zero/false.
var innerHTML = props.dangerouslySetInnerHTML;
if (innerHTML != null) {
if (innerHTML.__html != null) {
setInnerHTML(el, innerHTML.__html);
}
} else {
var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;
var childrenToUse = contentToUse != null ? null : props.children;
if (contentToUse != null) {
// TODO: Validate that text is allowed as a child of this node
setTextContent(el, contentToUse);
} else if (childrenToUse != null) {
var mountImages = this.mountChildren(childrenToUse, transaction, context);
for (var i = 0; i < mountImages.length; i++) {
el.appendChild(mountImages[i]);
}
}
}
},
/**
* Receives a next element and updates the component.
*
* @internal
* @param {ReactElement} nextElement
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @param {object} context
*/
receiveComponent: function (nextElement, transaction, context) {
var prevElement = this._currentElement;
this._currentElement = nextElement;
this.updateComponent(transaction, prevElement, nextElement, context);
},
/**
* Updates a native DOM component after it has already been allocated and
* attached to the DOM. Reconciles the root DOM node, then recurses.
*
* @param {ReactReconcileTransaction} transaction
* @param {ReactElement} prevElement
* @param {ReactElement} nextElement
* @internal
* @overridable
*/
updateComponent: function (transaction, prevElement, nextElement, context) {
var lastProps = prevElement.props;
var nextProps = this._currentElement.props;
switch (this._tag) {
case 'button':
lastProps = ReactDOMButton.getNativeProps(this, lastProps);
nextProps = ReactDOMButton.getNativeProps(this, nextProps);
break;
case 'input':
ReactDOMInput.updateWrapper(this);
lastProps = ReactDOMInput.getNativeProps(this, lastProps);
nextProps = ReactDOMInput.getNativeProps(this, nextProps);
break;
case 'option':
lastProps = ReactDOMOption.getNativeProps(this, lastProps);
nextProps = ReactDOMOption.getNativeProps(this, nextProps);
break;
case 'select':
lastProps = ReactDOMSelect.getNativeProps(this, lastProps);
nextProps = ReactDOMSelect.getNativeProps(this, nextProps);
break;
case 'textarea':
ReactDOMTextarea.updateWrapper(this);
lastProps = ReactDOMTextarea.getNativeProps(this, lastProps);
nextProps = ReactDOMTextarea.getNativeProps(this, nextProps);
break;
}
if (process.env.NODE_ENV !== 'production') {
// If the context is reference-equal to the old one, pass down the same
// processed object so the update bailout in ReactReconciler behaves
// correctly (and identically in dev and prod). See #5005.
if (this._unprocessedContextDev !== context) {
this._unprocessedContextDev = context;
this._processedContextDev = processChildContextDev(context, this);
}
context = this._processedContextDev;
}
assertValidProps(this, nextProps);
this._updateDOMProperties(lastProps, nextProps, transaction, null);
this._updateDOMChildren(lastProps, nextProps, transaction, context);
if (!canDefineProperty && this._nodeWithLegacyProperties) {
this._nodeWithLegacyProperties.props = nextProps;
}
if (this._tag === 'select') {
// <select> value update needs to occur after <option> children
// reconciliation
transaction.getReactMountReady().enqueue(postUpdateSelectWrapper, this);
}
},
/**
* Reconciles the properties by detecting differences in property values and
* updating the DOM as necessary. This function is probably the single most
* critical path for performance optimization.
*
* TODO: Benchmark whether checking for changed values in memory actually
* improves performance (especially statically positioned elements).
* TODO: Benchmark the effects of putting this at the top since 99% of props
* do not change for a given reconciliation.
* TODO: Benchmark areas that can be improved with caching.
*
* @private
* @param {object} lastProps
* @param {object} nextProps
* @param {ReactReconcileTransaction} transaction
* @param {?DOMElement} node
*/
_updateDOMProperties: function (lastProps, nextProps, transaction, node) {
var propKey;
var styleName;
var styleUpdates;
for (propKey in lastProps) {
if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey)) {
continue;
}
if (propKey === STYLE) {
var lastStyle = this._previousStyleCopy;
for (styleName in lastStyle) {
if (lastStyle.hasOwnProperty(styleName)) {
styleUpdates = styleUpdates || {};
styleUpdates[styleName] = '';
}
}
this._previousStyleCopy = null;
} else if (registrationNameModules.hasOwnProperty(propKey)) {
if (lastProps[propKey]) {
// Only call deleteListener if there was a listener previously or
// else willDeleteListener gets called when there wasn't actually a
// listener (e.g., onClick={null})
deleteListener(this._rootNodeID, propKey);
}
} else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {
if (!node) {
node = ReactMount.getNode(this._rootNodeID);
}
DOMPropertyOperations.deleteValueForProperty(node, propKey);
}
}
for (propKey in nextProps) {
var nextProp = nextProps[propKey];
var lastProp = propKey === STYLE ? this._previousStyleCopy : lastProps[propKey];
if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp) {
continue;
}
if (propKey === STYLE) {
if (nextProp) {
if (process.env.NODE_ENV !== 'production') {
checkAndWarnForMutatedStyle(this._previousStyleCopy, this._previousStyle, this);
this._previousStyle = nextProp;
}
nextProp = this._previousStyleCopy = assign({}, nextProp);
} else {
this._previousStyleCopy = null;
}
if (lastProp) {
// Unset styles on `lastProp` but not on `nextProp`.
for (styleName in lastProp) {
if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) {
styleUpdates = styleUpdates || {};
styleUpdates[styleName] = '';
}
}
// Update styles that changed since `lastProp`.
for (styleName in nextProp) {
if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) {
styleUpdates = styleUpdates || {};
styleUpdates[styleName] = nextProp[styleName];
}
}
} else {
// Relies on `updateStylesByID` not mutating `styleUpdates`.
styleUpdates = nextProp;
}
} else if (registrationNameModules.hasOwnProperty(propKey)) {
if (nextProp) {
enqueuePutListener(this._rootNodeID, propKey, nextProp, transaction);
} else if (lastProp) {
deleteListener(this._rootNodeID, propKey);
}
} else if (isCustomComponent(this._tag, nextProps)) {
if (!node) {
node = ReactMount.getNode(this._rootNodeID);
}
if (propKey === CHILDREN) {
nextProp = null;
}
DOMPropertyOperations.setValueForAttribute(node, propKey, nextProp);
} else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {
if (!node) {
node = ReactMount.getNode(this._rootNodeID);
}
// If we're updating to null or undefined, we should remove the property
// from the DOM node instead of inadvertantly setting to a string. This
// brings us in line with the same behavior we have on initial render.
if (nextProp != null) {
DOMPropertyOperations.setValueForProperty(node, propKey, nextProp);
} else {
DOMPropertyOperations.deleteValueForProperty(node, propKey);
}
}
}
if (styleUpdates) {
if (!node) {
node = ReactMount.getNode(this._rootNodeID);
}
CSSPropertyOperations.setValueForStyles(node, styleUpdates);
}
},
/**
* Reconciles the children with the various properties that affect the
* children content.
*
* @param {object} lastProps
* @param {object} nextProps
* @param {ReactReconcileTransaction} transaction
* @param {object} context
*/
_updateDOMChildren: function (lastProps, nextProps, transaction, context) {
var lastContent = CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null;
var nextContent = CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;
var lastHtml = lastProps.dangerouslySetInnerHTML && lastProps.dangerouslySetInnerHTML.__html;
var nextHtml = nextProps.dangerouslySetInnerHTML && nextProps.dangerouslySetInnerHTML.__html;
// Note the use of `!=` which checks for null or undefined.
var lastChildren = lastContent != null ? null : lastProps.children;
var nextChildren = nextContent != null ? null : nextProps.children;
// If we're switching from children to content/html or vice versa, remove
// the old content
var lastHasContentOrHtml = lastContent != null || lastHtml != null;
var nextHasContentOrHtml = nextContent != null || nextHtml != null;
if (lastChildren != null && nextChildren == null) {
this.updateChildren(null, transaction, context);
} else if (lastHasContentOrHtml && !nextHasContentOrHtml) {
this.updateTextContent('');
}
if (nextContent != null) {
if (lastContent !== nextContent) {
this.updateTextContent('' + nextContent);
}
} else if (nextHtml != null) {
if (lastHtml !== nextHtml) {
this.updateMarkup('' + nextHtml);
}
} else if (nextChildren != null) {
this.updateChildren(nextChildren, transaction, context);
}
},
/**
* Destroys all event registrations for this instance. Does not remove from
* the DOM. That must be done by the parent.
*
* @internal
*/
unmountComponent: function () {
switch (this._tag) {
case 'iframe':
case 'img':
case 'form':
case 'video':
case 'audio':
var listeners = this._wrapperState.listeners;
if (listeners) {
for (var i = 0; i < listeners.length; i++) {
listeners[i].remove();
}
}
break;
case 'input':
ReactDOMInput.unmountWrapper(this);
break;
case 'html':
case 'head':
case 'body':
/**
* Components like <html> <head> and <body> can't be removed or added
* easily in a cross-browser way, however it's valuable to be able to
* take advantage of React's reconciliation for styling and <title>
* management. So we just document it and throw in dangerous cases.
*/
true ? process.env.NODE_ENV !== 'production' ? invariant(false, '<%s> tried to unmount. Because of cross-browser quirks it is ' + 'impossible to unmount some top-level components (eg <html>, ' + '<head>, and <body>) reliably and efficiently. To fix this, have a ' + 'single top-level component that never unmounts render these ' + 'elements.', this._tag) : invariant(false) : undefined;
break;
}
this.unmountChildren();
ReactBrowserEventEmitter.deleteAllListeners(this._rootNodeID);
ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);
this._rootNodeID = null;
this._wrapperState = null;
if (this._nodeWithLegacyProperties) {
var node = this._nodeWithLegacyProperties;
node._reactInternalComponent = null;
this._nodeWithLegacyProperties = null;
}
},
getPublicInstance: function () {
if (!this._nodeWithLegacyProperties) {
var node = ReactMount.getNode(this._rootNodeID);
node._reactInternalComponent = this;
node.getDOMNode = legacyGetDOMNode;
node.isMounted = legacyIsMounted;
node.setState = legacySetStateEtc;
node.replaceState = legacySetStateEtc;
node.forceUpdate = legacySetStateEtc;
node.setProps = legacySetProps;
node.replaceProps = legacyReplaceProps;
if (process.env.NODE_ENV !== 'production') {
if (canDefineProperty) {
Object.defineProperties(node, legacyPropsDescriptor);
} else {
// updateComponent will update this property on subsequent renders
node.props = this._currentElement.props;
}
} else {
// updateComponent will update this property on subsequent renders
node.props = this._currentElement.props;
}
this._nodeWithLegacyProperties = node;
}
return this._nodeWithLegacyProperties;
}
};
ReactPerf.measureMethods(ReactDOMComponent, 'ReactDOMComponent', {
mountComponent: 'mountComponent',
updateComponent: 'updateComponent'
});
assign(ReactDOMComponent.prototype, ReactDOMComponent.Mixin, ReactMultiChild.Mixin);
module.exports = ReactDOMComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 94 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule AutoFocusUtils
* @typechecks static-only
*/
'use strict';
var ReactMount = __webpack_require__(28);
var findDOMNode = __webpack_require__(91);
var focusNode = __webpack_require__(95);
var Mixin = {
componentDidMount: function () {
if (this.props.autoFocus) {
focusNode(findDOMNode(this));
}
}
};
var AutoFocusUtils = {
Mixin: Mixin,
focusDOMComponent: function () {
focusNode(ReactMount.getNode(this._rootNodeID));
}
};
module.exports = AutoFocusUtils;
/***/ },
/* 95 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule focusNode
*/
'use strict';
/**
* @param {DOMElement} node input/textarea to focus
*/
function focusNode(node) {
// IE8 can throw "Can't move focus to the control because it is invisible,
// not enabled, or of a type that does not accept the focus." for all kinds of
// reasons that are too expensive and fragile to test.
try {
node.focus();
} catch (e) {}
}
module.exports = focusNode;
/***/ },
/* 96 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule CSSPropertyOperations
* @typechecks static-only
*/
'use strict';
var CSSProperty = __webpack_require__(97);
var ExecutionEnvironment = __webpack_require__(9);
var ReactPerf = __webpack_require__(18);
var camelizeStyleName = __webpack_require__(98);
var dangerousStyleValue = __webpack_require__(100);
var hyphenateStyleName = __webpack_require__(101);
var memoizeStringOnly = __webpack_require__(103);
var warning = __webpack_require__(25);
var processStyleName = memoizeStringOnly(function (styleName) {
return hyphenateStyleName(styleName);
});
var hasShorthandPropertyBug = false;
var styleFloatAccessor = 'cssFloat';
if (ExecutionEnvironment.canUseDOM) {
var tempStyle = document.createElement('div').style;
try {
// IE8 throws "Invalid argument." if resetting shorthand style properties.
tempStyle.font = '';
} catch (e) {
hasShorthandPropertyBug = true;
}
// IE8 only supports accessing cssFloat (standard) as styleFloat
if (document.documentElement.style.cssFloat === undefined) {
styleFloatAccessor = 'styleFloat';
}
}
if (process.env.NODE_ENV !== 'production') {
// 'msTransform' is correct, but the other prefixes should be capitalized
var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
// style values shouldn't contain a semicolon
var badStyleValueWithSemicolonPattern = /;\s*$/;
var warnedStyleNames = {};
var warnedStyleValues = {};
var warnHyphenatedStyleName = function (name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?', name, camelizeStyleName(name)) : undefined;
};
var warnBadVendoredStyleName = function (name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1)) : undefined;
};
var warnStyleValueWithSemicolon = function (name, value) {
if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
return;
}
warnedStyleValues[value] = true;
process.env.NODE_ENV !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon. ' + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, '')) : undefined;
};
/**
* @param {string} name
* @param {*} value
*/
var warnValidStyle = function (name, value) {
if (name.indexOf('-') > -1) {
warnHyphenatedStyleName(name);
} else if (badVendoredStyleNamePattern.test(name)) {
warnBadVendoredStyleName(name);
} else if (badStyleValueWithSemicolonPattern.test(value)) {
warnStyleValueWithSemicolon(name, value);
}
};
}
/**
* Operations for dealing with CSS properties.
*/
var CSSPropertyOperations = {
/**
* Serializes a mapping of style properties for use as inline styles:
*
* > createMarkupForStyles({width: '200px', height: 0})
* "width:200px;height:0;"
*
* Undefined values are ignored so that declarative programming is easier.
* The result should be HTML-escaped before insertion into the DOM.
*
* @param {object} styles
* @return {?string}
*/
createMarkupForStyles: function (styles) {
var serialized = '';
for (var styleName in styles) {
if (!styles.hasOwnProperty(styleName)) {
continue;
}
var styleValue = styles[styleName];
if (process.env.NODE_ENV !== 'production') {
warnValidStyle(styleName, styleValue);
}
if (styleValue != null) {
serialized += processStyleName(styleName) + ':';
serialized += dangerousStyleValue(styleName, styleValue) + ';';
}
}
return serialized || null;
},
/**
* Sets the value for multiple styles on a node. If a value is specified as
* '' (empty string), the corresponding style property will be unset.
*
* @param {DOMElement} node
* @param {object} styles
*/
setValueForStyles: function (node, styles) {
var style = node.style;
for (var styleName in styles) {
if (!styles.hasOwnProperty(styleName)) {
continue;
}
if (process.env.NODE_ENV !== 'production') {
warnValidStyle(styleName, styles[styleName]);
}
var styleValue = dangerousStyleValue(styleName, styles[styleName]);
if (styleName === 'float') {
styleName = styleFloatAccessor;
}
if (styleValue) {
style[styleName] = styleValue;
} else {
var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];
if (expansion) {
// Shorthand property that IE8 won't like unsetting, so unset each
// component to placate it
for (var individualStyleName in expansion) {
style[individualStyleName] = '';
}
} else {
style[styleName] = '';
}
}
}
}
};
ReactPerf.measureMethods(CSSPropertyOperations, 'CSSPropertyOperations', {
setValueForStyles: 'setValueForStyles'
});
module.exports = CSSPropertyOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 97 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule CSSProperty
*/
'use strict';
/**
* CSS properties which accept numbers but are not in units of "px".
*/
var isUnitlessNumber = {
animationIterationCount: true,
boxFlex: true,
boxFlexGroup: true,
boxOrdinalGroup: true,
columnCount: true,
flex: true,
flexGrow: true,
flexPositive: true,
flexShrink: true,
flexNegative: true,
flexOrder: true,
fontWeight: true,
lineClamp: true,
lineHeight: true,
opacity: true,
order: true,
orphans: true,
tabSize: true,
widows: true,
zIndex: true,
zoom: true,
// SVG-related properties
fillOpacity: true,
stopOpacity: true,
strokeDashoffset: true,
strokeOpacity: true,
strokeWidth: true
};
/**
* @param {string} prefix vendor-specific prefix, eg: Webkit
* @param {string} key style name, eg: transitionDuration
* @return {string} style name prefixed with `prefix`, properly camelCased, eg:
* WebkitTransitionDuration
*/
function prefixKey(prefix, key) {
return prefix + key.charAt(0).toUpperCase() + key.substring(1);
}
/**
* Support style names that may come passed in prefixed by adding permutations
* of vendor prefixes.
*/
var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
// infinite loop, because it iterates over the newly added props too.
Object.keys(isUnitlessNumber).forEach(function (prop) {
prefixes.forEach(function (prefix) {
isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
});
});
/**
* Most style properties can be unset by doing .style[prop] = '' but IE8
* doesn't like doing that with shorthand properties so for the properties that
* IE8 breaks on, which are listed here, we instead unset each of the
* individual properties. See http://bugs.jquery.com/ticket/12385.
* The 4-value 'clock' properties like margin, padding, border-width seem to
* behave without any problems. Curiously, list-style works too without any
* special prodding.
*/
var shorthandPropertyExpansions = {
background: {
backgroundAttachment: true,
backgroundColor: true,
backgroundImage: true,
backgroundPositionX: true,
backgroundPositionY: true,
backgroundRepeat: true
},
backgroundPosition: {
backgroundPositionX: true,
backgroundPositionY: true
},
border: {
borderWidth: true,
borderStyle: true,
borderColor: true
},
borderBottom: {
borderBottomWidth: true,
borderBottomStyle: true,
borderBottomColor: true
},
borderLeft: {
borderLeftWidth: true,
borderLeftStyle: true,
borderLeftColor: true
},
borderRight: {
borderRightWidth: true,
borderRightStyle: true,
borderRightColor: true
},
borderTop: {
borderTopWidth: true,
borderTopStyle: true,
borderTopColor: true
},
font: {
fontStyle: true,
fontVariant: true,
fontWeight: true,
fontSize: true,
lineHeight: true,
fontFamily: true
},
outline: {
outlineWidth: true,
outlineStyle: true,
outlineColor: true
}
};
var CSSProperty = {
isUnitlessNumber: isUnitlessNumber,
shorthandPropertyExpansions: shorthandPropertyExpansions
};
module.exports = CSSProperty;
/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule camelizeStyleName
* @typechecks
*/
'use strict';
var camelize = __webpack_require__(99);
var msPattern = /^-ms-/;
/**
* Camelcases a hyphenated CSS property name, for example:
*
* > camelizeStyleName('background-color')
* < "backgroundColor"
* > camelizeStyleName('-moz-transition')
* < "MozTransition"
* > camelizeStyleName('-ms-transition')
* < "msTransition"
*
* As Andi Smith suggests
* (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
* is converted to lowercase `ms`.
*
* @param {string} string
* @return {string}
*/
function camelizeStyleName(string) {
return camelize(string.replace(msPattern, 'ms-'));
}
module.exports = camelizeStyleName;
/***/ },
/* 99 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule camelize
* @typechecks
*/
"use strict";
var _hyphenPattern = /-(.)/g;
/**
* Camelcases a hyphenated string, for example:
*
* > camelize('background-color')
* < "backgroundColor"
*
* @param {string} string
* @return {string}
*/
function camelize(string) {
return string.replace(_hyphenPattern, function (_, character) {
return character.toUpperCase();
});
}
module.exports = camelize;
/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule dangerousStyleValue
* @typechecks static-only
*/
'use strict';
var CSSProperty = __webpack_require__(97);
var isUnitlessNumber = CSSProperty.isUnitlessNumber;
/**
* Convert a value into the proper css writable value. The style name `name`
* should be logical (no hyphens), as specified
* in `CSSProperty.isUnitlessNumber`.
*
* @param {string} name CSS property name such as `topMargin`.
* @param {*} value CSS property value such as `10px`.
* @return {string} Normalized style value with dimensions applied.
*/
function dangerousStyleValue(name, value) {
// Note that we've removed escapeTextForBrowser() calls here since the
// whole string will be escaped when the attribute is injected into
// the markup. If you provide unsafe user data here they can inject
// arbitrary CSS which may be problematic (I couldn't repro this):
// https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
// http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
// This is not an XSS hole but instead a potential CSS injection issue
// which has lead to a greater discussion about how we're going to
// trust URLs moving forward. See #2115901
var isEmpty = value == null || typeof value === 'boolean' || value === '';
if (isEmpty) {
return '';
}
var isNonNumeric = isNaN(value);
if (isNonNumeric || value === 0 || isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {
return '' + value; // cast to string
}
if (typeof value === 'string') {
value = value.trim();
}
return value + 'px';
}
module.exports = dangerousStyleValue;
/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule hyphenateStyleName
* @typechecks
*/
'use strict';
var hyphenate = __webpack_require__(102);
var msPattern = /^ms-/;
/**
* Hyphenates a camelcased CSS property name, for example:
*
* > hyphenateStyleName('backgroundColor')
* < "background-color"
* > hyphenateStyleName('MozTransition')
* < "-moz-transition"
* > hyphenateStyleName('msTransition')
* < "-ms-transition"
*
* As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
* is converted to `-ms-`.
*
* @param {string} string
* @return {string}
*/
function hyphenateStyleName(string) {
return hyphenate(string).replace(msPattern, '-ms-');
}
module.exports = hyphenateStyleName;
/***/ },
/* 102 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule hyphenate
* @typechecks
*/
'use strict';
var _uppercasePattern = /([A-Z])/g;
/**
* Hyphenates a camelcased string, for example:
*
* > hyphenate('backgroundColor')
* < "background-color"
*
* For CSS style names, use `hyphenateStyleName` instead which works properly
* with all vendor prefixes, including `ms`.
*
* @param {string} string
* @return {string}
*/
function hyphenate(string) {
return string.replace(_uppercasePattern, '-$1').toLowerCase();
}
module.exports = hyphenate;
/***/ },
/* 103 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule memoizeStringOnly
* @typechecks static-only
*/
'use strict';
/**
* Memoizes the return value of a function that accepts one string argument.
*
* @param {function} callback
* @return {function}
*/
function memoizeStringOnly(callback) {
var cache = {};
return function (string) {
if (!cache.hasOwnProperty(string)) {
cache[string] = callback.call(this, string);
}
return cache[string];
};
}
module.exports = memoizeStringOnly;
/***/ },
/* 104 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMButton
*/
'use strict';
var mouseListenerNames = {
onClick: true,
onDoubleClick: true,
onMouseDown: true,
onMouseMove: true,
onMouseUp: true,
onClickCapture: true,
onDoubleClickCapture: true,
onMouseDownCapture: true,
onMouseMoveCapture: true,
onMouseUpCapture: true
};
/**
* Implements a <button> native component that does not receive mouse events
* when `disabled` is set.
*/
var ReactDOMButton = {
getNativeProps: function (inst, props, context) {
if (!props.disabled) {
return props;
}
// Copy the props, except the mouse listeners
var nativeProps = {};
for (var key in props) {
if (props.hasOwnProperty(key) && !mouseListenerNames[key]) {
nativeProps[key] = props[key];
}
}
return nativeProps;
}
};
module.exports = ReactDOMButton;
/***/ },
/* 105 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMInput
*/
'use strict';
var ReactDOMIDOperations = __webpack_require__(27);
var LinkedValueUtils = __webpack_require__(106);
var ReactMount = __webpack_require__(28);
var ReactUpdates = __webpack_require__(54);
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
var instancesByReactID = {};
function forceUpdateIfMounted() {
if (this._rootNodeID) {
// DOM component is still mounted; update
ReactDOMInput.updateWrapper(this);
}
}
/**
* Implements an <input> native component that allows setting these optional
* props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
*
* If `checked` or `value` are not supplied (or null/undefined), user actions
* that affect the checked state or value will trigger updates to the element.
*
* If they are supplied (and not null/undefined), the rendered element will not
* trigger updates to the element. Instead, the props must change in order for
* the rendered element to be updated.
*
* The rendered element will be initialized as unchecked (or `defaultChecked`)
* with an empty value (or `defaultValue`).
*
* @see http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
*/
var ReactDOMInput = {
getNativeProps: function (inst, props, context) {
var value = LinkedValueUtils.getValue(props);
var checked = LinkedValueUtils.getChecked(props);
var nativeProps = assign({}, props, {
defaultChecked: undefined,
defaultValue: undefined,
value: value != null ? value : inst._wrapperState.initialValue,
checked: checked != null ? checked : inst._wrapperState.initialChecked,
onChange: inst._wrapperState.onChange
});
return nativeProps;
},
mountWrapper: function (inst, props) {
if (process.env.NODE_ENV !== 'production') {
LinkedValueUtils.checkPropTypes('input', props, inst._currentElement._owner);
}
var defaultValue = props.defaultValue;
inst._wrapperState = {
initialChecked: props.defaultChecked || false,
initialValue: defaultValue != null ? defaultValue : null,
onChange: _handleChange.bind(inst)
};
},
mountReadyWrapper: function (inst) {
// Can't be in mountWrapper or else server rendering leaks.
instancesByReactID[inst._rootNodeID] = inst;
},
unmountWrapper: function (inst) {
delete instancesByReactID[inst._rootNodeID];
},
updateWrapper: function (inst) {
var props = inst._currentElement.props;
// TODO: Shouldn't this be getChecked(props)?
var checked = props.checked;
if (checked != null) {
ReactDOMIDOperations.updatePropertyByID(inst._rootNodeID, 'checked', checked || false);
}
var value = LinkedValueUtils.getValue(props);
if (value != null) {
// Cast `value` to a string to ensure the value is set correctly. While
// browsers typically do this as necessary, jsdom doesn't.
ReactDOMIDOperations.updatePropertyByID(inst._rootNodeID, 'value', '' + value);
}
}
};
function _handleChange(event) {
var props = this._currentElement.props;
var returnValue = LinkedValueUtils.executeOnChange(props, event);
// Here we use asap to wait until all updates have propagated, which
// is important when using controlled components within layers:
// https://github.com/facebook/react/issues/1698
ReactUpdates.asap(forceUpdateIfMounted, this);
var name = props.name;
if (props.type === 'radio' && name != null) {
var rootNode = ReactMount.getNode(this._rootNodeID);
var queryRoot = rootNode;
while (queryRoot.parentNode) {
queryRoot = queryRoot.parentNode;
}
// If `rootNode.form` was non-null, then we could try `form.elements`,
// but that sometimes behaves strangely in IE8. We could also try using
// `form.getElementsByName`, but that will only return direct children
// and won't include inputs that use the HTML5 `form=` attribute. Since
// the input might not even be in a form, let's just use the global
// `querySelectorAll` to ensure we don't miss anything.
var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]');
for (var i = 0; i < group.length; i++) {
var otherNode = group[i];
if (otherNode === rootNode || otherNode.form !== rootNode.form) {
continue;
}
// This will throw if radio buttons rendered by different copies of React
// and the same name are rendered into the same form (same as #1939).
// That's probably okay; we don't support it just as we don't support
// mixing React with non-React.
var otherID = ReactMount.getID(otherNode);
!otherID ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the ' + 'same `name` is not supported.') : invariant(false) : undefined;
var otherInstance = instancesByReactID[otherID];
!otherInstance ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOMInput: Unknown radio button ID %s.', otherID) : invariant(false) : undefined;
// If this is a controlled radio button group, forcing the input that
// was previously checked to update will cause it to be come re-checked
// as appropriate.
ReactUpdates.asap(forceUpdateIfMounted, otherInstance);
}
}
return returnValue;
}
module.exports = ReactDOMInput;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 106 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule LinkedValueUtils
* @typechecks static-only
*/
'use strict';
var ReactPropTypes = __webpack_require__(107);
var ReactPropTypeLocations = __webpack_require__(65);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
var hasReadOnlyValue = {
'button': true,
'checkbox': true,
'image': true,
'hidden': true,
'radio': true,
'reset': true,
'submit': true
};
function _assertSingleLink(inputProps) {
!(inputProps.checkedLink == null || inputProps.valueLink == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a valueLink. If you want to use ' + 'checkedLink, you probably don\'t want to use valueLink and vice versa.') : invariant(false) : undefined;
}
function _assertValueLink(inputProps) {
_assertSingleLink(inputProps);
!(inputProps.value == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a valueLink and a value or onChange event. If you want ' + 'to use value or onChange, you probably don\'t want to use valueLink.') : invariant(false) : undefined;
}
function _assertCheckedLink(inputProps) {
_assertSingleLink(inputProps);
!(inputProps.checked == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a checked property or onChange event. ' + 'If you want to use checked or onChange, you probably don\'t want to ' + 'use checkedLink') : invariant(false) : undefined;
}
var propTypes = {
value: function (props, propName, componentName) {
if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) {
return null;
}
return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
},
checked: function (props, propName, componentName) {
if (!props[propName] || props.onChange || props.readOnly || props.disabled) {
return null;
}
return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
},
onChange: ReactPropTypes.func
};
var loggedTypeFailures = {};
function getDeclarationErrorAddendum(owner) {
if (owner) {
var name = owner.getName();
if (name) {
return ' Check the render method of `' + name + '`.';
}
}
return '';
}
/**
* Provide a linked `value` attribute for controlled forms. You should not use
* this outside of the ReactDOM controlled form components.
*/
var LinkedValueUtils = {
checkPropTypes: function (tagName, props, owner) {
for (var propName in propTypes) {
if (propTypes.hasOwnProperty(propName)) {
var error = propTypes[propName](props, propName, tagName, ReactPropTypeLocations.prop);
}
if (error instanceof Error && !(error.message in loggedTypeFailures)) {
// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error.message] = true;
var addendum = getDeclarationErrorAddendum(owner);
process.env.NODE_ENV !== 'production' ? warning(false, 'Failed form propType: %s%s', error.message, addendum) : undefined;
}
}
},
/**
* @param {object} inputProps Props for form component
* @return {*} current value of the input either from value prop or link.
*/
getValue: function (inputProps) {
if (inputProps.valueLink) {
_assertValueLink(inputProps);
return inputProps.valueLink.value;
}
return inputProps.value;
},
/**
* @param {object} inputProps Props for form component
* @return {*} current checked status of the input either from checked prop
* or link.
*/
getChecked: function (inputProps) {
if (inputProps.checkedLink) {
_assertCheckedLink(inputProps);
return inputProps.checkedLink.value;
}
return inputProps.checked;
},
/**
* @param {object} inputProps Props for form component
* @param {SyntheticEvent} event change event to handle
*/
executeOnChange: function (inputProps, event) {
if (inputProps.valueLink) {
_assertValueLink(inputProps);
return inputProps.valueLink.requestChange(event.target.value);
} else if (inputProps.checkedLink) {
_assertCheckedLink(inputProps);
return inputProps.checkedLink.requestChange(event.target.checked);
} else if (inputProps.onChange) {
return inputProps.onChange.call(undefined, event);
}
}
};
module.exports = LinkedValueUtils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 107 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactPropTypes
*/
'use strict';
var ReactElement = __webpack_require__(42);
var ReactPropTypeLocationNames = __webpack_require__(66);
var emptyFunction = __webpack_require__(15);
var getIteratorFn = __webpack_require__(108);
/**
* Collection of methods that allow declaration and validation of props that are
* supplied to React components. Example usage:
*
* var Props = require('ReactPropTypes');
* var MyArticle = React.createClass({
* propTypes: {
* // An optional string prop named "description".
* description: Props.string,
*
* // A required enum prop named "category".
* category: Props.oneOf(['News','Photos']).isRequired,
*
* // A prop named "dialog" that requires an instance of Dialog.
* dialog: Props.instanceOf(Dialog).isRequired
* },
* render: function() { ... }
* });
*
* A more formal specification of how these methods are used:
*
* type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
* decl := ReactPropTypes.{type}(.isRequired)?
*
* Each and every declaration produces a function with the same signature. This
* allows the creation of custom validation functions. For example:
*
* var MyLink = React.createClass({
* propTypes: {
* // An optional string or URI prop named "href".
* href: function(props, propName, componentName) {
* var propValue = props[propName];
* if (propValue != null && typeof propValue !== 'string' &&
* !(propValue instanceof URI)) {
* return new Error(
* 'Expected a string or an URI for ' + propName + ' in ' +
* componentName
* );
* }
* }
* },
* render: function() {...}
* });
*
* @internal
*/
var ANONYMOUS = '<<anonymous>>';
var ReactPropTypes = {
array: createPrimitiveTypeChecker('array'),
bool: createPrimitiveTypeChecker('boolean'),
func: createPrimitiveTypeChecker('function'),
number: createPrimitiveTypeChecker('number'),
object: createPrimitiveTypeChecker('object'),
string: createPrimitiveTypeChecker('string'),
any: createAnyTypeChecker(),
arrayOf: createArrayOfTypeChecker,
element: createElementTypeChecker(),
instanceOf: createInstanceTypeChecker,
node: createNodeChecker(),
objectOf: createObjectOfTypeChecker,
oneOf: createEnumTypeChecker,
oneOfType: createUnionTypeChecker,
shape: createShapeTypeChecker
};
function createChainableTypeChecker(validate) {
function checkType(isRequired, props, propName, componentName, location, propFullName) {
componentName = componentName || ANONYMOUS;
propFullName = propFullName || propName;
if (props[propName] == null) {
var locationName = ReactPropTypeLocationNames[location];
if (isRequired) {
return new Error('Required ' + locationName + ' `' + propFullName + '` was not specified in ' + ('`' + componentName + '`.'));
}
return null;
} else {
return validate(props, propName, componentName, location, propFullName);
}
}
var chainedCheckType = checkType.bind(null, false);
chainedCheckType.isRequired = checkType.bind(null, true);
return chainedCheckType;
}
function createPrimitiveTypeChecker(expectedType) {
function validate(props, propName, componentName, location, propFullName) {
var propValue = props[propName];
var propType = getPropType(propValue);
if (propType !== expectedType) {
var locationName = ReactPropTypeLocationNames[location];
// `propValue` being instance of, say, date/regexp, pass the 'object'
// check, but we can offer a more precise error message here rather than
// 'of type `object`'.
var preciseType = getPreciseType(propValue);
return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
}
return null;
}
return createChainableTypeChecker(validate);
}
function createAnyTypeChecker() {
return createChainableTypeChecker(emptyFunction.thatReturns(null));
}
function createArrayOfTypeChecker(typeChecker) {
function validate(props, propName, componentName, location, propFullName) {
var propValue = props[propName];
if (!Array.isArray(propValue)) {
var locationName = ReactPropTypeLocationNames[location];
var propType = getPropType(propValue);
return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
}
for (var i = 0; i < propValue.length; i++) {
var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']');
if (error instanceof Error) {
return error;
}
}
return null;
}
return createChainableTypeChecker(validate);
}
function createElementTypeChecker() {
function validate(props, propName, componentName, location, propFullName) {
if (!ReactElement.isValidElement(props[propName])) {
var locationName = ReactPropTypeLocationNames[location];
return new Error('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a single ReactElement.'));
}
return null;
}
return createChainableTypeChecker(validate);
}
function createInstanceTypeChecker(expectedClass) {
function validate(props, propName, componentName, location, propFullName) {
if (!(props[propName] instanceof expectedClass)) {
var locationName = ReactPropTypeLocationNames[location];
var expectedClassName = expectedClass.name || ANONYMOUS;
var actualClassName = getClassName(props[propName]);
return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
}
return null;
}
return createChainableTypeChecker(validate);
}
function createEnumTypeChecker(expectedValues) {
if (!Array.isArray(expectedValues)) {
return createChainableTypeChecker(function () {
return new Error('Invalid argument supplied to oneOf, expected an instance of array.');
});
}
function validate(props, propName, componentName, location, propFullName) {
var propValue = props[propName];
for (var i = 0; i < expectedValues.length; i++) {
if (propValue === expectedValues[i]) {
return null;
}
}
var locationName = ReactPropTypeLocationNames[location];
var valuesString = JSON.stringify(expectedValues);
return new Error('Invalid ' + locationName + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
}
return createChainableTypeChecker(validate);
}
function createObjectOfTypeChecker(typeChecker) {
function validate(props, propName, componentName, location, propFullName) {
var propValue = props[propName];
var propType = getPropType(propValue);
if (propType !== 'object') {
var locationName = ReactPropTypeLocationNames[location];
return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
}
for (var key in propValue) {
if (propValue.hasOwnProperty(key)) {
var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key);
if (error instanceof Error) {
return error;
}
}
}
return null;
}
return createChainableTypeChecker(validate);
}
function createUnionTypeChecker(arrayOfTypeCheckers) {
if (!Array.isArray(arrayOfTypeCheckers)) {
return createChainableTypeChecker(function () {
return new Error('Invalid argument supplied to oneOfType, expected an instance of array.');
});
}
function validate(props, propName, componentName, location, propFullName) {
for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
var checker = arrayOfTypeCheckers[i];
if (checker(props, propName, componentName, location, propFullName) == null) {
return null;
}
}
var locationName = ReactPropTypeLocationNames[location];
return new Error('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
}
return createChainableTypeChecker(validate);
}
function createNodeChecker() {
function validate(props, propName, componentName, location, propFullName) {
if (!isNode(props[propName])) {
var locationName = ReactPropTypeLocationNames[location];
return new Error('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
}
return null;
}
return createChainableTypeChecker(validate);
}
function createShapeTypeChecker(shapeTypes) {
function validate(props, propName, componentName, location, propFullName) {
var propValue = props[propName];
var propType = getPropType(propValue);
if (propType !== 'object') {
var locationName = ReactPropTypeLocationNames[location];
return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
}
for (var key in shapeTypes) {
var checker = shapeTypes[key];
if (!checker) {
continue;
}
var error = checker(propValue, key, componentName, location, propFullName + '.' + key);
if (error) {
return error;
}
}
return null;
}
return createChainableTypeChecker(validate);
}
function isNode(propValue) {
switch (typeof propValue) {
case 'number':
case 'string':
case 'undefined':
return true;
case 'boolean':
return !propValue;
case 'object':
if (Array.isArray(propValue)) {
return propValue.every(isNode);
}
if (propValue === null || ReactElement.isValidElement(propValue)) {
return true;
}
var iteratorFn = getIteratorFn(propValue);
if (iteratorFn) {
var iterator = iteratorFn.call(propValue);
var step;
if (iteratorFn !== propValue.entries) {
while (!(step = iterator.next()).done) {
if (!isNode(step.value)) {
return false;
}
}
} else {
// Iterator will provide entry [k,v] tuples rather than values.
while (!(step = iterator.next()).done) {
var entry = step.value;
if (entry) {
if (!isNode(entry[1])) {
return false;
}
}
}
}
} else {
return false;
}
return true;
default:
return false;
}
}
// Equivalent of `typeof` but with special handling for array and regexp.
function getPropType(propValue) {
var propType = typeof propValue;
if (Array.isArray(propValue)) {
return 'array';
}
if (propValue instanceof RegExp) {
// Old webkits (at least until Android 4.0) return 'function' rather than
// 'object' for typeof a RegExp. We'll normalize this here so that /bla/
// passes PropTypes.object.
return 'object';
}
return propType;
}
// This handles more types than `getPropType`. Only used for error messages.
// See `createPrimitiveTypeChecker`.
function getPreciseType(propValue) {
var propType = getPropType(propValue);
if (propType === 'object') {
if (propValue instanceof Date) {
return 'date';
} else if (propValue instanceof RegExp) {
return 'regexp';
}
}
return propType;
}
// Returns class name of the object, if any.
function getClassName(propValue) {
if (!propValue.constructor || !propValue.constructor.name) {
return '<<anonymous>>';
}
return propValue.constructor.name;
}
module.exports = ReactPropTypes;
/***/ },
/* 108 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getIteratorFn
* @typechecks static-only
*/
'use strict';
/* global Symbol */
var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
/**
* Returns the iterator method function contained on the iterable object.
*
* Be sure to invoke the function with the iterable as context:
*
* var iteratorFn = getIteratorFn(myIterable);
* if (iteratorFn) {
* var iterator = iteratorFn.call(myIterable);
* ...
* }
*
* @param {?object} maybeIterable
* @return {?function}
*/
function getIteratorFn(maybeIterable) {
var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
if (typeof iteratorFn === 'function') {
return iteratorFn;
}
}
module.exports = getIteratorFn;
/***/ },
/* 109 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMOption
*/
'use strict';
var ReactChildren = __webpack_require__(110);
var ReactDOMSelect = __webpack_require__(112);
var assign = __webpack_require__(39);
var warning = __webpack_require__(25);
var valueContextKey = ReactDOMSelect.valueContextKey;
/**
* Implements an <option> native component that warns when `selected` is set.
*/
var ReactDOMOption = {
mountWrapper: function (inst, props, context) {
// TODO (yungsters): Remove support for `selected` in <option>.
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(props.selected == null, 'Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.') : undefined;
}
// Look up whether this option is 'selected' via context
var selectValue = context[valueContextKey];
// If context key is null (e.g., no specified value or after initial mount)
// or missing (e.g., for <datalist>), we don't change props.selected
var selected = null;
if (selectValue != null) {
selected = false;
if (Array.isArray(selectValue)) {
// multiple
for (var i = 0; i < selectValue.length; i++) {
if ('' + selectValue[i] === '' + props.value) {
selected = true;
break;
}
}
} else {
selected = '' + selectValue === '' + props.value;
}
}
inst._wrapperState = { selected: selected };
},
getNativeProps: function (inst, props, context) {
var nativeProps = assign({ selected: undefined, children: undefined }, props);
// Read state only from initial mount because <select> updates value
// manually; we need the initial state only for server rendering
if (inst._wrapperState.selected != null) {
nativeProps.selected = inst._wrapperState.selected;
}
var content = '';
// Flatten children and warn if they aren't strings or numbers;
// invalid types are ignored.
ReactChildren.forEach(props.children, function (child) {
if (child == null) {
return;
}
if (typeof child === 'string' || typeof child === 'number') {
content += child;
} else {
process.env.NODE_ENV !== 'production' ? warning(false, 'Only strings and numbers are supported as <option> children.') : undefined;
}
});
if (content) {
nativeProps.children = content;
}
return nativeProps;
}
};
module.exports = ReactDOMOption;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 110 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactChildren
*/
'use strict';
var PooledClass = __webpack_require__(56);
var ReactElement = __webpack_require__(42);
var emptyFunction = __webpack_require__(15);
var traverseAllChildren = __webpack_require__(111);
var twoArgumentPooler = PooledClass.twoArgumentPooler;
var fourArgumentPooler = PooledClass.fourArgumentPooler;
var userProvidedKeyEscapeRegex = /\/(?!\/)/g;
function escapeUserProvidedKey(text) {
return ('' + text).replace(userProvidedKeyEscapeRegex, '//');
}
/**
* PooledClass representing the bookkeeping associated with performing a child
* traversal. Allows avoiding binding callbacks.
*
* @constructor ForEachBookKeeping
* @param {!function} forEachFunction Function to perform traversal with.
* @param {?*} forEachContext Context to perform context with.
*/
function ForEachBookKeeping(forEachFunction, forEachContext) {
this.func = forEachFunction;
this.context = forEachContext;
this.count = 0;
}
ForEachBookKeeping.prototype.destructor = function () {
this.func = null;
this.context = null;
this.count = 0;
};
PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);
function forEachSingleChild(bookKeeping, child, name) {
var func = bookKeeping.func;
var context = bookKeeping.context;
func.call(context, child, bookKeeping.count++);
}
/**
* Iterates through children that are typically specified as `props.children`.
*
* The provided forEachFunc(child, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} forEachFunc
* @param {*} forEachContext Context for forEachContext.
*/
function forEachChildren(children, forEachFunc, forEachContext) {
if (children == null) {
return children;
}
var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext);
traverseAllChildren(children, forEachSingleChild, traverseContext);
ForEachBookKeeping.release(traverseContext);
}
/**
* PooledClass representing the bookkeeping associated with performing a child
* mapping. Allows avoiding binding callbacks.
*
* @constructor MapBookKeeping
* @param {!*} mapResult Object containing the ordered map of results.
* @param {!function} mapFunction Function to perform mapping with.
* @param {?*} mapContext Context to perform mapping with.
*/
function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
this.result = mapResult;
this.keyPrefix = keyPrefix;
this.func = mapFunction;
this.context = mapContext;
this.count = 0;
}
MapBookKeeping.prototype.destructor = function () {
this.result = null;
this.keyPrefix = null;
this.func = null;
this.context = null;
this.count = 0;
};
PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler);
function mapSingleChildIntoContext(bookKeeping, child, childKey) {
var result = bookKeeping.result;
var keyPrefix = bookKeeping.keyPrefix;
var func = bookKeeping.func;
var context = bookKeeping.context;
var mappedChild = func.call(context, child, bookKeeping.count++);
if (Array.isArray(mappedChild)) {
mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);
} else if (mappedChild != null) {
if (ReactElement.isValidElement(mappedChild)) {
mappedChild = ReactElement.cloneAndReplaceKey(mappedChild,
// Keep both the (mapped) and old keys if they differ, just as
// traverseAllChildren used to do for objects as children
keyPrefix + (mappedChild !== child ? escapeUserProvidedKey(mappedChild.key || '') + '/' : '') + childKey);
}
result.push(mappedChild);
}
}
function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
var escapedPrefix = '';
if (prefix != null) {
escapedPrefix = escapeUserProvidedKey(prefix) + '/';
}
var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context);
traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
MapBookKeeping.release(traverseContext);
}
/**
* Maps children that are typically specified as `props.children`.
*
* The provided mapFunction(child, key, index) will be called for each
* leaf child.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} func The map function.
* @param {*} context Context for mapFunction.
* @return {object} Object containing the ordered map of results.
*/
function mapChildren(children, func, context) {
if (children == null) {
return children;
}
var result = [];
mapIntoWithKeyPrefixInternal(children, result, null, func, context);
return result;
}
function forEachSingleChildDummy(traverseContext, child, name) {
return null;
}
/**
* Count the number of children that are typically specified as
* `props.children`.
*
* @param {?*} children Children tree container.
* @return {number} The number of children.
*/
function countChildren(children, context) {
return traverseAllChildren(children, forEachSingleChildDummy, null);
}
/**
* Flatten a children object (typically specified as `props.children`) and
* return an array with appropriately re-keyed children.
*/
function toArray(children) {
var result = [];
mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
return result;
}
var ReactChildren = {
forEach: forEachChildren,
map: mapChildren,
mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal,
count: countChildren,
toArray: toArray
};
module.exports = ReactChildren;
/***/ },
/* 111 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule traverseAllChildren
*/
'use strict';
var ReactCurrentOwner = __webpack_require__(5);
var ReactElement = __webpack_require__(42);
var ReactInstanceHandles = __webpack_require__(45);
var getIteratorFn = __webpack_require__(108);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
var SEPARATOR = ReactInstanceHandles.SEPARATOR;
var SUBSEPARATOR = ':';
/**
* TODO: Test that a single child and an array with one item have the same key
* pattern.
*/
var userProvidedKeyEscaperLookup = {
'=': '=0',
'.': '=1',
':': '=2'
};
var userProvidedKeyEscapeRegex = /[=.:]/g;
var didWarnAboutMaps = false;
function userProvidedKeyEscaper(match) {
return userProvidedKeyEscaperLookup[match];
}
/**
* Generate a key string that identifies a component within a set.
*
* @param {*} component A component that could contain a manual key.
* @param {number} index Index that is used if a manual key is not provided.
* @return {string}
*/
function getComponentKey(component, index) {
if (component && component.key != null) {
// Explicit key
return wrapUserProvidedKey(component.key);
}
// Implicit key determined by the index in the set
return index.toString(36);
}
/**
* Escape a component key so that it is safe to use in a reactid.
*
* @param {*} text Component key to be escaped.
* @return {string} An escaped string.
*/
function escapeUserProvidedKey(text) {
return ('' + text).replace(userProvidedKeyEscapeRegex, userProvidedKeyEscaper);
}
/**
* Wrap a `key` value explicitly provided by the user to distinguish it from
* implicitly-generated keys generated by a component's index in its parent.
*
* @param {string} key Value of a user-provided `key` attribute
* @return {string}
*/
function wrapUserProvidedKey(key) {
return '$' + escapeUserProvidedKey(key);
}
/**
* @param {?*} children Children tree container.
* @param {!string} nameSoFar Name of the key path so far.
* @param {!function} callback Callback to invoke with each child found.
* @param {?*} traverseContext Used to pass information throughout the traversal
* process.
* @return {!number} The number of children in this subtree.
*/
function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
var type = typeof children;
if (type === 'undefined' || type === 'boolean') {
// All of the above are perceived as null.
children = null;
}
if (children === null || type === 'string' || type === 'number' || ReactElement.isValidElement(children)) {
callback(traverseContext, children,
// If it's the only child, treat the name as if it was wrapped in an array
// so that it's consistent if the number of children grows.
nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
return 1;
}
var child;
var nextName;
var subtreeCount = 0; // Count of children found in the current subtree.
var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
if (Array.isArray(children)) {
for (var i = 0; i < children.length; i++) {
child = children[i];
nextName = nextNamePrefix + getComponentKey(child, i);
subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
}
} else {
var iteratorFn = getIteratorFn(children);
if (iteratorFn) {
var iterator = iteratorFn.call(children);
var step;
if (iteratorFn !== children.entries) {
var ii = 0;
while (!(step = iterator.next()).done) {
child = step.value;
nextName = nextNamePrefix + getComponentKey(child, ii++);
subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
}
} else {
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.') : undefined;
didWarnAboutMaps = true;
}
// Iterator will provide entry [k,v] tuples rather than values.
while (!(step = iterator.next()).done) {
var entry = step.value;
if (entry) {
child = entry[1];
nextName = nextNamePrefix + wrapUserProvidedKey(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
}
}
}
} else if (type === 'object') {
var addendum = '';
if (process.env.NODE_ENV !== 'production') {
addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
if (children._isReactElement) {
addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
}
if (ReactCurrentOwner.current) {
var name = ReactCurrentOwner.current.getName();
if (name) {
addendum += ' Check the render method of `' + name + '`.';
}
}
}
var childrenString = String(children);
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : invariant(false) : undefined;
}
}
return subtreeCount;
}
/**
* Traverses children that are typically specified as `props.children`, but
* might also be specified through attributes:
*
* - `traverseAllChildren(this.props.children, ...)`
* - `traverseAllChildren(this.props.leftPanelChildren, ...)`
*
* The `traverseContext` is an optional argument that is passed through the
* entire traversal. It can be used to store accumulations or anything else that
* the callback might find relevant.
*
* @param {?*} children Children tree object.
* @param {!function} callback To invoke upon traversing each child.
* @param {?*} traverseContext Context for traversal.
* @return {!number} The number of children in this subtree.
*/
function traverseAllChildren(children, callback, traverseContext) {
if (children == null) {
return 0;
}
return traverseAllChildrenImpl(children, '', callback, traverseContext);
}
module.exports = traverseAllChildren;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 112 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMSelect
*/
'use strict';
var LinkedValueUtils = __webpack_require__(106);
var ReactMount = __webpack_require__(28);
var ReactUpdates = __webpack_require__(54);
var assign = __webpack_require__(39);
var warning = __webpack_require__(25);
var valueContextKey = '__ReactDOMSelect_value$' + Math.random().toString(36).slice(2);
function updateOptionsIfPendingUpdateAndMounted() {
if (this._rootNodeID && this._wrapperState.pendingUpdate) {
this._wrapperState.pendingUpdate = false;
var props = this._currentElement.props;
var value = LinkedValueUtils.getValue(props);
if (value != null) {
updateOptions(this, Boolean(props.multiple), value);
}
}
}
function getDeclarationErrorAddendum(owner) {
if (owner) {
var name = owner.getName();
if (name) {
return ' Check the render method of `' + name + '`.';
}
}
return '';
}
var valuePropNames = ['value', 'defaultValue'];
/**
* Validation function for `value` and `defaultValue`.
* @private
*/
function checkSelectPropTypes(inst, props) {
var owner = inst._currentElement._owner;
LinkedValueUtils.checkPropTypes('select', props, owner);
for (var i = 0; i < valuePropNames.length; i++) {
var propName = valuePropNames[i];
if (props[propName] == null) {
continue;
}
if (props.multiple) {
process.env.NODE_ENV !== 'production' ? warning(Array.isArray(props[propName]), 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : undefined;
} else {
process.env.NODE_ENV !== 'production' ? warning(!Array.isArray(props[propName]), 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : undefined;
}
}
}
/**
* @param {ReactDOMComponent} inst
* @param {boolean} multiple
* @param {*} propValue A stringable (with `multiple`, a list of stringables).
* @private
*/
function updateOptions(inst, multiple, propValue) {
var selectedValue, i;
var options = ReactMount.getNode(inst._rootNodeID).options;
if (multiple) {
selectedValue = {};
for (i = 0; i < propValue.length; i++) {
selectedValue['' + propValue[i]] = true;
}
for (i = 0; i < options.length; i++) {
var selected = selectedValue.hasOwnProperty(options[i].value);
if (options[i].selected !== selected) {
options[i].selected = selected;
}
}
} else {
// Do not set `select.value` as exact behavior isn't consistent across all
// browsers for all cases.
selectedValue = '' + propValue;
for (i = 0; i < options.length; i++) {
if (options[i].value === selectedValue) {
options[i].selected = true;
return;
}
}
if (options.length) {
options[0].selected = true;
}
}
}
/**
* Implements a <select> native component that allows optionally setting the
* props `value` and `defaultValue`. If `multiple` is false, the prop must be a
* stringable. If `multiple` is true, the prop must be an array of stringables.
*
* If `value` is not supplied (or null/undefined), user actions that change the
* selected option will trigger updates to the rendered options.
*
* If it is supplied (and not null/undefined), the rendered options will not
* update in response to user actions. Instead, the `value` prop must change in
* order for the rendered options to update.
*
* If `defaultValue` is provided, any options with the supplied values will be
* selected.
*/
var ReactDOMSelect = {
valueContextKey: valueContextKey,
getNativeProps: function (inst, props, context) {
return assign({}, props, {
onChange: inst._wrapperState.onChange,
value: undefined
});
},
mountWrapper: function (inst, props) {
if (process.env.NODE_ENV !== 'production') {
checkSelectPropTypes(inst, props);
}
var value = LinkedValueUtils.getValue(props);
inst._wrapperState = {
pendingUpdate: false,
initialValue: value != null ? value : props.defaultValue,
onChange: _handleChange.bind(inst),
wasMultiple: Boolean(props.multiple)
};
},
processChildContext: function (inst, props, context) {
// Pass down initial value so initial generated markup has correct
// `selected` attributes
var childContext = assign({}, context);
childContext[valueContextKey] = inst._wrapperState.initialValue;
return childContext;
},
postUpdateWrapper: function (inst) {
var props = inst._currentElement.props;
// After the initial mount, we control selected-ness manually so don't pass
// the context value down
inst._wrapperState.initialValue = undefined;
var wasMultiple = inst._wrapperState.wasMultiple;
inst._wrapperState.wasMultiple = Boolean(props.multiple);
var value = LinkedValueUtils.getValue(props);
if (value != null) {
inst._wrapperState.pendingUpdate = false;
updateOptions(inst, Boolean(props.multiple), value);
} else if (wasMultiple !== Boolean(props.multiple)) {
// For simplicity, reapply `defaultValue` if `multiple` is toggled.
if (props.defaultValue != null) {
updateOptions(inst, Boolean(props.multiple), props.defaultValue);
} else {
// Revert the select back to its default unselected state.
updateOptions(inst, Boolean(props.multiple), props.multiple ? [] : '');
}
}
}
};
function _handleChange(event) {
var props = this._currentElement.props;
var returnValue = LinkedValueUtils.executeOnChange(props, event);
this._wrapperState.pendingUpdate = true;
ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);
return returnValue;
}
module.exports = ReactDOMSelect;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 113 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMTextarea
*/
'use strict';
var LinkedValueUtils = __webpack_require__(106);
var ReactDOMIDOperations = __webpack_require__(27);
var ReactUpdates = __webpack_require__(54);
var assign = __webpack_require__(39);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
function forceUpdateIfMounted() {
if (this._rootNodeID) {
// DOM component is still mounted; update
ReactDOMTextarea.updateWrapper(this);
}
}
/**
* Implements a <textarea> native component that allows setting `value`, and
* `defaultValue`. This differs from the traditional DOM API because value is
* usually set as PCDATA children.
*
* If `value` is not supplied (or null/undefined), user actions that affect the
* value will trigger updates to the element.
*
* If `value` is supplied (and not null/undefined), the rendered element will
* not trigger updates to the element. Instead, the `value` prop must change in
* order for the rendered element to be updated.
*
* The rendered element will be initialized with an empty value, the prop
* `defaultValue` if specified, or the children content (deprecated).
*/
var ReactDOMTextarea = {
getNativeProps: function (inst, props, context) {
!(props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`dangerouslySetInnerHTML` does not make sense on <textarea>.') : invariant(false) : undefined;
// Always set children to the same thing. In IE9, the selection range will
// get reset if `textContent` is mutated.
var nativeProps = assign({}, props, {
defaultValue: undefined,
value: undefined,
children: inst._wrapperState.initialValue,
onChange: inst._wrapperState.onChange
});
return nativeProps;
},
mountWrapper: function (inst, props) {
if (process.env.NODE_ENV !== 'production') {
LinkedValueUtils.checkPropTypes('textarea', props, inst._currentElement._owner);
}
var defaultValue = props.defaultValue;
// TODO (yungsters): Remove support for children content in <textarea>.
var children = props.children;
if (children != null) {
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(false, 'Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.') : undefined;
}
!(defaultValue == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'If you supply `defaultValue` on a <textarea>, do not pass children.') : invariant(false) : undefined;
if (Array.isArray(children)) {
!(children.length <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, '<textarea> can only have at most one child.') : invariant(false) : undefined;
children = children[0];
}
defaultValue = '' + children;
}
if (defaultValue == null) {
defaultValue = '';
}
var value = LinkedValueUtils.getValue(props);
inst._wrapperState = {
// We save the initial value so that `ReactDOMComponent` doesn't update
// `textContent` (unnecessary since we update value).
// The initial value can be a boolean or object so that's why it's
// forced to be a string.
initialValue: '' + (value != null ? value : defaultValue),
onChange: _handleChange.bind(inst)
};
},
updateWrapper: function (inst) {
var props = inst._currentElement.props;
var value = LinkedValueUtils.getValue(props);
if (value != null) {
// Cast `value` to a string to ensure the value is set correctly. While
// browsers typically do this as necessary, jsdom doesn't.
ReactDOMIDOperations.updatePropertyByID(inst._rootNodeID, 'value', '' + value);
}
}
};
function _handleChange(event) {
var props = this._currentElement.props;
var returnValue = LinkedValueUtils.executeOnChange(props, event);
ReactUpdates.asap(forceUpdateIfMounted, this);
return returnValue;
}
module.exports = ReactDOMTextarea;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 114 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactMultiChild
* @typechecks static-only
*/
'use strict';
var ReactComponentEnvironment = __webpack_require__(64);
var ReactMultiChildUpdateTypes = __webpack_require__(16);
var ReactCurrentOwner = __webpack_require__(5);
var ReactReconciler = __webpack_require__(50);
var ReactChildReconciler = __webpack_require__(115);
var flattenChildren = __webpack_require__(116);
/**
* Updating children of a component may trigger recursive updates. The depth is
* used to batch recursive updates to render markup more efficiently.
*
* @type {number}
* @private
*/
var updateDepth = 0;
/**
* Queue of update configuration objects.
*
* Each object has a `type` property that is in `ReactMultiChildUpdateTypes`.
*
* @type {array<object>}
* @private
*/
var updateQueue = [];
/**
* Queue of markup to be rendered.
*
* @type {array<string>}
* @private
*/
var markupQueue = [];
/**
* Enqueues markup to be rendered and inserted at a supplied index.
*
* @param {string} parentID ID of the parent component.
* @param {string} markup Markup that renders into an element.
* @param {number} toIndex Destination index.
* @private
*/
function enqueueInsertMarkup(parentID, markup, toIndex) {
// NOTE: Null values reduce hidden classes.
updateQueue.push({
parentID: parentID,
parentNode: null,
type: ReactMultiChildUpdateTypes.INSERT_MARKUP,
markupIndex: markupQueue.push(markup) - 1,
content: null,
fromIndex: null,
toIndex: toIndex
});
}
/**
* Enqueues moving an existing element to another index.
*
* @param {string} parentID ID of the parent component.
* @param {number} fromIndex Source index of the existing element.
* @param {number} toIndex Destination index of the element.
* @private
*/
function enqueueMove(parentID, fromIndex, toIndex) {
// NOTE: Null values reduce hidden classes.
updateQueue.push({
parentID: parentID,
parentNode: null,
type: ReactMultiChildUpdateTypes.MOVE_EXISTING,
markupIndex: null,
content: null,
fromIndex: fromIndex,
toIndex: toIndex
});
}
/**
* Enqueues removing an element at an index.
*
* @param {string} parentID ID of the parent component.
* @param {number} fromIndex Index of the element to remove.
* @private
*/
function enqueueRemove(parentID, fromIndex) {
// NOTE: Null values reduce hidden classes.
updateQueue.push({
parentID: parentID,
parentNode: null,
type: ReactMultiChildUpdateTypes.REMOVE_NODE,
markupIndex: null,
content: null,
fromIndex: fromIndex,
toIndex: null
});
}
/**
* Enqueues setting the markup of a node.
*
* @param {string} parentID ID of the parent component.
* @param {string} markup Markup that renders into an element.
* @private
*/
function enqueueSetMarkup(parentID, markup) {
// NOTE: Null values reduce hidden classes.
updateQueue.push({
parentID: parentID,
parentNode: null,
type: ReactMultiChildUpdateTypes.SET_MARKUP,
markupIndex: null,
content: markup,
fromIndex: null,
toIndex: null
});
}
/**
* Enqueues setting the text content.
*
* @param {string} parentID ID of the parent component.
* @param {string} textContent Text content to set.
* @private
*/
function enqueueTextContent(parentID, textContent) {
// NOTE: Null values reduce hidden classes.
updateQueue.push({
parentID: parentID,
parentNode: null,
type: ReactMultiChildUpdateTypes.TEXT_CONTENT,
markupIndex: null,
content: textContent,
fromIndex: null,
toIndex: null
});
}
/**
* Processes any enqueued updates.
*
* @private
*/
function processQueue() {
if (updateQueue.length) {
ReactComponentEnvironment.processChildrenUpdates(updateQueue, markupQueue);
clearQueue();
}
}
/**
* Clears any enqueued updates.
*
* @private
*/
function clearQueue() {
updateQueue.length = 0;
markupQueue.length = 0;
}
/**
* ReactMultiChild are capable of reconciling multiple children.
*
* @class ReactMultiChild
* @internal
*/
var ReactMultiChild = {
/**
* Provides common functionality for components that must reconcile multiple
* children. This is used by `ReactDOMComponent` to mount, update, and
* unmount child components.
*
* @lends {ReactMultiChild.prototype}
*/
Mixin: {
_reconcilerInstantiateChildren: function (nestedChildren, transaction, context) {
if (process.env.NODE_ENV !== 'production') {
if (this._currentElement) {
try {
ReactCurrentOwner.current = this._currentElement._owner;
return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context);
} finally {
ReactCurrentOwner.current = null;
}
}
}
return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context);
},
_reconcilerUpdateChildren: function (prevChildren, nextNestedChildrenElements, transaction, context) {
var nextChildren;
if (process.env.NODE_ENV !== 'production') {
if (this._currentElement) {
try {
ReactCurrentOwner.current = this._currentElement._owner;
nextChildren = flattenChildren(nextNestedChildrenElements);
} finally {
ReactCurrentOwner.current = null;
}
return ReactChildReconciler.updateChildren(prevChildren, nextChildren, transaction, context);
}
}
nextChildren = flattenChildren(nextNestedChildrenElements);
return ReactChildReconciler.updateChildren(prevChildren, nextChildren, transaction, context);
},
/**
* Generates a "mount image" for each of the supplied children. In the case
* of `ReactDOMComponent`, a mount image is a string of markup.
*
* @param {?object} nestedChildren Nested child maps.
* @return {array} An array of mounted representations.
* @internal
*/
mountChildren: function (nestedChildren, transaction, context) {
var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context);
this._renderedChildren = children;
var mountImages = [];
var index = 0;
for (var name in children) {
if (children.hasOwnProperty(name)) {
var child = children[name];
// Inlined for performance, see `ReactInstanceHandles.createReactID`.
var rootID = this._rootNodeID + name;
var mountImage = ReactReconciler.mountComponent(child, rootID, transaction, context);
child._mountIndex = index++;
mountImages.push(mountImage);
}
}
return mountImages;
},
/**
* Replaces any rendered children with a text content string.
*
* @param {string} nextContent String of content.
* @internal
*/
updateTextContent: function (nextContent) {
updateDepth++;
var errorThrown = true;
try {
var prevChildren = this._renderedChildren;
// Remove any rendered children.
ReactChildReconciler.unmountChildren(prevChildren);
// TODO: The setTextContent operation should be enough
for (var name in prevChildren) {
if (prevChildren.hasOwnProperty(name)) {
this._unmountChild(prevChildren[name]);
}
}
// Set new text content.
this.setTextContent(nextContent);
errorThrown = false;
} finally {
updateDepth--;
if (!updateDepth) {
if (errorThrown) {
clearQueue();
} else {
processQueue();
}
}
}
},
/**
* Replaces any rendered children with a markup string.
*
* @param {string} nextMarkup String of markup.
* @internal
*/
updateMarkup: function (nextMarkup) {
updateDepth++;
var errorThrown = true;
try {
var prevChildren = this._renderedChildren;
// Remove any rendered children.
ReactChildReconciler.unmountChildren(prevChildren);
for (var name in prevChildren) {
if (prevChildren.hasOwnProperty(name)) {
this._unmountChildByName(prevChildren[name], name);
}
}
this.setMarkup(nextMarkup);
errorThrown = false;
} finally {
updateDepth--;
if (!updateDepth) {
if (errorThrown) {
clearQueue();
} else {
processQueue();
}
}
}
},
/**
* Updates the rendered children with new children.
*
* @param {?object} nextNestedChildrenElements Nested child element maps.
* @param {ReactReconcileTransaction} transaction
* @internal
*/
updateChildren: function (nextNestedChildrenElements, transaction, context) {
updateDepth++;
var errorThrown = true;
try {
this._updateChildren(nextNestedChildrenElements, transaction, context);
errorThrown = false;
} finally {
updateDepth--;
if (!updateDepth) {
if (errorThrown) {
clearQueue();
} else {
processQueue();
}
}
}
},
/**
* Improve performance by isolating this hot code path from the try/catch
* block in `updateChildren`.
*
* @param {?object} nextNestedChildrenElements Nested child element maps.
* @param {ReactReconcileTransaction} transaction
* @final
* @protected
*/
_updateChildren: function (nextNestedChildrenElements, transaction, context) {
var prevChildren = this._renderedChildren;
var nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, transaction, context);
this._renderedChildren = nextChildren;
if (!nextChildren && !prevChildren) {
return;
}
var name;
// `nextIndex` will increment for each child in `nextChildren`, but
// `lastIndex` will be the last index visited in `prevChildren`.
var lastIndex = 0;
var nextIndex = 0;
for (name in nextChildren) {
if (!nextChildren.hasOwnProperty(name)) {
continue;
}
var prevChild = prevChildren && prevChildren[name];
var nextChild = nextChildren[name];
if (prevChild === nextChild) {
this.moveChild(prevChild, nextIndex, lastIndex);
lastIndex = Math.max(prevChild._mountIndex, lastIndex);
prevChild._mountIndex = nextIndex;
} else {
if (prevChild) {
// Update `lastIndex` before `_mountIndex` gets unset by unmounting.
lastIndex = Math.max(prevChild._mountIndex, lastIndex);
this._unmountChild(prevChild);
}
// The child must be instantiated before it's mounted.
this._mountChildByNameAtIndex(nextChild, name, nextIndex, transaction, context);
}
nextIndex++;
}
// Remove children that are no longer present.
for (name in prevChildren) {
if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {
this._unmountChild(prevChildren[name]);
}
}
},
/**
* Unmounts all rendered children. This should be used to clean up children
* when this component is unmounted.
*
* @internal
*/
unmountChildren: function () {
var renderedChildren = this._renderedChildren;
ReactChildReconciler.unmountChildren(renderedChildren);
this._renderedChildren = null;
},
/**
* Moves a child component to the supplied index.
*
* @param {ReactComponent} child Component to move.
* @param {number} toIndex Destination index of the element.
* @param {number} lastIndex Last index visited of the siblings of `child`.
* @protected
*/
moveChild: function (child, toIndex, lastIndex) {
// If the index of `child` is less than `lastIndex`, then it needs to
// be moved. Otherwise, we do not need to move it because a child will be
// inserted or moved before `child`.
if (child._mountIndex < lastIndex) {
enqueueMove(this._rootNodeID, child._mountIndex, toIndex);
}
},
/**
* Creates a child component.
*
* @param {ReactComponent} child Component to create.
* @param {string} mountImage Markup to insert.
* @protected
*/
createChild: function (child, mountImage) {
enqueueInsertMarkup(this._rootNodeID, mountImage, child._mountIndex);
},
/**
* Removes a child component.
*
* @param {ReactComponent} child Child to remove.
* @protected
*/
removeChild: function (child) {
enqueueRemove(this._rootNodeID, child._mountIndex);
},
/**
* Sets this text content string.
*
* @param {string} textContent Text content to set.
* @protected
*/
setTextContent: function (textContent) {
enqueueTextContent(this._rootNodeID, textContent);
},
/**
* Sets this markup string.
*
* @param {string} markup Markup to set.
* @protected
*/
setMarkup: function (markup) {
enqueueSetMarkup(this._rootNodeID, markup);
},
/**
* Mounts a child with the supplied name.
*
* NOTE: This is part of `updateChildren` and is here for readability.
*
* @param {ReactComponent} child Component to mount.
* @param {string} name Name of the child.
* @param {number} index Index at which to insert the child.
* @param {ReactReconcileTransaction} transaction
* @private
*/
_mountChildByNameAtIndex: function (child, name, index, transaction, context) {
// Inlined for performance, see `ReactInstanceHandles.createReactID`.
var rootID = this._rootNodeID + name;
var mountImage = ReactReconciler.mountComponent(child, rootID, transaction, context);
child._mountIndex = index;
this.createChild(child, mountImage);
},
/**
* Unmounts a rendered child.
*
* NOTE: This is part of `updateChildren` and is here for readability.
*
* @param {ReactComponent} child Component to unmount.
* @private
*/
_unmountChild: function (child) {
this.removeChild(child);
child._mountIndex = null;
}
}
};
module.exports = ReactMultiChild;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 115 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactChildReconciler
* @typechecks static-only
*/
'use strict';
var ReactReconciler = __webpack_require__(50);
var instantiateReactComponent = __webpack_require__(62);
var shouldUpdateReactComponent = __webpack_require__(67);
var traverseAllChildren = __webpack_require__(111);
var warning = __webpack_require__(25);
function instantiateChild(childInstances, child, name) {
// We found a component instance.
var keyUnique = childInstances[name] === undefined;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(keyUnique, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.', name) : undefined;
}
if (child != null && keyUnique) {
childInstances[name] = instantiateReactComponent(child, null);
}
}
/**
* ReactChildReconciler provides helpers for initializing or updating a set of
* children. Its output is suitable for passing it onto ReactMultiChild which
* does diffed reordering and insertion.
*/
var ReactChildReconciler = {
/**
* Generates a "mount image" for each of the supplied children. In the case
* of `ReactDOMComponent`, a mount image is a string of markup.
*
* @param {?object} nestedChildNodes Nested child maps.
* @return {?object} A set of child instances.
* @internal
*/
instantiateChildren: function (nestedChildNodes, transaction, context) {
if (nestedChildNodes == null) {
return null;
}
var childInstances = {};
traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);
return childInstances;
},
/**
* Updates the rendered children and returns a new set of children.
*
* @param {?object} prevChildren Previously initialized set of children.
* @param {?object} nextChildren Flat child element maps.
* @param {ReactReconcileTransaction} transaction
* @param {object} context
* @return {?object} A new set of child instances.
* @internal
*/
updateChildren: function (prevChildren, nextChildren, transaction, context) {
// We currently don't have a way to track moves here but if we use iterators
// instead of for..in we can zip the iterators and check if an item has
// moved.
// TODO: If nothing has changed, return the prevChildren object so that we
// can quickly bailout if nothing has changed.
if (!nextChildren && !prevChildren) {
return null;
}
var name;
for (name in nextChildren) {
if (!nextChildren.hasOwnProperty(name)) {
continue;
}
var prevChild = prevChildren && prevChildren[name];
var prevElement = prevChild && prevChild._currentElement;
var nextElement = nextChildren[name];
if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) {
ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context);
nextChildren[name] = prevChild;
} else {
if (prevChild) {
ReactReconciler.unmountComponent(prevChild, name);
}
// The child must be instantiated before it's mounted.
var nextChildInstance = instantiateReactComponent(nextElement, null);
nextChildren[name] = nextChildInstance;
}
}
// Unmount children that are no longer present.
for (name in prevChildren) {
if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {
ReactReconciler.unmountComponent(prevChildren[name]);
}
}
return nextChildren;
},
/**
* Unmounts all rendered children. This should be used to clean up children
* when this component is unmounted.
*
* @param {?object} renderedChildren Previously initialized set of children.
* @internal
*/
unmountChildren: function (renderedChildren) {
for (var name in renderedChildren) {
if (renderedChildren.hasOwnProperty(name)) {
var renderedChild = renderedChildren[name];
ReactReconciler.unmountComponent(renderedChild);
}
}
}
};
module.exports = ReactChildReconciler;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 116 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule flattenChildren
*/
'use strict';
var traverseAllChildren = __webpack_require__(111);
var warning = __webpack_require__(25);
/**
* @param {function} traverseContext Context passed through traversal.
* @param {?ReactComponent} child React child component.
* @param {!string} name String name of key path to child.
*/
function flattenSingleChildIntoContext(traverseContext, child, name) {
// We found a component instance.
var result = traverseContext;
var keyUnique = result[name] === undefined;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(keyUnique, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.', name) : undefined;
}
if (keyUnique && child != null) {
result[name] = child;
}
}
/**
* Flattens children that are typically specified as `props.children`. Any null
* children will not be included in the resulting object.
* @return {!object} flattened children keyed by name.
*/
function flattenChildren(children) {
if (children == null) {
return children;
}
var result = {};
traverseAllChildren(children, flattenSingleChildIntoContext, result);
return result;
}
module.exports = flattenChildren;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 117 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule shallowEqual
* @typechecks
*
*/
'use strict';
var hasOwnProperty = Object.prototype.hasOwnProperty;
/**
* Performs equality by iterating through keys on an object and returning false
* when any key has values which are not strictly equal between the arguments.
* Returns true when the values of all keys are strictly equal.
*/
function shallowEqual(objA, objB) {
if (objA === objB) {
return true;
}
if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
return false;
}
var keysA = Object.keys(objA);
var keysB = Object.keys(objB);
if (keysA.length !== keysB.length) {
return false;
}
// Test for A's keys different from B.
var bHasOwnProperty = hasOwnProperty.bind(objB);
for (var i = 0; i < keysA.length; i++) {
if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
return false;
}
}
return true;
}
module.exports = shallowEqual;
/***/ },
/* 118 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactEventListener
* @typechecks static-only
*/
'use strict';
var EventListener = __webpack_require__(119);
var ExecutionEnvironment = __webpack_require__(9);
var PooledClass = __webpack_require__(56);
var ReactInstanceHandles = __webpack_require__(45);
var ReactMount = __webpack_require__(28);
var ReactUpdates = __webpack_require__(54);
var assign = __webpack_require__(39);
var getEventTarget = __webpack_require__(81);
var getUnboundedScrollPosition = __webpack_require__(120);
var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
/**
* Finds the parent React component of `node`.
*
* @param {*} node
* @return {?DOMEventTarget} Parent container, or `null` if the specified node
* is not nested.
*/
function findParent(node) {
// TODO: It may be a good idea to cache this to prevent unnecessary DOM
// traversal, but caching is difficult to do correctly without using a
// mutation observer to listen for all DOM changes.
var nodeID = ReactMount.getID(node);
var rootID = ReactInstanceHandles.getReactRootIDFromNodeID(nodeID);
var container = ReactMount.findReactContainerForID(rootID);
var parent = ReactMount.getFirstReactDOM(container);
return parent;
}
// Used to store ancestor hierarchy in top level callback
function TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {
this.topLevelType = topLevelType;
this.nativeEvent = nativeEvent;
this.ancestors = [];
}
assign(TopLevelCallbackBookKeeping.prototype, {
destructor: function () {
this.topLevelType = null;
this.nativeEvent = null;
this.ancestors.length = 0;
}
});
PooledClass.addPoolingTo(TopLevelCallbackBookKeeping, PooledClass.twoArgumentPooler);
function handleTopLevelImpl(bookKeeping) {
// TODO: Re-enable event.path handling
//
// if (bookKeeping.nativeEvent.path && bookKeeping.nativeEvent.path.length > 1) {
// // New browsers have a path attribute on native events
// handleTopLevelWithPath(bookKeeping);
// } else {
// // Legacy browsers don't have a path attribute on native events
// handleTopLevelWithoutPath(bookKeeping);
// }
void handleTopLevelWithPath; // temporarily unused
handleTopLevelWithoutPath(bookKeeping);
}
// Legacy browsers don't have a path attribute on native events
function handleTopLevelWithoutPath(bookKeeping) {
var topLevelTarget = ReactMount.getFirstReactDOM(getEventTarget(bookKeeping.nativeEvent)) || window;
// Loop through the hierarchy, in case there's any nested components.
// It's important that we build the array of ancestors before calling any
// event handlers, because event handlers can modify the DOM, leading to
// inconsistencies with ReactMount's node cache. See #1105.
var ancestor = topLevelTarget;
while (ancestor) {
bookKeeping.ancestors.push(ancestor);
ancestor = findParent(ancestor);
}
for (var i = 0; i < bookKeeping.ancestors.length; i++) {
topLevelTarget = bookKeeping.ancestors[i];
var topLevelTargetID = ReactMount.getID(topLevelTarget) || '';
ReactEventListener._handleTopLevel(bookKeeping.topLevelType, topLevelTarget, topLevelTargetID, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent));
}
}
// New browsers have a path attribute on native events
function handleTopLevelWithPath(bookKeeping) {
var path = bookKeeping.nativeEvent.path;
var currentNativeTarget = path[0];
var eventsFired = 0;
for (var i = 0; i < path.length; i++) {
var currentPathElement = path[i];
if (currentPathElement.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE) {
currentNativeTarget = path[i + 1];
}
// TODO: slow
var reactParent = ReactMount.getFirstReactDOM(currentPathElement);
if (reactParent === currentPathElement) {
var currentPathElementID = ReactMount.getID(currentPathElement);
var newRootID = ReactInstanceHandles.getReactRootIDFromNodeID(currentPathElementID);
bookKeeping.ancestors.push(currentPathElement);
var topLevelTargetID = ReactMount.getID(currentPathElement) || '';
eventsFired++;
ReactEventListener._handleTopLevel(bookKeeping.topLevelType, currentPathElement, topLevelTargetID, bookKeeping.nativeEvent, currentNativeTarget);
// Jump to the root of this React render tree
while (currentPathElementID !== newRootID) {
i++;
currentPathElement = path[i];
currentPathElementID = ReactMount.getID(currentPathElement);
}
}
}
if (eventsFired === 0) {
ReactEventListener._handleTopLevel(bookKeeping.topLevelType, window, '', bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent));
}
}
function scrollValueMonitor(cb) {
var scrollPosition = getUnboundedScrollPosition(window);
cb(scrollPosition);
}
var ReactEventListener = {
_enabled: true,
_handleTopLevel: null,
WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null,
setHandleTopLevel: function (handleTopLevel) {
ReactEventListener._handleTopLevel = handleTopLevel;
},
setEnabled: function (enabled) {
ReactEventListener._enabled = !!enabled;
},
isEnabled: function () {
return ReactEventListener._enabled;
},
/**
* Traps top-level events by using event bubbling.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {string} handlerBaseName Event name (e.g. "click").
* @param {object} handle Element on which to attach listener.
* @return {?object} An object with a remove function which will forcefully
* remove the listener.
* @internal
*/
trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
var element = handle;
if (!element) {
return null;
}
return EventListener.listen(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));
},
/**
* Traps a top-level event by using event capturing.
*
* @param {string} topLevelType Record from `EventConstants`.
* @param {string} handlerBaseName Event name (e.g. "click").
* @param {object} handle Element on which to attach listener.
* @return {?object} An object with a remove function which will forcefully
* remove the listener.
* @internal
*/
trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
var element = handle;
if (!element) {
return null;
}
return EventListener.capture(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));
},
monitorScrollValue: function (refresh) {
var callback = scrollValueMonitor.bind(null, refresh);
EventListener.listen(window, 'scroll', callback);
},
dispatchEvent: function (topLevelType, nativeEvent) {
if (!ReactEventListener._enabled) {
return;
}
var bookKeeping = TopLevelCallbackBookKeeping.getPooled(topLevelType, nativeEvent);
try {
// Event queue being processed in the same cycle allows
// `preventDefault`.
ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping);
} finally {
TopLevelCallbackBookKeeping.release(bookKeeping);
}
}
};
module.exports = ReactEventListener;
/***/ },
/* 119 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
*
* 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.
*
* @providesModule EventListener
* @typechecks
*/
'use strict';
var emptyFunction = __webpack_require__(15);
/**
* Upstream version of event listener. Does not take into account specific
* nature of platform.
*/
var EventListener = {
/**
* Listen to DOM events during the bubble phase.
*
* @param {DOMEventTarget} target DOM element to register listener on.
* @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
* @param {function} callback Callback function.
* @return {object} Object with a `remove` method.
*/
listen: function (target, eventType, callback) {
if (target.addEventListener) {
target.addEventListener(eventType, callback, false);
return {
remove: function () {
target.removeEventListener(eventType, callback, false);
}
};
} else if (target.attachEvent) {
target.attachEvent('on' + eventType, callback);
return {
remove: function () {
target.detachEvent('on' + eventType, callback);
}
};
}
},
/**
* Listen to DOM events during the capture phase.
*
* @param {DOMEventTarget} target DOM element to register listener on.
* @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
* @param {function} callback Callback function.
* @return {object} Object with a `remove` method.
*/
capture: function (target, eventType, callback) {
if (target.addEventListener) {
target.addEventListener(eventType, callback, true);
return {
remove: function () {
target.removeEventListener(eventType, callback, true);
}
};
} else {
if (process.env.NODE_ENV !== 'production') {
console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.');
}
return {
remove: emptyFunction
};
}
},
registerDefault: function () {}
};
module.exports = EventListener;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 120 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getUnboundedScrollPosition
* @typechecks
*/
'use strict';
/**
* Gets the scroll position of the supplied element or window.
*
* The return values are unbounded, unlike `getScrollPosition`. This means they
* may be negative or exceed the element boundaries (which is possible using
* inertial scrolling).
*
* @param {DOMWindow|DOMElement} scrollable
* @return {object} Map with `x` and `y` keys.
*/
function getUnboundedScrollPosition(scrollable) {
if (scrollable === window) {
return {
x: window.pageXOffset || document.documentElement.scrollLeft,
y: window.pageYOffset || document.documentElement.scrollTop
};
}
return {
x: scrollable.scrollLeft,
y: scrollable.scrollTop
};
}
module.exports = getUnboundedScrollPosition;
/***/ },
/* 121 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactInjection
*/
'use strict';
var DOMProperty = __webpack_require__(23);
var EventPluginHub = __webpack_require__(31);
var ReactComponentEnvironment = __webpack_require__(64);
var ReactClass = __webpack_require__(122);
var ReactEmptyComponent = __webpack_require__(68);
var ReactBrowserEventEmitter = __webpack_require__(29);
var ReactNativeComponent = __webpack_require__(69);
var ReactPerf = __webpack_require__(18);
var ReactRootIndex = __webpack_require__(46);
var ReactUpdates = __webpack_require__(54);
var ReactInjection = {
Component: ReactComponentEnvironment.injection,
Class: ReactClass.injection,
DOMProperty: DOMProperty.injection,
EmptyComponent: ReactEmptyComponent.injection,
EventPluginHub: EventPluginHub.injection,
EventEmitter: ReactBrowserEventEmitter.injection,
NativeComponent: ReactNativeComponent.injection,
Perf: ReactPerf.injection,
RootIndex: ReactRootIndex.injection,
Updates: ReactUpdates.injection
};
module.exports = ReactInjection;
/***/ },
/* 122 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactClass
*/
'use strict';
var ReactComponent = __webpack_require__(123);
var ReactElement = __webpack_require__(42);
var ReactPropTypeLocations = __webpack_require__(65);
var ReactPropTypeLocationNames = __webpack_require__(66);
var ReactNoopUpdateQueue = __webpack_require__(124);
var assign = __webpack_require__(39);
var emptyObject = __webpack_require__(58);
var invariant = __webpack_require__(13);
var keyMirror = __webpack_require__(17);
var keyOf = __webpack_require__(79);
var warning = __webpack_require__(25);
var MIXINS_KEY = keyOf({ mixins: null });
/**
* Policies that describe methods in `ReactClassInterface`.
*/
var SpecPolicy = keyMirror({
/**
* These methods may be defined only once by the class specification or mixin.
*/
DEFINE_ONCE: null,
/**
* These methods may be defined by both the class specification and mixins.
* Subsequent definitions will be chained. These methods must return void.
*/
DEFINE_MANY: null,
/**
* These methods are overriding the base class.
*/
OVERRIDE_BASE: null,
/**
* These methods are similar to DEFINE_MANY, except we assume they return
* objects. We try to merge the keys of the return values of all the mixed in
* functions. If there is a key conflict we throw.
*/
DEFINE_MANY_MERGED: null
});
var injectedMixins = [];
var warnedSetProps = false;
function warnSetProps() {
if (!warnedSetProps) {
warnedSetProps = true;
process.env.NODE_ENV !== 'production' ? warning(false, 'setProps(...) and replaceProps(...) are deprecated. ' + 'Instead, call render again at the top level.') : undefined;
}
}
/**
* Composite components are higher-level components that compose other composite
* or native components.
*
* To create a new type of `ReactClass`, pass a specification of
* your new class to `React.createClass`. The only requirement of your class
* specification is that you implement a `render` method.
*
* var MyComponent = React.createClass({
* render: function() {
* return <div>Hello World</div>;
* }
* });
*
* The class specification supports a specific protocol of methods that have
* special meaning (e.g. `render`). See `ReactClassInterface` for
* more the comprehensive protocol. Any other properties and methods in the
* class specification will be available on the prototype.
*
* @interface ReactClassInterface
* @internal
*/
var ReactClassInterface = {
/**
* An array of Mixin objects to include when defining your component.
*
* @type {array}
* @optional
*/
mixins: SpecPolicy.DEFINE_MANY,
/**
* An object containing properties and methods that should be defined on
* the component's constructor instead of its prototype (static methods).
*
* @type {object}
* @optional
*/
statics: SpecPolicy.DEFINE_MANY,
/**
* Definition of prop types for this component.
*
* @type {object}
* @optional
*/
propTypes: SpecPolicy.DEFINE_MANY,
/**
* Definition of context types for this component.
*
* @type {object}
* @optional
*/
contextTypes: SpecPolicy.DEFINE_MANY,
/**
* Definition of context types this component sets for its children.
*
* @type {object}
* @optional
*/
childContextTypes: SpecPolicy.DEFINE_MANY,
// ==== Definition methods ====
/**
* Invoked when the component is mounted. Values in the mapping will be set on
* `this.props` if that prop is not specified (i.e. using an `in` check).
*
* This method is invoked before `getInitialState` and therefore cannot rely
* on `this.state` or use `this.setState`.
*
* @return {object}
* @optional
*/
getDefaultProps: SpecPolicy.DEFINE_MANY_MERGED,
/**
* Invoked once before the component is mounted. The return value will be used
* as the initial value of `this.state`.
*
* getInitialState: function() {
* return {
* isOn: false,
* fooBaz: new BazFoo()
* }
* }
*
* @return {object}
* @optional
*/
getInitialState: SpecPolicy.DEFINE_MANY_MERGED,
/**
* @return {object}
* @optional
*/
getChildContext: SpecPolicy.DEFINE_MANY_MERGED,
/**
* Uses props from `this.props` and state from `this.state` to render the
* structure of the component.
*
* No guarantees are made about when or how often this method is invoked, so
* it must not have side effects.
*
* render: function() {
* var name = this.props.name;
* return <div>Hello, {name}!</div>;
* }
*
* @return {ReactComponent}
* @nosideeffects
* @required
*/
render: SpecPolicy.DEFINE_ONCE,
// ==== Delegate methods ====
/**
* Invoked when the component is initially created and about to be mounted.
* This may have side effects, but any external subscriptions or data created
* by this method must be cleaned up in `componentWillUnmount`.
*
* @optional
*/
componentWillMount: SpecPolicy.DEFINE_MANY,
/**
* Invoked when the component has been mounted and has a DOM representation.
* However, there is no guarantee that the DOM node is in the document.
*
* Use this as an opportunity to operate on the DOM when the component has
* been mounted (initialized and rendered) for the first time.
*
* @param {DOMElement} rootNode DOM element representing the component.
* @optional
*/
componentDidMount: SpecPolicy.DEFINE_MANY,
/**
* Invoked before the component receives new props.
*
* Use this as an opportunity to react to a prop transition by updating the
* state using `this.setState`. Current props are accessed via `this.props`.
*
* componentWillReceiveProps: function(nextProps, nextContext) {
* this.setState({
* likesIncreasing: nextProps.likeCount > this.props.likeCount
* });
* }
*
* NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop
* transition may cause a state change, but the opposite is not true. If you
* need it, you are probably looking for `componentWillUpdate`.
*
* @param {object} nextProps
* @optional
*/
componentWillReceiveProps: SpecPolicy.DEFINE_MANY,
/**
* Invoked while deciding if the component should be updated as a result of
* receiving new props, state and/or context.
*
* Use this as an opportunity to `return false` when you're certain that the
* transition to the new props/state/context will not require a component
* update.
*
* shouldComponentUpdate: function(nextProps, nextState, nextContext) {
* return !equal(nextProps, this.props) ||
* !equal(nextState, this.state) ||
* !equal(nextContext, this.context);
* }
*
* @param {object} nextProps
* @param {?object} nextState
* @param {?object} nextContext
* @return {boolean} True if the component should update.
* @optional
*/
shouldComponentUpdate: SpecPolicy.DEFINE_ONCE,
/**
* Invoked when the component is about to update due to a transition from
* `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
* and `nextContext`.
*
* Use this as an opportunity to perform preparation before an update occurs.
*
* NOTE: You **cannot** use `this.setState()` in this method.
*
* @param {object} nextProps
* @param {?object} nextState
* @param {?object} nextContext
* @param {ReactReconcileTransaction} transaction
* @optional
*/
componentWillUpdate: SpecPolicy.DEFINE_MANY,
/**
* Invoked when the component's DOM representation has been updated.
*
* Use this as an opportunity to operate on the DOM when the component has
* been updated.
*
* @param {object} prevProps
* @param {?object} prevState
* @param {?object} prevContext
* @param {DOMElement} rootNode DOM element representing the component.
* @optional
*/
componentDidUpdate: SpecPolicy.DEFINE_MANY,
/**
* Invoked when the component is about to be removed from its parent and have
* its DOM representation destroyed.
*
* Use this as an opportunity to deallocate any external resources.
*
* NOTE: There is no `componentDidUnmount` since your component will have been
* destroyed by that point.
*
* @optional
*/
componentWillUnmount: SpecPolicy.DEFINE_MANY,
// ==== Advanced methods ====
/**
* Updates the component's currently mounted DOM representation.
*
* By default, this implements React's rendering and reconciliation algorithm.
* Sophisticated clients may wish to override this.
*
* @param {ReactReconcileTransaction} transaction
* @internal
* @overridable
*/
updateComponent: SpecPolicy.OVERRIDE_BASE
};
/**
* Mapping from class specification keys to special processing functions.
*
* Although these are declared like instance properties in the specification
* when defining classes using `React.createClass`, they are actually static
* and are accessible on the constructor instead of the prototype. Despite
* being static, they must be defined outside of the "statics" key under
* which all other static methods are defined.
*/
var RESERVED_SPEC_KEYS = {
displayName: function (Constructor, displayName) {
Constructor.displayName = displayName;
},
mixins: function (Constructor, mixins) {
if (mixins) {
for (var i = 0; i < mixins.length; i++) {
mixSpecIntoComponent(Constructor, mixins[i]);
}
}
},
childContextTypes: function (Constructor, childContextTypes) {
if (process.env.NODE_ENV !== 'production') {
validateTypeDef(Constructor, childContextTypes, ReactPropTypeLocations.childContext);
}
Constructor.childContextTypes = assign({}, Constructor.childContextTypes, childContextTypes);
},
contextTypes: function (Constructor, contextTypes) {
if (process.env.NODE_ENV !== 'production') {
validateTypeDef(Constructor, contextTypes, ReactPropTypeLocations.context);
}
Constructor.contextTypes = assign({}, Constructor.contextTypes, contextTypes);
},
/**
* Special case getDefaultProps which should move into statics but requires
* automatic merging.
*/
getDefaultProps: function (Constructor, getDefaultProps) {
if (Constructor.getDefaultProps) {
Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
} else {
Constructor.getDefaultProps = getDefaultProps;
}
},
propTypes: function (Constructor, propTypes) {
if (process.env.NODE_ENV !== 'production') {
validateTypeDef(Constructor, propTypes, ReactPropTypeLocations.prop);
}
Constructor.propTypes = assign({}, Constructor.propTypes, propTypes);
},
statics: function (Constructor, statics) {
mixStaticSpecIntoComponent(Constructor, statics);
},
autobind: function () {} };
// noop
function validateTypeDef(Constructor, typeDef, location) {
for (var propName in typeDef) {
if (typeDef.hasOwnProperty(propName)) {
// use a warning instead of an invariant so components
// don't show up in prod but not in __DEV__
process.env.NODE_ENV !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : undefined;
}
}
}
function validateMethodOverride(proto, name) {
var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
// Disallow overriding of base class methods unless explicitly allowed.
if (ReactClassMixin.hasOwnProperty(name)) {
!(specPolicy === SpecPolicy.OVERRIDE_BASE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override ' + '`%s` from your class specification. Ensure that your method names ' + 'do not overlap with React methods.', name) : invariant(false) : undefined;
}
// Disallow defining methods more than once unless explicitly allowed.
if (proto.hasOwnProperty(name)) {
!(specPolicy === SpecPolicy.DEFINE_MANY || specPolicy === SpecPolicy.DEFINE_MANY_MERGED) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define ' + '`%s` on your component more than once. This conflict may be due ' + 'to a mixin.', name) : invariant(false) : undefined;
}
}
/**
* Mixin helper which handles policy validation and reserved
* specification keys when building React classses.
*/
function mixSpecIntoComponent(Constructor, spec) {
if (!spec) {
return;
}
!(typeof spec !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to ' + 'use a component class as a mixin. Instead, just use a regular object.') : invariant(false) : undefined;
!!ReactElement.isValidElement(spec) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to ' + 'use a component as a mixin. Instead, just use a regular object.') : invariant(false) : undefined;
var proto = Constructor.prototype;
// By handling mixins before any other properties, we ensure the same
// chaining order is applied to methods with DEFINE_MANY policy, whether
// mixins are listed before or after these methods in the spec.
if (spec.hasOwnProperty(MIXINS_KEY)) {
RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
}
for (var name in spec) {
if (!spec.hasOwnProperty(name)) {
continue;
}
if (name === MIXINS_KEY) {
// We have already handled mixins in a special case above.
continue;
}
var property = spec[name];
validateMethodOverride(proto, name);
if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
RESERVED_SPEC_KEYS[name](Constructor, property);
} else {
// Setup methods on prototype:
// The following member methods should not be automatically bound:
// 1. Expected ReactClass methods (in the "interface").
// 2. Overridden methods (that were mixed in).
var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
var isAlreadyDefined = proto.hasOwnProperty(name);
var isFunction = typeof property === 'function';
var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
if (shouldAutoBind) {
if (!proto.__reactAutoBindMap) {
proto.__reactAutoBindMap = {};
}
proto.__reactAutoBindMap[name] = property;
proto[name] = property;
} else {
if (isAlreadyDefined) {
var specPolicy = ReactClassInterface[name];
// These cases should already be caught by validateMethodOverride.
!(isReactClassMethod && (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s ' + 'when mixing in component specs.', specPolicy, name) : invariant(false) : undefined;
// For methods which are defined more than once, call the existing
// methods before calling the new property, merging if appropriate.
if (specPolicy === SpecPolicy.DEFINE_MANY_MERGED) {
proto[name] = createMergedResultFunction(proto[name], property);
} else if (specPolicy === SpecPolicy.DEFINE_MANY) {
proto[name] = createChainedFunction(proto[name], property);
}
} else {
proto[name] = property;
if (process.env.NODE_ENV !== 'production') {
// Add verbose displayName to the function, which helps when looking
// at profiling tools.
if (typeof property === 'function' && spec.displayName) {
proto[name].displayName = spec.displayName + '_' + name;
}
}
}
}
}
}
}
function mixStaticSpecIntoComponent(Constructor, statics) {
if (!statics) {
return;
}
for (var name in statics) {
var property = statics[name];
if (!statics.hasOwnProperty(name)) {
continue;
}
var isReserved = (name in RESERVED_SPEC_KEYS);
!!isReserved ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved ' + 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + 'as an instance property instead; it will still be accessible on the ' + 'constructor.', name) : invariant(false) : undefined;
var isInherited = (name in Constructor);
!!isInherited ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define ' + '`%s` on your component more than once. This conflict may be ' + 'due to a mixin.', name) : invariant(false) : undefined;
Constructor[name] = property;
}
}
/**
* Merge two objects, but throw if both contain the same key.
*
* @param {object} one The first object, which is mutated.
* @param {object} two The second object
* @return {object} one after it has been mutated to contain everything in two.
*/
function mergeIntoWithNoDuplicateKeys(one, two) {
!(one && two && typeof one === 'object' && typeof two === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : invariant(false) : undefined;
for (var key in two) {
if (two.hasOwnProperty(key)) {
!(one[key] === undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): ' + 'Tried to merge two objects with the same key: `%s`. This conflict ' + 'may be due to a mixin; in particular, this may be caused by two ' + 'getInitialState() or getDefaultProps() methods returning objects ' + 'with clashing keys.', key) : invariant(false) : undefined;
one[key] = two[key];
}
}
return one;
}
/**
* Creates a function that invokes two functions and merges their return values.
*
* @param {function} one Function to invoke first.
* @param {function} two Function to invoke second.
* @return {function} Function that invokes the two argument functions.
* @private
*/
function createMergedResultFunction(one, two) {
return function mergedResult() {
var a = one.apply(this, arguments);
var b = two.apply(this, arguments);
if (a == null) {
return b;
} else if (b == null) {
return a;
}
var c = {};
mergeIntoWithNoDuplicateKeys(c, a);
mergeIntoWithNoDuplicateKeys(c, b);
return c;
};
}
/**
* Creates a function that invokes two functions and ignores their return vales.
*
* @param {function} one Function to invoke first.
* @param {function} two Function to invoke second.
* @return {function} Function that invokes the two argument functions.
* @private
*/
function createChainedFunction(one, two) {
return function chainedFunction() {
one.apply(this, arguments);
two.apply(this, arguments);
};
}
/**
* Binds a method to the component.
*
* @param {object} component Component whose method is going to be bound.
* @param {function} method Method to be bound.
* @return {function} The bound method.
*/
function bindAutoBindMethod(component, method) {
var boundMethod = method.bind(component);
if (process.env.NODE_ENV !== 'production') {
boundMethod.__reactBoundContext = component;
boundMethod.__reactBoundMethod = method;
boundMethod.__reactBoundArguments = null;
var componentName = component.constructor.displayName;
var _bind = boundMethod.bind;
/* eslint-disable block-scoped-var, no-undef */
boundMethod.bind = function (newThis) {
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
// User is trying to bind() an autobound method; we effectively will
// ignore the value of "this" that the user is trying to use, so
// let's warn.
if (newThis !== component && newThis !== null) {
process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : undefined;
} else if (!args.length) {
process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : undefined;
return boundMethod;
}
var reboundMethod = _bind.apply(boundMethod, arguments);
reboundMethod.__reactBoundContext = component;
reboundMethod.__reactBoundMethod = method;
reboundMethod.__reactBoundArguments = args;
return reboundMethod;
/* eslint-enable */
};
}
return boundMethod;
}
/**
* Binds all auto-bound methods in a component.
*
* @param {object} component Component whose method is going to be bound.
*/
function bindAutoBindMethods(component) {
for (var autoBindKey in component.__reactAutoBindMap) {
if (component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {
var method = component.__reactAutoBindMap[autoBindKey];
component[autoBindKey] = bindAutoBindMethod(component, method);
}
}
}
/**
* Add more to the ReactClass base class. These are all legacy features and
* therefore not already part of the modern ReactComponent.
*/
var ReactClassMixin = {
/**
* TODO: This will be deprecated because state should always keep a consistent
* type signature and the only use case for this, is to avoid that.
*/
replaceState: function (newState, callback) {
this.updater.enqueueReplaceState(this, newState);
if (callback) {
this.updater.enqueueCallback(this, callback);
}
},
/**
* Checks whether or not this composite component is mounted.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/
isMounted: function () {
return this.updater.isMounted(this);
},
/**
* Sets a subset of the props.
*
* @param {object} partialProps Subset of the next props.
* @param {?function} callback Called after props are updated.
* @final
* @public
* @deprecated
*/
setProps: function (partialProps, callback) {
if (process.env.NODE_ENV !== 'production') {
warnSetProps();
}
this.updater.enqueueSetProps(this, partialProps);
if (callback) {
this.updater.enqueueCallback(this, callback);
}
},
/**
* Replace all the props.
*
* @param {object} newProps Subset of the next props.
* @param {?function} callback Called after props are updated.
* @final
* @public
* @deprecated
*/
replaceProps: function (newProps, callback) {
if (process.env.NODE_ENV !== 'production') {
warnSetProps();
}
this.updater.enqueueReplaceProps(this, newProps);
if (callback) {
this.updater.enqueueCallback(this, callback);
}
}
};
var ReactClassComponent = function () {};
assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
/**
* Module for creating composite components.
*
* @class ReactClass
*/
var ReactClass = {
/**
* Creates a composite component class given a class specification.
*
* @param {object} spec Class specification (which must define `render`).
* @return {function} Component constructor function.
* @public
*/
createClass: function (spec) {
var Constructor = function (props, context, updater) {
// This constructor is overridden by mocks. The argument is used
// by mocks to assert on what gets mounted.
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : undefined;
}
// Wire up auto-binding
if (this.__reactAutoBindMap) {
bindAutoBindMethods(this);
}
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
this.state = null;
// ReactClasses doesn't have constructors. Instead, they use the
// getInitialState and componentWillMount methods for initialization.
var initialState = this.getInitialState ? this.getInitialState() : null;
if (process.env.NODE_ENV !== 'production') {
// We allow auto-mocks to proceed as if they're returning null.
if (typeof initialState === 'undefined' && this.getInitialState._isMockFunction) {
// This is probably bad practice. Consider warning here and
// deprecating this convenience.
initialState = null;
}
}
!(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : invariant(false) : undefined;
this.state = initialState;
};
Constructor.prototype = new ReactClassComponent();
Constructor.prototype.constructor = Constructor;
injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
mixSpecIntoComponent(Constructor, spec);
// Initialize the defaultProps property after all mixins have been merged.
if (Constructor.getDefaultProps) {
Constructor.defaultProps = Constructor.getDefaultProps();
}
if (process.env.NODE_ENV !== 'production') {
// This is a tag to indicate that the use of these method names is ok,
// since it's used with createClass. If it's not, then it's likely a
// mistake so we'll warn you to use the static property, property
// initializer or constructor respectively.
if (Constructor.getDefaultProps) {
Constructor.getDefaultProps.isReactClassApproved = {};
}
if (Constructor.prototype.getInitialState) {
Constructor.prototype.getInitialState.isReactClassApproved = {};
}
}
!Constructor.prototype.render ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : invariant(false) : undefined;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : undefined;
process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : undefined;
}
// Reduce time spent doing lookups by setting these on the prototype.
for (var methodName in ReactClassInterface) {
if (!Constructor.prototype[methodName]) {
Constructor.prototype[methodName] = null;
}
}
return Constructor;
},
injection: {
injectMixin: function (mixin) {
injectedMixins.push(mixin);
}
}
};
module.exports = ReactClass;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 123 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactComponent
*/
'use strict';
var ReactNoopUpdateQueue = __webpack_require__(124);
var canDefineProperty = __webpack_require__(43);
var emptyObject = __webpack_require__(58);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
/**
* Base class helpers for the updating state of a component.
*/
function ReactComponent(props, context, updater) {
this.props = props;
this.context = context;
this.refs = emptyObject;
// We initialize the default updater but the real one gets injected by the
// renderer.
this.updater = updater || ReactNoopUpdateQueue;
}
ReactComponent.prototype.isReactComponent = {};
/**
* Sets a subset of the state. Always use this to mutate
* state. You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* There is no guarantee that calls to `setState` will run synchronously,
* as they may eventually be batched together. You can provide an optional
* callback that will be executed when the call to setState is actually
* completed.
*
* When a function is provided to setState, it will be called at some point in
* the future (not synchronously). It will be called with the up to date
* component arguments (state, props, context). These values can be different
* from this.* because your function may be called after receiveProps but before
* shouldComponentUpdate, and this new state, props, and context will not yet be
* assigned to this.
*
* @param {object|function} partialState Next partial state or function to
* produce next partial state to be merged with current state.
* @param {?function} callback Called after state is updated.
* @final
* @protected
*/
ReactComponent.prototype.setState = function (partialState, callback) {
!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.') : invariant(false) : undefined;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(partialState != null, 'setState(...): You passed an undefined or null state object; ' + 'instead, use forceUpdate().') : undefined;
}
this.updater.enqueueSetState(this, partialState);
if (callback) {
this.updater.enqueueCallback(this, callback);
}
};
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {?function} callback Called after update is complete.
* @final
* @protected
*/
ReactComponent.prototype.forceUpdate = function (callback) {
this.updater.enqueueForceUpdate(this);
if (callback) {
this.updater.enqueueCallback(this, callback);
}
};
/**
* Deprecated APIs. These APIs used to exist on classic React classes but since
* we would like to deprecate them, we're not going to move them over to this
* modern base class. Instead, we define a getter that warns if it's accessed.
*/
if (process.env.NODE_ENV !== 'production') {
var deprecatedAPIs = {
getDOMNode: ['getDOMNode', 'Use ReactDOM.findDOMNode(component) instead.'],
isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
replaceProps: ['replaceProps', 'Instead, call render again at the top level.'],
replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'],
setProps: ['setProps', 'Instead, call render again at the top level.']
};
var defineDeprecationWarning = function (methodName, info) {
if (canDefineProperty) {
Object.defineProperty(ReactComponent.prototype, methodName, {
get: function () {
process.env.NODE_ENV !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : undefined;
return undefined;
}
});
}
};
for (var fnName in deprecatedAPIs) {
if (deprecatedAPIs.hasOwnProperty(fnName)) {
defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
}
}
}
module.exports = ReactComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 124 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactNoopUpdateQueue
*/
'use strict';
var warning = __webpack_require__(25);
function warnTDZ(publicInstance, callerName) {
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, publicInstance.constructor && publicInstance.constructor.displayName || '') : undefined;
}
}
/**
* This is the abstract API for an update queue.
*/
var ReactNoopUpdateQueue = {
/**
* Checks whether or not this composite component is mounted.
* @param {ReactClass} publicInstance The instance we want to test.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/
isMounted: function (publicInstance) {
return false;
},
/**
* Enqueue a callback that will be executed after all the pending updates
* have processed.
*
* @param {ReactClass} publicInstance The instance to use as `this` context.
* @param {?function} callback Called after state is updated.
* @internal
*/
enqueueCallback: function (publicInstance, callback) {},
/**
* Forces an update. This should only be invoked when it is known with
* certainty that we are **not** in a DOM transaction.
*
* You may want to call this when you know that some deeper aspect of the
* component's state has changed but `setState` was not called.
*
* This will not invoke `shouldComponentUpdate`, but it will invoke
* `componentWillUpdate` and `componentDidUpdate`.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @internal
*/
enqueueForceUpdate: function (publicInstance) {
warnTDZ(publicInstance, 'forceUpdate');
},
/**
* Replaces all of the state. Always use this or `setState` to mutate state.
* You should treat `this.state` as immutable.
*
* There is no guarantee that `this.state` will be immediately updated, so
* accessing `this.state` after calling this method may return the old value.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} completeState Next state.
* @internal
*/
enqueueReplaceState: function (publicInstance, completeState) {
warnTDZ(publicInstance, 'replaceState');
},
/**
* Sets a subset of the state. This only exists because _pendingState is
* internal. This provides a merging strategy that is not available to deep
* properties which is confusing. TODO: Expose pendingState or don't use it
* during the merge.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialState Next partial state to be merged with state.
* @internal
*/
enqueueSetState: function (publicInstance, partialState) {
warnTDZ(publicInstance, 'setState');
},
/**
* Sets a subset of the props.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} partialProps Subset of the next props.
* @internal
*/
enqueueSetProps: function (publicInstance, partialProps) {
warnTDZ(publicInstance, 'setProps');
},
/**
* Replaces all of the props.
*
* @param {ReactClass} publicInstance The instance that should rerender.
* @param {object} props New props.
* @internal
*/
enqueueReplaceProps: function (publicInstance, props) {
warnTDZ(publicInstance, 'replaceProps');
}
};
module.exports = ReactNoopUpdateQueue;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 125 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactReconcileTransaction
* @typechecks static-only
*/
'use strict';
var CallbackQueue = __webpack_require__(55);
var PooledClass = __webpack_require__(56);
var ReactBrowserEventEmitter = __webpack_require__(29);
var ReactDOMFeatureFlags = __webpack_require__(41);
var ReactInputSelection = __webpack_require__(126);
var Transaction = __webpack_require__(57);
var assign = __webpack_require__(39);
/**
* Ensures that, when possible, the selection range (currently selected text
* input) is not disturbed by performing the transaction.
*/
var SELECTION_RESTORATION = {
/**
* @return {Selection} Selection information.
*/
initialize: ReactInputSelection.getSelectionInformation,
/**
* @param {Selection} sel Selection information returned from `initialize`.
*/
close: ReactInputSelection.restoreSelection
};
/**
* Suppresses events (blur/focus) that could be inadvertently dispatched due to
* high level DOM manipulations (like temporarily removing a text input from the
* DOM).
*/
var EVENT_SUPPRESSION = {
/**
* @return {boolean} The enabled status of `ReactBrowserEventEmitter` before
* the reconciliation.
*/
initialize: function () {
var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();
ReactBrowserEventEmitter.setEnabled(false);
return currentlyEnabled;
},
/**
* @param {boolean} previouslyEnabled Enabled status of
* `ReactBrowserEventEmitter` before the reconciliation occurred. `close`
* restores the previous value.
*/
close: function (previouslyEnabled) {
ReactBrowserEventEmitter.setEnabled(previouslyEnabled);
}
};
/**
* Provides a queue for collecting `componentDidMount` and
* `componentDidUpdate` callbacks during the the transaction.
*/
var ON_DOM_READY_QUEUEING = {
/**
* Initializes the internal `onDOMReady` queue.
*/
initialize: function () {
this.reactMountReady.reset();
},
/**
* After DOM is flushed, invoke all registered `onDOMReady` callbacks.
*/
close: function () {
this.reactMountReady.notifyAll();
}
};
/**
* Executed within the scope of the `Transaction` instance. Consider these as
* being member methods, but with an implied ordering while being isolated from
* each other.
*/
var TRANSACTION_WRAPPERS = [SELECTION_RESTORATION, EVENT_SUPPRESSION, ON_DOM_READY_QUEUEING];
/**
* Currently:
* - The order that these are listed in the transaction is critical:
* - Suppresses events.
* - Restores selection range.
*
* Future:
* - Restore document/overflow scroll positions that were unintentionally
* modified via DOM insertions above the top viewport boundary.
* - Implement/integrate with customized constraint based layout system and keep
* track of which dimensions must be remeasured.
*
* @class ReactReconcileTransaction
*/
function ReactReconcileTransaction(forceHTML) {
this.reinitializeTransaction();
// Only server-side rendering really needs this option (see
// `ReactServerRendering`), but server-side uses
// `ReactServerRenderingTransaction` instead. This option is here so that it's
// accessible and defaults to false when `ReactDOMComponent` and
// `ReactTextComponent` checks it in `mountComponent`.`
this.renderToStaticMarkup = false;
this.reactMountReady = CallbackQueue.getPooled(null);
this.useCreateElement = !forceHTML && ReactDOMFeatureFlags.useCreateElement;
}
var Mixin = {
/**
* @see Transaction
* @abstract
* @final
* @return {array<object>} List of operation wrap procedures.
* TODO: convert to array<TransactionWrapper>
*/
getTransactionWrappers: function () {
return TRANSACTION_WRAPPERS;
},
/**
* @return {object} The queue to collect `onDOMReady` callbacks with.
*/
getReactMountReady: function () {
return this.reactMountReady;
},
/**
* `PooledClass` looks for this, and will invoke this before allowing this
* instance to be reused.
*/
destructor: function () {
CallbackQueue.release(this.reactMountReady);
this.reactMountReady = null;
}
};
assign(ReactReconcileTransaction.prototype, Transaction.Mixin, Mixin);
PooledClass.addPoolingTo(ReactReconcileTransaction);
module.exports = ReactReconcileTransaction;
/***/ },
/* 126 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactInputSelection
*/
'use strict';
var ReactDOMSelection = __webpack_require__(127);
var containsNode = __webpack_require__(59);
var focusNode = __webpack_require__(95);
var getActiveElement = __webpack_require__(129);
function isInDocument(node) {
return containsNode(document.documentElement, node);
}
/**
* @ReactInputSelection: React input selection module. Based on Selection.js,
* but modified to be suitable for react and has a couple of bug fixes (doesn't
* assume buttons have range selections allowed).
* Input selection module for React.
*/
var ReactInputSelection = {
hasSelectionCapabilities: function (elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true');
},
getSelectionInformation: function () {
var focusedElem = getActiveElement();
return {
focusedElem: focusedElem,
selectionRange: ReactInputSelection.hasSelectionCapabilities(focusedElem) ? ReactInputSelection.getSelection(focusedElem) : null
};
},
/**
* @restoreSelection: If any selection information was potentially lost,
* restore it. This is useful when performing operations that could remove dom
* nodes and place them back in, resulting in focus being lost.
*/
restoreSelection: function (priorSelectionInformation) {
var curFocusedElem = getActiveElement();
var priorFocusedElem = priorSelectionInformation.focusedElem;
var priorSelectionRange = priorSelectionInformation.selectionRange;
if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange);
}
focusNode(priorFocusedElem);
}
},
/**
* @getSelection: Gets the selection bounds of a focused textarea, input or
* contentEditable node.
* -@input: Look up selection bounds of this input
* -@return {start: selectionStart, end: selectionEnd}
*/
getSelection: function (input) {
var selection;
if ('selectionStart' in input) {
// Modern browser with input or textarea.
selection = {
start: input.selectionStart,
end: input.selectionEnd
};
} else if (document.selection && (input.nodeName && input.nodeName.toLowerCase() === 'input')) {
// IE8 input.
var range = document.selection.createRange();
// There can only be one selection per document in IE, so it must
// be in our element.
if (range.parentElement() === input) {
selection = {
start: -range.moveStart('character', -input.value.length),
end: -range.moveEnd('character', -input.value.length)
};
}
} else {
// Content editable or old IE textarea.
selection = ReactDOMSelection.getOffsets(input);
}
return selection || { start: 0, end: 0 };
},
/**
* @setSelection: Sets the selection bounds of a textarea or input and focuses
* the input.
* -@input Set selection bounds of this input or textarea
* -@offsets Object of same form that is returned from get*
*/
setSelection: function (input, offsets) {
var start = offsets.start;
var end = offsets.end;
if (typeof end === 'undefined') {
end = start;
}
if ('selectionStart' in input) {
input.selectionStart = start;
input.selectionEnd = Math.min(end, input.value.length);
} else if (document.selection && (input.nodeName && input.nodeName.toLowerCase() === 'input')) {
var range = input.createTextRange();
range.collapse(true);
range.moveStart('character', start);
range.moveEnd('character', end - start);
range.select();
} else {
ReactDOMSelection.setOffsets(input, offsets);
}
}
};
module.exports = ReactInputSelection;
/***/ },
/* 127 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMSelection
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var getNodeForCharacterOffset = __webpack_require__(128);
var getTextContentAccessor = __webpack_require__(75);
/**
* While `isCollapsed` is available on the Selection object and `collapsed`
* is available on the Range object, IE11 sometimes gets them wrong.
* If the anchor/focus nodes and offsets are the same, the range is collapsed.
*/
function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {
return anchorNode === focusNode && anchorOffset === focusOffset;
}
/**
* Get the appropriate anchor and focus node/offset pairs for IE.
*
* The catch here is that IE's selection API doesn't provide information
* about whether the selection is forward or backward, so we have to
* behave as though it's always forward.
*
* IE text differs from modern selection in that it behaves as though
* block elements end with a new line. This means character offsets will
* differ between the two APIs.
*
* @param {DOMElement} node
* @return {object}
*/
function getIEOffsets(node) {
var selection = document.selection;
var selectedRange = selection.createRange();
var selectedLength = selectedRange.text.length;
// Duplicate selection so we can move range without breaking user selection.
var fromStart = selectedRange.duplicate();
fromStart.moveToElementText(node);
fromStart.setEndPoint('EndToStart', selectedRange);
var startOffset = fromStart.text.length;
var endOffset = startOffset + selectedLength;
return {
start: startOffset,
end: endOffset
};
}
/**
* @param {DOMElement} node
* @return {?object}
*/
function getModernOffsets(node) {
var selection = window.getSelection && window.getSelection();
if (!selection || selection.rangeCount === 0) {
return null;
}
var anchorNode = selection.anchorNode;
var anchorOffset = selection.anchorOffset;
var focusNode = selection.focusNode;
var focusOffset = selection.focusOffset;
var currentRange = selection.getRangeAt(0);
// In Firefox, range.startContainer and range.endContainer can be "anonymous
// divs", e.g. the up/down buttons on an <input type="number">. Anonymous
// divs do not seem to expose properties, triggering a "Permission denied
// error" if any of its properties are accessed. The only seemingly possible
// way to avoid erroring is to access a property that typically works for
// non-anonymous divs and catch any error that may otherwise arise. See
// https://bugzilla.mozilla.org/show_bug.cgi?id=208427
try {
/* eslint-disable no-unused-expressions */
currentRange.startContainer.nodeType;
currentRange.endContainer.nodeType;
/* eslint-enable no-unused-expressions */
} catch (e) {
return null;
}
// If the node and offset values are the same, the selection is collapsed.
// `Selection.isCollapsed` is available natively, but IE sometimes gets
// this value wrong.
var isSelectionCollapsed = isCollapsed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);
var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;
var tempRange = currentRange.cloneRange();
tempRange.selectNodeContents(node);
tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);
var isTempRangeCollapsed = isCollapsed(tempRange.startContainer, tempRange.startOffset, tempRange.endContainer, tempRange.endOffset);
var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;
var end = start + rangeLength;
// Detect whether the selection is backward.
var detectionRange = document.createRange();
detectionRange.setStart(anchorNode, anchorOffset);
detectionRange.setEnd(focusNode, focusOffset);
var isBackward = detectionRange.collapsed;
return {
start: isBackward ? end : start,
end: isBackward ? start : end
};
}
/**
* @param {DOMElement|DOMTextNode} node
* @param {object} offsets
*/
function setIEOffsets(node, offsets) {
var range = document.selection.createRange().duplicate();
var start, end;
if (typeof offsets.end === 'undefined') {
start = offsets.start;
end = start;
} else if (offsets.start > offsets.end) {
start = offsets.end;
end = offsets.start;
} else {
start = offsets.start;
end = offsets.end;
}
range.moveToElementText(node);
range.moveStart('character', start);
range.setEndPoint('EndToStart', range);
range.moveEnd('character', end - start);
range.select();
}
/**
* In modern non-IE browsers, we can support both forward and backward
* selections.
*
* Note: IE10+ supports the Selection object, but it does not support
* the `extend` method, which means that even in modern IE, it's not possible
* to programatically create a backward selection. Thus, for all IE
* versions, we use the old IE API to create our selections.
*
* @param {DOMElement|DOMTextNode} node
* @param {object} offsets
*/
function setModernOffsets(node, offsets) {
if (!window.getSelection) {
return;
}
var selection = window.getSelection();
var length = node[getTextContentAccessor()].length;
var start = Math.min(offsets.start, length);
var end = typeof offsets.end === 'undefined' ? start : Math.min(offsets.end, length);
// IE 11 uses modern selection, but doesn't support the extend method.
// Flip backward selections, so we can set with a single range.
if (!selection.extend && start > end) {
var temp = end;
end = start;
start = temp;
}
var startMarker = getNodeForCharacterOffset(node, start);
var endMarker = getNodeForCharacterOffset(node, end);
if (startMarker && endMarker) {
var range = document.createRange();
range.setStart(startMarker.node, startMarker.offset);
selection.removeAllRanges();
if (start > end) {
selection.addRange(range);
selection.extend(endMarker.node, endMarker.offset);
} else {
range.setEnd(endMarker.node, endMarker.offset);
selection.addRange(range);
}
}
}
var useIEOffsets = ExecutionEnvironment.canUseDOM && 'selection' in document && !('getSelection' in window);
var ReactDOMSelection = {
/**
* @param {DOMElement} node
*/
getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,
/**
* @param {DOMElement|DOMTextNode} node
* @param {object} offsets
*/
setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets
};
module.exports = ReactDOMSelection;
/***/ },
/* 128 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getNodeForCharacterOffset
*/
'use strict';
/**
* Given any node return the first leaf node without children.
*
* @param {DOMElement|DOMTextNode} node
* @return {DOMElement|DOMTextNode}
*/
function getLeafNode(node) {
while (node && node.firstChild) {
node = node.firstChild;
}
return node;
}
/**
* Get the next sibling within a container. This will walk up the
* DOM if a node's siblings have been exhausted.
*
* @param {DOMElement|DOMTextNode} node
* @return {?DOMElement|DOMTextNode}
*/
function getSiblingNode(node) {
while (node) {
if (node.nextSibling) {
return node.nextSibling;
}
node = node.parentNode;
}
}
/**
* Get object describing the nodes which contain characters at offset.
*
* @param {DOMElement|DOMTextNode} root
* @param {number} offset
* @return {?object}
*/
function getNodeForCharacterOffset(root, offset) {
var node = getLeafNode(root);
var nodeStart = 0;
var nodeEnd = 0;
while (node) {
if (node.nodeType === 3) {
nodeEnd = nodeStart + node.textContent.length;
if (nodeStart <= offset && nodeEnd >= offset) {
return {
node: node,
offset: offset - nodeStart
};
}
nodeStart = nodeEnd;
}
node = getLeafNode(getSiblingNode(node));
}
}
module.exports = getNodeForCharacterOffset;
/***/ },
/* 129 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getActiveElement
* @typechecks
*/
/* eslint-disable fb-www/typeof-undefined */
/**
* Same as document.activeElement but wraps in a try-catch block. In IE it is
* not safe to call document.activeElement if there is nothing focused.
*
* The activeElement will be null only if the document or document body is not
* yet defined.
*/
'use strict';
function getActiveElement() /*?DOMElement*/{
if (typeof document === 'undefined') {
return null;
}
try {
return document.activeElement || document.body;
} catch (e) {
return document.body;
}
}
module.exports = getActiveElement;
/***/ },
/* 130 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SelectEventPlugin
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventPropagators = __webpack_require__(73);
var ExecutionEnvironment = __webpack_require__(9);
var ReactInputSelection = __webpack_require__(126);
var SyntheticEvent = __webpack_require__(77);
var getActiveElement = __webpack_require__(129);
var isTextInputElement = __webpack_require__(82);
var keyOf = __webpack_require__(79);
var shallowEqual = __webpack_require__(117);
var topLevelTypes = EventConstants.topLevelTypes;
var skipSelectionChangeEvent = ExecutionEnvironment.canUseDOM && 'documentMode' in document && document.documentMode <= 11;
var eventTypes = {
select: {
phasedRegistrationNames: {
bubbled: keyOf({ onSelect: null }),
captured: keyOf({ onSelectCapture: null })
},
dependencies: [topLevelTypes.topBlur, topLevelTypes.topContextMenu, topLevelTypes.topFocus, topLevelTypes.topKeyDown, topLevelTypes.topMouseDown, topLevelTypes.topMouseUp, topLevelTypes.topSelectionChange]
}
};
var activeElement = null;
var activeElementID = null;
var lastSelection = null;
var mouseDown = false;
// Track whether a listener exists for this plugin. If none exist, we do
// not extract events.
var hasListener = false;
var ON_SELECT_KEY = keyOf({ onSelect: null });
/**
* Get an object which is a unique representation of the current selection.
*
* The return value will not be consistent across nodes or browsers, but
* two identical selections on the same node will return identical objects.
*
* @param {DOMElement} node
* @return {object}
*/
function getSelection(node) {
if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) {
return {
start: node.selectionStart,
end: node.selectionEnd
};
} else if (window.getSelection) {
var selection = window.getSelection();
return {
anchorNode: selection.anchorNode,
anchorOffset: selection.anchorOffset,
focusNode: selection.focusNode,
focusOffset: selection.focusOffset
};
} else if (document.selection) {
var range = document.selection.createRange();
return {
parentElement: range.parentElement(),
text: range.text,
top: range.boundingTop,
left: range.boundingLeft
};
}
}
/**
* Poll selection to see whether it's changed.
*
* @param {object} nativeEvent
* @return {?SyntheticEvent}
*/
function constructSelectEvent(nativeEvent, nativeEventTarget) {
// Ensure we have the right element, and that the user is not dragging a
// selection (this matches native `select` event behavior). In HTML5, select
// fires only on input and textarea thus if there's no focused element we
// won't dispatch.
if (mouseDown || activeElement == null || activeElement !== getActiveElement()) {
return null;
}
// Only fire when selection has actually changed.
var currentSelection = getSelection(activeElement);
if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
lastSelection = currentSelection;
var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementID, nativeEvent, nativeEventTarget);
syntheticEvent.type = 'select';
syntheticEvent.target = activeElement;
EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);
return syntheticEvent;
}
return null;
}
/**
* This plugin creates an `onSelect` event that normalizes select events
* across form elements.
*
* Supported elements are:
* - input (see `isTextInputElement`)
* - textarea
* - contentEditable
*
* This differs from native browser implementations in the following ways:
* - Fires on contentEditable fields as well as inputs.
* - Fires for collapsed selection.
* - Fires after user input.
*/
var SelectEventPlugin = {
eventTypes: eventTypes,
/**
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {*} An accumulation of synthetic events.
* @see {EventPluginHub.extractEvents}
*/
extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
if (!hasListener) {
return null;
}
switch (topLevelType) {
// Track the input node that has focus.
case topLevelTypes.topFocus:
if (isTextInputElement(topLevelTarget) || topLevelTarget.contentEditable === 'true') {
activeElement = topLevelTarget;
activeElementID = topLevelTargetID;
lastSelection = null;
}
break;
case topLevelTypes.topBlur:
activeElement = null;
activeElementID = null;
lastSelection = null;
break;
// Don't fire the event while the user is dragging. This matches the
// semantics of the native select event.
case topLevelTypes.topMouseDown:
mouseDown = true;
break;
case topLevelTypes.topContextMenu:
case topLevelTypes.topMouseUp:
mouseDown = false;
return constructSelectEvent(nativeEvent, nativeEventTarget);
// Chrome and IE fire non-standard event when selection is changed (and
// sometimes when it hasn't). IE's event fires out of order with respect
// to key and input events on deletion, so we discard it.
//
// Firefox doesn't support selectionchange, so check selection status
// after each key entry. The selection changes after keydown and before
// keyup, but we check on keydown as well in the case of holding down a
// key, when multiple keydown events are fired but only one keyup is.
// This is also our approach for IE handling, for the reason above.
case topLevelTypes.topSelectionChange:
if (skipSelectionChangeEvent) {
break;
}
// falls through
case topLevelTypes.topKeyDown:
case topLevelTypes.topKeyUp:
return constructSelectEvent(nativeEvent, nativeEventTarget);
}
return null;
},
didPutListener: function (id, registrationName, listener) {
if (registrationName === ON_SELECT_KEY) {
hasListener = true;
}
}
};
module.exports = SelectEventPlugin;
/***/ },
/* 131 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ServerReactRootIndex
* @typechecks
*/
'use strict';
/**
* Size of the reactRoot ID space. We generate random numbers for React root
* IDs and if there's a collision the events and DOM update system will
* get confused. In the future we need a way to generate GUIDs but for
* now this will work on a smaller scale.
*/
var GLOBAL_MOUNT_POINT_MAX = Math.pow(2, 53);
var ServerReactRootIndex = {
createReactRootIndex: function () {
return Math.ceil(Math.random() * GLOBAL_MOUNT_POINT_MAX);
}
};
module.exports = ServerReactRootIndex;
/***/ },
/* 132 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SimpleEventPlugin
*/
'use strict';
var EventConstants = __webpack_require__(30);
var EventListener = __webpack_require__(119);
var EventPropagators = __webpack_require__(73);
var ReactMount = __webpack_require__(28);
var SyntheticClipboardEvent = __webpack_require__(133);
var SyntheticEvent = __webpack_require__(77);
var SyntheticFocusEvent = __webpack_require__(134);
var SyntheticKeyboardEvent = __webpack_require__(135);
var SyntheticMouseEvent = __webpack_require__(86);
var SyntheticDragEvent = __webpack_require__(138);
var SyntheticTouchEvent = __webpack_require__(139);
var SyntheticUIEvent = __webpack_require__(87);
var SyntheticWheelEvent = __webpack_require__(140);
var emptyFunction = __webpack_require__(15);
var getEventCharCode = __webpack_require__(136);
var invariant = __webpack_require__(13);
var keyOf = __webpack_require__(79);
var topLevelTypes = EventConstants.topLevelTypes;
var eventTypes = {
abort: {
phasedRegistrationNames: {
bubbled: keyOf({ onAbort: true }),
captured: keyOf({ onAbortCapture: true })
}
},
blur: {
phasedRegistrationNames: {
bubbled: keyOf({ onBlur: true }),
captured: keyOf({ onBlurCapture: true })
}
},
canPlay: {
phasedRegistrationNames: {
bubbled: keyOf({ onCanPlay: true }),
captured: keyOf({ onCanPlayCapture: true })
}
},
canPlayThrough: {
phasedRegistrationNames: {
bubbled: keyOf({ onCanPlayThrough: true }),
captured: keyOf({ onCanPlayThroughCapture: true })
}
},
click: {
phasedRegistrationNames: {
bubbled: keyOf({ onClick: true }),
captured: keyOf({ onClickCapture: true })
}
},
contextMenu: {
phasedRegistrationNames: {
bubbled: keyOf({ onContextMenu: true }),
captured: keyOf({ onContextMenuCapture: true })
}
},
copy: {
phasedRegistrationNames: {
bubbled: keyOf({ onCopy: true }),
captured: keyOf({ onCopyCapture: true })
}
},
cut: {
phasedRegistrationNames: {
bubbled: keyOf({ onCut: true }),
captured: keyOf({ onCutCapture: true })
}
},
doubleClick: {
phasedRegistrationNames: {
bubbled: keyOf({ onDoubleClick: true }),
captured: keyOf({ onDoubleClickCapture: true })
}
},
drag: {
phasedRegistrationNames: {
bubbled: keyOf({ onDrag: true }),
captured: keyOf({ onDragCapture: true })
}
},
dragEnd: {
phasedRegistrationNames: {
bubbled: keyOf({ onDragEnd: true }),
captured: keyOf({ onDragEndCapture: true })
}
},
dragEnter: {
phasedRegistrationNames: {
bubbled: keyOf({ onDragEnter: true }),
captured: keyOf({ onDragEnterCapture: true })
}
},
dragExit: {
phasedRegistrationNames: {
bubbled: keyOf({ onDragExit: true }),
captured: keyOf({ onDragExitCapture: true })
}
},
dragLeave: {
phasedRegistrationNames: {
bubbled: keyOf({ onDragLeave: true }),
captured: keyOf({ onDragLeaveCapture: true })
}
},
dragOver: {
phasedRegistrationNames: {
bubbled: keyOf({ onDragOver: true }),
captured: keyOf({ onDragOverCapture: true })
}
},
dragStart: {
phasedRegistrationNames: {
bubbled: keyOf({ onDragStart: true }),
captured: keyOf({ onDragStartCapture: true })
}
},
drop: {
phasedRegistrationNames: {
bubbled: keyOf({ onDrop: true }),
captured: keyOf({ onDropCapture: true })
}
},
durationChange: {
phasedRegistrationNames: {
bubbled: keyOf({ onDurationChange: true }),
captured: keyOf({ onDurationChangeCapture: true })
}
},
emptied: {
phasedRegistrationNames: {
bubbled: keyOf({ onEmptied: true }),
captured: keyOf({ onEmptiedCapture: true })
}
},
encrypted: {
phasedRegistrationNames: {
bubbled: keyOf({ onEncrypted: true }),
captured: keyOf({ onEncryptedCapture: true })
}
},
ended: {
phasedRegistrationNames: {
bubbled: keyOf({ onEnded: true }),
captured: keyOf({ onEndedCapture: true })
}
},
error: {
phasedRegistrationNames: {
bubbled: keyOf({ onError: true }),
captured: keyOf({ onErrorCapture: true })
}
},
focus: {
phasedRegistrationNames: {
bubbled: keyOf({ onFocus: true }),
captured: keyOf({ onFocusCapture: true })
}
},
input: {
phasedRegistrationNames: {
bubbled: keyOf({ onInput: true }),
captured: keyOf({ onInputCapture: true })
}
},
keyDown: {
phasedRegistrationNames: {
bubbled: keyOf({ onKeyDown: true }),
captured: keyOf({ onKeyDownCapture: true })
}
},
keyPress: {
phasedRegistrationNames: {
bubbled: keyOf({ onKeyPress: true }),
captured: keyOf({ onKeyPressCapture: true })
}
},
keyUp: {
phasedRegistrationNames: {
bubbled: keyOf({ onKeyUp: true }),
captured: keyOf({ onKeyUpCapture: true })
}
},
load: {
phasedRegistrationNames: {
bubbled: keyOf({ onLoad: true }),
captured: keyOf({ onLoadCapture: true })
}
},
loadedData: {
phasedRegistrationNames: {
bubbled: keyOf({ onLoadedData: true }),
captured: keyOf({ onLoadedDataCapture: true })
}
},
loadedMetadata: {
phasedRegistrationNames: {
bubbled: keyOf({ onLoadedMetadata: true }),
captured: keyOf({ onLoadedMetadataCapture: true })
}
},
loadStart: {
phasedRegistrationNames: {
bubbled: keyOf({ onLoadStart: true }),
captured: keyOf({ onLoadStartCapture: true })
}
},
// Note: We do not allow listening to mouseOver events. Instead, use the
// onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`.
mouseDown: {
phasedRegistrationNames: {
bubbled: keyOf({ onMouseDown: true }),
captured: keyOf({ onMouseDownCapture: true })
}
},
mouseMove: {
phasedRegistrationNames: {
bubbled: keyOf({ onMouseMove: true }),
captured: keyOf({ onMouseMoveCapture: true })
}
},
mouseOut: {
phasedRegistrationNames: {
bubbled: keyOf({ onMouseOut: true }),
captured: keyOf({ onMouseOutCapture: true })
}
},
mouseOver: {
phasedRegistrationNames: {
bubbled: keyOf({ onMouseOver: true }),
captured: keyOf({ onMouseOverCapture: true })
}
},
mouseUp: {
phasedRegistrationNames: {
bubbled: keyOf({ onMouseUp: true }),
captured: keyOf({ onMouseUpCapture: true })
}
},
paste: {
phasedRegistrationNames: {
bubbled: keyOf({ onPaste: true }),
captured: keyOf({ onPasteCapture: true })
}
},
pause: {
phasedRegistrationNames: {
bubbled: keyOf({ onPause: true }),
captured: keyOf({ onPauseCapture: true })
}
},
play: {
phasedRegistrationNames: {
bubbled: keyOf({ onPlay: true }),
captured: keyOf({ onPlayCapture: true })
}
},
playing: {
phasedRegistrationNames: {
bubbled: keyOf({ onPlaying: true }),
captured: keyOf({ onPlayingCapture: true })
}
},
progress: {
phasedRegistrationNames: {
bubbled: keyOf({ onProgress: true }),
captured: keyOf({ onProgressCapture: true })
}
},
rateChange: {
phasedRegistrationNames: {
bubbled: keyOf({ onRateChange: true }),
captured: keyOf({ onRateChangeCapture: true })
}
},
reset: {
phasedRegistrationNames: {
bubbled: keyOf({ onReset: true }),
captured: keyOf({ onResetCapture: true })
}
},
scroll: {
phasedRegistrationNames: {
bubbled: keyOf({ onScroll: true }),
captured: keyOf({ onScrollCapture: true })
}
},
seeked: {
phasedRegistrationNames: {
bubbled: keyOf({ onSeeked: true }),
captured: keyOf({ onSeekedCapture: true })
}
},
seeking: {
phasedRegistrationNames: {
bubbled: keyOf({ onSeeking: true }),
captured: keyOf({ onSeekingCapture: true })
}
},
stalled: {
phasedRegistrationNames: {
bubbled: keyOf({ onStalled: true }),
captured: keyOf({ onStalledCapture: true })
}
},
submit: {
phasedRegistrationNames: {
bubbled: keyOf({ onSubmit: true }),
captured: keyOf({ onSubmitCapture: true })
}
},
suspend: {
phasedRegistrationNames: {
bubbled: keyOf({ onSuspend: true }),
captured: keyOf({ onSuspendCapture: true })
}
},
timeUpdate: {
phasedRegistrationNames: {
bubbled: keyOf({ onTimeUpdate: true }),
captured: keyOf({ onTimeUpdateCapture: true })
}
},
touchCancel: {
phasedRegistrationNames: {
bubbled: keyOf({ onTouchCancel: true }),
captured: keyOf({ onTouchCancelCapture: true })
}
},
touchEnd: {
phasedRegistrationNames: {
bubbled: keyOf({ onTouchEnd: true }),
captured: keyOf({ onTouchEndCapture: true })
}
},
touchMove: {
phasedRegistrationNames: {
bubbled: keyOf({ onTouchMove: true }),
captured: keyOf({ onTouchMoveCapture: true })
}
},
touchStart: {
phasedRegistrationNames: {
bubbled: keyOf({ onTouchStart: true }),
captured: keyOf({ onTouchStartCapture: true })
}
},
volumeChange: {
phasedRegistrationNames: {
bubbled: keyOf({ onVolumeChange: true }),
captured: keyOf({ onVolumeChangeCapture: true })
}
},
waiting: {
phasedRegistrationNames: {
bubbled: keyOf({ onWaiting: true }),
captured: keyOf({ onWaitingCapture: true })
}
},
wheel: {
phasedRegistrationNames: {
bubbled: keyOf({ onWheel: true }),
captured: keyOf({ onWheelCapture: true })
}
}
};
var topLevelEventsToDispatchConfig = {
topAbort: eventTypes.abort,
topBlur: eventTypes.blur,
topCanPlay: eventTypes.canPlay,
topCanPlayThrough: eventTypes.canPlayThrough,
topClick: eventTypes.click,
topContextMenu: eventTypes.contextMenu,
topCopy: eventTypes.copy,
topCut: eventTypes.cut,
topDoubleClick: eventTypes.doubleClick,
topDrag: eventTypes.drag,
topDragEnd: eventTypes.dragEnd,
topDragEnter: eventTypes.dragEnter,
topDragExit: eventTypes.dragExit,
topDragLeave: eventTypes.dragLeave,
topDragOver: eventTypes.dragOver,
topDragStart: eventTypes.dragStart,
topDrop: eventTypes.drop,
topDurationChange: eventTypes.durationChange,
topEmptied: eventTypes.emptied,
topEncrypted: eventTypes.encrypted,
topEnded: eventTypes.ended,
topError: eventTypes.error,
topFocus: eventTypes.focus,
topInput: eventTypes.input,
topKeyDown: eventTypes.keyDown,
topKeyPress: eventTypes.keyPress,
topKeyUp: eventTypes.keyUp,
topLoad: eventTypes.load,
topLoadedData: eventTypes.loadedData,
topLoadedMetadata: eventTypes.loadedMetadata,
topLoadStart: eventTypes.loadStart,
topMouseDown: eventTypes.mouseDown,
topMouseMove: eventTypes.mouseMove,
topMouseOut: eventTypes.mouseOut,
topMouseOver: eventTypes.mouseOver,
topMouseUp: eventTypes.mouseUp,
topPaste: eventTypes.paste,
topPause: eventTypes.pause,
topPlay: eventTypes.play,
topPlaying: eventTypes.playing,
topProgress: eventTypes.progress,
topRateChange: eventTypes.rateChange,
topReset: eventTypes.reset,
topScroll: eventTypes.scroll,
topSeeked: eventTypes.seeked,
topSeeking: eventTypes.seeking,
topStalled: eventTypes.stalled,
topSubmit: eventTypes.submit,
topSuspend: eventTypes.suspend,
topTimeUpdate: eventTypes.timeUpdate,
topTouchCancel: eventTypes.touchCancel,
topTouchEnd: eventTypes.touchEnd,
topTouchMove: eventTypes.touchMove,
topTouchStart: eventTypes.touchStart,
topVolumeChange: eventTypes.volumeChange,
topWaiting: eventTypes.waiting,
topWheel: eventTypes.wheel
};
for (var type in topLevelEventsToDispatchConfig) {
topLevelEventsToDispatchConfig[type].dependencies = [type];
}
var ON_CLICK_KEY = keyOf({ onClick: null });
var onClickListeners = {};
var SimpleEventPlugin = {
eventTypes: eventTypes,
/**
* @param {string} topLevelType Record from `EventConstants`.
* @param {DOMEventTarget} topLevelTarget The listening component root node.
* @param {string} topLevelTargetID ID of `topLevelTarget`.
* @param {object} nativeEvent Native browser event.
* @return {*} An accumulation of synthetic events.
* @see {EventPluginHub.extractEvents}
*/
extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];
if (!dispatchConfig) {
return null;
}
var EventConstructor;
switch (topLevelType) {
case topLevelTypes.topAbort:
case topLevelTypes.topCanPlay:
case topLevelTypes.topCanPlayThrough:
case topLevelTypes.topDurationChange:
case topLevelTypes.topEmptied:
case topLevelTypes.topEncrypted:
case topLevelTypes.topEnded:
case topLevelTypes.topError:
case topLevelTypes.topInput:
case topLevelTypes.topLoad:
case topLevelTypes.topLoadedData:
case topLevelTypes.topLoadedMetadata:
case topLevelTypes.topLoadStart:
case topLevelTypes.topPause:
case topLevelTypes.topPlay:
case topLevelTypes.topPlaying:
case topLevelTypes.topProgress:
case topLevelTypes.topRateChange:
case topLevelTypes.topReset:
case topLevelTypes.topSeeked:
case topLevelTypes.topSeeking:
case topLevelTypes.topStalled:
case topLevelTypes.topSubmit:
case topLevelTypes.topSuspend:
case topLevelTypes.topTimeUpdate:
case topLevelTypes.topVolumeChange:
case topLevelTypes.topWaiting:
// HTML Events
// @see http://www.w3.org/TR/html5/index.html#events-0
EventConstructor = SyntheticEvent;
break;
case topLevelTypes.topKeyPress:
// FireFox creates a keypress event for function keys too. This removes
// the unwanted keypress events. Enter is however both printable and
// non-printable. One would expect Tab to be as well (but it isn't).
if (getEventCharCode(nativeEvent) === 0) {
return null;
}
/* falls through */
case topLevelTypes.topKeyDown:
case topLevelTypes.topKeyUp:
EventConstructor = SyntheticKeyboardEvent;
break;
case topLevelTypes.topBlur:
case topLevelTypes.topFocus:
EventConstructor = SyntheticFocusEvent;
break;
case topLevelTypes.topClick:
// Firefox creates a click event on right mouse clicks. This removes the
// unwanted click events.
if (nativeEvent.button === 2) {
return null;
}
/* falls through */
case topLevelTypes.topContextMenu:
case topLevelTypes.topDoubleClick:
case topLevelTypes.topMouseDown:
case topLevelTypes.topMouseMove:
case topLevelTypes.topMouseOut:
case topLevelTypes.topMouseOver:
case topLevelTypes.topMouseUp:
EventConstructor = SyntheticMouseEvent;
break;
case topLevelTypes.topDrag:
case topLevelTypes.topDragEnd:
case topLevelTypes.topDragEnter:
case topLevelTypes.topDragExit:
case topLevelTypes.topDragLeave:
case topLevelTypes.topDragOver:
case topLevelTypes.topDragStart:
case topLevelTypes.topDrop:
EventConstructor = SyntheticDragEvent;
break;
case topLevelTypes.topTouchCancel:
case topLevelTypes.topTouchEnd:
case topLevelTypes.topTouchMove:
case topLevelTypes.topTouchStart:
EventConstructor = SyntheticTouchEvent;
break;
case topLevelTypes.topScroll:
EventConstructor = SyntheticUIEvent;
break;
case topLevelTypes.topWheel:
EventConstructor = SyntheticWheelEvent;
break;
case topLevelTypes.topCopy:
case topLevelTypes.topCut:
case topLevelTypes.topPaste:
EventConstructor = SyntheticClipboardEvent;
break;
}
!EventConstructor ? process.env.NODE_ENV !== 'production' ? invariant(false, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : invariant(false) : undefined;
var event = EventConstructor.getPooled(dispatchConfig, topLevelTargetID, nativeEvent, nativeEventTarget);
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
},
didPutListener: function (id, registrationName, listener) {
// Mobile Safari does not fire properly bubble click events on
// non-interactive elements, which means delegated click listeners do not
// fire. The workaround for this bug involves attaching an empty click
// listener on the target node.
if (registrationName === ON_CLICK_KEY) {
var node = ReactMount.getNode(id);
if (!onClickListeners[id]) {
onClickListeners[id] = EventListener.listen(node, 'click', emptyFunction);
}
}
},
willDeleteListener: function (id, registrationName) {
if (registrationName === ON_CLICK_KEY) {
onClickListeners[id].remove();
delete onClickListeners[id];
}
}
};
module.exports = SimpleEventPlugin;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 133 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticClipboardEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = __webpack_require__(77);
/**
* @interface Event
* @see http://www.w3.org/TR/clipboard-apis/
*/
var ClipboardEventInterface = {
clipboardData: function (event) {
return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
}
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);
module.exports = SyntheticClipboardEvent;
/***/ },
/* 134 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticFocusEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = __webpack_require__(87);
/**
* @interface FocusEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var FocusEventInterface = {
relatedTarget: null
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);
module.exports = SyntheticFocusEvent;
/***/ },
/* 135 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticKeyboardEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = __webpack_require__(87);
var getEventCharCode = __webpack_require__(136);
var getEventKey = __webpack_require__(137);
var getEventModifierState = __webpack_require__(88);
/**
* @interface KeyboardEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var KeyboardEventInterface = {
key: getEventKey,
location: null,
ctrlKey: null,
shiftKey: null,
altKey: null,
metaKey: null,
repeat: null,
locale: null,
getModifierState: getEventModifierState,
// Legacy Interface
charCode: function (event) {
// `charCode` is the result of a KeyPress event and represents the value of
// the actual printable character.
// KeyPress is deprecated, but its replacement is not yet final and not
// implemented in any major browser. Only KeyPress has charCode.
if (event.type === 'keypress') {
return getEventCharCode(event);
}
return 0;
},
keyCode: function (event) {
// `keyCode` is the result of a KeyDown/Up event and represents the value of
// physical keyboard key.
// The actual meaning of the value depends on the users' keyboard layout
// which cannot be detected. Assuming that it is a US keyboard layout
// provides a surprisingly accurate mapping for US and European users.
// Due to this, it is left to the user to implement at this time.
if (event.type === 'keydown' || event.type === 'keyup') {
return event.keyCode;
}
return 0;
},
which: function (event) {
// `which` is an alias for either `keyCode` or `charCode` depending on the
// type of the event.
if (event.type === 'keypress') {
return getEventCharCode(event);
}
if (event.type === 'keydown' || event.type === 'keyup') {
return event.keyCode;
}
return 0;
}
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);
module.exports = SyntheticKeyboardEvent;
/***/ },
/* 136 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getEventCharCode
* @typechecks static-only
*/
'use strict';
/**
* `charCode` represents the actual "character code" and is safe to use with
* `String.fromCharCode`. As such, only keys that correspond to printable
* characters produce a valid `charCode`, the only exception to this is Enter.
* The Tab-key is considered non-printable and does not have a `charCode`,
* presumably because it does not produce a tab-character in browsers.
*
* @param {object} nativeEvent Native browser event.
* @return {number} Normalized `charCode` property.
*/
function getEventCharCode(nativeEvent) {
var charCode;
var keyCode = nativeEvent.keyCode;
if ('charCode' in nativeEvent) {
charCode = nativeEvent.charCode;
// FF does not set `charCode` for the Enter-key, check against `keyCode`.
if (charCode === 0 && keyCode === 13) {
charCode = 13;
}
} else {
// IE8 does not implement `charCode`, but `keyCode` has the correct value.
charCode = keyCode;
}
// Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
// Must not discard the (non-)printable Enter-key.
if (charCode >= 32 || charCode === 13) {
return charCode;
}
return 0;
}
module.exports = getEventCharCode;
/***/ },
/* 137 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule getEventKey
* @typechecks static-only
*/
'use strict';
var getEventCharCode = __webpack_require__(136);
/**
* Normalization of deprecated HTML5 `key` values
* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
*/
var normalizeKey = {
'Esc': 'Escape',
'Spacebar': ' ',
'Left': 'ArrowLeft',
'Up': 'ArrowUp',
'Right': 'ArrowRight',
'Down': 'ArrowDown',
'Del': 'Delete',
'Win': 'OS',
'Menu': 'ContextMenu',
'Apps': 'ContextMenu',
'Scroll': 'ScrollLock',
'MozPrintableKey': 'Unidentified'
};
/**
* Translation from legacy `keyCode` to HTML5 `key`
* Only special keys supported, all others depend on keyboard layout or browser
* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
*/
var translateToKey = {
8: 'Backspace',
9: 'Tab',
12: 'Clear',
13: 'Enter',
16: 'Shift',
17: 'Control',
18: 'Alt',
19: 'Pause',
20: 'CapsLock',
27: 'Escape',
32: ' ',
33: 'PageUp',
34: 'PageDown',
35: 'End',
36: 'Home',
37: 'ArrowLeft',
38: 'ArrowUp',
39: 'ArrowRight',
40: 'ArrowDown',
45: 'Insert',
46: 'Delete',
112: 'F1', 113: 'F2', 114: 'F3', 115: 'F4', 116: 'F5', 117: 'F6',
118: 'F7', 119: 'F8', 120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12',
144: 'NumLock',
145: 'ScrollLock',
224: 'Meta'
};
/**
* @param {object} nativeEvent Native browser event.
* @return {string} Normalized `key` property.
*/
function getEventKey(nativeEvent) {
if (nativeEvent.key) {
// Normalize inconsistent values reported by browsers due to
// implementations of a working draft specification.
// FireFox implements `key` but returns `MozPrintableKey` for all
// printable characters (normalized to `Unidentified`), ignore it.
var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
if (key !== 'Unidentified') {
return key;
}
}
// Browser does not implement `key`, polyfill as much of it as we can.
if (nativeEvent.type === 'keypress') {
var charCode = getEventCharCode(nativeEvent);
// The enter-key is technically both printable and non-printable and can
// thus be captured by `keypress`, no other non-printable key should.
return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
}
if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
// While user keyboard layout determines the actual meaning of each
// `keyCode` value, almost all function keys have a universal value.
return translateToKey[nativeEvent.keyCode] || 'Unidentified';
}
return '';
}
module.exports = getEventKey;
/***/ },
/* 138 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticDragEvent
* @typechecks static-only
*/
'use strict';
var SyntheticMouseEvent = __webpack_require__(86);
/**
* @interface DragEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var DragEventInterface = {
dataTransfer: null
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);
module.exports = SyntheticDragEvent;
/***/ },
/* 139 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticTouchEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = __webpack_require__(87);
var getEventModifierState = __webpack_require__(88);
/**
* @interface TouchEvent
* @see http://www.w3.org/TR/touch-events/
*/
var TouchEventInterface = {
touches: null,
targetTouches: null,
changedTouches: null,
altKey: null,
metaKey: null,
ctrlKey: null,
shiftKey: null,
getModifierState: getEventModifierState
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);
module.exports = SyntheticTouchEvent;
/***/ },
/* 140 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SyntheticWheelEvent
* @typechecks static-only
*/
'use strict';
var SyntheticMouseEvent = __webpack_require__(86);
/**
* @interface WheelEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var WheelEventInterface = {
deltaX: function (event) {
return 'deltaX' in event ? event.deltaX :
// Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
'wheelDeltaX' in event ? -event.wheelDeltaX : 0;
},
deltaY: function (event) {
return 'deltaY' in event ? event.deltaY :
// Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
'wheelDeltaY' in event ? -event.wheelDeltaY :
// Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
'wheelDelta' in event ? -event.wheelDelta : 0;
},
deltaZ: null,
// Browsers without "deltaMode" is reporting in raw wheel delta where one
// notch on the scroll is always +/- 120, roughly equivalent to pixels.
// A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
// ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
deltaMode: null
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticMouseEvent}
*/
function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);
module.exports = SyntheticWheelEvent;
/***/ },
/* 141 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule SVGDOMPropertyConfig
*/
'use strict';
var DOMProperty = __webpack_require__(23);
var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
var NS = {
xlink: 'http://www.w3.org/1999/xlink',
xml: 'http://www.w3.org/XML/1998/namespace'
};
var SVGDOMPropertyConfig = {
Properties: {
clipPath: MUST_USE_ATTRIBUTE,
cx: MUST_USE_ATTRIBUTE,
cy: MUST_USE_ATTRIBUTE,
d: MUST_USE_ATTRIBUTE,
dx: MUST_USE_ATTRIBUTE,
dy: MUST_USE_ATTRIBUTE,
fill: MUST_USE_ATTRIBUTE,
fillOpacity: MUST_USE_ATTRIBUTE,
fontFamily: MUST_USE_ATTRIBUTE,
fontSize: MUST_USE_ATTRIBUTE,
fx: MUST_USE_ATTRIBUTE,
fy: MUST_USE_ATTRIBUTE,
gradientTransform: MUST_USE_ATTRIBUTE,
gradientUnits: MUST_USE_ATTRIBUTE,
markerEnd: MUST_USE_ATTRIBUTE,
markerMid: MUST_USE_ATTRIBUTE,
markerStart: MUST_USE_ATTRIBUTE,
offset: MUST_USE_ATTRIBUTE,
opacity: MUST_USE_ATTRIBUTE,
patternContentUnits: MUST_USE_ATTRIBUTE,
patternUnits: MUST_USE_ATTRIBUTE,
points: MUST_USE_ATTRIBUTE,
preserveAspectRatio: MUST_USE_ATTRIBUTE,
r: MUST_USE_ATTRIBUTE,
rx: MUST_USE_ATTRIBUTE,
ry: MUST_USE_ATTRIBUTE,
spreadMethod: MUST_USE_ATTRIBUTE,
stopColor: MUST_USE_ATTRIBUTE,
stopOpacity: MUST_USE_ATTRIBUTE,
stroke: MUST_USE_ATTRIBUTE,
strokeDasharray: MUST_USE_ATTRIBUTE,
strokeLinecap: MUST_USE_ATTRIBUTE,
strokeOpacity: MUST_USE_ATTRIBUTE,
strokeWidth: MUST_USE_ATTRIBUTE,
textAnchor: MUST_USE_ATTRIBUTE,
transform: MUST_USE_ATTRIBUTE,
version: MUST_USE_ATTRIBUTE,
viewBox: MUST_USE_ATTRIBUTE,
x1: MUST_USE_ATTRIBUTE,
x2: MUST_USE_ATTRIBUTE,
x: MUST_USE_ATTRIBUTE,
xlinkActuate: MUST_USE_ATTRIBUTE,
xlinkArcrole: MUST_USE_ATTRIBUTE,
xlinkHref: MUST_USE_ATTRIBUTE,
xlinkRole: MUST_USE_ATTRIBUTE,
xlinkShow: MUST_USE_ATTRIBUTE,
xlinkTitle: MUST_USE_ATTRIBUTE,
xlinkType: MUST_USE_ATTRIBUTE,
xmlBase: MUST_USE_ATTRIBUTE,
xmlLang: MUST_USE_ATTRIBUTE,
xmlSpace: MUST_USE_ATTRIBUTE,
y1: MUST_USE_ATTRIBUTE,
y2: MUST_USE_ATTRIBUTE,
y: MUST_USE_ATTRIBUTE
},
DOMAttributeNamespaces: {
xlinkActuate: NS.xlink,
xlinkArcrole: NS.xlink,
xlinkHref: NS.xlink,
xlinkRole: NS.xlink,
xlinkShow: NS.xlink,
xlinkTitle: NS.xlink,
xlinkType: NS.xlink,
xmlBase: NS.xml,
xmlLang: NS.xml,
xmlSpace: NS.xml
},
DOMAttributeNames: {
clipPath: 'clip-path',
fillOpacity: 'fill-opacity',
fontFamily: 'font-family',
fontSize: 'font-size',
gradientTransform: 'gradientTransform',
gradientUnits: 'gradientUnits',
markerEnd: 'marker-end',
markerMid: 'marker-mid',
markerStart: 'marker-start',
patternContentUnits: 'patternContentUnits',
patternUnits: 'patternUnits',
preserveAspectRatio: 'preserveAspectRatio',
spreadMethod: 'spreadMethod',
stopColor: 'stop-color',
stopOpacity: 'stop-opacity',
strokeDasharray: 'stroke-dasharray',
strokeLinecap: 'stroke-linecap',
strokeOpacity: 'stroke-opacity',
strokeWidth: 'stroke-width',
textAnchor: 'text-anchor',
viewBox: 'viewBox',
xlinkActuate: 'xlink:actuate',
xlinkArcrole: 'xlink:arcrole',
xlinkHref: 'xlink:href',
xlinkRole: 'xlink:role',
xlinkShow: 'xlink:show',
xlinkTitle: 'xlink:title',
xlinkType: 'xlink:type',
xmlBase: 'xml:base',
xmlLang: 'xml:lang',
xmlSpace: 'xml:space'
}
};
module.exports = SVGDOMPropertyConfig;
/***/ },
/* 142 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDefaultPerf
* @typechecks static-only
*/
'use strict';
var DOMProperty = __webpack_require__(23);
var ReactDefaultPerfAnalysis = __webpack_require__(143);
var ReactMount = __webpack_require__(28);
var ReactPerf = __webpack_require__(18);
var performanceNow = __webpack_require__(144);
function roundFloat(val) {
return Math.floor(val * 100) / 100;
}
function addValue(obj, key, val) {
obj[key] = (obj[key] || 0) + val;
}
var ReactDefaultPerf = {
_allMeasurements: [], // last item in the list is the current one
_mountStack: [0],
_injected: false,
start: function () {
if (!ReactDefaultPerf._injected) {
ReactPerf.injection.injectMeasure(ReactDefaultPerf.measure);
}
ReactDefaultPerf._allMeasurements.length = 0;
ReactPerf.enableMeasure = true;
},
stop: function () {
ReactPerf.enableMeasure = false;
},
getLastMeasurements: function () {
return ReactDefaultPerf._allMeasurements;
},
printExclusive: function (measurements) {
measurements = measurements || ReactDefaultPerf._allMeasurements;
var summary = ReactDefaultPerfAnalysis.getExclusiveSummary(measurements);
console.table(summary.map(function (item) {
return {
'Component class name': item.componentName,
'Total inclusive time (ms)': roundFloat(item.inclusive),
'Exclusive mount time (ms)': roundFloat(item.exclusive),
'Exclusive render time (ms)': roundFloat(item.render),
'Mount time per instance (ms)': roundFloat(item.exclusive / item.count),
'Render time per instance (ms)': roundFloat(item.render / item.count),
'Instances': item.count
};
}));
// TODO: ReactDefaultPerfAnalysis.getTotalTime() does not return the correct
// number.
},
printInclusive: function (measurements) {
measurements = measurements || ReactDefaultPerf._allMeasurements;
var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(measurements);
console.table(summary.map(function (item) {
return {
'Owner > component': item.componentName,
'Inclusive time (ms)': roundFloat(item.time),
'Instances': item.count
};
}));
console.log('Total time:', ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms');
},
getMeasurementsSummaryMap: function (measurements) {
var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(measurements, true);
return summary.map(function (item) {
return {
'Owner > component': item.componentName,
'Wasted time (ms)': item.time,
'Instances': item.count
};
});
},
printWasted: function (measurements) {
measurements = measurements || ReactDefaultPerf._allMeasurements;
console.table(ReactDefaultPerf.getMeasurementsSummaryMap(measurements));
console.log('Total time:', ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms');
},
printDOM: function (measurements) {
measurements = measurements || ReactDefaultPerf._allMeasurements;
var summary = ReactDefaultPerfAnalysis.getDOMSummary(measurements);
console.table(summary.map(function (item) {
var result = {};
result[DOMProperty.ID_ATTRIBUTE_NAME] = item.id;
result.type = item.type;
result.args = JSON.stringify(item.args);
return result;
}));
console.log('Total time:', ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms');
},
_recordWrite: function (id, fnName, totalTime, args) {
// TODO: totalTime isn't that useful since it doesn't count paints/reflows
var writes = ReactDefaultPerf._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1].writes;
writes[id] = writes[id] || [];
writes[id].push({
type: fnName,
time: totalTime,
args: args
});
},
measure: function (moduleName, fnName, func) {
return function () {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var totalTime;
var rv;
var start;
if (fnName === '_renderNewRootComponent' || fnName === 'flushBatchedUpdates') {
// A "measurement" is a set of metrics recorded for each flush. We want
// to group the metrics for a given flush together so we can look at the
// components that rendered and the DOM operations that actually
// happened to determine the amount of "wasted work" performed.
ReactDefaultPerf._allMeasurements.push({
exclusive: {},
inclusive: {},
render: {},
counts: {},
writes: {},
displayNames: {},
totalTime: 0,
created: {}
});
start = performanceNow();
rv = func.apply(this, args);
ReactDefaultPerf._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1].totalTime = performanceNow() - start;
return rv;
} else if (fnName === '_mountImageIntoNode' || moduleName === 'ReactBrowserEventEmitter' || moduleName === 'ReactDOMIDOperations' || moduleName === 'CSSPropertyOperations' || moduleName === 'DOMChildrenOperations' || moduleName === 'DOMPropertyOperations') {
start = performanceNow();
rv = func.apply(this, args);
totalTime = performanceNow() - start;
if (fnName === '_mountImageIntoNode') {
var mountID = ReactMount.getID(args[1]);
ReactDefaultPerf._recordWrite(mountID, fnName, totalTime, args[0]);
} else if (fnName === 'dangerouslyProcessChildrenUpdates') {
// special format
args[0].forEach(function (update) {
var writeArgs = {};
if (update.fromIndex !== null) {
writeArgs.fromIndex = update.fromIndex;
}
if (update.toIndex !== null) {
writeArgs.toIndex = update.toIndex;
}
if (update.textContent !== null) {
writeArgs.textContent = update.textContent;
}
if (update.markupIndex !== null) {
writeArgs.markup = args[1][update.markupIndex];
}
ReactDefaultPerf._recordWrite(update.parentID, update.type, totalTime, writeArgs);
});
} else {
// basic format
var id = args[0];
if (typeof id === 'object') {
id = ReactMount.getID(args[0]);
}
ReactDefaultPerf._recordWrite(id, fnName, totalTime, Array.prototype.slice.call(args, 1));
}
return rv;
} else if (moduleName === 'ReactCompositeComponent' && (fnName === 'mountComponent' || fnName === 'updateComponent' || // TODO: receiveComponent()?
fnName === '_renderValidatedComponent')) {
if (this._currentElement.type === ReactMount.TopLevelWrapper) {
return func.apply(this, args);
}
var rootNodeID = fnName === 'mountComponent' ? args[0] : this._rootNodeID;
var isRender = fnName === '_renderValidatedComponent';
var isMount = fnName === 'mountComponent';
var mountStack = ReactDefaultPerf._mountStack;
var entry = ReactDefaultPerf._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1];
if (isRender) {
addValue(entry.counts, rootNodeID, 1);
} else if (isMount) {
entry.created[rootNodeID] = true;
mountStack.push(0);
}
start = performanceNow();
rv = func.apply(this, args);
totalTime = performanceNow() - start;
if (isRender) {
addValue(entry.render, rootNodeID, totalTime);
} else if (isMount) {
var subMountTime = mountStack.pop();
mountStack[mountStack.length - 1] += totalTime;
addValue(entry.exclusive, rootNodeID, totalTime - subMountTime);
addValue(entry.inclusive, rootNodeID, totalTime);
} else {
addValue(entry.inclusive, rootNodeID, totalTime);
}
entry.displayNames[rootNodeID] = {
current: this.getName(),
owner: this._currentElement._owner ? this._currentElement._owner.getName() : '<root>'
};
return rv;
} else {
return func.apply(this, args);
}
};
}
};
module.exports = ReactDefaultPerf;
/***/ },
/* 143 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDefaultPerfAnalysis
*/
'use strict';
var assign = __webpack_require__(39);
// Don't try to save users less than 1.2ms (a number I made up)
var DONT_CARE_THRESHOLD = 1.2;
var DOM_OPERATION_TYPES = {
'_mountImageIntoNode': 'set innerHTML',
INSERT_MARKUP: 'set innerHTML',
MOVE_EXISTING: 'move',
REMOVE_NODE: 'remove',
SET_MARKUP: 'set innerHTML',
TEXT_CONTENT: 'set textContent',
'setValueForProperty': 'update attribute',
'setValueForAttribute': 'update attribute',
'deleteValueForProperty': 'remove attribute',
'setValueForStyles': 'update styles',
'replaceNodeWithMarkup': 'replace',
'updateTextContent': 'set textContent'
};
function getTotalTime(measurements) {
// TODO: return number of DOM ops? could be misleading.
// TODO: measure dropped frames after reconcile?
// TODO: log total time of each reconcile and the top-level component
// class that triggered it.
var totalTime = 0;
for (var i = 0; i < measurements.length; i++) {
var measurement = measurements[i];
totalTime += measurement.totalTime;
}
return totalTime;
}
function getDOMSummary(measurements) {
var items = [];
measurements.forEach(function (measurement) {
Object.keys(measurement.writes).forEach(function (id) {
measurement.writes[id].forEach(function (write) {
items.push({
id: id,
type: DOM_OPERATION_TYPES[write.type] || write.type,
args: write.args
});
});
});
});
return items;
}
function getExclusiveSummary(measurements) {
var candidates = {};
var displayName;
for (var i = 0; i < measurements.length; i++) {
var measurement = measurements[i];
var allIDs = assign({}, measurement.exclusive, measurement.inclusive);
for (var id in allIDs) {
displayName = measurement.displayNames[id].current;
candidates[displayName] = candidates[displayName] || {
componentName: displayName,
inclusive: 0,
exclusive: 0,
render: 0,
count: 0
};
if (measurement.render[id]) {
candidates[displayName].render += measurement.render[id];
}
if (measurement.exclusive[id]) {
candidates[displayName].exclusive += measurement.exclusive[id];
}
if (measurement.inclusive[id]) {
candidates[displayName].inclusive += measurement.inclusive[id];
}
if (measurement.counts[id]) {
candidates[displayName].count += measurement.counts[id];
}
}
}
// Now make a sorted array with the results.
var arr = [];
for (displayName in candidates) {
if (candidates[displayName].exclusive >= DONT_CARE_THRESHOLD) {
arr.push(candidates[displayName]);
}
}
arr.sort(function (a, b) {
return b.exclusive - a.exclusive;
});
return arr;
}
function getInclusiveSummary(measurements, onlyClean) {
var candidates = {};
var inclusiveKey;
for (var i = 0; i < measurements.length; i++) {
var measurement = measurements[i];
var allIDs = assign({}, measurement.exclusive, measurement.inclusive);
var cleanComponents;
if (onlyClean) {
cleanComponents = getUnchangedComponents(measurement);
}
for (var id in allIDs) {
if (onlyClean && !cleanComponents[id]) {
continue;
}
var displayName = measurement.displayNames[id];
// Inclusive time is not useful for many components without knowing where
// they are instantiated. So we aggregate inclusive time with both the
// owner and current displayName as the key.
inclusiveKey = displayName.owner + ' > ' + displayName.current;
candidates[inclusiveKey] = candidates[inclusiveKey] || {
componentName: inclusiveKey,
time: 0,
count: 0
};
if (measurement.inclusive[id]) {
candidates[inclusiveKey].time += measurement.inclusive[id];
}
if (measurement.counts[id]) {
candidates[inclusiveKey].count += measurement.counts[id];
}
}
}
// Now make a sorted array with the results.
var arr = [];
for (inclusiveKey in candidates) {
if (candidates[inclusiveKey].time >= DONT_CARE_THRESHOLD) {
arr.push(candidates[inclusiveKey]);
}
}
arr.sort(function (a, b) {
return b.time - a.time;
});
return arr;
}
function getUnchangedComponents(measurement) {
// For a given reconcile, look at which components did not actually
// render anything to the DOM and return a mapping of their ID to
// the amount of time it took to render the entire subtree.
var cleanComponents = {};
var dirtyLeafIDs = Object.keys(measurement.writes);
var allIDs = assign({}, measurement.exclusive, measurement.inclusive);
for (var id in allIDs) {
var isDirty = false;
// For each component that rendered, see if a component that triggered
// a DOM op is in its subtree.
for (var i = 0; i < dirtyLeafIDs.length; i++) {
if (dirtyLeafIDs[i].indexOf(id) === 0) {
isDirty = true;
break;
}
}
// check if component newly created
if (measurement.created[id]) {
isDirty = true;
}
if (!isDirty && measurement.counts[id] > 0) {
cleanComponents[id] = true;
}
}
return cleanComponents;
}
var ReactDefaultPerfAnalysis = {
getExclusiveSummary: getExclusiveSummary,
getInclusiveSummary: getInclusiveSummary,
getDOMSummary: getDOMSummary,
getTotalTime: getTotalTime
};
module.exports = ReactDefaultPerfAnalysis;
/***/ },
/* 144 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule performanceNow
* @typechecks
*/
'use strict';
var performance = __webpack_require__(145);
var performanceNow;
/**
* Detect if we can use `window.performance.now()` and gracefully fallback to
* `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now
* because of Facebook's testing infrastructure.
*/
if (performance.now) {
performanceNow = function () {
return performance.now();
};
} else {
performanceNow = function () {
return Date.now();
};
}
module.exports = performanceNow;
/***/ },
/* 145 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule performance
* @typechecks
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(9);
var performance;
if (ExecutionEnvironment.canUseDOM) {
performance = window.performance || window.msPerformance || window.webkitPerformance;
}
module.exports = performance || {};
/***/ },
/* 146 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactVersion
*/
'use strict';
module.exports = '0.14.7';
/***/ },
/* 147 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule renderSubtreeIntoContainer
*/
'use strict';
var ReactMount = __webpack_require__(28);
module.exports = ReactMount.renderSubtreeIntoContainer;
/***/ },
/* 148 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMServer
*/
'use strict';
var ReactDefaultInjection = __webpack_require__(71);
var ReactServerRendering = __webpack_require__(149);
var ReactVersion = __webpack_require__(146);
ReactDefaultInjection.inject();
var ReactDOMServer = {
renderToString: ReactServerRendering.renderToString,
renderToStaticMarkup: ReactServerRendering.renderToStaticMarkup,
version: ReactVersion
};
module.exports = ReactDOMServer;
/***/ },
/* 149 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @typechecks static-only
* @providesModule ReactServerRendering
*/
'use strict';
var ReactDefaultBatchingStrategy = __webpack_require__(92);
var ReactElement = __webpack_require__(42);
var ReactInstanceHandles = __webpack_require__(45);
var ReactMarkupChecksum = __webpack_require__(48);
var ReactServerBatchingStrategy = __webpack_require__(150);
var ReactServerRenderingTransaction = __webpack_require__(151);
var ReactUpdates = __webpack_require__(54);
var emptyObject = __webpack_require__(58);
var instantiateReactComponent = __webpack_require__(62);
var invariant = __webpack_require__(13);
/**
* @param {ReactElement} element
* @return {string} the HTML markup
*/
function renderToString(element) {
!ReactElement.isValidElement(element) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'renderToString(): You must pass a valid ReactElement.') : invariant(false) : undefined;
var transaction;
try {
ReactUpdates.injection.injectBatchingStrategy(ReactServerBatchingStrategy);
var id = ReactInstanceHandles.createReactRootID();
transaction = ReactServerRenderingTransaction.getPooled(false);
return transaction.perform(function () {
var componentInstance = instantiateReactComponent(element, null);
var markup = componentInstance.mountComponent(id, transaction, emptyObject);
return ReactMarkupChecksum.addChecksumToMarkup(markup);
}, null);
} finally {
ReactServerRenderingTransaction.release(transaction);
// Revert to the DOM batching strategy since these two renderers
// currently share these stateful modules.
ReactUpdates.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy);
}
}
/**
* @param {ReactElement} element
* @return {string} the HTML markup, without the extra React ID and checksum
* (for generating static pages)
*/
function renderToStaticMarkup(element) {
!ReactElement.isValidElement(element) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'renderToStaticMarkup(): You must pass a valid ReactElement.') : invariant(false) : undefined;
var transaction;
try {
ReactUpdates.injection.injectBatchingStrategy(ReactServerBatchingStrategy);
var id = ReactInstanceHandles.createReactRootID();
transaction = ReactServerRenderingTransaction.getPooled(true);
return transaction.perform(function () {
var componentInstance = instantiateReactComponent(element, null);
return componentInstance.mountComponent(id, transaction, emptyObject);
}, null);
} finally {
ReactServerRenderingTransaction.release(transaction);
// Revert to the DOM batching strategy since these two renderers
// currently share these stateful modules.
ReactUpdates.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy);
}
}
module.exports = {
renderToString: renderToString,
renderToStaticMarkup: renderToStaticMarkup
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 150 */
/***/ function(module, exports) {
/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactServerBatchingStrategy
* @typechecks
*/
'use strict';
var ReactServerBatchingStrategy = {
isBatchingUpdates: false,
batchedUpdates: function (callback) {
// Don't do anything here. During the server rendering we don't want to
// schedule any updates. We will simply ignore them.
}
};
module.exports = ReactServerBatchingStrategy;
/***/ },
/* 151 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactServerRenderingTransaction
* @typechecks
*/
'use strict';
var PooledClass = __webpack_require__(56);
var CallbackQueue = __webpack_require__(55);
var Transaction = __webpack_require__(57);
var assign = __webpack_require__(39);
var emptyFunction = __webpack_require__(15);
/**
* Provides a `CallbackQueue` queue for collecting `onDOMReady` callbacks
* during the performing of the transaction.
*/
var ON_DOM_READY_QUEUEING = {
/**
* Initializes the internal `onDOMReady` queue.
*/
initialize: function () {
this.reactMountReady.reset();
},
close: emptyFunction
};
/**
* Executed within the scope of the `Transaction` instance. Consider these as
* being member methods, but with an implied ordering while being isolated from
* each other.
*/
var TRANSACTION_WRAPPERS = [ON_DOM_READY_QUEUEING];
/**
* @class ReactServerRenderingTransaction
* @param {boolean} renderToStaticMarkup
*/
function ReactServerRenderingTransaction(renderToStaticMarkup) {
this.reinitializeTransaction();
this.renderToStaticMarkup = renderToStaticMarkup;
this.reactMountReady = CallbackQueue.getPooled(null);
this.useCreateElement = false;
}
var Mixin = {
/**
* @see Transaction
* @abstract
* @final
* @return {array} Empty list of operation wrap procedures.
*/
getTransactionWrappers: function () {
return TRANSACTION_WRAPPERS;
},
/**
* @return {object} The queue to collect `onDOMReady` callbacks with.
*/
getReactMountReady: function () {
return this.reactMountReady;
},
/**
* `PooledClass` looks for this, and will invoke this before allowing this
* instance to be reused.
*/
destructor: function () {
CallbackQueue.release(this.reactMountReady);
this.reactMountReady = null;
}
};
assign(ReactServerRenderingTransaction.prototype, Transaction.Mixin, Mixin);
PooledClass.addPoolingTo(ReactServerRenderingTransaction);
module.exports = ReactServerRenderingTransaction;
/***/ },
/* 152 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactIsomorphic
*/
'use strict';
var ReactChildren = __webpack_require__(110);
var ReactComponent = __webpack_require__(123);
var ReactClass = __webpack_require__(122);
var ReactDOMFactories = __webpack_require__(153);
var ReactElement = __webpack_require__(42);
var ReactElementValidator = __webpack_require__(154);
var ReactPropTypes = __webpack_require__(107);
var ReactVersion = __webpack_require__(146);
var assign = __webpack_require__(39);
var onlyChild = __webpack_require__(156);
var createElement = ReactElement.createElement;
var createFactory = ReactElement.createFactory;
var cloneElement = ReactElement.cloneElement;
if (process.env.NODE_ENV !== 'production') {
createElement = ReactElementValidator.createElement;
createFactory = ReactElementValidator.createFactory;
cloneElement = ReactElementValidator.cloneElement;
}
var React = {
// Modern
Children: {
map: ReactChildren.map,
forEach: ReactChildren.forEach,
count: ReactChildren.count,
toArray: ReactChildren.toArray,
only: onlyChild
},
Component: ReactComponent,
createElement: createElement,
cloneElement: cloneElement,
isValidElement: ReactElement.isValidElement,
// Classic
PropTypes: ReactPropTypes,
createClass: ReactClass.createClass,
createFactory: createFactory,
createMixin: function (mixin) {
// Currently a noop. Will be used to validate and trace mixins.
return mixin;
},
// This looks DOM specific but these are actually isomorphic helpers
// since they are just generating DOM strings.
DOM: ReactDOMFactories,
version: ReactVersion,
// Hook for JSX spread, don't use this for anything else.
__spread: assign
};
module.exports = React;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 153 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMFactories
* @typechecks static-only
*/
'use strict';
var ReactElement = __webpack_require__(42);
var ReactElementValidator = __webpack_require__(154);
var mapObject = __webpack_require__(155);
/**
* Create a factory that creates HTML tag elements.
*
* @param {string} tag Tag name (e.g. `div`).
* @private
*/
function createDOMFactory(tag) {
if (process.env.NODE_ENV !== 'production') {
return ReactElementValidator.createFactory(tag);
}
return ReactElement.createFactory(tag);
}
/**
* Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.
* This is also accessible via `React.DOM`.
*
* @public
*/
var ReactDOMFactories = mapObject({
a: 'a',
abbr: 'abbr',
address: 'address',
area: 'area',
article: 'article',
aside: 'aside',
audio: 'audio',
b: 'b',
base: 'base',
bdi: 'bdi',
bdo: 'bdo',
big: 'big',
blockquote: 'blockquote',
body: 'body',
br: 'br',
button: 'button',
canvas: 'canvas',
caption: 'caption',
cite: 'cite',
code: 'code',
col: 'col',
colgroup: 'colgroup',
data: 'data',
datalist: 'datalist',
dd: 'dd',
del: 'del',
details: 'details',
dfn: 'dfn',
dialog: 'dialog',
div: 'div',
dl: 'dl',
dt: 'dt',
em: 'em',
embed: 'embed',
fieldset: 'fieldset',
figcaption: 'figcaption',
figure: 'figure',
footer: 'footer',
form: 'form',
h1: 'h1',
h2: 'h2',
h3: 'h3',
h4: 'h4',
h5: 'h5',
h6: 'h6',
head: 'head',
header: 'header',
hgroup: 'hgroup',
hr: 'hr',
html: 'html',
i: 'i',
iframe: 'iframe',
img: 'img',
input: 'input',
ins: 'ins',
kbd: 'kbd',
keygen: 'keygen',
label: 'label',
legend: 'legend',
li: 'li',
link: 'link',
main: 'main',
map: 'map',
mark: 'mark',
menu: 'menu',
menuitem: 'menuitem',
meta: 'meta',
meter: 'meter',
nav: 'nav',
noscript: 'noscript',
object: 'object',
ol: 'ol',
optgroup: 'optgroup',
option: 'option',
output: 'output',
p: 'p',
param: 'param',
picture: 'picture',
pre: 'pre',
progress: 'progress',
q: 'q',
rp: 'rp',
rt: 'rt',
ruby: 'ruby',
s: 's',
samp: 'samp',
script: 'script',
section: 'section',
select: 'select',
small: 'small',
source: 'source',
span: 'span',
strong: 'strong',
style: 'style',
sub: 'sub',
summary: 'summary',
sup: 'sup',
table: 'table',
tbody: 'tbody',
td: 'td',
textarea: 'textarea',
tfoot: 'tfoot',
th: 'th',
thead: 'thead',
time: 'time',
title: 'title',
tr: 'tr',
track: 'track',
u: 'u',
ul: 'ul',
'var': 'var',
video: 'video',
wbr: 'wbr',
// SVG
circle: 'circle',
clipPath: 'clipPath',
defs: 'defs',
ellipse: 'ellipse',
g: 'g',
image: 'image',
line: 'line',
linearGradient: 'linearGradient',
mask: 'mask',
path: 'path',
pattern: 'pattern',
polygon: 'polygon',
polyline: 'polyline',
radialGradient: 'radialGradient',
rect: 'rect',
stop: 'stop',
svg: 'svg',
text: 'text',
tspan: 'tspan'
}, createDOMFactory);
module.exports = ReactDOMFactories;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 154 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2014-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactElementValidator
*/
/**
* ReactElementValidator provides a wrapper around a element factory
* which validates the props passed to the element. This is intended to be
* used only in DEV and could be replaced by a static type checker for languages
* that support it.
*/
'use strict';
var ReactElement = __webpack_require__(42);
var ReactPropTypeLocations = __webpack_require__(65);
var ReactPropTypeLocationNames = __webpack_require__(66);
var ReactCurrentOwner = __webpack_require__(5);
var canDefineProperty = __webpack_require__(43);
var getIteratorFn = __webpack_require__(108);
var invariant = __webpack_require__(13);
var warning = __webpack_require__(25);
function getDeclarationErrorAddendum() {
if (ReactCurrentOwner.current) {
var name = ReactCurrentOwner.current.getName();
if (name) {
return ' Check the render method of `' + name + '`.';
}
}
return '';
}
/**
* Warn if there's no key explicitly set on dynamic arrays of children or
* object keys are not valid. This allows us to keep track of children between
* updates.
*/
var ownerHasKeyUseWarning = {};
var loggedTypeFailures = {};
/**
* Warn if the element doesn't have an explicit key assigned to it.
* This element is in an array. The array could grow and shrink or be
* reordered. All children that haven't already been validated are required to
* have a "key" property assigned to it.
*
* @internal
* @param {ReactElement} element Element that requires a key.
* @param {*} parentType element's parent's type.
*/
function validateExplicitKey(element, parentType) {
if (!element._store || element._store.validated || element.key != null) {
return;
}
element._store.validated = true;
var addenda = getAddendaForKeyUse('uniqueKey', element, parentType);
if (addenda === null) {
// we already showed the warning
return;
}
process.env.NODE_ENV !== 'production' ? warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s%s', addenda.parentOrOwner || '', addenda.childOwner || '', addenda.url || '') : undefined;
}
/**
* Shared warning and monitoring code for the key warnings.
*
* @internal
* @param {string} messageType A key used for de-duping warnings.
* @param {ReactElement} element Component that requires a key.
* @param {*} parentType element's parent's type.
* @returns {?object} A set of addenda to use in the warning message, or null
* if the warning has already been shown before (and shouldn't be shown again).
*/
function getAddendaForKeyUse(messageType, element, parentType) {
var addendum = getDeclarationErrorAddendum();
if (!addendum) {
var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
if (parentName) {
addendum = ' Check the top-level render call using <' + parentName + '>.';
}
}
var memoizer = ownerHasKeyUseWarning[messageType] || (ownerHasKeyUseWarning[messageType] = {});
if (memoizer[addendum]) {
return null;
}
memoizer[addendum] = true;
var addenda = {
parentOrOwner: addendum,
url: ' See https://fb.me/react-warning-keys for more information.',
childOwner: null
};
// Usually the current owner is the offender, but if it accepts children as a
// property, it may be the creator of the child that's responsible for
// assigning it a key.
if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
// Give the component that originally created this child.
addenda.childOwner = ' It was passed a child from ' + element._owner.getName() + '.';
}
return addenda;
}
/**
* Ensure that every element either is passed in a static location, in an
* array with an explicit keys property defined, or in an object literal
* with valid key property.
*
* @internal
* @param {ReactNode} node Statically passed child of any type.
* @param {*} parentType node's parent's type.
*/
function validateChildKeys(node, parentType) {
if (typeof node !== 'object') {
return;
}
if (Array.isArray(node)) {
for (var i = 0; i < node.length; i++) {
var child = node[i];
if (ReactElement.isValidElement(child)) {
validateExplicitKey(child, parentType);
}
}
} else if (ReactElement.isValidElement(node)) {
// This element was passed in a valid location.
if (node._store) {
node._store.validated = true;
}
} else if (node) {
var iteratorFn = getIteratorFn(node);
// Entry iterators provide implicit keys.
if (iteratorFn) {
if (iteratorFn !== node.entries) {
var iterator = iteratorFn.call(node);
var step;
while (!(step = iterator.next()).done) {
if (ReactElement.isValidElement(step.value)) {
validateExplicitKey(step.value, parentType);
}
}
}
}
}
}
/**
* Assert that the props are valid
*
* @param {string} componentName Name of the component for error messages.
* @param {object} propTypes Map of prop name to a ReactPropType
* @param {object} props
* @param {string} location e.g. "prop", "context", "child context"
* @private
*/
function checkPropTypes(componentName, propTypes, props, location) {
for (var propName in propTypes) {
if (propTypes.hasOwnProperty(propName)) {
var error;
// Prop type validation may throw. In case they do, we don't want to
// fail the render phase where it didn't fail before. So we log it.
// After these have been cleaned up, we'll let them throw.
try {
// This is intentionally an invariant that gets caught. It's the same
// behavior as without this statement except with a better message.
!(typeof propTypes[propName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], propName) : invariant(false) : undefined;
error = propTypes[propName](props, propName, componentName, location);
} catch (ex) {
error = ex;
}
process.env.NODE_ENV !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], propName, typeof error) : undefined;
if (error instanceof Error && !(error.message in loggedTypeFailures)) {
// Only monitor this failure once because there tends to be a lot of the
// same error.
loggedTypeFailures[error.message] = true;
var addendum = getDeclarationErrorAddendum();
process.env.NODE_ENV !== 'production' ? warning(false, 'Failed propType: %s%s', error.message, addendum) : undefined;
}
}
}
}
/**
* Given an element, validate that its props follow the propTypes definition,
* provided by the type.
*
* @param {ReactElement} element
*/
function validatePropTypes(element) {
var componentClass = element.type;
if (typeof componentClass !== 'function') {
return;
}
var name = componentClass.displayName || componentClass.name;
if (componentClass.propTypes) {
checkPropTypes(name, componentClass.propTypes, element.props, ReactPropTypeLocations.prop);
}
if (typeof componentClass.getDefaultProps === 'function') {
process.env.NODE_ENV !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : undefined;
}
}
var ReactElementValidator = {
createElement: function (type, props, children) {
var validType = typeof type === 'string' || typeof type === 'function';
// We warn in this case but don't throw. We expect the element creation to
// succeed and there will likely be errors in render.
process.env.NODE_ENV !== 'production' ? warning(validType, 'React.createElement: type should not be null, undefined, boolean, or ' + 'number. It should be a string (for DOM elements) or a ReactClass ' + '(for composite components).%s', getDeclarationErrorAddendum()) : undefined;
var element = ReactElement.createElement.apply(this, arguments);
// The result can be nullish if a mock or a custom function is used.
// TODO: Drop this when these are no longer allowed as the type argument.
if (element == null) {
return element;
}
// Skip key warning if the type isn't valid since our key validation logic
// doesn't expect a non-string/function type and can throw confusing errors.
// We don't want exception behavior to differ between dev and prod.
// (Rendering will throw with a helpful message and as soon as the type is
// fixed, the key warnings will appear.)
if (validType) {
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], type);
}
}
validatePropTypes(element);
return element;
},
createFactory: function (type) {
var validatedFactory = ReactElementValidator.createElement.bind(null, type);
// Legacy hook TODO: Warn if this is accessed
validatedFactory.type = type;
if (process.env.NODE_ENV !== 'production') {
if (canDefineProperty) {
Object.defineProperty(validatedFactory, 'type', {
enumerable: false,
get: function () {
process.env.NODE_ENV !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : undefined;
Object.defineProperty(this, 'type', {
value: type
});
return type;
}
});
}
}
return validatedFactory;
},
cloneElement: function (element, props, children) {
var newElement = ReactElement.cloneElement.apply(this, arguments);
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], newElement.type);
}
validatePropTypes(newElement);
return newElement;
}
};
module.exports = ReactElementValidator;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 155 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule mapObject
*/
'use strict';
var hasOwnProperty = Object.prototype.hasOwnProperty;
/**
* Executes the provided `callback` once for each enumerable own property in the
* object and constructs a new object from the results. The `callback` is
* invoked with three arguments:
*
* - the property value
* - the property name
* - the object being traversed
*
* Properties that are added after the call to `mapObject` will not be visited
* by `callback`. If the values of existing properties are changed, the value
* passed to `callback` will be the value at the time `mapObject` visits them.
* Properties that are deleted before being visited are not visited.
*
* @grep function objectMap()
* @grep function objMap()
*
* @param {?object} object
* @param {function} callback
* @param {*} context
* @return {?object}
*/
function mapObject(object, callback, context) {
if (!object) {
return null;
}
var result = {};
for (var name in object) {
if (hasOwnProperty.call(object, name)) {
result[name] = callback.call(context, object[name], name, object);
}
}
return result;
}
module.exports = mapObject;
/***/ },
/* 156 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule onlyChild
*/
'use strict';
var ReactElement = __webpack_require__(42);
var invariant = __webpack_require__(13);
/**
* Returns the first child in a collection of children and verifies that there
* is only one child in the collection. The current implementation of this
* function assumes that a single child gets passed without a wrapper, but the
* purpose of this helper function is to abstract away the particular structure
* of children.
*
* @param {?object} children Child collection structure.
* @return {ReactComponent} The first and only `ReactComponent` contained in the
* structure.
*/
function onlyChild(children) {
!ReactElement.isValidElement(children) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'onlyChild must be passed a children with exactly one child.') : invariant(false) : undefined;
return children;
}
module.exports = onlyChild;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 157 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule deprecated
*/
'use strict';
var assign = __webpack_require__(39);
var warning = __webpack_require__(25);
/**
* This will log a single deprecation notice per function and forward the call
* on to the new API.
*
* @param {string} fnName The name of the function
* @param {string} newModule The module that fn will exist in
* @param {string} newPackage The module that fn will exist in
* @param {*} ctx The context this forwarded call should run in
* @param {function} fn The function to forward on to
* @return {function} The function that will warn once and then call fn
*/
function deprecated(fnName, newModule, newPackage, ctx, fn) {
var warned = false;
if (process.env.NODE_ENV !== 'production') {
var newFn = function () {
process.env.NODE_ENV !== 'production' ? warning(warned,
// Require examples in this string must be split to prevent React's
// build tools from mistaking them for real requires.
// Otherwise the build tools will attempt to build a '%s' module.
'React.%s is deprecated. Please use %s.%s from require' + '(\'%s\') ' + 'instead.', fnName, newModule, fnName, newPackage) : undefined;
warned = true;
return fn.apply(ctx, arguments);
};
// We need to make sure all properties of the original fn are copied over.
// In particular, this is needed to support PropTypes
return assign(newFn, fn);
}
return fn;
}
module.exports = deprecated;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 158 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
module.exports = __webpack_require__(3);
/***/ },
/* 159 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _react = __webpack_require__(1);
var _react2 = _interopRequireDefault(_react);
var _reactDom = __webpack_require__(158);
var _reactDom2 = _interopRequireDefault(_reactDom);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
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; }
var Navigation = function (_React$Component) {
_inherits(Navigation, _React$Component);
function Navigation(props) {
_classCallCheck(this, Navigation);
var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Navigation).call(this, props));
_this.state = {
color: '#2276BF'
};
_this.sheet = cssx();
return _this;
}
_createClass(Navigation, [{
key: 'componentWillMount',
value: function componentWillMount() {
var color = this.state.color;
this.sheet.add(function () {
var _2 = {},
_3 = {},
_4 = {},
_5 = {};
_3['padding-left'] = '0';
_3['transition'] = 'padding-left 300ms ease';
_4['display'] = 'block';
_4['cursor'] = 'pointer';
_4['padding'] = '0.6em 1em';
_4['border-bottom'] = "solid 2px " + color;
_4['border-radius'] = '6px';
_4['background-color'] = shadeColor(color, 0.5);
_4['transition'] = 'background-color 400ms ease';
_5['background-color'] = shadeColor(color, 0.2);
_2['li'] = _3;
_2['.btn'] = _4;
_2['.btn:hover'] = _5;
return _2;
}.apply(this));
}
}, {
key: 'render',
value: function render() {
return _react2.default.createElement(
'ul',
null,
this._getItems()
);
}
}, {
key: '_getItems',
value: function _getItems() {
var _this2 = this;
return this.props.items.map(function (item, i) {
return _react2.default.createElement(
'li',
{ key: i },
_react2.default.createElement(
'a',
{ className: 'btn', onClick: _this2._handleClick.bind(_this2, i) },
item
)
);
});
}
}, {
key: '_handleClick',
value: function _handleClick(index) {
cssx('selected').clear().add(function () {
var _7 = {},
_8 = {},
_9 = {};
_8['padding-left'] = '2em';
_9['background-color'] = this.state.color;
_7["li:nth-child(" + (index + 1) + ")"] = _8;
_7["li:nth-child(" + (index + 1) + ") .btn"] = _9;
return _7;
}.apply(this));
}
}]);
return Navigation;
}(_react2.default.Component);
function shadeColor(color, percent) {
var f = parseInt(color.slice(1), 16),
t = percent < 0 ? 0 : 255,
p = percent < 0 ? percent * -1 : percent,
R = f >> 16,
G = f >> 8 & 0x00FF,
B = f & 0x0000FF;
return "#" + (0x1000000 + (Math.round((t - R) * p) + R) * 0x10000 + (Math.round((t - G) * p) + G) * 0x100 + (Math.round((t - B) * p) + B)).toString(16).slice(1);
}
exports.default = Navigation;
/***/ },
/* 160 */
/***/ function(module, exports, __webpack_require__) {
(function webpackUniversalModuleDefinition(root, factory) {
if(true)
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define("cssx", [], factory);
else if(typeof exports === 'object')
exports["cssx"] = factory();
else
root["cssx"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
var factory, goGlobal, stylesheets, api, randomId, plugins = [];
__webpack_require__(1);
factory = __webpack_require__(5);
goGlobal = __webpack_require__(15);
randomId = __webpack_require__(16);
stylesheets = [];
function createStyleSheet(id) {
var s, i;
if (typeof id === 'undefined') {
id = randomId();
}
for (i = 0; i < stylesheets.length; i++) {
if (stylesheets[i].id() === id) {
return stylesheets[i];
}
}
s = factory.apply(factory, arguments);
stylesheets.push(s);
return s;
};
api = function (id) { return createStyleSheet(id, plugins); };
api.domChanges = function (flag) {
factory.disableDOMChanges = !flag;
};
api.minify = function (flag) {
factory.minify = flag;
};
api.nextTick = function (flag) {
factory.useNextTick = flag;
};
api.getStylesheets = function () {
return stylesheets;
};
api.clear = function () {
var i;
for (i = 0; i < stylesheets.length; i++) {
stylesheets[i].clear();
}
stylesheets = [];
return api;
};
api.getCSS = function () {
var i, css = '';
for (i = 0; i < stylesheets.length; i++) {
css += stylesheets[i].getCSS();
}
return css;
};
api.plugins = function (arr) {
plugins = plugins.concat(arr);
};
module.exports = api;
goGlobal(module.exports);
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(2);
__webpack_require__(3);
__webpack_require__(4);
/***/ },
/* 2 */
/***/ function(module, exports) {
if (!Array.prototype.filter) {
Array.prototype.filter = function(fun/*, thisArg*/) {
'use strict';
if (this === void 0 || this === null) {
throw new TypeError();
}
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun !== 'function') {
throw new TypeError();
}
var res = [];
var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
for (var i = 0; i < len; i++) {
if (i in t) {
var val = t[i];
// NOTE: Technically this should Object.defineProperty at
// the next index, as push can be affected by
// properties on Object.prototype and Array.prototype.
// But that method's new, and collisions should be
// rare, so use the more-compatible alternative.
if (fun.call(thisArg, val, i, t)) {
res.push(val);
}
}
}
return res;
};
}
/***/ },
/* 3 */
/***/ function(module, exports) {
// Production steps of ECMA-262, Edition 5, 15.4.4.18
// Reference: http://es5.github.io/#x15.4.4.18
if (!Array.prototype.forEach) {
Array.prototype.forEach = function(callback, thisArg) {
var T, k;
if (this == null) {
throw new TypeError(' this is null or not defined');
}
// 1. Let O be the result of calling ToObject passing the |this| value as the argument.
var O = Object(this);
// 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
// 3. Let len be ToUint32(lenValue).
var len = O.length >>> 0;
// 4. If IsCallable(callback) is false, throw a TypeError exception.
// See: http://es5.github.com/#x9.11
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
// 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
if (arguments.length > 1) {
T = thisArg;
}
// 6. Let k be 0
k = 0;
// 7. Repeat, while k < len
while (k < len) {
var kValue;
// a. Let Pk be ToString(k).
// This is implicit for LHS operands of the in operator
// b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
// This step can be combined with c
// c. If kPresent is true, then
if (k in O) {
// i. Let kValue be the result of calling the Get internal method of O with argument Pk.
kValue = O[k];
// ii. Call the Call internal method of callback with T as the this value and
// argument list containing kValue, k, and O.
callback.call(T, kValue, k, O);
}
// d. Increase k by 1.
k++;
}
// 8. return undefined
};
}
/***/ },
/* 4 */
/***/ function(module, exports) {
// Production steps of ECMA-262, Edition 5, 15.4.4.19
// Reference: http://es5.github.io/#x15.4.4.19
if (!Array.prototype.map) {
Array.prototype.map = function(callback, thisArg) {
var T, A, k;
if (this == null) {
throw new TypeError(' this is null or not defined');
}
// 1. Let O be the result of calling ToObject passing the |this|
// value as the argument.
var O = Object(this);
// 2. Let lenValue be the result of calling the Get internal
// method of O with the argument "length".
// 3. Let len be ToUint32(lenValue).
var len = O.length >>> 0;
// 4. If IsCallable(callback) is false, throw a TypeError exception.
// See: http://es5.github.com/#x9.11
if (typeof callback !== 'function') {
throw new TypeError(callback + ' is not a function');
}
// 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
if (arguments.length > 1) {
T = thisArg;
}
// 6. Let A be a new array created as if by the expression new Array(len)
// where Array is the standard built-in constructor with that name and
// len is the value of len.
A = new Array(len);
// 7. Let k be 0
k = 0;
// 8. Repeat, while k < len
while (k < len) {
var kValue, mappedValue;
// a. Let Pk be ToString(k).
// This is implicit for LHS operands of the in operator
// b. Let kPresent be the result of calling the HasProperty internal
// method of O with argument Pk.
// This step can be combined with c
// c. If kPresent is true, then
if (k in O) {
// i. Let kValue be the result of calling the Get internal
// method of O with argument Pk.
kValue = O[k];
// ii. Let mappedValue be the result of calling the Call internal
// method of callback with T as the this value and argument
// list containing kValue, k, and O.
mappedValue = callback.call(T, kValue, k, O);
// iii. Call the DefineOwnProperty internal method of A with arguments
// Pk, Property Descriptor
// { Value: mappedValue,
// Writable: true,
// Enumerable: true,
// Configurable: true },
// and false.
// In browsers that support Object.defineProperty, use the following:
// Object.defineProperty(A, k, {
// value: mappedValue,
// writable: true,
// enumerable: true,
// configurable: true
// });
// For best browser support, use the following:
A[k] = mappedValue;
}
// d. Increase k by 1.
k++;
}
// 9. return A
return A;
};
}
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
var CSSRule = __webpack_require__(6);
var applyToDOM = __webpack_require__(7);
var nextTick = __webpack_require__(8);
var generate = __webpack_require__(12);
var isArray = __webpack_require__(14);
var ids = 0;
var getId = function () { return 'x' + (++ids); };
module.exports = function (id, plugins) {
var _id = id || getId();
var _api = {};
var _rules = [];
var _customProperties = {};
var _remove = null;
var _css = '';
var _scope = '';
var ruleExists = function (rules, selector, parent) {
return rules.reduce(function (result, rule) {
if (result !== false) return result;
if (rule.selector === selector) {
if (parent) {
return rule.parent && parent.selector === rule.parent.selector ? rule : false;
}
return rule;
}
return false;
}, false);
};
var registerRule = function (rule, addAt) {
if (typeof addAt !== 'undefined') {
_rules.splice(addAt, 0, rule);
} else {
_rules.push(rule);
}
rule.index = _rules.length - 1;
};
_api.id = function () {
return _id;
};
_api.add = _api.update = function (rawRules, parent, addAt) {
var rule, prop, tmpRawRules, cssProps, props, nestedRules, selector, tmp;
var created = [];
if (typeof rawRules === 'string') {
tmp = {};
tmp[rawRules] = {};
rawRules = tmp;
}
if (typeof rawRules === 'function') {
rawRules = rawRules();
}
for (selector in rawRules) {
rule = ruleExists(_rules, selector, parent);
cssProps = {};
props = {};
nestedRules = [];
// new rule
if (!rule) {
props = rawRules[selector];
for (prop in props) {
if (typeof props[prop] !== 'object' || isArray(props[prop])) {
cssProps[prop] = props[prop];
} else {
tmpRawRules = {};
tmpRawRules[prop] = props[prop];
nestedRules.push(tmpRawRules);
}
}
rule = CSSRule(selector, this.resolveCustomProps(cssProps), _api);
if (!parent) {
registerRule(rule, addAt);
} else {
rule.parent = parent;
parent.registerNested(rule);
}
nestedRules.forEach(function (rawRulesNested) {
_api.add(rawRulesNested, rule);
});
// existing rule
} else {
rule.update(rawRules[selector]);
}
this.compile();
created.push(rule);
}
return created.length === 1 ? created[0] : created;
};
_api.rules = function () {
return _rules;
};
_api.compile = function () {
if (module.exports.useNextTick) {
nextTick(function () {
_api.compileImmediate();
}, _id);
return _api;
}
return _api.compileImmediate();
};
_api.compileImmediate = function () {
_css = generate(_rules, module.exports.minify, plugins, _scope);
if (!module.exports.disableDOMChanges) {
_remove = applyToDOM(_css, _id);
}
return _api;
};
_api.clear = function () {
_rules = [];
_css = '';
if (_remove !== null) {
_remove();
_remove = null;
}
return _api;
};
_api.destroy = function () {
return _api.clear();
};
_api.getCSS = function () {
this.compileImmediate();
return _css;
};
_api.define = function (prop, func) {
_customProperties[prop] = func;
};
_api.scope = function (scope) {
_scope = scope;
};
_api._getCustomProps = function () {
return _customProperties;
};
_api.resolveCustomProps = function (actual) {
var result = actual, prop, newProp, value;
var custom = _customProperties;
for (prop in custom) {
if (typeof actual[prop] !== 'undefined') {
value = custom[prop](actual[prop]);
delete actual[prop];
for (newProp in value) {
actual[newProp] = value[newProp];
}
}
}
return result;
};
return _api;
};
module.exports.disableDOMChanges = false;
module.exports.minify = true;
module.exports.useNextTick = true;
/***/ },
/* 6 */
/***/ function(module, exports) {
module.exports = function CSSRule(selector, props, stylesheet) {
var _api = {
selector: selector,
props: props,
stylesheet: stylesheet,
index: null,
nestedRules: null,
parent: null
};
_api.clone = function () {
var rule = CSSRule(this.selector, this.props, this.stylesheet);
rule.index = this.index;
rule.nestedRules = this.nestedRules;
rule.parent = this.parent;
return rule;
};
_api.descendant = _api.d = function (rawRules) {
var selector;
if (typeof rawRules === 'function') rawRules = rawRules();
for (selector in rawRules) {
rawRules[_api.selector + ' ' + selector] = rawRules[selector];
delete rawRules[selector];
}
return _api.stylesheet.add(rawRules, this.parent, this.index);
};
_api.nested = _api.n = function (rawRules) {
return _api.stylesheet.add(rawRules, this);
};
_api.update = function (props) {
var prop, areThereNestedRules = this.nestedRules !== null;
if (typeof props === 'function') {
props = props();
}
props = this.stylesheet.resolveCustomProps(props);
for (prop in props) {
if (typeof props[prop] !== 'object') {
this.props[prop] = props[prop];
} else if (areThereNestedRules) {
if (this.nestedRules[prop]) {
this.nestedRules[prop].update(props[prop]);
}
}
}
return this;
};
_api.registerNested = function (rule) {
if (this.nestedRules === null) this.nestedRules = {};
this.nestedRules[rule.selector] = rule;
return this;
};
return _api;
};
/***/ },
/* 7 */
/***/ function(module, exports) {
var cache = {};
var qs = function (selector) {
return document.querySelector(selector);
};
var createNode = function (type, attrs, content) {
var node = document.createElement(type), i, a;
for (i = 0; i < attrs.length; i++) {
a = attrs[i];
node.setAttribute(a.name, a.value);
}
node.innerHTML = content;
(qs('head') || qs('body')).appendChild(node);
return node;
};
var remove = function (id) {
return function () {
if (cache[id]) {
cache[id].el.parentNode.removeChild(cache[id].el);
delete cache[id];
}
};
};
module.exports = function (css, id) {
var el;
if (!cache[id]) {
el = createNode(
'style', [
{ name: 'id', value: id },
{ name: 'type', value: 'text/css'}
],
css
);
cache[id] = { el: el, css: css, remove: remove(id) };
} else {
if (cache[id].css !== css) {
cache[id].css = css;
cache[id].el.innerHTML = css;
}
}
return cache[id].remove;
};
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(setImmediate) {var cache = {};
__webpack_require__(11);
module.exports = function (work, id) {
if (!cache[id]) {
cache[id] = work;
setImmediate(function () {
delete cache[id];
work();
});
}
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9).setImmediate))
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(setImmediate, clearImmediate) {var nextTick = __webpack_require__(10).nextTick;
var apply = Function.prototype.apply;
var slice = Array.prototype.slice;
var immediateIds = {};
var nextImmediateId = 0;
// DOM APIs, for completeness
exports.setTimeout = function() {
return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
};
exports.setInterval = function() {
return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
};
exports.clearTimeout =
exports.clearInterval = function(timeout) { timeout.close(); };
function Timeout(id, clearFn) {
this._id = id;
this._clearFn = clearFn;
}
Timeout.prototype.unref = Timeout.prototype.ref = function() {};
Timeout.prototype.close = function() {
this._clearFn.call(window, this._id);
};
// Does not start the time, just sets up the members needed.
exports.enroll = function(item, msecs) {
clearTimeout(item._idleTimeoutId);
item._idleTimeout = msecs;
};
exports.unenroll = function(item) {
clearTimeout(item._idleTimeoutId);
item._idleTimeout = -1;
};
exports._unrefActive = exports.active = function(item) {
clearTimeout(item._idleTimeoutId);
var msecs = item._idleTimeout;
if (msecs >= 0) {
item._idleTimeoutId = setTimeout(function onTimeout() {
if (item._onTimeout)
item._onTimeout();
}, msecs);
}
};
// That's not how node.js implements it but the exposed api is the same.
exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
var id = nextImmediateId++;
var args = arguments.length < 2 ? false : slice.call(arguments, 1);
immediateIds[id] = true;
nextTick(function onNextTick() {
if (immediateIds[id]) {
// fn.call() is faster so we optimize for the common use-case
// @see http://jsperf.com/call-apply-segu
if (args) {
fn.apply(null, args);
} else {
fn.call(null);
}
// Prevent ids from leaking
exports.clearImmediate(id);
}
});
return id;
};
exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
delete immediateIds[id];
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9).setImmediate, __webpack_require__(9).clearImmediate))
/***/ },
/* 10 */
/***/ function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = setTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
clearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
setTimeout(drainQueue, 0);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, clearImmediate, process) {(function (global, undefined) {
"use strict";
if (global.setImmediate) {
return;
}
var nextHandle = 1; // Spec says greater than zero
var tasksByHandle = {};
var currentlyRunningATask = false;
var doc = global.document;
var setImmediate;
function addFromSetImmediateArguments(args) {
tasksByHandle[nextHandle] = partiallyApplied.apply(undefined, args);
return nextHandle++;
}
// This function accepts the same arguments as setImmediate, but
// returns a function that requires no arguments.
function partiallyApplied(handler) {
var args = [].slice.call(arguments, 1);
return function() {
if (typeof handler === "function") {
handler.apply(undefined, args);
} else {
(new Function("" + handler))();
}
};
}
function runIfPresent(handle) {
// From the spec: "Wait until any invocations of this algorithm started before this one have completed."
// So if we're currently running a task, we'll need to delay this invocation.
if (currentlyRunningATask) {
// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
// "too much recursion" error.
setTimeout(partiallyApplied(runIfPresent, handle), 0);
} else {
var task = tasksByHandle[handle];
if (task) {
currentlyRunningATask = true;
try {
task();
} finally {
clearImmediate(handle);
currentlyRunningATask = false;
}
}
}
}
function clearImmediate(handle) {
delete tasksByHandle[handle];
}
function installNextTickImplementation() {
setImmediate = function() {
var handle = addFromSetImmediateArguments(arguments);
process.nextTick(partiallyApplied(runIfPresent, handle));
return handle;
};
}
function canUsePostMessage() {
// The test against `importScripts` prevents this implementation from being installed inside a web worker,
// where `global.postMessage` means something completely different and can't be used for this purpose.
if (global.postMessage && !global.importScripts) {
var postMessageIsAsynchronous = true;
var oldOnMessage = global.onmessage;
global.onmessage = function() {
postMessageIsAsynchronous = false;
};
global.postMessage("", "*");
global.onmessage = oldOnMessage;
return postMessageIsAsynchronous;
}
}
function installPostMessageImplementation() {
// Installs an event handler on `global` for the `message` event: see
// * https://developer.mozilla.org/en/DOM/window.postMessage
// * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
var messagePrefix = "setImmediate$" + Math.random() + "$";
var onGlobalMessage = function(event) {
if (event.source === global &&
typeof event.data === "string" &&
event.data.indexOf(messagePrefix) === 0) {
runIfPresent(+event.data.slice(messagePrefix.length));
}
};
if (global.addEventListener) {
global.addEventListener("message", onGlobalMessage, false);
} else {
global.attachEvent("onmessage", onGlobalMessage);
}
setImmediate = function() {
var handle = addFromSetImmediateArguments(arguments);
global.postMessage(messagePrefix + handle, "*");
return handle;
};
}
function installMessageChannelImplementation() {
var channel = new MessageChannel();
channel.port1.onmessage = function(event) {
var handle = event.data;
runIfPresent(handle);
};
setImmediate = function() {
var handle = addFromSetImmediateArguments(arguments);
channel.port2.postMessage(handle);
return handle;
};
}
function installReadyStateChangeImplementation() {
var html = doc.documentElement;
setImmediate = function() {
var handle = addFromSetImmediateArguments(arguments);
// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
var script = doc.createElement("script");
script.onreadystatechange = function () {
runIfPresent(handle);
script.onreadystatechange = null;
html.removeChild(script);
script = null;
};
html.appendChild(script);
return handle;
};
}
function installSetTimeoutImplementation() {
setImmediate = function() {
var handle = addFromSetImmediateArguments(arguments);
setTimeout(partiallyApplied(runIfPresent, handle), 0);
return handle;
};
}
// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
// Don't get fooled by e.g. browserify environments.
if ({}.toString.call(global.process) === "[object process]") {
// For Node.js before 0.9
installNextTickImplementation();
} else if (canUsePostMessage()) {
// For non-IE10 modern browsers
installPostMessageImplementation();
} else if (global.MessageChannel) {
// For web workers, where supported
installMessageChannelImplementation();
} else if (doc && "onreadystatechange" in doc.createElement("script")) {
// For IE 6–8
installReadyStateChangeImplementation();
} else {
// For older browsers
installSetTimeoutImplementation();
}
attachTo.setImmediate = setImmediate;
attachTo.clearImmediate = clearImmediate;
}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(9).clearImmediate, __webpack_require__(10)))
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
var isEmpty = __webpack_require__(13);
var isArray = __webpack_require__(14);
module.exports = function (topRules, minify, plugins, scope) {
var scopeTheSelector = function (selector) {
if (scope === '') return selector;
if (selector.indexOf(scope) === 0 || selector.indexOf('@') === 0) return selector;
return scope + ' ' + selector;
};
var applyPlugins = function (props) {
var n;
for (n = 0; n < plugins.length; n++) {
props = plugins[n](props);
}
return props;
};
var newLine = minify ? '' : '\n';
var interval = minify ? '' : ' ';
var tab = minify ? '' : ' ';
var process = function (rules, indent) {
var css = '', r, prop, props, value;
var addLine = function (line, noNewLine) {
css += line + (noNewLine ? '' : newLine);
};
var processRule = function (rule) {
if (!isEmpty(rule.props) || rule.nestedRules !== null) {
addLine(indent + scopeTheSelector(rule.selector) + interval + '{');
props = applyPlugins(rule.props);
for (prop in props) {
value = typeof props[prop] === 'function' ? props[prop]() : props[prop];
if (isArray(value)) {
value.forEach(function (v) {
addLine(indent + tab + prop + ':' + interval + v + ';');
});
} else {
addLine(indent + tab + prop + ':' + interval + value + ';');
}
}
if (rule.nestedRules !== null) {
addLine(process(rule.nestedRules, indent + tab), true);
}
addLine(indent + '}');
}
};
indent = minify ? '' : indent;
if (isArray(rules)) {
rules.forEach(processRule);
} else {
for (r in rules) {
processRule(rules[r]);
}
};
return css;
};
return process(topRules, '');
};
/***/ },
/* 13 */
/***/ function(module, exports) {
module.exports = function (obj) {
var prop;
for (prop in obj) {
if (obj.hasOwnProperty(prop)) {
return false;
}
}
return true;
};
/***/ },
/* 14 */
/***/ function(module, exports) {
module.exports = function (v) {
return Object.prototype.toString.call(v) === '[object Array]';
};
/***/ },
/* 15 */
/***/ function(module, exports) {
/* WEBPACK VAR INJECTION */(function(global) {module.exports = function (api) {
if (typeof global !== 'undefined') {
global.cssx = api;
}
if (typeof window !== 'undefined') {
window.cssx = api;
}
};
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
/***/ },
/* 16 */
/***/ function(module, exports) {
var ids = 0;
module.exports = function () {
return '_cssx' + (++ids);
};
module.exports.resetIDs = function () {
ids = 0;
};
/***/ }
/******/ ])
});
;
//# sourceMappingURL=cssx.js.map
/***/ }
/******/ ]);
//# sourceMappingURL=app.js.map
|
import uniqBy from 'lodash/uniqBy'
import uniq from 'lodash/uniq'
import last from 'lodash/last'
import find from 'lodash/find'
import createReducer from '@zap/utils/createReducer'
import { showSystemNotification } from '@zap/utils/notifications'
import { convert } from '@zap/utils/btc'
import { getIntl } from '@zap/i18n'
import delay from '@zap/utils/delay'
import genId from '@zap/utils/genId'
import errorToUserFriendly from '@zap/utils/userFriendlyErrors'
import { grpc } from 'workers'
import { newAddress, addressSelectors } from 'reducers/address'
import { fetchBalance } from 'reducers/balance'
import { fetchChannels, channelsSelectors } from 'reducers/channels'
import transactionSelectors from './selectors'
import { decorateTransaction } from './utils'
import messages from './messages'
import * as constants from './constants'
const {
GET_TRANSACTIONS,
RECEIVE_TRANSACTIONS,
SEND_TRANSACTION,
TRANSACTION_SUCCESSFUL,
TRANSACTION_FAILED,
TRANSACTION_COMPLETE,
} = constants
let usedAddresses = []
/**
* @typedef Transaction
* @property {string} txHash The transaction hash
* @property {string} amount The transaction amount, denominated in satoshis
* @property {number} numConfirmations The number of confirmations
* @property {string} blockHash The hash of the block this transaction was included in
* @property {number} blockHeight The height of the block this transaction was included in
* @property {string} timeStamp Timestamp of this transaction
* @property {string} totalFees Fees paid for this transaction
* @property {string[]} destAddresses Addresses that received funds for this transaction
* @property {string} rawTxHex The raw transaction hex.
*/
/**
* @typedef State
* @property {boolean} transactionLoading Boolean indicating if transactions are loading
* @property {Transaction[]} transactions List of transactions
* @property {object[]} transactionsSending List of transactions in process of sending
*/
// ------------------------------------
// Initial State
// ------------------------------------
/** @type {State} */
const initialState = {
transactionLoading: false,
transactions: [],
transactionsSending: [],
}
// ------------------------------------
// Actions
// ------------------------------------
/**
* sendTransaction - Store details of sending in progress onchain transaction.
*
* @param {object} data Transaction data
* @returns {object} Action
*/
export function sendTransaction(data) {
const transaction = {
...data,
status: 'sending',
isSending: true,
timeStamp: Math.round(Date.now() / 1000),
numConfirmations: 0,
}
return {
type: SEND_TRANSACTION,
transaction,
}
}
/**
* receiveTransactions - Success callback for fetch transactions.
*
* @param {Transaction[]} transactions of transaction.
* @param {boolean} updateOnly if true only update known transactions or adds new ones
* (ones whose timestamp is greater than the newest known one)
* @returns {(dispatch:Function, getState:Function) => void} Thunk
*/
export const receiveTransactions = (transactions, updateOnly = false) => async (
dispatch,
getState
) => {
const state = getState()
const currentAddresses = addressSelectors.currentAddresses(state)
// index of the last tx in `transactions`
// that is newer(or equal) than the last tx from the state.
// This is used to only update known transactions or add new if
// we are in `updateOnly` mode
let lastKnownTxIndex = 0
const lastTx = last(transactionSelectors.transactions(state))
transactions.forEach((transaction, index) => {
const { timeStamp, destAddresses } = transaction
if (updateOnly && !lastKnownTxIndex && lastTx && timeStamp >= lastTx.timeStamp) {
lastKnownTxIndex = index
}
// Keep track of used addresses.
usedAddresses = uniq(usedAddresses.concat(destAddresses))
})
dispatch({
type: RECEIVE_TRANSACTIONS,
transactions: lastKnownTxIndex ? transactions.slice(lastKnownTxIndex) : transactions,
})
// If our current wallet address has been used, generate a new one.
Object.entries(currentAddresses).forEach(([type, address]) => {
if (usedAddresses.includes(address)) {
dispatch(newAddress(type))
}
})
}
/**
* fetchTransactions - Fetch details of all transactions.
*
* @param {boolean} updateOnly if true only update known transactions or adds new ones
* (ones whose timestamp is greater than the newest known one)
* @returns {(dispatch:Function) => Promise<void>} Thunk
*/
export const fetchTransactions = updateOnly => async dispatch => {
dispatch({ type: GET_TRANSACTIONS })
const transactions = await grpc.services.Lightning.getTransactions()
dispatch(receiveTransactions(transactions.transactions, updateOnly))
}
/**
* transactionSuccessful - Success handler for sendCoins.
*
* @param {string} internalId transaction internal id
* @returns {(dispatch:Function, getState:Function) => Promise<void>} Thunk
*/
export const transactionSuccessful = ({ internalId }) => async (dispatch, getState) => {
const { timestamp } = find(transactionSelectors.transactionsSending(getState(), { internalId }))
// Ensure payment stays in sending state for at least 2 seconds.
await delay(2000 - (Date.now() - timestamp * 1000))
// Mark the payment as successful.
dispatch({ type: TRANSACTION_SUCCESSFUL, internalId })
// Wait for another second.
await delay(1000)
// Mark the payment as successful.
dispatch({ type: TRANSACTION_COMPLETE, internalId })
}
/**
* transactionFailed - Error handler for sendCoins.
*
* @param {object} details Details
* @param {string} details.internalId transaction internal id
* @param {string} details.error Error message
* @returns {(dispatch:Function, getState:Function) => Promise<void>} Thunk
*/
export const transactionFailed = ({ internalId, error }) => async (dispatch, getState) => {
const { timestamp } = find(transactionSelectors.transactionsSending(getState()), { internalId })
// Ensure payment stays in sending state for at least 2 seconds.
await delay(2000 - (Date.now() - timestamp * 1000))
// Mark the payment as failed.
dispatch({ type: TRANSACTION_FAILED, internalId, error })
}
/**
* sendCoins - Send an onchain transaction.
*
* @param {object} options Options
* @param {number} options.value Number of units to send
* @param {string} options.addr Destination address
* @param {string} options.cryptoUnit Crypto unit that value is denominated in (converted to sats prior to send)
* @param {number} options.targetConf Number of blocks to target for conf time
* @param {number} options.satPerByte Sat per byte fee rate to apply
* @param {boolean} options.isCoinSweep Boolean indicating whether this is a coin sweep (will send all funds).
* @param {boolean} options.spendUnconfirmed Whether unconfirmed outputs should be used as inputs for the transaction.
* @returns {(dispatch:Function) => Promise<void>} Thunk
*/
export const sendCoins = ({
value,
addr,
cryptoUnit,
targetConf,
satPerByte,
isCoinSweep,
spendUnconfirmed = true,
}) => async dispatch => {
// backend needs amount in satoshis no matter what currency we are using
const amount = convert(cryptoUnit, 'sats', value)
// Generate a unique id for the transaction attempt.
const internalId = genId()
// Add to sendingPayments in the state.
const payload = {
internalId,
addr,
amount: isCoinSweep ? null : amount,
targetConf,
satPerByte,
sendAll: isCoinSweep,
spendUnconfirmed,
}
dispatch(sendTransaction(payload))
// Submit the transaction to LND.
try {
await grpc.services.Lightning.sendCoins(payload)
dispatch(transactionSuccessful({ ...payload, internalId }))
} catch (e) {
e.message = errorToUserFriendly(e.message)
dispatch(transactionFailed({ internalId, error: e }))
}
}
/**
* receiveTransactionData - Listener for when a new transaction is pushed from the subscriber.
*
* @param {Transaction} transaction Transaction
* @returns {(dispatch:Function, getState:Function) => void} Thunk
*/
export const receiveTransactionData = transaction => async (dispatch, getState) => {
const isNew = !transactionSelectors
.transactions(getState())
.find(tx => tx.txHash === transaction.txHash)
// Add/Update the transaction.
await dispatch(receiveTransactions([transaction]))
// Fetch updated channels and balance.
await dispatch(fetchBalance())
await dispatch(fetchChannels())
const intl = getIntl()
const decoratedTransaction = decorateTransaction(transaction)
const { isSent, isReceived } = decoratedTransaction
if (isNew) {
// Send HTML 5 desktop notification for newly received transactions.
if (isReceived) {
showSystemNotification(intl.formatMessage(messages.transaction_received_title), {
body: intl.formatMessage(messages.transaction_received_body),
})
}
// Send HTML 5 desktop notification for newly sent transactions.
// (excluding channel opening or channel closing transactions)
else if (isSent) {
const poc = channelsSelectors.pendingOpenChannelsRaw(getState())
const isChannelOpen = poc.some(
c => c.channel.channelPoint.split(':')[0] === transaction.txHash
)
if (!isChannelOpen) {
showSystemNotification(intl.formatMessage(messages.transaction_sent_title), {
body: intl.formatMessage(messages.transaction_sent_body),
})
}
}
}
}
// ------------------------------------
// Action Handlers
// ------------------------------------
const ACTION_HANDLERS = {
[GET_TRANSACTIONS]: state => {
state.transactionLoading = true
},
[SEND_TRANSACTION]: (state, { transaction }) => {
state.transactionsSending.push(transaction)
},
[RECEIVE_TRANSACTIONS]: (state, { transactions }) => {
state.transactionLoading = false
state.transactions = uniqBy(transactions.concat(state.transactions), 'txHash')
},
[TRANSACTION_SUCCESSFUL]: (state, { internalId }) => {
const txIndex = state.transactionsSending.findIndex(item => item.internalId === internalId)
if (txIndex >= 0) {
state.transactionsSending[txIndex].status = 'successful'
}
},
[TRANSACTION_FAILED]: (state, { internalId, error }) => {
const txIndex = state.transactionsSending.findIndex(item => item.internalId === internalId)
if (txIndex >= 0) {
state.transactionsSending[txIndex].status = 'failed'
state.transactionsSending[txIndex].error = error
}
},
[TRANSACTION_COMPLETE]: (state, { internalId }) => {
state.transactionsSending = state.transactionsSending.filter(
item => item.internalId !== internalId
)
},
}
export default createReducer(initialState, ACTION_HANDLERS)
|
require('./proof')(1, function (step, once, equal) {
step(function () {
once(step, 'fixtures//hello', [])
}, function (response) {
equal(response.body, 'Hello, World!\n', 'delimiter')
})
})
|
const path = require('path');
const fs = require('fs');
const { BitmapText, BitmapFont } = require('../');
const { Texture } = require('@pixi/core');
describe('PIXI.BitmapText', function ()
{
before(function (done)
{
this.fontXML = null;
this.fontImage = null;
this.font = null;
const resolveURL = (url) => path.resolve(this.resources, url);
const loadXML = (url) => new Promise((resolve) =>
fs.readFile(resolveURL(url), 'utf8', (err, data) =>
{
expect(err).to.be.null;
resolve((new window.DOMParser()).parseFromString(data, 'text/xml'));
}));
const loadImage = (url) => new Promise((resolve) =>
{
const image = new Image();
image.onload = () => resolve(image);
image.src = resolveURL(url);
});
this.resources = path.join(__dirname, 'resources');
Promise.all([
loadXML('font.fnt'),
loadXML('font-no-page.fnt'),
loadImage('font.png'),
]).then(([
fontXML,
font2XML,
fontImage,
]) =>
{
this.fontXML = fontXML;
this.font2XML = font2XML;
this.fontImage = fontImage;
done();
});
});
after(function ()
{
BitmapFont.uninstall(this.font.font);
BitmapFont.uninstall(this.font2.font);
this.texture.destroy(true);
this.texture = null;
this.font = null;
this.font2 = null;
});
it('should register fonts from preloaded images', function ()
{
this.texture = Texture.from(this.fontImage);
this.font = BitmapFont.install(this.fontXML, this.texture);
this.font2 = BitmapFont.install(this.font2XML, this.texture);
expect(this.font).instanceof(BitmapFont);
expect(this.font2).instanceof(BitmapFont);
expect(BitmapFont.available[this.font.font]).to.equal(this.font);
expect(BitmapFont.available[this.font2.font]).to.equal(this.font2);
});
it('should have correct children when modified', function ()
{
BitmapFont.from('testFont', {
fill: '#333333',
fontSize: 4,
});
const text = new BitmapText('ABCDEFG', {
fontName: 'testFont',
});
const listener = sinon.spy(text, 'addChild');
text.updateText();
expect(listener.callCount).to.equal(1);
expect(text.children.length).to.equal(1);
text.updateText();
expect(listener.callCount).to.equal(1);
expect(text.children.length).to.equal(1);
text.text = 'hiya';
text.updateText();
expect(listener.callCount).to.equal(1);
expect(text.children.length).to.equal(1);
});
it('should render text even if there are unsupported characters', function ()
{
const text = new BitmapText('ABCDEFG', {
fontName: this.font.font,
});
text.updateText();
expect(text._activePagesMeshData[0].total).to.equal(4);
});
it('should support font without page reference', function ()
{
const text = new BitmapText('A', {
fontName: this.font2.font,
});
text.updateText();
expect(text.children[0].width).to.equal(19);
expect(text.children[0].height).to.equal(20);
});
it('should break line on space', function ()
{
const bmpText = new BitmapText('', {
fontName: this.font.font,
size: 24,
});
bmpText.updateText();
bmpText.maxWidth = 40;
bmpText.text = 'A A A A A A A ';
bmpText.updateText();
expect(bmpText.textWidth).to.lessThan(bmpText.maxWidth);
bmpText.maxWidth = 40;
bmpText.text = 'A A A A A A A';
bmpText.updateText();
expect(bmpText.textWidth).to.lessThan(bmpText.maxWidth);
});
it('letterSpacing should add extra space between characters', function ()
{
const text = 'ABCD zz DCBA';
const bmpText = new BitmapText(text, {
fontName: this.font.font,
});
bmpText.updateText();
const positions = [];
const renderedChars = bmpText.children.length;
for (let x = 0; x < renderedChars; ++x)
{
positions.push(bmpText.children[x].x);
}
for (let space = 1; space < 20; ++space)
{
bmpText.letterSpacing = space;
bmpText.updateText();
let prevPos = bmpText.children[0].x;
for (let char = 1; char < renderedChars; ++char)
{
expect(bmpText.children[char].x).to.equal(prevPos + space + positions[char] - positions[char - 1]);
prevPos = bmpText.children[char].x;
}
}
});
});
|
version https://git-lfs.github.com/spec/v1
oid sha256:83b62519896952609b891ea567a06d007ad10a4d4aa296cea256df1a37363927
size 57041
|
version https://git-lfs.github.com/spec/v1
oid sha256:2af938b8718086cc1a60fb31a17afbb2a0143170e2b0a8436416e58c6c8e4de5
size 7343
|
/*
* live-list.js
*
* Copyright (c) 2013 Maximilian Antoni <mail@maxantoni.de>
*
* @license MIT
*/
'use strict';
var inherits = require('inherits');
var MinIterator = require('min-iterator');
var Item = require('./item').Item;
function Iterator(list) {
this._list = list;
this._item = list._head;
}
inherits(Iterator, MinIterator);
Iterator.prototype.next = function () {
var c = this._item.next;
if (c) {
this._item = c;
return this._item.value;
}
return undefined;
};
Iterator.prototype.insert = function (value) {
var c = this._item;
var i = new Item(value, c, c.prev);
c.prev.next = i;
c.prev = i;
this._list.length++;
};
Iterator.prototype.remove = function () {
var c = this._item;
c.prev.next = c.next;
if (c.next) {
c.next.prev = c.prev;
}
if (this._list._tail === c) {
this._list._tail = c.prev;
}
this._item = c.prev;
this._list.length--;
};
exports.Iterator = Iterator;
|
/* @flow */
import prompt from './prompt'
import fse from 'fs-extra'
import generate from './generate'
// TODO: Add options object, { silent, force }
// TODO: Prompt for overwrite, defaults to yes
export default async function scaffold (srcDir: string, destDir: string, questions: Object = {}, props: Object = {}): Promise {
fse.ensureDirSync(destDir)
const data = await prompt(questions, props)
generate(srcDir, destDir, data)
}
|
import _ from 'lodash';
import { trans } from 'actions';
import { handleActions } from 'redux-actions';
const initialState = {
trans: {},
transPutStatus: 'waiting',
transPostStatus: 'waiting',
transDelStatus: 'waiting',
};
export default handleActions({
[trans.PUT_TRANSPORT]: (state, action) => _.assign({}, state, action.payload),
[trans.POST_TRANSPORT]: (state, action) => _.assign({}, state, action.payload),
[trans.DEL_TRANSPORT]: (state, action) => _.assign({}, state, action.payload),
}, initialState);
|
/*
* Paper.js - The Swiss Army Knife of Vector Graphics Scripting.
* http://paperjs.org/
*
* Copyright (c) 2011 - 2013, Juerg Lehni & Jonathan Puckey
* http://lehni.org/ & http://jonathanpuckey.com/
*
* Distributed under the MIT license. See LICENSE file for details.
*
* All rights reserved.
*/
module('Path Curves');
test('path.curves synchronisation', function() {
var path = new Path();
path.add(new Point(100, 100));
equals(path.segments.toString(), "{ point: { x: 100, y: 100 } }", "path.segments: path.add(new Point(100, 100));");
equals(path.curves.toString(), "", "path.curves: path.add(new Point(100, 100));");
path.insert(0, new Point(0, 100));
equals(path.segments.toString(), "{ point: { x: 0, y: 100 } },{ point: { x: 100, y: 100 } }", "path.segments: path.insert(0, new Point(0, 100));");
equals(path.curves.toString(), "{ point1: { x: 0, y: 100 }, point2: { x: 100, y: 100 } }", "path.curves: path.insert(0, new Point(0, 100));");
path.insert(1, {point:[50, 0], handleIn:[-25, 0], handleOut:[25, 0]});
equals(path.segments.toString(), "{ point: { x: 0, y: 100 } },{ point: { x: 50, y: 0 }, handleIn: { x: -25, y: 0 }, handleOut: { x: 25, y: 0 } },{ point: { x: 100, y: 100 } }", "path.segments: path.insert(1, {point:[50, 0], handleIn:[-25, 0], handleOut:[25, 0]});");
equals(path.curves.toString(), "{ point1: { x: 0, y: 100 }, handle2: { x: -25, y: 0 }, point2: { x: 50, y: 0 } },{ point1: { x: 50, y: 0 }, handle1: { x: 25, y: 0 }, point2: { x: 100, y: 100 } }", "path.curves: path.insert(1, {point:[50, 0], handleIn:[-25, 0], handleOut:[25, 0]});");
path.closed = true;
equals(path.segments.toString(), "{ point: { x: 0, y: 100 } },{ point: { x: 50, y: 0 }, handleIn: { x: -25, y: 0 }, handleOut: { x: 25, y: 0 } },{ point: { x: 100, y: 100 } }", "path.segments: path.closed = true;");
equals(path.curves.toString(), "{ point1: { x: 0, y: 100 }, handle2: { x: -25, y: 0 }, point2: { x: 50, y: 0 } },{ point1: { x: 50, y: 0 }, handle1: { x: 25, y: 0 }, point2: { x: 100, y: 100 } },{ point1: { x: 100, y: 100 }, point2: { x: 0, y: 100 } }", "path.curves: path.closed = true;");
path.removeSegments(2, 3);
equals(path.segments.toString(), "{ point: { x: 0, y: 100 } },{ point: { x: 50, y: 0 }, handleIn: { x: -25, y: 0 }, handleOut: { x: 25, y: 0 } }", "path.segments: path.removeSegments(2, 3);");
equals(path.curves.toString(), "{ point1: { x: 0, y: 100 }, handle2: { x: -25, y: 0 }, point2: { x: 50, y: 0 } },{ point1: { x: 50, y: 0 }, handle1: { x: 25, y: 0 }, point2: { x: 0, y: 100 } }", "path.curves: path.removeSegments(2, 3);");
path.add(new Point(100, 100));
path.removeSegments(1, 2);
equals(path.segments.toString(), "{ point: { x: 0, y: 100 } },{ point: { x: 100, y: 100 } }", "path.segments: path.add(new Point(100, 100));\npath.removeSegments(1, 2);");
equals(path.curves.toString(), "{ point1: { x: 0, y: 100 }, point2: { x: 100, y: 100 } },{ point1: { x: 100, y: 100 }, point2: { x: 0, y: 100 } }", "path.curves: path.add(new Point(100, 100));\npath.removeSegments(1, 2);");
// Transform the path, and the curves length should be invalidated (first, force-cache the first segment's length by accessing it
var length = path.curves[0].length;
ok(path.curves[0]._length, 'Curve length does not appear to be cached');
path.scale(2, [0, 0]);
equals(path.curves[0].length, 200, 'Curve length should be updated when path is transformed');
var points = [];
for (var i = 0; i < 40; i++)
points.push(Point.random());
var path = new Path(points);
equals(path.segments.length, 40, 'segments.length');
equals(path.curves.length, 39, 'curves.length');
path.removeSegments();
equals(path.segments.length, 0, 'segments.length');
equals(path.curves.length, 0, 'curves.length');
});
test('path.curves on closed paths', function() {
var path = new Path.Circle(new Point(100, 100) , 100);
equals(path.curves.toString(), "{ point1: { x: 0, y: 100 }, handle1: { x: 0, y: -55.22847 }, handle2: { x: -55.22847, y: 0 }, point2: { x: 100, y: 0 } },{ point1: { x: 100, y: 0 }, handle1: { x: 55.22847, y: 0 }, handle2: { x: 0, y: -55.22847 }, point2: { x: 200, y: 100 } },{ point1: { x: 200, y: 100 }, handle1: { x: 0, y: 55.22847 }, handle2: { x: 55.22847, y: 0 }, point2: { x: 100, y: 200 } },{ point1: { x: 100, y: 200 }, handle1: { x: -55.22847, y: 0 }, handle2: { x: 0, y: 55.22847 }, point2: { x: 0, y: 100 } }");
path.removeSegments(0, 1);
equals(path.curves.toString(), "{ point1: { x: 100, y: 0 }, handle1: { x: 55.22847, y: 0 }, handle2: { x: 0, y: -55.22847 }, point2: { x: 200, y: 100 } },{ point1: { x: 200, y: 100 }, handle1: { x: 0, y: 55.22847 }, handle2: { x: 55.22847, y: 0 }, point2: { x: 100, y: 200 } },{ point1: { x: 100, y: 200 }, handle1: { x: -55.22847, y: 0 }, handle2: { x: -55.22847, y: 0 }, point2: { x: 100, y: 0 } }");
});
test('path.flatten(maxDistance)', function() {
var path = new Path.Circle(new Size(80, 50), 35);
// Convert its curves to points, with a max distance of 20:
path.flatten(20);
equals(function() {
return path.lastSegment.point.equals(path.firstSegment.point);
}, false, 'The points of the last and first segments should not be the same.');
equals(function() {
return path.lastSegment.point.toString() != path.segments[path.segments.length - 2].point.toString();
}, true, 'The points of the last and before last segments should not be so close, that calling toString on them returns the same string value.');
});
test('Curve list after removing a segment - 1', function() {
var path = new paper.Path([0, 0], [1, 1], [2, 2]);
equals(function() {
return path.curves.length;
}, 2, 'After creating a path with three segments, we should have two curves. By accessing path.curves we also make sure the curves are created internally.');
equals(function() {
return path.segments[1].remove();
}, true, 'Removing the paths second segment should be succesfull.');
equals(function() {
return path.curves.length;
}, 1, 'After removing the middle segment, we should be left with one curve');
});
test('Curve list after removing a segment - 2', function() {
var path = new paper.Path([0, 0], [1, 1], [2, 2]);
equals(function() {
return path.curves.length;
}, 2, 'After creating a path with three segments, we should have two curves. By accessing path.curves we also make sure the curves are created internally.');
equals(function() {
return path.segments[2].remove();
}, true, 'Removing the paths last segment should be succesfull.');
equals(function() {
return path.curves.length;
}, 1, 'After removing the last segment, we should be left with one curve');
});
test('Splitting a straight path should produce linear segments', function() {
var path = new Path.Line([0, 0], [50, 50]);
var path2 = path.split(0, 0.5);
equals(function() {
return path2.firstSegment.linear;
}, true);
});
|
ngulor
.module('tas')
.controller('LogoutController', LogoutController);
function LogoutController ($scope, $location, authFactory) {
authFactory.logout(function(){
$location.path('/login');
$scope.$apply();
});
}
|
$(document).ready(function() {
var BASE_URL = $('#hdnBaseUrl').val();
$('form#registerForm').validate({
rules:{
fullname: 'required',
course: 'required',
age:{
number: true,
required: true
}
},
submitHandler: function(form) {
$.ajax({
type: "post",
url: BASE_URL + "useraccount/registerSuccess",
data: $(form).serialize(),
success: function (data) {
//alert('success');
swal("Successfully Registered", "", "success");
window.setTimeout(function(){location.reload()},2000)
}
});
}
});
});
|
const localNodes = exports.nodes = {
'simple-storage@1.0.0': require('./SimpleStorageNode'),
'json-stringify@1.0.0': require('./JsonStringifyNode'),
'https-request@1.0.0': require('./HttpsRequestNode'),
'http-server@1.0.0': require('./HttpServerNode'),
'javascript@1.0.0': require('./JavascriptNode'),
'tcp-server@1.0.0': require('./TcpServerNode'),
'timer@1.0.0': require('./TimerNode'),
'stdio@1.0.0': require('./StdioNode')
};
exports.createNode = (nodeData) => {
const Node = localNodes[nodeData.type];
if (!Node) {
return Promise.reject(new Error('Node type is not supported'));
}
return Promise.resolve(new Node(nodeData.id, nodeData.props));
};
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _VideoSpan = require('./VideoSpan');
var _VideoSpan2 = _interopRequireDefault(_VideoSpan);
var _draftJsWhkfzyx = require('draft-js-whkfzyx');
var _main = require('../utils/stateUtils/main');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function findVideoEntities(contentBlock, callback) {
contentBlock.findEntityRanges(function (character) {
var entityKey = character.getEntity();
return entityKey != null && _draftJsWhkfzyx.Entity.get(entityKey).getType() === _main.ENTITY_TYPE.VIDEO;
}, callback);
}
exports.default = {
strategy: findVideoEntities,
component: _VideoSpan2.default
};
|
angular.module("EmmetBlue")
.controller('verifyHmoProceedController', function($scope, utils){
$scope.getHmoProceedStatus = function(id){
if (typeof id !== "undefined"){
var request = utils.serverRequest("/accounts-biller/hmo-sales-verification/get-status?uuid="+id+"&staff="+utils.userSession.getID(), "GET");
request.then(function(response){
if (typeof response[0] !== "undefined" && typeof response[0].ProceedStatus !== "undefined" && response[0].ProceedStatus != false && response[0].ProceedStatus != null){
utils.alert("Verification successful", "Proceed status confirmed", "success");
if (response[0].SignComment !== null && response[0].SignComment !== ""){
utils.notify("HMO Proceed Message", response[0].SignComment, "info");
}
}
else if (typeof response[0] !== "undefined" && response[0].ProceedStatus == null){
utils.notify("Request unconfirmed", "The specified request has not been processed, please refer patient to HMO", "info");
}
else{
utils.alert("Verification Denied", "The specified request has been denied, please refer patient to HMO", "error");
if (typeof response[0] !== "undefined" && response[0].SignComment !== null && response[0].SignComment !== ""){
utils.notify("HMO Proceed Message", response[0].SignComment, "info");
}
}
$("#verifyHmoProceed").modal("hide");
}, function(error){
utils.errorHandler(error);
})
}
else {
utils.notify("Unable to retrieve status", "Please provide a patient ID", "warning");
}
}
});
|
$(function (){
$("a").on("click", function(e){
e.preventDefault();
//alert(this.text)
var city = this.text.toLowerCase();
$.ajax({
type: 'GET',
url: 'http://api.openweathermap.org/data/2.5/weather?q='+ city +'&appid=9fc92320165fc94d421601aeb79d3de1',
success: function(data){
//console.log(data);
$("#container").html(data.name + ": ");
$("#container").html("");
function convertC(temp){
temp = Math.round(temp - 273.15);
return (temp +"°C");
};
function convertF(temp){
temp = Math.round((temp * 9 / 5)-459.67);
return (temp + "°F");
};
$("#celsius").click(function(){
$("#container").html(convertC(data.main.temp));
});
$("#fahrenheit").click(function(){
$("#container").html(convertF(data.main.temp));
});
}
});
});
});
|
"use strict";
var Greeter = function Greeter() {};
($traceurRuntime.createClass)(Greeter, {sayHi: function() {
var name = arguments[0] !== (void 0) ? arguments[0] : 'Anonymous';
console.log(("Hi " + name + "!"));
}}, {});
var greeter = new Greeter();
greeter.sayHi();
|
/* eslint no-console: 0 */
const { defaultFrontmatter } = require(`${__dirname}/../lib/frontmatter`)
const chalk = require("chalk")
const fs = require("fs")
const glob = require("glob")
const matter = require("gray-matter")
const { promisify } = require("util")
glob.promise = promisify(glob)
const readFile = promisify(fs.readFile)
const writeFile = promisify(fs.writeFile)
const processPage = async (path) => {
const input = await readFile(path, "utf-8")
const file = matter(input)
const frontmatter = Object.assign({}, defaultFrontmatter, file.data)
if (frontmatter.date) return 0
if (frontmatter.draft) return 1
file.data.date = new Date()
await writeFile(path, file.stringify())
return path
}
const publishPages = async () => {
try {
const files = await glob.promise(`${__dirname}/../contents/**/*.md`)
const results = await Promise.all(
files.map(async (path) => await processPage(path))
)
const published = results.filter((f) => typeof f === "string").length
const drafts = results.filter((f) => f === 1).length
if (published) {
console.warn(
chalk.bold.yellow(
`${published} page${
published > 1 ? "s have" : " has"
} been marked as published!`
)
)
console.warn(
chalk.yellow("Review and stage the changes, then try committing again.")
)
process.exit(1)
}
console.info(chalk.green("No changes made!"))
if (drafts) {
console.info(
chalk.blue(
chalk`{bold ${drafts}} draft${
drafts > 1 ? "s are" : " is"
} waiting to be published.`
)
)
}
} catch (err) {
console.error(chalk.bold.red("Something went wrong!"))
console.error(err)
process.exit(2)
}
}
publishPages()
|
var express = require('express');
var Basket = require('../models/basket');
module.exports = function() {
let basketRouting = express.Router();
basketRouting.get('/:user_id', function(req, res){
Basket.find({
'user_id': req.params['user_id'],
'ordered_by_current_user': false
}).populate('product')
.exec(function(err, basket) {
if(!err && !!basket) {
res.send(basket);
}
else {
res.send([]);
}
})
});
basketRouting.post('/', function(req, res){
let basket = new Basket({
user_id: req.body.user_id,
product: req.body.product,
color: req.body.color,
quantity: req.body.quantity,
price: req.body.price,
ordered_by_current_user: req.body.ordered_by_current_user
});
basket.save(function(err, _basket) {
if (!!err) {
res.send(err);
return;
}
res.send(_basket);
})
})
basketRouting.delete('/:product_id/:user_id', function(req, res){
Basket.remove({
'_id': req.params['product_id']
}, function(err) {
Basket.find({
'user_id': req.params['user_id'],
'ordered_by_current_user': false
}).populate('product')
.exec(function(err, basket) {
if(!err && !!basket) {
res.send(basket);
}
else {
res.send([]);
}
})
})
});
basketRouting.post('/:user_id', function(req, res){
Basket.update(
{ 'user_id': req.params['user_id'] },
{ $set: {'ordered_by_current_user': req.params['ordered_by_current_user']} },
{ 'multi': true }, function(err) {
Basket.find({
'user_id': req.params['user_id']
}).populate('product')
.exec(function(err, basket) {
if(!err && !!basket) {
res.send(basket);
}
else {
res.send([]);
}
})
}
)
})
return basketRouting;
}
|
'use strict';
const nodemailer = require('nodemailer');
// create reusable transporter object using the default SMTP transport
let transporter = nodemailer.createTransport({
service: 'QQ',
auth: {
user: 'notification.help@qq.com',
pass: 'ytvvffttlzpebhjj'
}
});
// setup email data with unicode symbols
// send mail with defined transport object
module.exports = function (to, subject, text, html) {
transporter.sendMail({
from: '"帮助中心" <notification.help@qq.com>', // sender address
to: to, // list of receivers
subject: subject, // Subject line
text: text, // plain text body
html: html // html body
}, (error, info) => {
if (error) {
return console.log(error);
}
console.log('Message %s sent: %s', info.messageId, info.response);
});
}
|
var x =0;
function preload() {
myData = loadTable("data/results.csv","csv","header");
}
function setup() {
createCanvas(2000,5000);
background(0);
var col = myData.getColumn("SAT Math Avg. Score");
println(col);
println(col.length);
fill(0);
for (var i=0; i < col.length; i++) {
x = x + 10;
if (col[i] > 400 ) {
fill('red');
} else if (col[i] < 400 ) {
fill('green');
}
noStroke();
rect(x,col[i],5,5);
}
}
function draw() {
}
f
|
/*!
* robust-admin-theme (http://demo.pixinvent.com/robust-admin)
* Copyright 2017 PIXINVENT
* Licensed under the Themeforest Standard Licenses
*/
!function(window,document,$){"use strict";$(".card-form").card({container:".card-wrapper"})}(window,document,jQuery);
|
#!/usr/bin/env node
'use strict';
var
Promise = require('bluebird'),
U = require('lodash'),
FilePath = require('filepath').FilePath;
exports.main = function () {
var
cwd = FilePath.create(),
wrapper = cwd.append('src', 'browser_wrapper.js').read(),
brixx = cwd.append('node_modules', 'brixx', 'index.js').read(),
kixx = cwd.append('index.js').read(),
dest = cwd.append('dist', 'browser.js');
return Promise.all([wrapper, brixx, kixx])
.then(function (res) {
var
wrapper = res[0],
brixx = res[1],
kixx = res[2].split('\n'),
text;
kixx = (function (lines) {
var
skip = false;
return U.filter(lines, function (line) {
if (!skip && /BUILD_SKIP_START/.test(line)) {
skip = true;
}
if (skip && /BUILD_SKIP_END/.test(line)) {
skip = false;
return false;
}
return !skip;
}).join('\n');
}(kixx));
text = U.template(wrapper)({
brixx : brixx,
kixx : kixx
});
return dest.write(text);
});
};
if (require.main === module) {
exports.main()
.then(function () {
console.log('build_browser succeeded :)');
})
.catch(function (err) {
console.error('build_browser run failed:');
console.error(err.stack || err.message || err);
});
}
|
'use strict';
var chalk = require('chalk');
var moment = require('moment');
var open = require('open');
var editor = process.env.EDITOR;
var spawn = require('child_process').spawn;
var path = require('path');
var inquirer = require('inquirer');
module.exports = function modExports(args) {
var title = args._ || '';
var after = args.a || args.after || null;
var before = args.b || args.before || null;
var cat = args.c || args.category || args.categories || null;
var draft = args.d || args.draft || args.drafts || null;
var folder = args.f || args.folder || null;
var gui = args.g || args.gui || !editor;
var layout = args.l || args.layout || null;
var page = args.p || args.page || args.pages || null;
var tag = args.t || args.tag || null;
// load in the posts before processing them
this.load().then(function loadDB() {
var sourceDir = this.source_dir;
var searchDir = sourceDir;
var selected;
var entries;
var query = (page) ? 'pages' : 'posts';
Promise.resolve(this.locals.get(query).sort('-date').toArray()).then(function loadArticles(posts) {
var filtered = posts.slice();
// allow omission of leading underscore or trailing s for the common _drafts and _posts folders;
if (/post|draft/.test(folder)) {
folder = (/^_/.test(folder)) ? folder : '_' + folder;
folder = (/s$/.test(folder)) ? folder : folder + 's';
}
filtered = filterTitle(filtered);
filtered = (!!draft) ? filterDrafts(filtered) : filtered;
filtered = (!!layout) ? filterLayout(filtered) : filtered;
filtered = (!!folder) ? filterFolder(filtered) : filtered;
filtered = (!!tag) ? filterTag(filtered) : filtered;
filtered = (!!cat) ? filterCategory(filtered) : filtered;
filtered = (!!before) ? filterBefore(filtered) : filtered;
filtered = (!!after) ? filterAfter(filtered) : filtered;
if (filtered.length === 0) {
console.log(chalk.red('Sorry, no filtered matched your query. Exiting.'));
process.exit();
} else if (filtered.length === 1) {
// no menu necessary if there is only one matching file
selected = path.join(searchDir, filtered[0].source);
openFile(selected);
} else {
// get a list of entries to put in the menu -- slugs are easy because it shows the subfolder and can easily be put back together with the searchDir to open it
entries = filtered.map(function makeEntries(post) {
var entry = '';
var loc = post.source.substr(0, post.source.lastIndexOf(path.sep));
if (!post.published) {
entry = ['[', chalk.yellow.bgBlack('draft'), '] ', post.title].join('');
} else {
entry = ['[', chalk.gray(post.date.format('MM-DD-YYYY')), '] ', post.title, ' (', chalk.green(loc), ')'].join('');
}
return entry;
});
inquirer.prompt([
{
type: 'list',
name: 'file',
message: 'Select the file you wish to edit.',
choices: entries,
},
], function getAnswer(answer) {
var pos = entries.indexOf(answer.file);
selected = path.join(sourceDir, filtered[pos].source);
openFile(selected);
});
}
});
// filter the posts with the supplied regular expression
function filterTitle(posts) {
var reTitle = title.map(function makeRE(word) {
return new RegExp(word, 'i');
});
return posts.filter(function filterPosts(post) {
return reTitle.every(function checkRE(regex) {
return regex.test(post.title) || regex.test(post.slug);
});
});
}
// filter the posts using a subfolder if supplied
function filterFolder(posts) {
var reFolder = new RegExp(folder);
return posts.filter(function filterPosts(post) {
return reFolder.test(post.source.substr(0, post.source.lastIndexOf(path.sep)));
});
}
// filter the posts using a tag if supplied
function filterTag(posts) {
var reTag = new RegExp(tag);
return posts.filter(function filterPosts(post) {
return post.tags.data.some(function checkRe(postTag) {
return reTag.test(postTag.name);
});
});
}
// filter the posts using a category if supplied
function filterCategory(posts) {
var reCat = new RegExp(cat);
return posts.filter(function filterPosts(post) {
return post.categories.data.some(function checkRe(postCat) {
return reCat.test(postCat.name);
});
});
}
// filter the posts using a layout if supplied
function filterLayout(posts) {
var reLayout = new RegExp(layout, 'i');
return posts.filter(function filterPosts(post) {
return reLayout.test(post.layout);
});
}
// filter out all non-published posts
function filterDrafts(posts) {
return posts.filter(function filterPosts(post) {
return !post.published;
});
}
// filter the posts using a before date if supplied
function filterBefore(posts) {
before = moment(before.replace(/\//g, '-'), 'MM-DD-YYYY', true);
if (!before.isValid()) {
console.log(chalk.red('Before date is not valid (expecting `MM-DD-YYYY`), ignoring argument.'));
return posts;
}
return posts.filter(function filterPosts(post) {
return moment(post.date).isBefore(before);
});
}
// filter the posts using an after date if supplied
function filterAfter(posts) {
after = moment(after.replace(/\//g, '-'), 'MM-DD-YYYY', true);
if (!after.isValid()) {
console.log(chalk.red('After date is not valid (expecting `MM-DD-YYYY`), ignoring argument.'));
return posts;
}
return posts.filter(function filterPosts(post) {
return moment(post.date).isAfter(after);
});
}
// spawn process and open with associated gui or terminal editor
function openFile(file) {
var edit;
if (!editor || gui) {
open(file);
} else {
edit = spawn(editor, [file], {stdio: 'inherit'});
edit.on('exit', process.exit);
}
}
}.bind(this));
};
|
import React from 'react'
import {Link} from 'react-router-dom'
import withoutLink from './withoutLink'
export default class Button extends withoutLink {
renderLinkButton() {
return (
<Link to={this.props.to} className="os_buttonLink">
{this.renderButton()}
</Link>
)
}
}
|
/*
* Support infrastructure for Tianbar.
*
* Requires 'jquery' to be available through RequireJS.
*/
define(['jquery'], function ($) {
"use strict";
var events = window.tianbarEvents = window.tianbarEvents || [];
/**
* Create a new server event.
* @param response {Object} Server response with the callback index
* @returns {Object} 'callback' for the jQuery callback object; 'callbackIndex' for the event index to supply to Tianbar
*/
function createEvent(response) {
var callbackIndex = JSON.parse(response).callbackIndex;
var evt = events[callbackIndex] = $.Callbacks();
return {
callback: evt,
callbackIndex: callbackIndex
};
}
return {
createEvent: createEvent
};
});
|
import React from 'react'
import ReactDom from 'react-dom'
import {Router, Route, browserHistory} from 'react-router'
import IndexComponent from "./components/index/index.js"
import DetailComponent from "./components/detail/index.js"
import ListComponent from "./components/list/list.js"
import {createStore} from 'redux'
import reducer from './reducer/reducer.js'
import {Provider} from 'react-redux'
const store = createStore(reducer, window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__());
class Root extends React.Component {
render() {
return (
<Provider store={store}>
<Router history={browserHistory}>
<Route path="/" component={IndexComponent}></Route>
<Route path="/detail/:id" component={DetailComponent}></Route>
<Route path="/list/:id" component={ListComponent}></Route>
</Router>
</Provider>
)
}
}
ReactDom.render(<Root />, document.getElementById("root"));
|
/*
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
const express = require("express");
const exphbs = require('express-handlebars');
const msal = require('@azure/msal-node');
const path = require('path');
/**
* Command line arguments can be used to configure:
* - The port the application runs on
* - The cache file location
* - The authentication scenario/configuration file name
*/
const argv = require("../cliArgs");
const RESOURCE_API_PATH = './resourceApi';
const SERVER_PORT = argv.p || 3000;
const cacheLocation = argv.c || "./data/cache.json";
const cachePlugin = require('../cachePlugin')(cacheLocation);
/**
* The scenario string is the name of a .json file which contains the MSAL client configuration
* For an example of what a configuration file should look like, check out the customConfig.json file in the
* /config directory.
*
* You can create your own configuration file and replace the path inside the "config" require statement below
* with the path to your custom configuraiton.
*/
const scenario = argv.s || "customConfig";
const config = require(`./config/${scenario}.json`);
/**
* This method sets the view engine and view directory
* in which the express-handlebars views are located for
* the application's user interface. It also sets the
* express router on the app and initializes the global
* application homeAccountId variable to null.
*/
function configureExpressApp(app, router) {
// Set handlebars view engine
app.engine('.hbs', exphbs({extname: '.hbs'}));
app.set('view engine', '.hbs');
app.set('views', path.join(__dirname, '/views'));
app.use(router);
// Set homeAccountId in memory
app.locals.homeAccountId = null;
}
/**
* This method receives the MSAL AuthenticationResult and the scenario configuration,
* using them to make an authorized request to the configured resource API endpoint.
* Once the response from the API is received, this method renders the authenticated
* view with the data from the requested resource in the template parameters.
*/
function callResourceApi(res, authResponse, templateParams, scenarioConfig) {
// Get scenario specific resource API
const resourceApi = require(RESOURCE_API_PATH)(scenarioConfig.resourceApi);
const username = authResponse.account.username;
// Call graph after successfully acquiring token
resourceApi.call(authResponse.accessToken, (authResponse, endpoint) => {
// Successful silent request
templateParams = {
...templateParams,
username,
profile: JSON.stringify(authResponse, null, 4)
};
res.render("authenticated", templateParams);
});
}
/**
* The method below contains the sample application code for MSAL Node's Silent Flow
*
* This application consists of a set of HTTP routes that each control a different piece of the application logic.
*
* This application's main route is the "silentLogin" route, which is the one that calls MSAL Node's acquireTokenSilent API.
*
* The rest of the applicaiton logic is included for the following reasons:
*
* 1. To perform initial Authorization Code authentication in order to have an access token in the cache,
* thus enabling the Silent Flow scenario.
* 2. To show the usage pattern in which a Node application acquires a token silently from the cache (without user interaction)
* and uses said access token to authenticate against a resource API (such as MS Graph).
*/
const getTokenSilent = function (scenarioConfig, clientApplication, port, msalTokenCache) {
// Initialize express application object
const app = express();
// Initialize express router
const router = require("express-promise-router")( );
configureExpressApp(app, router);
// Set the port that the express server will listen on
const serverPort = port || SERVER_PORT;
// Extract token request configuration from the scenarioConfig object passed in
const requestConfig = scenarioConfig.request;
/**
* App Routes
*/
// Home Route
router.get('/', (req, res) => {
res.render("login", { showSignInButton: true});
});
// This route performs interactive login to acquire and cache an Access Token/ID Token
router.get('/login', (req, res) => {
clientApplication.getAuthCodeUrl(requestConfig.authCodeUrlParameters)
.then((response) => {
res.redirect(response);
})
.catch((error) => console.log(JSON.stringify(error)));
});
/**
* Silent Login route
*
* This route attempts to login a user silently by checking
* the persisted cache for accounts.
*/
router.get('/silentLogin', async (req, res) => {
// Retrieve all cached accounts
const accounts = await msalTokenCache.getAllAccounts();
if (accounts.length > 0) {
const account = accounts[0];
// Set global homeAccountId of the first cached account found
app.locals.homeAccountId = account.homeAccountId;
// Build silent token request
const silentRequest = { ...requestConfig.silentRequest, account: account };
let templateParams = { showLoginButton: false };
/**
* MSAL Usage
* The code below demonstrates the correct usage pattern of the ClientApplicaiton.acquireTokenSilent API.
*
* In this code block, the application uses MSAL to obtain an Access Token from the MSAL Cache. If successful,
* the response contains an `accessToken` property. Said property contains a string representing an encoded Json Web Token
* which can be added to the `Authorization` header in a protected resource request to demonstrate authorization.
*/
clientApplication.acquireTokenSilent(silentRequest)
.then((authResponse) => {
callResourceApi(res, authResponse, templateParams, scenarioConfig);
})
.catch((error) => {
console.log(error);
templateParams.couldNotAcquireToken = true;
res.render("authenticated", templateParams)
});
} else {
// If there are no cached accounts, render the login page
res.render("login", { failedSilentLogin: true, showSignInButton: true });
}
});
// Second leg of Auth Code grant
router.get('/redirect', (req, res) => {
const tokenRequest = { ...requestConfig.tokenRequest, code: req.query.code };
clientApplication.acquireTokenByCode(tokenRequest).then((response) => {
app.locals.homeAccountId = response.account.homeAccountId;
const templateParams = { showLoginButton: false, username: response.account.username, profile: false};
res.render("authenticated", templateParams);
}).catch((error) => {
console.log(error);
res.status(500).send(error);
});
});
// Displays all cached accounts
router.get('/allAccounts', async (req, res) => {
const accounts = await msalTokenCache.getAllAccounts();
if (accounts.length > 0) {
res.render("authenticated", { accounts: JSON.stringify(accounts, null, 4) })
} else if(accounts.length === 0) {
res.render("authenticated", { accounts: JSON.stringify(accounts), noAccounts: true, showSignInButton: true });
} else {
res.render("authenticated", { failedToGetAccounts: true, showSignInButton: true })
}
});
// Call a resource API with an Access Token silently obtained from the MSAL Cache
router.get('/graphCall', async (req, res) => {
// get Accounts
const account = await msalTokenCache.getAccountByHomeId(app.locals.homeAccountId);
/**
* Account index must match the account's position in the cache. The sample cache file contains a dummy account
* entry in index 0, hence the actual account that is logged in will be index 1
*/
const silentRequest = { ...requestConfig.silentRequest, account: account };
let templateParams = { showLoginButton: false };
/**
* MSAL Usage
* The code below demonstrates the correct usage pattern of the ClientApplicaiton.acquireTokenSilent API.
*
* In this code block, the application uses MSAL to obtain an Access Token from the MSAL Cache. If successful,
* the response contains an `accessToken` property. Said property contains a string representing an encoded Json Web Token
* which can be added to the `Authorization` header in a protected resource request to demonstrate authorization.
*/
clientApplication.acquireTokenSilent(silentRequest)
.then((authResponse) => {
callResourceApi(res, authResponse, templateParams, scenarioConfig);
})
.catch((error) => {
console.log(error);
templateParams.couldNotAcquireToken = true;
res.render("authenticated", templateParams)
});
});
return app.listen(serverPort, () => console.log(`Msal Node Silent Flow Sample app listening on port ${serverPort}!`));
};
/**
* The code below checks if the script is being executed manually or in automation.
* If the script was executed manually, it will initialize a PublicClientApplication object
* and execute the sample application.
*/
if(argv.$0 === "index.js") {
const loggerOptions = {
loggerCallback(loglevel, message, containsPii) {
console.log(message);
},
piiLoggingEnabled: false,
logLevel: msal.LogLevel.Verbose,
}
// Build MSAL ClientApplication Configuration object
const clientConfig = {
auth: config.authOptions,
cache: {
cachePlugin
},
// Uncomment the code below to enable the MSAL logger
/*
* system: {
* loggerOptions: loggerOptions
* }
*/
};
// Create an MSAL PublicClientApplication object
const publicClientApplication = new msal.PublicClientApplication(clientConfig);
const msalTokenCache = publicClientApplication.getTokenCache();
// Execute sample application with the configured MSAL PublicClientApplication
return getTokenSilent(config, publicClientApplication, null, msalTokenCache);
}
// The application code is exported so it can be executed in automation environments
module.exports = getTokenSilent;
|
'use strict';
define([
'dojo/_base/lang',
'dojo/aspect',
'./article',
'./feed',
'../retrieveFeed'
], function (lang, aspect, articleStore, feedStore, retrieveFeed) {
let skipRecalculate = false;
function recalculateUnread(feedId) {
const feed = feedStore.getSync(feedId);
feed.unread = articleStore.filter({ feedId: feedId }).fetchSync().reduce((total, article) => {
return total + (article.isRead ? 0 : 1);
}, 0);
feedStore.putSync(feed);
}
var util = {
incrementUnread(feedId, increment) {
const feed = feedStore.getSync(feedId);
feed.unread += increment;
feedStore.putSync(feed);
},
addArticles(articles, feed) {
skipRecalculate = true;
articles.forEach(function (article) {
articleStore.addSync(lang.mixin(article, {
feedId: feed.id,
id: feed.id + ':' + article.id
}));
});
skipRecalculate = false;
recalculateUnread(feed.id);
},
addFeed(url, parent) {
return retrieveFeed(url).then(function (data) {
const feed = feedStore.addSync(lang.mixin({
parent: parent,
unread: 0
}, data.metadata));
util.addArticles(data.articles, feed);
return feed;
});
},
addFolder(name, parent) {
return feedStore.addSync({ title: name, parent: parent });
},
removeFeed(id) {
const articles = articleStore.filter({ feedId: id }).fetchSync();
skipRecalculate = true;
for (let i = articles.length; i--;) {
articleStore.removeSync(articles[i].id);
}
skipRecalculate = false;
recalculateUnread(id);
feedStore.removeSync(id);
}
};
// Use aspect rather than events to update unread counts in feedStore based on articleStore write operations,
// since dstore doesn't provide enough info in events to be useful (no data in delete)
aspect.after(articleStore, 'addSync', function (article) {
// This handler will be hammered during mass article adding (for new feeds or periodic refreshes),
// so avoid incurring N recalculations when we only need 1 (addArticles calls recalculateUnread).
if (!skipRecalculate && !article.isRead) {
util.incrementUnread(article.feedId, 1);
}
return article;
});
aspect.before(articleStore, 'removeSync', function (id) {
const article = this.getSync(id);
if (!skipRecalculate && article && !article.isRead) {
util.incrementUnread(article.feedId, -1);
}
});
aspect.before(articleStore, 'putSync', function (article) {
// Unfortunately we need to do a full recount for the feed, since Memory doesn't protect/clone its objects
// (IOW it's typically too late to get the old value by the time `put` is called).
// Fortunately this path is far rarer than the path manually covered in the select handler above.
if (!skipRecalculate) {
recalculateUnread(article.feedId);
}
});
return util;
});
|
(function($) {
Sammy = Sammy || {};
// `Sammy.Haml` provides a quick way of using haml style templates in your app.
// The plugin wraps haml-js library created by Tim Caswell at
// at http://github.com/creationix/haml-js
//
// Note: As of Sammy 0.7, Sammy.Haml does not include the actual templating engine in the source.
// Include haml.js before including sammy.haml.js
//
// Haml is an alternative HTML syntax that is really great for describing
// the structure of HTML documents.
//
// By default using Sammy.Haml in your app adds the <tt>haml()</tt> method to the EventContext
// prototype. However, just like `Sammy.Template` you can change the default name of the method
// by passing a second argument (e.g. you could use the hml() as the method alias so that all the template
// files could be in the form file.hml instead of file.haml)
//
// ### Example
//
// The template (mytemplate.haml):
//
// %h1&= title
//
// Hey, #{name}! Welcome to Haml!
//
// The app:
//
// var $.app = $.sammy(function() {
// // include the plugin
// this.use(Sammy.Haml);
//
// this.get('#/hello/:name', function() {
// // set local vars
// this.title = 'Hello!'
// this.name = this.params.name;
// // render the template and pass it through haml
// this.partial('mytemplate.haml');
// });
//
// });
//
// If I go to `#/hello/AQ` in the browser, Sammy will render this to the `body`:
//
// <h1>Hello!</h1>
//
// Hey, AQ! Welcome to HAML!
//
// Note: You dont have to include the haml.js file on top of the plugin as the plugin
// includes the full source.
//
Sammy.Haml = function(app, method_alias) {
var haml_cache = {};
// *Helper* Uses haml-js to parse a template and interpolate and work with the passed data
//
// ### Arguments
//
// * `template` A String template.
// * `data` An Object containing the replacement values for the template.
// data is extended with the <tt>EventContext</tt> allowing you to call its methods within the template.
//
var haml = function(template, data, name) {
// use name for caching
if (typeof name == 'undefined') { name = template; }
var fn = haml_cache[name];
if (!fn) {
fn = haml_cache[name] = Haml(template);
}
return fn($.extend({}, this, data));
};
// set the default method name/extension
if (!method_alias) { method_alias = 'haml'; }
app.helper(method_alias, haml);
};
})(jQuery);
|
'use strict';
var q = require('q'),
_ = require('lodash'),
Contact = require('mongoose').model('contact');
module.exports = {
create: function(params) {
var that = this;
return Contact.create(params)
.then(function(contact) {
if (_.isArray(contact)) {
return that.find({
_id: {
$in: _.map(contact, '_id')
}
});
}
return that.findById(contact._id);
})
.catch(function(error) {
return q.reject({
code: 400,
reason: error.message
});
});
},
find: function(query) {
return Contact
.find(query)
.sort('lastname')
.select('-__v -_type')
.populate('poste')
.exec()
.catch(function(error) {
return q.reject({
code: 400,
reason: error.message
});
});
},
findById: function(contactId) {
return Contact
.findById(contactId)
.select('-__v -_type')
.populate('poste')
.exec()
.catch(function(error) {
return q.reject({
code: 400,
reason: error.message
});
});
},
update: function(contactId, params) {
var that = this;
return Contact.findByIdAndUpdate(contactId, params)
.then(function() {
return that.findById(contactId);
})
.catch(function(error) {
return q.reject({
code: 400,
reason: error.message
});
});
},
remove: function(contactId) {
return Contact.findByIdAndRemove(contactId)
.exec()
.catch(function(error) {
return q.reject({
code: 400,
reason: error.message
});
});
}
};
|
"use strict";
let { Server: WebSocketServer } = require("ws");
let { Side, Packet } = require("../common/network");
let PlayerServer = require("./PlayerServer");
let Main = require("../common/Main");
let Block = require("../common/Block");
let { extend } = require("../common/utility");
let Server = module.exports = class Server extends Main {
constructor(port) {
super(Side.SERVER);
this.port = port;
this.clients = new Set();
}
start() {
this.wss = new WebSocketServer({ port: this.port });
this.wss.on("connection", (socket) => {
let player = new PlayerServer(socket);
this.add(player);
this.clients.add(player);
this.emit("connect", player);
socket.on("message", (data) => {
Packet.parse(player, data, Side.SERVER); });
socket.on("close", (code, reason) => {
this.emit("disconnect", player);
this.remove(player);
this.clients.delete(player); });
});
}
stop(reason = "Shutting down ...") {
throw new Error("Not implemted! :O");
}
};
let server = new Server(42006);
server.on("connect", (player) => { console.log(`${ player } connected`); });
server.on("disconnect", (player) => { console.log(`${ player } disconnected`); });
server.on("login", (player) => {
console.log(`${ player } logged in`);
for (let entity of server.entities.values())
if (entity instanceof Block)
player.send("spawn", { id: entity.id, type: 0, x: entity.pos[0], y: entity.pos[1] });
});
for (let x = 16; x < 240; x += 16) {
server.add(extend(new Block(), { pos: [ x, 16 ], color: [ 1, 0, 0, 1 ] }));
server.add(extend(new Block(), { pos: [ x, 160 - 16 ], color: [ 0, 1, 0, 1 ] }));
}
for (let y = 32; y < 160 - 16; y += 16) {
server.add(extend(new Block(), { pos: [ 16, y ], color: [ 0, 0, 1, 1 ] }));
server.add(extend(new Block(), { pos: [ 240 - 16, y ], color: [ 1, 1, 0, 1 ] }));
}
server.start();
|
var assert = require('assert');
var http = require('http');
var os = require('os');
var request = require('supertest');
var spdy = require('spdy');
var zetta = require('../');
var Query = require('calypso').Query;
var rels = require('zetta-rels');
var zettacluster = require('zetta-cluster');
var Scout = require('./fixture/example_scout');
var Driver = require('./fixture/example_driver');
var HttpDriver = require('./fixture/example_http_driver');
var Registry = require('./fixture/mem_registry');
var PeerRegistry = require('./fixture/mem_peer_registry');
function getHttpServer(app) {
return app.httpServer.server;
}
function getBody(fn) {
return function(res) {
try {
if(res.text) {
var body = JSON.parse(res.text);
} else {
var body = '';
}
} catch(err) {
throw new Error('Failed to parse json body');
}
fn(res, body);
}
}
function checkDeviceOnRootUri(entity) {
assert(entity.class.indexOf('device') >= 0);
assert(entity.class.indexOf(entity.properties.type) >= 0);
assert.deepEqual(entity.rel, ["http://rels.zettajs.io/device"]);
assert(entity.properties.name);
assert(entity.properties.type);
assert(entity.properties.state);
assert(!entity.actions); // should not have actions on it
assert(entity.links);
hasLinkRel(entity.links, rels.self);
hasLinkRel(entity.links, rels.server);
hasLinkRel(entity.links, rels.type);
hasLinkRel(entity.links, rels.edit);
}
function hasLinkRel(links, rel, title, href) {
var found = false;
links.forEach(function(link) {
if(link.rel.indexOf(rel) != -1) {
found = true;
if(title !== undefined && link.title !== title) {
throw new Error('link title does not match');
}
if(href !== undefined && link.href !== href) {
throw new Error('link href does not match');
}
}
});
if(!found) {
throw new Error('Link rel:'+rel+' not found in links');
}
}
describe('Zetta Api', function() {
var reg = null;
var peerRegistry = null;
beforeEach(function() {
reg = new Registry();
peerRegistry = new PeerRegistry();
});
it('updates href hosts using x-forwarded-host header', function(done) {
var app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.name('local')
._run(function(err) {
if (err) {
return done(err);
}
request(getHttpServer(app))
.get('/')
.set('x-forwarded-host', 'google.com')
.expect(getBody(function(res, body) {
var self = body.links.filter(function(link) { return link.rel.indexOf('self') >= 0; })[0];
assert.equal(self.href, 'http://google.com/');
}))
.end(done);
});
})
it('updates href path using x-forwarded-path header', function(done) {
var app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.name('local')
._run(function(err) {
if (err) {
return done(err);
}
var rootPath = '/api/v1';
request(getHttpServer(app))
.get('/')
.set('x-forwarded-path', rootPath)
.expect(getBody(function(res, body) {
var self = body.links.filter(function(link) { return link.rel.indexOf('self') >= 0; })[0];
var resultPath = require('url').parse(self.href).pathname;
assert.equal(resultPath.substr(0, rootPath.length), rootPath);
}))
.end(done);
});
})
it('allow for x-forwarded-host header to be disabled', function(done) {
var app = zetta({ registry: reg, peerRegistry: peerRegistry, useXForwardedHostHeader: false })
.silent()
.name('local')
._run(function(err) {
if (err) {
return done(err);
}
request(getHttpServer(app))
.get('/')
.set('x-forwarded-host', 'google.com')
.expect(getBody(function(res, body) {
var self = body.links.filter(function(link) { return link.rel.indexOf('self') >= 0; })[0];
assert.notEqual(self.href, 'http://google.com/');
}))
.end(done);
});
})
it('allow for x-forwarded-path header to be disabled', function(done) {
var app = zetta({ registry: reg, peerRegistry: peerRegistry, useXForwardedPathHeader: false })
.silent()
.name('local')
._run(function(err) {
if (err) {
return done(err);
}
var rootPath = '/api/v1';
request(getHttpServer(app))
.get('/')
.set('x-forwarded-path', rootPath)
.expect(getBody(function(res, body) {
var self = body.links.filter(function(link) { return link.rel.indexOf('self') >= 0; })[0];
var resultPath = require('url').parse(self.href).pathname;
var resultPathSub = resultPath.substr(0,rootPath.length);
assert.notEqual(resultPathSub, rootPath);
assert.equal(resultPathSub, '/');
}))
.end(done);
});
})
describe('/servers/<peer id> ', function() {
var app = null;
var url = null;
beforeEach(function(done) {
app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.properties({ custom: 123 })
.use(Scout)
.use(HttpDriver)
.name('local')
.expose('*')
._run(done);
url = '/servers/'+app._name;
});
it('should have content type application/vnd.siren+json', function(done) {
request(getHttpServer(app))
.get(url)
.expect('Content-Type', 'application/vnd.siren+json', done);
});
it('should return status code 200', function(done) {
request(getHttpServer(app))
.get(url)
.expect(200, done);
});
it('should have class ["server"]', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert.deepEqual(body.class, ['server']);
}))
.end(done);
});
it('should have proper name and id property', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert.equal(body.properties.name, 'local');
}))
.end(done);
});
it('should have custom properties in resp', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert.equal(body.properties.name, 'local');
assert.equal(body.properties.custom, 123);
}))
.end(done);
});
it('should have self link and log link', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert(body.links);
hasLinkRel(body.links, 'self');
hasLinkRel(body.links, 'monitor');
}))
.end(done);
});
it('should have a metadata link', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert(body.links);
hasLinkRel(body.links, rels.metadata);
}))
.end(done);
});
it('should have monitor log link formatted correctly for HTTP requests', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
var link = body.links.filter(function(l) {
return l.rel.indexOf('monitor') > -1;
})[0];
var obj = require('url').parse(link.href, true);
assert.equal(obj.protocol, 'ws:');
assert(obj.query.topic);
}))
.end(done);
});
it('should have monitor log link formatted correctly for SPDY requests', function(done) {
var a = getHttpServer(app);
if (!a.address()) a.listen(0);
var agent = spdy.createAgent({
host: '127.0.0.1',
port: a.address().port,
spdy: {
plain: true,
ssl: false
}
});
var request = http.get({
host: '127.0.0.1',
port: a.address().port,
path: url,
agent: agent
}, function(response) {
var buffers = [];
response.on('readable', function() {
var data;
while ((data = response.read()) !== null) {
buffers.push(data);
}
});
response.on('end', function() {
var body = JSON.parse(Buffer.concat(buffers));
var link = body.links.filter(function(l) {
return l.rel.indexOf('monitor') > -1;
})[0];
var obj = require('url').parse(link.href, true);
assert.equal(obj.protocol, 'http:');
assert(obj.query.topic);
agent.close();
});
response.on('end', done);
}).end();
});
it('should not have an events link for SPDY requests', function(done) {
var a = getHttpServer(app);
if (!a.address()) a.listen(0);
var agent = spdy.createAgent({
host: '127.0.0.1',
port: a.address().port,
spdy: {
plain: true,
ssl: false
}
});
var request = http.get({
host: '127.0.0.1',
port: a.address().port,
path: '/',
agent: agent
}, function(response) {
var buffers = [];
response.on('readable', function() {
var data;
while ((data = response.read()) !== null) {
buffers.push(data);
}
});
response.on('end', function() {
var body = JSON.parse(Buffer.concat(buffers));
var links = body.links.filter(function(l) {
return l.rel.indexOf('http://rels.zettajs.io/events') > -1;
});
assert.equal(links.length, 0);
agent.close();
});
response.on('end', done);
}).end();
});
it('should have valid entities', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert(body.entities);
assert.equal(body.entities.length, 1);
checkDeviceOnRootUri(body.entities[0]);
}))
.end(done);
});
it('should have one action', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert(body.actions);
assert.equal(body.actions.length, 1);
}))
.end(done);
});
it('should accept remote devices of type testdriver', function(done) {
request(getHttpServer(app))
.post(url + '/devices')
.send('type=testdriver')
.end(function(err, res) {
getBody(function(res, body) {
assert.equal(res.statusCode, 201);
var query = Query.of('devices');
reg.find(query, function(err, machines) {
assert.equal(machines.length, 2);
assert.equal(machines[1].type, 'testdriver');
done();
});
})(res);
});
});
it('should not accept a remote device of type foo', function(done) {
request(getHttpServer(app))
.post(url + '/devices')
.send('type=foo')
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 404);
}))
.end(done);
});
it('should accept remote devices of type testdriver, and allow them to set their own id properties', function(done) {
request(getHttpServer(app))
.post(url + '/devices')
.send('type=testdriver&id=12345&name=test')
.end(function(err, res) {
getBody(function(res, body) {
assert.equal(res.statusCode, 201);
var query = Query.of('devices').where('id', { eq: '12345'});
reg.find(query, function(err, machines) {
assert.equal(machines.length, 1);
assert.equal(machines[0].type, 'testdriver');
assert.equal(machines[0].id, '12345');
done();
});
})(res);
});
});
it('query for device should respond with properly formated api response', function(done) {
request(getHttpServer(app))
.get(url+'?server=local&ql=where%20type="testdriver"')
.expect(getBody(function(res, body) {
assert(body.entities);
assert.equal(body.entities.length, 1);
checkDeviceOnRootUri(body.entities[0]);
}))
.end(done);
});
});
describe('/', function() {
var app = null;
beforeEach(function() {
app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.use(Scout)
.name('local')
.expose('*')
._run();
});
it('should have content type application/vnd.siren+json', function(done) {
request(getHttpServer(app))
.get('/')
.expect('Content-Type', 'application/vnd.siren+json', done);
});
it('should have status code 200', function(done) {
request(getHttpServer(app))
.get('/')
.expect(200, done);
});
it('body should contain class ["root"]', function(done) {
request(getHttpServer(app))
.get('/')
.expect(getBody(function(res, body) {
assert.deepEqual(body.class, ['root']);
}))
.end(done)
});
it('body should contain links property', function(done) {
request(getHttpServer(app))
.get('/')
.expect(getBody(function(res, body) {
assert.equal(body.links.length, 4);
hasLinkRel(body.links, 'self');
}))
.end(done)
});
it('links should contain rel to server', function(done) {
request(getHttpServer(app))
.get('/')
.expect(getBody(function(res, body) {
hasLinkRel(body.links, rels.server);
}))
.end(done)
});
it('should contain link for event stream', function(done) {
request(getHttpServer(app))
.get('/')
.expect(getBody(function(res, body) {
hasLinkRel(body.links, rels.events);
}))
.end(done)
});
it('should use a default server name if none has been provided', function(done) {
var app = zetta({ registry: reg, peerRegistry: peerRegistry }).silent()._run();
request(getHttpServer(app))
.get('/')
.expect(getBody(function(res, body) {
var self = body.links.filter(function(link) {
return link.rel.indexOf(rels.server) !== -1;
})[0];
assert.equal(self.title, os.hostname());
}))
.end(done);
});
});
describe('/peer-management', function() {
var app = null;
before(function(done) {
peerRegistry.save({
id: '12341234',
name: 'test-peer'
}, done);
});
beforeEach(function(done) {
app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.use(Scout)
.name('local')
.expose('*')
._run(done);
});
it('should have content type application/vnd.siren+json', function(done) {
request(getHttpServer(app))
.get('/peer-management')
.expect('Content-Type', 'application/vnd.siren+json', done);
});
it('should return status code 200', function(done) {
request(getHttpServer(app))
.get('/peer-management')
.expect(200, done);
});
it('should have class ["peer-management"]', function(done) {
request(getHttpServer(app))
.get('/peer-management')
.expect(getBody(function(err, body) {
assert.deepEqual(body.class, ['peer-management']);
}))
.end(done);
});
it('subentities should have rel ["item"]', function(done) {
peerRegistry.save({ id: '0' }, function() {
request(getHttpServer(app))
.get('/peer-management')
.expect(getBody(function(err, body) {
body.entities.forEach(function(entity) {
assert(entity.rel.indexOf('item') >= 0)
})
}))
.end(done);
});
});
it('should list saved peers', function(done) {
peerRegistry.save({ id: '0' }, function() {
request(getHttpServer(app))
.get('/peer-management')
.expect(getBody(function(err, body) {
assert.equal(body.entities.length, 1);
}))
.end(done);
});
});
it('should allow the querying of peers with the ql parameter', function(done) {
peerRegistry.save({ id: '1', type: 'initiator'}, function() {
request(getHttpServer(app))
.get('/peer-management?ql=where%20type%3D%22initiator%22')
.expect(getBody(function(err, body) {
assert.equal(body.entities.length, 1);
var entity = body.entities[0];
assert.equal(entity.properties.id, '1');
}))
.end(done);
});
});
describe('#link', function() {
it('should return status code 202', function(done) {
request(getHttpServer(app))
.post('/peer-management')
.send('url=http://testurl')
.expect(202, done);
});
it('should return a Location header', function(done) {
request(getHttpServer(app))
.post('/peer-management')
.send('url=http://testurl')
.expect('Location', /^http.+/)
.end(done);
});
it('should return Location header whose value honors forwarded host', function(done) {
request(getHttpServer(app))
.post('/peer-management')
.set('x-forwarded-host', 'google.com')
.send('url=http://testurl')
.expect('Location', /^http.+/)
.expect(function(res){
var loc = res.headers['location'];
var locHost = require('url').parse(loc).hostname;
assert.equal(locHost, 'google.com');
})
.end(done);
});
it('should return Location header whose value honors forwarded path', function(done) {
var rootPath = '/ipa/1v';
request(getHttpServer(app))
.post('/peer-management')
.set('x-forwarded-path', rootPath)
.send('url=http://testurl')
.expect('Location', /^http.+/)
.expect(function(res){
var loc = res.headers['location'];
var locPath = require('url').parse(loc).pathname;
assert.equal(locPath.substr(0,rootPath.length), rootPath);
})
.end(done);
});
});
describe('#show', function() {
it('should return the peer item representation', function(done) {
var id = '1234-5678-9ABCD';
peerRegistry.save({ id: id }, function() {
request(getHttpServer(app))
.get('/peer-management/' + id)
.expect(200, done);
});
});
});
});
describe('/devices of server', function() {
var app = null;
beforeEach(function(done) {
app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.use(Scout)
.name('local')
.expose('*')
._run(done);
});
it('should have content type application/vnd.siren+json', function(done) {
request(getHttpServer(app))
.get('/devices')
.expect('Content-Type', 'application/vnd.siren+json', done);
});
it('should return status code 200', function(done) {
request(getHttpServer(app))
.get('/devices')
.expect(200, done);
});
it('should have class ["devices"]', function(done) {
request(getHttpServer(app))
.get('/devices')
.expect(getBody(function(res, body) {
assert.deepEqual(body.class, ['devices']);
}))
.end(done);
});
it('should have one valid entity', function(done) {
request(getHttpServer(app))
.get('/devices')
.expect(getBody(function(res, body) {
assert(body.entities);
assert.equal(body.entities.length, 1);
checkDeviceOnRootUri(body.entities[0]);
hasLinkRel(body.links, 'self');
}))
.end(done);
});
it('should replace url host in all device links using forwarded host', function(done) {
var rootPath = '/alpha/v1';
request(getHttpServer(app))
.get('/devices')
.set('x-forwarded-host', 'google.ca')
.expect(getBody(function(res, body) {
body.links.forEach(function(link){
var linkHost = require('url').parse(link.href).hostname;
assert.equal(linkHost, 'google.ca');
});
}))
.end(done);
});
it('should inject path in all device links using forwared root path', function(done) {
var rootPath = '/alpha/v1';
request(getHttpServer(app))
.get('/devices')
.set('x-forwarded-path', rootPath)
.expect(getBody(function(res, body) {
body.links.forEach(function(link){
var linkPath = require('url').parse(link.href).pathname;
assert.equal(linkPath.substr(0,rootPath.length), rootPath);
});
}))
.end(done);
});
});
describe('/servers/:id/devices/:id', function() {
var app = null;
var url = null;
var device = null;
beforeEach(function(done) {
app = zetta({ registry: reg, peerRegistry: peerRegistry })
.silent()
.use(Scout)
.name('local')
.expose('*')
._run(function() {
device = app.runtime._jsDevices[Object.keys(app.runtime._jsDevices)[0]];
url = '/servers/' + app._name + '/devices/' + device.id;
done();
});
});
it('should have content type application/vnd.siren+json', function(done) {
request(getHttpServer(app))
.get(url)
.expect('Content-Type', 'application/vnd.siren+json', done);
});
it('class should be ["device", ":type"]', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert(body.class.indexOf('device') >= 0);
assert(body.class.indexOf(body.properties.type) >= 0);
}))
.end(done);
});
/*
checkDeviceOnRootUri(body.entities[0]);
hasLinkRel(body.links, 'self');
*/
it('properties should match expected', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert(body.properties);
assert.equal(body.properties.name, device.name);
assert.equal(body.properties.type, device.type);
assert.equal(body.properties.id, device.id);
assert.equal(body.properties.state, device.state);
}))
.end(done);
});
it('device should have action change', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert.equal(body.actions.length, 8);
var action = body.actions[0];
assert.equal(action.name, 'change');
assert.equal(action.method, 'POST');
assert(action.href);
assert.deepEqual(action.fields[0], { name: 'action', type: 'hidden', value: 'change' });
}))
.end(done);
});
it('device actions should have class "transition"', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
assert.equal(body.actions.length, 8);
body.actions.forEach(function(action) {
assert(action.class.indexOf('transition') >= 0);
})
}))
.end(done);
});
it('device should have self link', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
hasLinkRel(body.links, 'self');
}))
.end(done);
});
it('device should have edit link', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
hasLinkRel(body.links, 'edit');
}))
.end(done);
});
it('device should have up link to server', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
hasLinkRel(body.links, 'up', 'local');
}))
.end(done);
});
it('device should have monitor link for bar', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
hasLinkRel(body.links, 'monitor');
}))
.end(done);
});
it('disabling a stream should remove it from the API.', function(done) {
Object.keys(app.runtime._jsDevices).forEach(function(name) {
var device = app.runtime._jsDevices[name];
device.disableStream('foo');
});
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
var foo = body.links.filter(function(link) {
return link.title === 'foo';
});
assert.equal(foo.length, 0);
}))
.end(done);
});
it('enabling a stream should show it in the API.', function(done) {
var device = null;
Object.keys(app.runtime._jsDevices).forEach(function(name) {
device = app.runtime._jsDevices[name];
device.disableStream('foo');
device.enableStream('foo');
});
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
var foo = body.links.filter(function(link) {
return link.title === 'foo';
});
assert.equal(foo.length, 1);
}))
.end(done);
});
it('device should have monitor link for bar formatted correctly for HTTP requests', function(done) {
request(getHttpServer(app))
.get(url)
.expect(getBody(function(res, body) {
var fooBar = body.links.filter(function(link) {
return link.title === 'foobar';
});
hasLinkRel(fooBar, rels.binaryStream);
var parsed = require('url').parse(fooBar[0].href);
assert.equal(parsed.protocol, 'ws:');
}))
.end(done);
});
it('should have a monitor link for bar formatted correctly for SPDY requests', function(done) {
var a = getHttpServer(app);
if (!a.address()) a.listen(0);
var agent = spdy.createAgent({
host: '127.0.0.1',
port: a.address().port,
spdy: {
plain: true,
ssl: false
}
});
var request = http.get({
host: '127.0.0.1',
port: a.address().port,
path: url,
agent: agent
}, function(response) {
var buffers = [];
response.on('readable', function() {
var data;
while ((data = response.read()) !== null) {
buffers.push(data);
}
});
response.on('end', function() {
var body = JSON.parse(Buffer.concat(buffers));
var fooBar = body.links.filter(function(link) {
return link.title === 'foobar';
});
hasLinkRel(fooBar, rels.binaryStream);
var parsed = require('url').parse(fooBar[0].href);
assert.equal(parsed.protocol, 'http:');
agent.close();
});
response.on('end', done);
}).end();
});
it('device action should return a 400 status code on a missing request body', function(done) {
request(getHttpServer(app))
.post(url)
.send()
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 400);
}))
.end(done);
});
it('device action should return a 400 status code on an invalid request body', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.send('{ "what": "invalid" }')
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 400);
}))
.end(done);
});
it('device action should work', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.send({ action: 'test', value: 123 })
.expect(getBody(function(res, body) {
assert.equal(body.properties.value, 123);
hasLinkRel(body.links, 'monitor');
}))
.end(done);
});
it('device action should support extended characters', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.send({ action: 'test-text', value: "🙌💸🙌" })
.expect(getBody(function(res, body) {
assert.equal(body.properties.message, "🙌💸🙌");
}))
.end(done);
});
var createTransitionArgTest = function(action, testType, input) {
it('api should decode transition args to ' + testType + ' for ' + action, function(done) {
var device = app.runtime._jsDevices[Object.keys(app.runtime._jsDevices)[0]];
var orig = device._transitions[action].handler;
device._transitions[action].handler = function(x) {
assert.equal(typeof x, testType);
orig.apply(device, arguments);
};
request(getHttpServer(app))
.post(url)
.type('form')
.expect(200)
.send({ action: action, value: input })
.end(done);
});
};
createTransitionArgTest('test-number', 'number', 123)
createTransitionArgTest('test-text', 'string', 'Hello');
createTransitionArgTest('test-none', 'string', 'Anything');
createTransitionArgTest('test-date', 'object', '2015-01-02');
it('api should respond with 400 when argument is not expected number', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.expect(400)
.expect(getBody(function(res, body) {
assert(body.class.indexOf('input-error') > -1);
assert.equal(body.properties.errors.length, 1);
}))
.send({ action: 'test-number', value: 'some string' })
.end(done);
})
it('api should respond with 400 when argument is not expected Date', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.expect(400)
.expect(getBody(function(res, body) {
assert(body.class.indexOf('input-error') > -1);
assert.equal(body.properties.errors.length, 1);
}))
.send({ action: 'test-date', value: 'some string' })
.end(done);
})
it('device action should return 400 when not available.', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.send({ action: 'prepare' })
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 400);
}))
.end(done);
});
it('should return 500 when a error is passed in a callback of device driver', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.send({ action: 'error', error: 'some error' })
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 500);
assert(body.class.indexOf('action-error') >= 0);
assert(body.properties.message);
assert.equal(body.properties.message, 'some error');
hasLinkRel(body.links, rels.self);
}))
.end(done);
});
it('should return custom error information when a error is passed in a callback of device driver', function(done) {
request(getHttpServer(app))
.post(url)
.type('form')
.send({action: 'test-custom-error'})
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 401);
assert(body.class.indexOf('action-error') >= 0);
assert(body.properties.message);
assert.equal('custom error message', body.properties.message);
hasLinkRel(body.links, rels.self);
}))
.end(done);
});
it('should support device updates using PUT', function(done) {
request(getHttpServer(app))
.put(url)
.type('json')
.send({ bar: 2, value: 3 })
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 200);
assert.equal(body.properties.bar, 2);
assert.equal(body.properties.value, 3);
}))
.end(done);
});
it('should support device deletes using DELETE', function(done) {
request(getHttpServer(app))
.del(url)
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 204);
assert.equal(Object.keys(app.runtime._jsDevices).length, 0);
}))
.end(done);
});
it('remoteDestroy hook should prevent the device from being destroyed with a DELETE', function(done) {
var deviceKey = Object.keys(app.runtime._jsDevices)[0];
var device = app.runtime._jsDevices[deviceKey];
var remoteDestroy = function(cb) {
cb(null, false);
}
device._remoteDestroy = remoteDestroy.bind(device);
request(getHttpServer(app))
.del(url)
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 500);
assert.equal(Object.keys(app.runtime._jsDevices).length, 1);
}))
.end(done);
});
it('remoteDestroy hook should prevent the device from being destroyed with a DELETE if callback has an error', function(done) {
var deviceKey = Object.keys(app.runtime._jsDevices)[0];
var device = app.runtime._jsDevices[deviceKey];
var remoteDestroy = function(cb) {
cb(new Error('Oof! Ouch!'));
}
device._remoteDestroy = remoteDestroy.bind(device);
request(getHttpServer(app))
.del(url)
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 500);
assert.equal(Object.keys(app.runtime._jsDevices).length, 1);
}))
.end(done);
});
it('remoteDestroy hook should allow the device to be destroyed when callback is called with true', function(done) {
var deviceKey = Object.keys(app.runtime._jsDevices)[0];
var device = app.runtime._jsDevices[deviceKey];
var remoteDestroy = function(cb) {
cb(null, true);
}
device._remoteDestroy = remoteDestroy.bind(device);
request(getHttpServer(app))
.del(url)
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 204);
assert.equal(Object.keys(app.runtime._jsDevices).length, 0);
}))
.end(done);
});
it('should not overwrite monitor properties using PUT', function(done) {
request(getHttpServer(app))
.put(url)
.type('json')
.send({ foo: 1 })
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 200);
assert.equal(body.properties.foo, 0);
}))
.end(done);
});
it('should return a 404 when updating a non-existent device', function(done) {
request(getHttpServer(app))
.put(url + '1234567890')
.type('json')
.send({ foo: 1, bar: 2, value: 3 })
.expect(function(res) {
assert.equal(res.statusCode, 404);
})
.end(done);
});
it('should return a 400 when updating with a Content-Range header', function(done) {
request(getHttpServer(app))
.put(url)
.set('Content-Range', 'bytes 0-499/1234')
.type('json')
.send({ foo: 1, bar: 2, value: 3 })
.expect(function(res) {
assert.equal(res.statusCode, 400);
})
.end(done);
});
it('should return a 400 when receiving invalid JSON input', function(done) {
request(getHttpServer(app))
.put(url)
.type('json')
.send('{"name":}')
.expect(function(res) {
assert.equal(res.statusCode, 400);
})
.end(done);
});
it('should not include reserved fields on device updates', function(done) {
var input = { foo: 1, bar: 2, value: 3, id: 'abcdef',
_x: 4, type: 'h', state: 'yo', streams: 's' };
request(getHttpServer(app))
.put(url)
.type('json')
.send(input)
.expect(getBody(function(res, body) {
assert.equal(res.statusCode, 200);
assert.notEqual(body.properties.id, 'abcdef');
assert.notEqual(body.properties._x, 4);
assert.notEqual(body.properties.streams, 's');
assert.notEqual(body.properties.state, 'yo');
assert.notEqual(body.properties.type, 'h');
}))
.end(done);
});
});
describe('Proxied requests', function() {
var base = null;
var cloudUrl = null;
var cluster = null;
beforeEach(function(done) {
cluster = zettacluster({ zetta: zetta })
.server('cloud')
.server('detroit', [Scout], ['cloud'])
.server('sanjose', [Scout], ['cloud'])
.on('ready', function(){
cloudUrl = 'localhost:' + cluster.servers['cloud']._testPort;
base = 'localhost:' + cluster.servers['cloud']._testPort + '/servers/' + cluster.servers['cloud'].locatePeer('detroit');
setTimeout(done, 300);
})
.run(function(err) {
console.log(err)
if (err) {
done(err);
}
});
});
afterEach(function(done) {
cluster.stop();
setTimeout(done, 10); // fix issues with server not being closed before a new one starts
});
it('zetta should not crash when req to hub is pending and hub disconnects', function(done) {
http.get('http://' + base, function(res) {
assert.equal(res.statusCode, 502);
done();
}).on('socket', function(socket) {
socket.on('connect', function() {
cluster.servers['cloud'].httpServer.peers['detroit'].close();
});
})
})
it('zetta should return 404 on non-existent peer', function(done) {
http.get('http://' + cloudUrl + '/servers/some-peer', function(res) {
assert.equal(res.statusCode, 404);
done();
})
})
it('zetta should return 404 on disconnected peer', function(done) {
cluster.servers['detroit']._peerClients[0].close()
http.get('http://' + cloudUrl + '/servers/detroit', function(res) {
assert.equal(res.statusCode, 404);
done();
})
})
it('device action should support extended characters throw a proxied connection', function(done) {
var device = cluster.servers['detroit'].runtime._jsDevices[Object.keys(cluster.servers['detroit'].runtime._jsDevices)[0]];
request(getHttpServer(cluster.servers['cloud']))
.post('/servers/detroit/devices/' + device.id)
.type('form')
.send({ action: 'test-text', value: "🙌💸🙌" })
.expect(getBody(function(res, body) {
assert.equal(body.properties.message, "🙌💸🙌");
}))
.end(done);
});
})
describe('Server name issues', function() {
var cluster;
var hubName = 'hub 1';
var getServer = function(peerName) {
return cluster.servers[peerName].httpServer.server;
};
beforeEach(function(done) {
cluster = zettacluster({ zetta: zetta })
.server('cloud')
.server(hubName, [Scout], ['cloud'])
.on('ready', done)
.run(function(err) {
if (err) {
done(err);
}
});
});
it('server name with space has correct path to root of server', function(done) {
request(getServer('cloud'))
.get('/')
.expect(getBody(function(res, body) {
var link = body.links.filter(function(link) { return link.title === hubName})[0];
var parsed = require('url').parse(link.href);
assert.equal(decodeURI(parsed.path), '/servers/' + hubName);
}))
.end(done);
})
it('server name with space has correct path to device', function(done) {
request(getServer('cloud'))
.get('/servers/' + hubName)
.expect(getBody(function(res, body) {
body.entities.forEach(function(entity) {
entity.links.forEach(function(link) {
var parsed = require('url').parse(link.href);
assert.equal(decodeURI(parsed.path).indexOf('/servers/' + hubName), 0);
});
});
}))
.end(done);
})
})
});
|
System.registerDynamic("ng2-charts/components/charts/charts", ["angular2/core", "angular2/common"], true, function($__require, exports, module) {
"use strict";
;
var define,
global = this,
GLOBAL = this;
var __decorate = (this && this.__decorate) || function(decorators, target, key, desc) {
var c = arguments.length,
r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var core_1 = $__require('angular2/core');
var common_1 = $__require('angular2/common');
var Charts = (function() {
function Charts(element) {}
Charts = __decorate([core_1.Component({
selector: 'chart, canvas[chart]',
template: "<canvas></canvas>",
directives: [common_1.CORE_DIRECTIVES, common_1.NgClass]
}), __metadata('design:paramtypes', [core_1.ElementRef])], Charts);
return Charts;
}());
exports.Charts = Charts;
var BaseChart = (function() {
function BaseChart(element) {
this.element = element;
this.data = [];
this.labels = [];
this.options = {responsive: true};
this.series = [];
this.colours = [];
this.initFlag = false;
this.chartClick = new core_1.EventEmitter();
this.chartHover = new core_1.EventEmitter();
this.defaultsColours = [{
fillColor: 'rgba(151,187,205,0.2)',
strokeColor: 'rgba(151,187,205,1)',
pointColor: 'rgba(151,187,205,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(151,187,205,0.8)',
color: 'rgba(151,187,205,1)',
highlight: 'rgba(151,187,205,0.8)'
}, {
fillColor: 'rgba(220,220,220,0.2)',
strokeColor: 'rgba(220,220,220,1)',
pointColor: 'rgba(220,220,220,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(220,220,220,0.8)',
color: 'rgba(220,220,220,1)',
highlight: 'rgba(220,220,220,0.8)'
}, {
fillColor: 'rgba(247,70,74,0.2)',
strokeColor: 'rgba(247,70,74,1)',
pointColor: 'rgba(247,70,74,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(247,70,74,0.8)',
color: 'rgba(247,70,74,1)',
highlight: 'rgba(247,70,74,0.8)'
}, {
fillColor: 'rgba(70,191,189,0.2)',
strokeColor: 'rgba(70,191,189,1)',
pointColor: 'rgba(70,191,189,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(70,191,189,0.8)',
color: 'rgba(70,191,189,1)',
highlight: 'rgba(70,191,189,0.8)'
}, {
fillColor: 'rgba(253,180,92,0.2)',
strokeColor: 'rgba(253,180,92,1)',
pointColor: 'rgba(253,180,92,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(253,180,92,0.8)',
color: 'rgba(253,180,92,1)',
highlight: 'rgba(253,180,92,0.8)'
}, {
fillColor: 'rgba(148,159,177,0.2)',
strokeColor: 'rgba(148,159,177,1)',
pointColor: 'rgba(148,159,177,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(148,159,177,0.8)',
color: 'rgba(148,159,177,1)',
highlight: 'rgba(148,159,177,0.8)'
}, {
fillColor: 'rgba(77,83,96,0.2)',
strokeColor: 'rgba(77,83,96,1)',
pointColor: 'rgba(77,83,96,1)',
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: 'rgba(77,83,96,0.8)',
color: 'rgba(77,83,96,1)',
highlight: 'rgba(77,83,96,0.8)'
}];
}
BaseChart.prototype.ngOnInit = function() {
this.ctx = this.element.nativeElement.children[0].getContext('2d');
this.cvs = this.element.nativeElement.children[0];
this.parent = this.element.nativeElement;
this.refresh();
this.initFlag = true;
};
BaseChart.prototype.ngOnChanges = function() {
if (this.initFlag) {
this.refresh();
}
};
BaseChart.prototype.ngOnDestroy = function() {
if (this.chart) {
this.chart.destroy();
this.chart = null;
}
if (this.legendTemplate) {
this.legendTemplate.destroy();
this.legendTemplate = null;
}
};
BaseChart.prototype.setLegend = function() {
var list = this.parent.getElementsByTagName('ul');
if (list.length) {
list[0].remove();
this.parent.insertAdjacentHTML('beforeend', this.chart.generateLegend());
} else {
this.parent.insertAdjacentHTML('beforeend', this.chart.generateLegend());
}
};
BaseChart.prototype.getColour = function(colour) {
return {
fillColor: this.rgba(colour, 0.2),
strokeColor: this.rgba(colour, 1),
pointColor: this.rgba(colour, 1),
pointStrokeColor: '#fff',
pointHighlightFill: '#fff',
pointHighlightStroke: this.rgba(colour, 0.8),
color: this.rgba(colour, 1),
highlight: this.rgba(colour, 0.8)
};
};
BaseChart.prototype.getRandomInt = function(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
};
BaseChart.prototype.rgba = function(colour, alpha) {
return 'rgba(' + colour.concat(alpha).join(',') + ')';
};
BaseChart.prototype.click = function(evt) {
var atEvent = this.chart.getPointsAtEvent || this.chart.getBarsAtEvent || this.chart.getSegmentsAtEvent;
var activePoints = atEvent.call(this.chart, evt);
if (activePoints.length > 0) {
var activeLabel = activePoints[0].label;
this.chartClick.emit({
activePoints: activePoints,
activeLabel: activeLabel
});
}
};
BaseChart.prototype.hover = function(evt) {
var atEvent = this.chart.getPointsAtEvent || this.chart.getBarsAtEvent || this.chart.getSegmentsAtEvent;
var activePoints = atEvent.call(this.chart, evt);
if (activePoints.length > 0) {
var activeLabel = activePoints[0].label;
var activePoint = activePoints[0].value;
this.chartHover.emit({
activePoints: activePoints,
activePoint: activePoint,
activeLabel: activeLabel
});
}
};
BaseChart.prototype.getChartBuilder = function(ctx, data, options) {
return new Chart(ctx)[this.chartType](data, options);
};
BaseChart.prototype.getDataObject = function(label, value) {
if (this.chartType === 'Line' || this.chartType === 'Bar' || this.chartType === 'Radar') {
return {
label: label,
data: value
};
}
if (this.chartType === 'Pie' || this.chartType === 'Doughnut' || this.chartType === 'PolarArea') {
return {
label: label,
value: value
};
}
return null;
};
BaseChart.prototype.getChartData = function(labels, dataObject) {
if (this.chartType === 'Line' || this.chartType === 'Bar' || this.chartType === 'Radar') {
return {
labels: labels,
datasets: dataObject
};
}
if (this.chartType === 'Pie' || this.chartType === 'Doughnut' || this.chartType === 'PolarArea') {
return dataObject;
}
};
BaseChart.prototype.refresh = function() {
var _this = this;
if (this.options.responsive && this.parent.clientHeight === 0) {
return setTimeout(function() {
return _this.refresh();
}, 50);
}
this.ngOnDestroy();
var dataset = [];
for (var i = 0; i < this.data.length; i++) {
var colourDesc = [this.getRandomInt(0, 255), this.getRandomInt(0, 255), this.getRandomInt(0, 255)];
var colour = i < this.colours.length ? this.colours[i] : this.defaultsColours[i] || this.getColour(colourDesc);
var data_1 = Object.assign(colour, this.getDataObject(this.series[i] || this.labels[i], this.data[i]));
dataset.push(data_1);
}
var data = this.getChartData(this.labels, dataset);
this.chart = this.getChartBuilder(this.ctx, data, this.options);
if (this.legend) {
this.setLegend();
}
};
__decorate([core_1.Input(), __metadata('design:type', Array)], BaseChart.prototype, "data", void 0);
__decorate([core_1.Input(), __metadata('design:type', Array)], BaseChart.prototype, "labels", void 0);
__decorate([core_1.Input(), __metadata('design:type', Object)], BaseChart.prototype, "options", void 0);
__decorate([core_1.Input(), __metadata('design:type', String)], BaseChart.prototype, "chartType", void 0);
__decorate([core_1.Input(), __metadata('design:type', Array)], BaseChart.prototype, "series", void 0);
__decorate([core_1.Input(), __metadata('design:type', Array)], BaseChart.prototype, "colours", void 0);
__decorate([core_1.Input(), __metadata('design:type', Boolean)], BaseChart.prototype, "legend", void 0);
BaseChart = __decorate([core_1.Component({
selector: 'base-chart',
properties: ['data', 'labels', 'series', 'colours', 'chartType', 'legend', 'options'],
events: ['chartClick', 'chartHover'],
template: "\n <canvas style=\"width: 100%; height: 100%;\" (click)=\"click($event)\" (mousemove)=\"hover($event)\"></canvas>\n ",
directives: [common_1.CORE_DIRECTIVES, common_1.FORM_DIRECTIVES, common_1.NgClass]
}), __metadata('design:paramtypes', [core_1.ElementRef])], BaseChart);
return BaseChart;
}());
exports.BaseChart = BaseChart;
exports.CHART_DIRECTIVES = [Charts, BaseChart];
return module.exports;
});
System.registerDynamic("ng2-charts/ng2-charts", ["./components/charts/charts"], true, function($__require, exports, module) {
"use strict";
;
var define,
global = this,
GLOBAL = this;
function __export(m) {
for (var p in m)
if (!exports.hasOwnProperty(p))
exports[p] = m[p];
}
__export($__require('./components/charts/charts'));
return module.exports;
});
//# sourceMappingURL=ng2-charts.js.map
|
'use strict';Object.defineProperty(exports,'__esModule',{value:!0});var _propTypes=require('prop-types'),_propTypes2=_interopRequireDefault(_propTypes),_react=require('react'),_react2=_interopRequireDefault(_react);function _interopRequireDefault(a){return a&&a.__esModule?a:{default:a}}var propTypes={on:_propTypes2.default.bool.isRequired,onClick:_propTypes2.default.func.isRequired,enabled:_propTypes2.default.bool,className:_propTypes2.default.string},defaultProps={enabled:!0,className:'',onDisabledClick:function onDisabledClick(){}};function Switch(a){var b=a.on,c=a.onClick,d=a.onDisabledClick,f=a.enabled,e=a.className,g=a.children,h=['switch',e,b?'on ':'',f?'':'disabled '].join(' ');return _react2.default.createElement('div',{className:h,onClick:function onClick(a){return f?c(a):d(a)}},_react2.default.createElement('div',{className:'switch-toggle',children:g}))}Switch.propTypes=propTypes,Switch.defaultProps=defaultProps,exports.default=Switch;
|
'use strict';
/**
* Module dependencies.
*/
var mongoose = require('mongoose'),
Biller = mongoose.model('Biller'),
helper = require('../../app/controllers/app-helper'),
_ = require('lodash');
/**
* Get the error message from error object
*/
var getErrorMessage = function(err) {
var message = '';
if (err.code) {
switch (err.code) {
case 11000:
case 11001:
message = 'Biller already exists';
break;
default:
message = 'Something went wrong';
}
} else {
for (var errName in err.errors) {
if (err.errors[errName].message) message = err.errors[errName].message;
}
}
return message;
};
/**
* Create a Biller
*/
exports.create = function(req, res) {
var biller = new Biller(req.body);
biller.user = req.user;
biller.save(function(err) {
if (err) {
return res.send(400, {
message: getErrorMessage(err)
});
} else {
res.jsonp(biller);
}
});
};
/**
* Show the current Biller
*/
exports.read = function(req, res) {
res.jsonp(req.biller);
};
/**
* Update a Biller
*/
exports.update = function(req, res) {
var biller = req.biller ;
var old_data = JSON.parse(JSON.stringify(req.biller));
biller = _.extend(biller , req.body);
helper.addAuditTrails('Biller', old_data, biller, req.user._id);
var member;
var getMember = function(next){
var Member = mongoose.model('Member');
Member.findById(biller.member).select('-password -salt').exec(function(err, _member){
if(err){
return res.send(400,{
message:getErrorMessage(err)
});
} else {
member = _member;
next();
}
});
};
function saveMember(next){
member.isUpdated = [];
member.save(function(err){
if(err){
return res.send(400,{
message:getErrorMessage(err)
});
} else {
next();
}
});
}
biller.save(function(err) {
if (err) {
return res.send(400, {
message: getErrorMessage(err)
});
} else {
getMember(function(){
saveMember(function(){
res.jsonp(biller);
});
});
}
});
};
/**
* Delete an Biller
*/
exports.delete = function(req, res) {
var biller = req.biller ;
biller.remove(function(err) {
if (err) {
return res.send(400, {
message: getErrorMessage(err)
});
} else {
res.jsonp(biller);
}
});
};
/**
* List of Billers
*/
exports.list = function(req, res) {
Biller.find().populate('user', 'displayName').exec(function(err, billers) {
if (err) {
return res.send(400, {
message: getErrorMessage(err)
});
} else {
res.jsonp(billers);
}
});
};
/**
* Biller middleware
*/
exports.billerByID = function(req, res, next, id) { Biller.findById(id).populate('user', 'displayName').exec(function(err, biller) {
if (err) return next(err);
if (! biller) return next(new Error('Failed to load Biller ' + id));
req.biller = biller ;
next();
});
};
/**
* Biller authorization middleware
*/
exports.hasAuthorization = function(req, res, next) {
if (req.biller.user.id !== req.user.id) {
return res.send(403, 'User is not authorized');
}
next();
};
|
'use strict';
module.exports = ['$scope', '$state', 'Upload', 'notify', '$resource', '$uibModal', '$rootScope', '$localStorage',
function ($scope, $state, Upload, notify, $resource, $uibModal, $rootScope, $localStorage) {
if (!$localStorage.isLogin) {
$rootScope.out();
}
//------------------地图模块开始----------------------
$scope.clickPosition = null;
$scope.show_map_dialog = function (data) {
if (data && data.lng && data.lat) {
$scope.editBuildData = data;
$scope.edit_build_mode = true;
} else if (data && data.center) {
$scope.editSettingData = data;
$scope.edit_setting_mode = true;
}
$scope.modal = $uibModal.open({
templateUrl: 'map_dialog',
scope: $scope,
size: 'md'
});
$scope.modal.rendered.then(function () {
var map = new AMap.Map('mapContainer');
if (map.r) {
map.setZoom(14);
if ($scope.edit_build_mode) {
var position = new AMap.LngLat($scope.editBuildData.lng, $scope.editBuildData.lat);
map.setCenter([$scope.editBuildData.lng, $scope.editBuildData.lat]);
new AMap.Marker({
position: position,
map: map
});
} else if ($scope.edit_setting_mode) {
var position = new AMap.LngLat($scope.editSettingData.center.lng, $scope.editSettingData.center.lat);
map.setCenter([$scope.editSettingData.center.lng, $scope.editSettingData.center.lat]);
new AMap.Marker({
position: position,
map: map
});
} else {
map.setCenter([$scope.settings.center.lng, $scope.settings.center.lat]);
}
var _onClick = function (e) {
map.clearMap();
new AMap.Marker({
position: e.lnglat,
map: map
});
$scope.clickPositionLng = e.lnglat.lng; //经度 - lng
$scope.clickPositionLat = e.lnglat.lat; //纬度 - lat
};
map.on('click', _onClick);
}
});
$scope.modal.closed.then(function () {
$scope.edit_setting_mode = false;
$scope.edit_build_mode = false;
});
};
$scope.set_map_position = function () {
if ($scope.edit_build_mode) {
$resource('/walker/player/:id').save({
id: $scope.editBuildData.playerid
}, {
lng: $scope.clickPositionLng + '',
lat: $scope.clickPositionLat + ''
}).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
$scope.editBuildData.lng = $scope.clickPositionLng + '';
$scope.editBuildData.lat = $scope.clickPositionLat + '';
$scope.edit_build_mode = false;
notify({ message: '修改成功', duration: 10000, classes: 'alert-success' });
$scope.modal.close();
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
} else if ($scope.edit_setting_mode) {
$resource('/walker/setting/ ').save({
}, {
centerLng: $scope.clickPositionLng + '',
centerLat: $scope.clickPositionLat + ''
}).$promise.then(function (req) {
if (req.code === 401) {
$rootScope.out();
} else {
$scope.settings.center.lng = $scope.clickPositionLng + '';
$scope.settings.center.lat = $scope.clickPositionLat + '';
$scope.edit_setting_mode = false;
notify({ message: '修改成功', duration: 10000, classes: 'alert-success' });
$scope.modal.close();
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
} else {
$scope.build.lng = $scope.clickPositionLng;
$scope.build.lat = $scope.clickPositionLat;
$scope.modal.close();
}
};
//-----------------------地图模块结束-----------------------
//------------------区域设置模块开始----------------------
$scope.query_setting = function () {
$resource('/walker/setting/ ').get().$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
$scope.settings = data;
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
};
$scope.query_setting();
$scope.edit_setting = function () {
var data = $scope.settings;
$scope.settingEdit = {
radius: data.radius,
mul: data.mul,
add: data.add,
switch: data.distanceWarning.warningSwitch,
distance: data.distanceWarning.distance
};
$scope.modal = $uibModal.open({
templateUrl: 'edit_setting_dialog',
scope: $scope,
size: 'edit-setting-dialog'
});
};
$scope.update_setting = function () {
var data = $scope.settingEdit;
$resource('/walker/setting/ ').save({
}, {
radius: parseInt(data.radius),
add: parseInt(data.add),
mul: parseInt(data.mul),
warningSwitch: data.switch,
warningDistance: parseInt(data.distance)
}).$promise.then(function (req) {
if (req.code === 401) {
$rootScope.out();
} else {
$scope.settings.radius = data.radius;
$scope.settings.add = data.add;
$scope.settings.mul = data.mul;
$scope.settings.distanceWarning.warningSwitch = data.switch;
$scope.settings.distanceWarning.distance = data.distance;
notify({ message: '修改成功', duration: 10000, classes: 'alert-success' });
$scope.modal.close();
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
};
//------------------区域设置模块结束----------------------
//------------------建筑模块开始----------------------
$scope.roleList = [{
name: '基地'
}, {
name: '监狱'
}, {
name: '赌场'
}, {
name: '安全屋'
}, {
name: '角斗场'
}, {
name: '移动商贩'
}, {
name: '天眼'
}];
$scope.build = {
playerid: '',
zbid: '',
avatar: '',
name: '',
role: '',
tel: '',
lng: '',
lat: ''
};
$scope.isAddBuild = false;
// 查询建筑物
$scope.query_build = function () {
$resource('/walker/player/building/list').query({
}).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
$scope.buildings = data;
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
};
$scope.query_build();
// 增加建筑物时 -- 上传图标
$scope.upload_build = function (file) {
if (file) {
Upload.upload({
url: '/v1/img/upload',
method: 'POST',
data: {
image: file
}
}).then(function (data) {
var data = data.data;
if (data.status === 'success') {
$scope.build.avatar = data.url;
notify({ message: '图标上传成功', duration: 10000, classes: 'alert-success' });
} else {
notify({ message: '图标上传失败', duration: 10000, classes: 'alert-danger' });
}
}, function (data) {
notify({ message: '图标上传失败', duration: 10000, classes: 'alert-danger' });
}, function (evt) {
});
}
};
// 增加建筑物时 -- 校验必填项
$scope.valid_build = function () {
if (!$scope.build.avatar) {
notify({ message: '请上传建筑图标', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.build.playerid)) {
notify({ message: '请填写建筑id', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.build.name)) {
notify({ message: '请填写建筑名称', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.build.role)) {
notify({ message: '请填写建筑角色', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.build.tel)) {
notify({ message: '请填写电话', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.build.lng && $scope.build.lat)) {
notify({ message: '请填写建筑坐标', duration: 10000, classes: 'alert-danger' });
return false;
}
return true;
};
// 增加建筑物
$scope.add_build = function () {
if ($scope.valid_build()) {
$scope.isAddBuild = true;
var data = {};
data.playerid = $scope.build.playerid;
data.zbid = $scope.build.playerid, 10;
data.avatar = $scope.build.avatar;
data.name = $scope.build.name;
data.role = $scope.build.role;
data.tel = $scope.build.tel;
data.lng = $scope.build.lng + '';
data.lat = $scope.build.lat + '';
$resource('/walker/player/ ', {
}, {
put: {
method: 'PUT',
isArray: false
}
}).put({
}, data).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
notify({ message: '添加特殊建筑成功', duration: 2000, classes: 'alert-success' });
$scope.isAddBuild = false;
$scope.build = {
playerid: '',
zbid: '',
avatar: '',
name: '',
role: '',
tel: '',
lng: '',
lat: ''
};
$scope.query_build();
}
}, function (data) {
$scope.isAddBuild = true;
notify({ message: '添加特殊建筑失败：' + data.data, duration: 10000, classes: 'alert-danger' });
});
}
};
// 删除建筑物
$scope.del_build = function (id) {
$scope.del_build_id = id;
$scope.modal = $uibModal.open({
templateUrl: 'remove_build_dialog',
scope: $scope,
size: 'edit-setting-dialog'
});
};
$scope.remove_build = function () {
$resource('/walker/player/:id').remove({
id: $scope.del_build_id
}, {
}).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
notify({ message: '删除特殊建筑成功', duration: 2000, classes: 'alert-success' });
$scope.query_build();
$scope.close();
}
}, function (data) {
notify({ message: '删除特殊建筑失败：' + data.data, duration: 10000, classes: 'alert-danger' });
});
};
$scope.buildEdit = {};
// 编辑建筑物时 -- 弹窗
$scope.edit_build = function (data) {
$scope.editBuildData = data;
$scope.buildEditId = data.playerid;
$scope.buildEdit = {
avatar: data.avatar,
name: data.name,
tel: data.tel
};
$scope.modal = $uibModal.open({
templateUrl: 'edit_build_dialog',
scope: $scope,
size: 'edit-build-dialog'
});
};
// 编辑建筑物时 -- 上传图标
$scope.edit_upload_build = function (file) {
if (file) {
Upload.upload({
url: '/v1/img/upload',
method: 'POST',
data: {
image: file
}
}).then(function (data) {
var data = data.data;
if (data.status === 'success') {
$scope.buildEdit.avatar = data.url;
notify({ message: '图标上传成功', duration: 10000, classes: 'alert-success' });
} else {
notify({ message: '图标上传失败', duration: 10000, classes: 'alert-danger' });
}
}, function (data) {
notify({ message: '图标上传失败', duration: 10000, classes: 'alert-danger' });
}, function (evt) {
});
}
};
// 修改建筑物
$scope.update_build = function () {
$resource('/walker/player/:id').save({
id: $scope.buildEditId
}, $scope.buildEdit).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
notify({ message: '修改成功', duration: 10000, classes: 'alert-success' });
$scope.editBuildData.avatar = $scope.buildEdit.avatar;
$scope.editBuildData.name = $scope.buildEdit.name;
$scope.editBuildData.tel = $scope.buildEdit.tel;
$scope.modal.close();
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
};
//------------------建筑模块开始----------------------
//------------------选手模块开始----------------------
$scope.player = {
avatar: '',
name: '',
tel: '',
role: '',
zburl: '',
playerid: '',
zbid: ''
};
$scope.isAddPlayer = false;
// 查询选手
$scope.query_player = function () {
$resource('/walker/player/simplelist').query({
}).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
$scope.players = data;
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
};
$scope.query_player();
// 增加选手时 -- 上传头像
$scope.upload_player = function (file) {
if (file) {
Upload.upload({
url: '/v1/img/upload',
method: 'POST',
data: {
image: file
}
}).then(function (data) {
var data = data.data;
if (data.status === 'success') {
$scope.player.avatar = data.url;
notify({ message: '头像上传成功', duration: 10000, classes: 'alert-success' });
} else {
notify({ message: '头像上传失败', duration: 10000, classes: 'alert-danger' });
}
}, function (data) {
notify({ message: '头像上传失败', duration: 10000, classes: 'alert-danger' });
}, function (evt) {
});
}
};
//增加选手弹出框
$scope.add_player_dialog = function () {
$scope.modal = $uibModal.open({
templateUrl: 'add_player_dialog',
scope: $scope,
size: 'edit-build-dialog'
});
};
// 增加选手时 -- 校验必填
$scope.valid_player = function () {
if (!$scope.player.avatar) {
notify({ message: '请上传选手头像', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.player.zburl)) {
notify({ message: '请填写直播url', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.player.playerid)) {
notify({ message: '请填写选手id', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.player.zbid)) {
notify({ message: '请填写房间id', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!($scope.player.name)) {
notify({ message: '请填写选手姓名', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!$scope.player.tel) {
notify({ message: '请填写选手手机号码', duration: 10000, classes: 'alert-danger' });
return false;
}
if (!$scope.player.role) {
notify({ message: '请填写选手角色', duration: 10000, classes: 'alert-danger' });
return false;
}
return true;
};
// 增加选手
$scope.add_player = function () {
if ($scope.valid_player()) {
$scope.isAddPlayer = true;
var data = {};
data.avatar = $scope.player.avatar;
data.name = $scope.player.name;
data.tel = $scope.player.tel;
data.role = $scope.player.role;
data.zburl = $scope.player.zburl;
data.playerid = $scope.player.playerid;
data.zbid = $scope.player.zbid;
$resource('/walker/player/ ', {
}, {
put: {
method: 'PUT',
isArray: false
}
}).put({
}, data).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
notify({ message: '添加选手成功', duration: 2000, classes: 'alert-success' });
$scope.modal.close();
$scope.isAddPlayer = false;
$scope.player = {
avatar: '',
name: '',
tel: '',
role: '',
zburl: '',
playerid: '',
zbid: ''
};
$scope.query_player();
}
}, function (data) {
notify({ message: '添加选手失败：' + data.data, duration: 10000, classes: 'alert-danger' });
});
}
};
//删除选手
$scope.del_player = function (id) {
$scope.del_player_id = id;
$scope.modal = $uibModal.open({
templateUrl: 'remove_player_dialog',
scope: $scope,
size: 'edit-setting-dialog'
});
};
$scope.remove_player = function () {
$resource('/walker/player/:id').remove({
id: $scope.del_player_id
}, {
}).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
notify({ message: '删除选手成功', duration: 2000, classes: 'alert-success' });
$scope.query_player();
$scope.close();
}
}, function (data) {
notify({ message: '删除选手失败：' + data.data, duration: 10000, classes: 'alert-danger' });
});
};
$scope.playerEdit = {};
// 编辑选手
$scope.edit_player = function (data) {
$scope.playerEditId = data.playerid;
$scope.playerEditData = data;
$scope.playerEdit = {
avatar: data.avatar,
name: data.name,
tel: data.tel,
role: data.role,
zburl: data.zburl,
playerid: data.playerid,
zbid: data.zbid
};
$scope.modal = $uibModal.open({
templateUrl: 'edit_player_dialog',
scope: $scope,
size: 'edit-build-dialog'
});
};
// 编辑选手时 -- 上传头像
$scope.edit_upload_player = function (file) {
if (file) {
Upload.upload({
url: '/v1/img/upload',
method: 'POST',
data: {
image: file
}
}).then(function (data) {
var data = data.data;
if (data.status === 'success') {
$scope.playerEdit.avatar = data.url;
notify({ message: '头像上传成功', duration: 10000, classes: 'alert-success' });
} else {
notify({ message: '头像上传失败', duration: 10000, classes: 'alert-danger' });
}
}, function (data) {
notify({ message: '头像上传失败', duration: 10000, classes: 'alert-danger' });
}, function (evt) {
});
}
};
// 修改选手
$scope.update_player = function () {
$resource('/walker/player/:id').save({
id: $scope.playerEditId
}, $scope.playerEdit).$promise.then(function (data) {
if (data.code === 401) {
$rootScope.out();
} else {
notify({ message: '修改成功', duration: 10000, classes: 'alert-success' });
$scope.modal.close();
$scope.playerEditData.avatar = $scope.playerEdit.avatar;
$scope.playerEditData.name = $scope.playerEdit.name;
$scope.playerEditData.tel = $scope.playerEdit.tel;
$scope.playerEditData.role = $scope.playerEdit.role;
$scope.playerEditData.zburl = $scope.playerEdit.zburl;
$scope.playerEditData.playerid = $scope.playerEdit.playerid;
$scope.playerEditData.zbid = $scope.playerEdit.zbid;
}
}, function (data) {
notify({ message: '出错啦', duration: 10000, classes: 'alert-danger' });
});
};
//------------------选手模块开始----------------------
$scope.close = function () {
$scope.modal.close();
};
}
];
|
/*!
* https://github.com/oakmac/chessboardjs
*
* Patched by Ngoc:
* https://github.com/oakmac/chessboardjs/issues/103
*/
// start anonymous scope
;(function() {
'use strict';
//------------------------------------------------------------------------------
// Chess Util Functions
//------------------------------------------------------------------------------
var COLUMNS = 'abcdefgh'.split('');
function validMove(move) {
// move should be a string
if (typeof move !== 'string') return false;
// move should be in the form of "e2-e4", "f6-d5"
var tmp = move.split('-');
if (tmp.length !== 2) return false;
return (validSquare(tmp[0]) === true && validSquare(tmp[1]) === true);
}
function validSquare(square) {
if (typeof square !== 'string') return false;
return (square.search(/^[a-h][1-8]$/) !== -1);
}
function validPieceCode(code) {
if (typeof code !== 'string') return false;
return (code.search(/^[bw][KQRNBP]$/) !== -1);
}
// TODO: this whole function could probably be replaced with a single regex
function validFen(fen) {
if (typeof fen !== 'string') return false;
// cut off any move, castling, etc info from the end
// we're only interested in position information
fen = fen.replace(/ .+$/, '');
// FEN should be 8 sections separated by slashes
var chunks = fen.split('/');
if (chunks.length !== 8) return false;
// check the piece sections
for (var i = 0; i < 8; i++) {
if (chunks[i] === '' ||
chunks[i].length > 8 ||
chunks[i].search(/[^kqrbnpKQRNBP1-8]/) !== -1) {
return false;
}
}
return true;
}
function validPositionObject(pos) {
if (typeof pos !== 'object') return false;
for (var i in pos) {
if (pos.hasOwnProperty(i) !== true) continue;
if (validSquare(i) !== true || validPieceCode(pos[i]) !== true) {
return false;
}
}
return true;
}
// convert FEN piece code to bP, wK, etc
function fenToPieceCode(piece) {
// black piece
if (piece.toLowerCase() === piece) {
return 'b' + piece.toUpperCase();
}
// white piece
return 'w' + piece.toUpperCase();
}
// convert bP, wK, etc code to FEN structure
function pieceCodeToFen(piece) {
var tmp = piece.split('');
// white piece
if (tmp[0] === 'w') {
return tmp[1].toUpperCase();
}
// black piece
return tmp[1].toLowerCase();
}
// convert FEN string to position object
// returns false if the FEN string is invalid
function fenToObj(fen) {
if (validFen(fen) !== true) {
return false;
}
// cut off any move, castling, etc info from the end
// we're only interested in position information
fen = fen.replace(/ .+$/, '');
var rows = fen.split('/');
var position = {};
var currentRow = 8;
for (var i = 0; i < 8; i++) {
var row = rows[i].split('');
var colIndex = 0;
// loop through each character in the FEN section
for (var j = 0; j < row.length; j++) {
// number / empty squares
if (row[j].search(/[1-8]/) !== -1) {
var emptySquares = parseInt(row[j], 10);
colIndex += emptySquares;
}
// piece
else {
var square = COLUMNS[colIndex] + currentRow;
position[square] = fenToPieceCode(row[j]);
colIndex++;
}
}
currentRow--;
}
return position;
}
// position object to FEN string
// returns false if the obj is not a valid position object
function objToFen(obj) {
if (validPositionObject(obj) !== true) {
return false;
}
var fen = '';
var currentRow = 8;
for (var i = 0; i < 8; i++) {
for (var j = 0; j < 8; j++) {
var square = COLUMNS[j] + currentRow;
// piece exists
if (obj.hasOwnProperty(square) === true) {
fen += pieceCodeToFen(obj[square]);
}
// empty space
else {
fen += '1';
}
}
if (i !== 7) {
fen += '/';
}
currentRow--;
}
// squeeze the numbers together
// haha, I love this solution...
fen = fen.replace(/11111111/g, '8');
fen = fen.replace(/1111111/g, '7');
fen = fen.replace(/111111/g, '6');
fen = fen.replace(/11111/g, '5');
fen = fen.replace(/1111/g, '4');
fen = fen.replace(/111/g, '3');
fen = fen.replace(/11/g, '2');
return fen;
}
window['ChessBoard'] = window['ChessBoard'] || function(containerElOrId, cfg) {
cfg = cfg || {};
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
var MINIMUM_JQUERY_VERSION = '1.7.0',
START_FEN = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR',
START_POSITION = fenToObj(START_FEN);
// use unique class names to prevent clashing with anything else on the page
// and simplify selectors
// NOTE: these should never change
var CSS = {
alpha: 'alpha-d2270',
black: 'black-3c85d',
board: 'board-b72b1',
chessboard: 'chessboard-63f37',
clearfix: 'clearfix-7da63',
highlight1: 'highlight1-32417',
highlight2: 'highlight2-9c5d2',
notation: 'notation-322f9',
numeric: 'numeric-fc462',
piece: 'piece-417db',
row: 'row-5277c',
sparePieces: 'spare-pieces-7492f',
sparePiecesBottom: 'spare-pieces-bottom-ae20f',
sparePiecesTop: 'spare-pieces-top-4028b',
square: 'square-55d63',
white: 'white-1e1d7'
};
//------------------------------------------------------------------------------
// Module Scope Variables
//------------------------------------------------------------------------------
// DOM elements
var containerEl,
boardEl,
draggedPieceEl,
sparePiecesTopEl,
sparePiecesBottomEl;
// constructor return object
var widget = {};
//------------------------------------------------------------------------------
// Stateful
//------------------------------------------------------------------------------
var ANIMATION_HAPPENING = false,
BOARD_BORDER_SIZE = 2,
CURRENT_ORIENTATION = 'white',
CURRENT_POSITION = {},
SQUARE_SIZE,
DRAGGED_PIECE,
DRAGGED_PIECE_LOCATION,
DRAGGED_PIECE_SOURCE,
DRAGGING_A_PIECE = false,
SPARE_PIECE_ELS_IDS = {},
SQUARE_ELS_IDS = {},
SQUARE_ELS_OFFSETS;
//------------------------------------------------------------------------------
// JS Util Functions
//------------------------------------------------------------------------------
// http://tinyurl.com/3ttloxj
function uuid() {
return 'xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx'.replace(/x/g, function(c) {
var r = Math.random() * 16 | 0;
return r.toString(16);
});
}
function deepCopy(thing) {
return JSON.parse(JSON.stringify(thing));
}
function parseSemVer(version) {
var tmp = version.split('.');
return {
major: parseInt(tmp[0], 10),
minor: parseInt(tmp[1], 10),
patch: parseInt(tmp[2], 10)
};
}
// returns true if version is >= minimum
function compareSemVer(version, minimum) {
version = parseSemVer(version);
minimum = parseSemVer(minimum);
var versionNum = (version.major * 10000 * 10000) +
(version.minor * 10000) + version.patch;
var minimumNum = (minimum.major * 10000 * 10000) +
(minimum.minor * 10000) + minimum.patch;
return (versionNum >= minimumNum);
}
//------------------------------------------------------------------------------
// Validation / Errors
//------------------------------------------------------------------------------
function error(code, msg, obj) {
// do nothing if showErrors is not set
if (cfg.hasOwnProperty('showErrors') !== true ||
cfg.showErrors === false) {
return;
}
var errorText = 'ChessBoard Error ' + code + ': ' + msg;
// print to console
if (cfg.showErrors === 'console' &&
typeof console === 'object' &&
typeof console.log === 'function') {
console.log(errorText);
if (arguments.length >= 2) {
console.log(obj);
}
return;
}
// alert errors
if (cfg.showErrors === 'alert') {
if (obj) {
errorText += '\n\n' + JSON.stringify(obj);
}
window.alert(errorText);
return;
}
// custom function
if (typeof cfg.showErrors === 'function') {
cfg.showErrors(code, msg, obj);
}
}
// check dependencies
function checkDeps() {
// if containerId is a string, it must be the ID of a DOM node
if (typeof containerElOrId === 'string') {
// cannot be empty
if (containerElOrId === '') {
window.alert('ChessBoard Error 1001: ' +
'The first argument to ChessBoard() cannot be an empty string.' +
'\n\nExiting...');
return false;
}
// make sure the container element exists in the DOM
var el = document.getElementById(containerElOrId);
if (! el) {
window.alert('ChessBoard Error 1002: Element with id "' +
containerElOrId + '" does not exist in the DOM.' +
'\n\nExiting...');
return false;
}
// set the containerEl
containerEl = $(el);
}
// else it must be something that becomes a jQuery collection
// with size 1
// ie: a single DOM node or jQuery object
else {
containerEl = $(containerElOrId);
if (containerEl.length !== 1) {
window.alert('ChessBoard Error 1003: The first argument to ' +
'ChessBoard() must be an ID or a single DOM node.' +
'\n\nExiting...');
return false;
}
}
// JSON must exist
if (! window.JSON ||
typeof JSON.stringify !== 'function' ||
typeof JSON.parse !== 'function') {
window.alert('ChessBoard Error 1004: JSON does not exist. ' +
'Please include a JSON polyfill.\n\nExiting...');
return false;
}
// check for a compatible version of jQuery
if (! (typeof window.$ && $.fn && $.fn.jquery &&
compareSemVer($.fn.jquery, MINIMUM_JQUERY_VERSION) === true)) {
window.alert('ChessBoard Error 1005: Unable to find a valid version ' +
'of jQuery. Please include jQuery ' + MINIMUM_JQUERY_VERSION + ' or ' +
'higher on the page.\n\nExiting...');
return false;
}
return true;
}
function validAnimationSpeed(speed) {
if (speed === 'fast' || speed === 'slow') {
return true;
}
if ((parseInt(speed, 10) + '') !== (speed + '')) {
return false;
}
return (speed >= 0);
}
// validate config / set default options
function expandConfig() {
if (typeof cfg === 'string' || validPositionObject(cfg) === true) {
cfg = {
position: cfg
};
}
// default for orientation is white
if (cfg.orientation !== 'black') {
cfg.orientation = 'white';
}
CURRENT_ORIENTATION = cfg.orientation;
// default for showNotation is true
if (cfg.showNotation !== false) {
cfg.showNotation = true;
}
// default for draggable is false
if (cfg.draggable !== true) {
cfg.draggable = false;
}
// default for dropOffBoard is 'snapback'
if (cfg.dropOffBoard !== 'trash') {
cfg.dropOffBoard = 'snapback';
}
// default for sparePieces is false
if (cfg.sparePieces !== true) {
cfg.sparePieces = false;
}
// draggable must be true if sparePieces is enabled
if (cfg.sparePieces === true) {
cfg.draggable = true;
}
// default piece theme is wikipedia
if (cfg.hasOwnProperty('pieceTheme') !== true ||
(typeof cfg.pieceTheme !== 'string' &&
typeof cfg.pieceTheme !== 'function')) {
cfg.pieceTheme = 'img/chesspieces/wikipedia/{piece}.png';
}
// animation speeds
if (cfg.hasOwnProperty('appearSpeed') !== true ||
validAnimationSpeed(cfg.appearSpeed) !== true) {
cfg.appearSpeed = 200;
}
if (cfg.hasOwnProperty('moveSpeed') !== true ||
validAnimationSpeed(cfg.moveSpeed) !== true) {
cfg.moveSpeed = 200;
}
if (cfg.hasOwnProperty('snapbackSpeed') !== true ||
validAnimationSpeed(cfg.snapbackSpeed) !== true) {
cfg.snapbackSpeed = 50;
}
if (cfg.hasOwnProperty('snapSpeed') !== true ||
validAnimationSpeed(cfg.snapSpeed) !== true) {
cfg.snapSpeed = 25;
}
if (cfg.hasOwnProperty('trashSpeed') !== true ||
validAnimationSpeed(cfg.trashSpeed) !== true) {
cfg.trashSpeed = 100;
}
// make sure position is valid
if (cfg.hasOwnProperty('position') === true) {
if (cfg.position === 'start') {
CURRENT_POSITION = deepCopy(START_POSITION);
}
else if (validFen(cfg.position) === true) {
CURRENT_POSITION = fenToObj(cfg.position);
}
else if (validPositionObject(cfg.position) === true) {
CURRENT_POSITION = deepCopy(cfg.position);
}
else {
error(7263, 'Invalid value passed to config.position.', cfg.position);
}
}
return true;
}
//------------------------------------------------------------------------------
// DOM Misc
//------------------------------------------------------------------------------
// calculates square size based on the width of the container
// got a little CSS black magic here, so let me explain:
// get the width of the container element (could be anything), reduce by 1 for
// fudge factor, and then keep reducing until we find an exact mod 8 for
// our square size
function calculateSquareSize() {
var containerWidth = parseInt(containerEl.width(), 10);
// defensive, prevent infinite loop
if (! containerWidth || containerWidth <= 0) {
return 0;
}
// pad one pixel
//var boardWidth = containerWidth - 1;
var boardWidth = containerWidth;
while (boardWidth % 8 !== 0 && boardWidth > 0) {
boardWidth--;
}
return (boardWidth / 8);
}
// create random IDs for elements
function createElIds() {
// squares on the board
for (var i = 0; i < COLUMNS.length; i++) {
for (var j = 1; j <= 8; j++) {
var square = COLUMNS[i] + j;
SQUARE_ELS_IDS[square] = square + '-' + uuid();
}
}
// spare pieces
var pieces = 'KQRBNP'.split('');
for (var i = 0; i < pieces.length; i++) {
var whitePiece = 'w' + pieces[i];
var blackPiece = 'b' + pieces[i];
SPARE_PIECE_ELS_IDS[whitePiece] = whitePiece + '-' + uuid();
SPARE_PIECE_ELS_IDS[blackPiece] = blackPiece + '-' + uuid();
}
}
//------------------------------------------------------------------------------
// Markup Building
//------------------------------------------------------------------------------
function buildBoardContainer() {
var html = '<div class="' + CSS.chessboard + '">';
if (cfg.sparePieces === true) {
html += '<div class="' + CSS.sparePieces + ' ' +
CSS.sparePiecesTop + '"></div>';
}
html += '<div class="' + CSS.board + '"></div>';
if (cfg.sparePieces === true) {
html += '<div class="' + CSS.sparePieces + ' ' +
CSS.sparePiecesBottom + '"></div>';
}
html += '</div>';
return html;
}
/*
var buildSquare = function(color, size, id) {
var html = '<div class="' + CSS.square + ' ' + CSS[color] + '" ' +
'style="width: ' + size + 'px; height: ' + size + 'px" ' +
'id="' + id + '">';
if (cfg.showNotation === true) {
}
html += '</div>';
return html;
};
*/
function buildBoard(orientation) {
if (orientation !== 'black') {
orientation = 'white';
}
var html = '';
// algebraic notation / orientation
var alpha = deepCopy(COLUMNS);
var row = 8;
if (orientation === 'black') {
alpha.reverse();
row = 1;
}
var squareColor = 'white';
for (var i = 0; i < 8; i++) {
html += '<div class="' + CSS.row + '">';
for (var j = 0; j < 8; j++) {
var square = alpha[j] + row;
html += '<div class="' + CSS.square + ' ' + CSS[squareColor] + ' ' +
'square-' + square + '" ' +
'style="width: 12.5%; height: ' + SQUARE_SIZE + 'px" ' +
'id="' + SQUARE_ELS_IDS[square] + '" ' +
'data-square="' + square + '">';
if (cfg.showNotation === true) {
// alpha notation
if ((orientation === 'white' && row === 1) ||
(orientation === 'black' && row === 8)) {
html += '<div class="' + CSS.notation + ' ' + CSS.alpha + '">' +
alpha[j] + '</div>';
}
// numeric notation
if (j === 0) {
html += '<div class="' + CSS.notation + ' ' + CSS.numeric + '">' +
row + '</div>';
}
}
html += '</div>'; // end .square
squareColor = (squareColor === 'white' ? 'black' : 'white');
}
html += '<div class="' + CSS.clearfix + '"></div></div>';
squareColor = (squareColor === 'white' ? 'black' : 'white');
if (orientation === 'white') {
row--;
}
else {
row++;
}
}
return html;
}
function buildPieceImgSrc(piece) {
if (typeof cfg.pieceTheme === 'function') {
return cfg.pieceTheme(piece);
}
if (typeof cfg.pieceTheme === 'string') {
return cfg.pieceTheme.replace(/{piece}/g, piece);
}
// NOTE: this should never happen
error(8272, 'Unable to build image source for cfg.pieceTheme.');
return '';
}
function buildPiece(percent, piece, hidden, id) {
var html = '<img src="' + buildPieceImgSrc(piece) + '" ';
if (id && typeof id === 'string') {
html += 'id="' + id + '" ';
}
html += 'alt="" ' +
'class="' + CSS.piece + '" ' +
'data-piece="' + piece + '" ' +
(percent ? 'style="width: 100%;' : ('style="width: ' + SQUARE_SIZE + 'px;')) +
'height: ' + SQUARE_SIZE + 'px;';
if (hidden === true) {
html += 'display:none;';
}
html += '" />';
return html;
}
function buildSparePieces(color) {
var pieces = ['wK', 'wQ', 'wR', 'wB', 'wN', 'wP'];
if (color === 'black') {
pieces = ['bK', 'bQ', 'bR', 'bB', 'bN', 'bP'];
}
var html = '';
for (var i = 0; i < pieces.length; i++) {
html += buildPiece(false, pieces[i], false, SPARE_PIECE_ELS_IDS[pieces[i]]);
}
return html;
}
//------------------------------------------------------------------------------
// Animations
//------------------------------------------------------------------------------
function animateSquareToSquare(src, dest, piece, completeFn) {
// get information about the source and destination squares
var srcSquareEl = $('#' + SQUARE_ELS_IDS[src]);
var srcSquarePosition = srcSquareEl.offset();
var destSquareEl = $('#' + SQUARE_ELS_IDS[dest]);
var destSquarePosition = destSquareEl.offset();
// create the animated piece and absolutely position it
// over the source square
var animatedPieceId = uuid();
$('body').append(buildPiece(false, piece, true, animatedPieceId));
var animatedPieceEl = $('#' + animatedPieceId);
animatedPieceEl.css({
display: '',
position: 'absolute',
top: srcSquarePosition.top,
left: srcSquarePosition.left
});
// remove original piece from source square
srcSquareEl.find('.' + CSS.piece).remove();
// on complete
var complete = function() {
// add the "real" piece to the destination square
destSquareEl.append(buildPiece(true, piece));
// remove the animated piece
animatedPieceEl.remove();
// run complete function
if (typeof completeFn === 'function') {
completeFn();
}
};
// animate the piece to the destination square
var dx = destSquarePosition.top - srcSquarePosition.top;
var dy = destSquarePosition.left - srcSquarePosition.left;
var d = Math.sqrt(dx*dx + dy*dy);
var t = d * 2.75;
if (t < 200) t = 200;
if (t > 700) t = 700;
var opts = {
duration: t,
queue: false,
complete: complete
};
animatedPieceEl.animate(destSquarePosition, opts);
}
function animateSparePieceToSquare(piece, dest, completeFn) {
var srcOffset = $('#' + SPARE_PIECE_ELS_IDS[piece]).offset();
var destSquareEl = $('#' + SQUARE_ELS_IDS[dest]);
var destOffset = destSquareEl.offset();
// create the animate piece
var pieceId = uuid();
$('body').append(buildPiece(false, piece, true, pieceId));
var animatedPieceEl = $('#' + pieceId);
animatedPieceEl.css({
display: '',
position: 'absolute',
left: srcOffset.left,
top: srcOffset.top
});
// on complete
var complete = function() {
// add the "real" piece to the destination square
destSquareEl.find('.' + CSS.piece).remove();
destSquareEl.append(buildPiece(true, piece));
// remove the animated piece
animatedPieceEl.remove();
// run complete function
if (typeof completeFn === 'function') {
completeFn();
}
};
// animate the piece to the destination square
var opts = {
duration: cfg.moveSpeed,
complete: complete
};
animatedPieceEl.animate(destOffset, opts);
}
// execute an array of animations
function doAnimations(a, oldPos, newPos) {
if (a.length === 0) {
return;
}
ANIMATION_HAPPENING = true;
var numFinished = 0;
function onFinish() {
numFinished++;
// exit if all the animations aren't finished
if (numFinished !== a.length) return;
drawPositionInstant();
ANIMATION_HAPPENING = false;
// run their onMoveEnd function
if (cfg.hasOwnProperty('onMoveEnd') === true &&
typeof cfg.onMoveEnd === 'function') {
cfg.onMoveEnd(deepCopy(oldPos), deepCopy(newPos));
}
}
for (var i = 0; i < a.length; i++) {
// clear a piece
if (a[i].type === 'clear') {
$('#' + SQUARE_ELS_IDS[a[i].square] + ' .' + CSS.piece)
.fadeOut(cfg.trashSpeed, onFinish);
}
// add a piece (no spare pieces)
if (a[i].type === 'add' && cfg.sparePieces !== true) {
$('#' + SQUARE_ELS_IDS[a[i].square])
.append(buildPiece(false, a[i].piece, true))
.find('.' + CSS.piece)
.fadeIn(cfg.appearSpeed, onFinish);
}
// add a piece from a spare piece
if (a[i].type === 'add' && cfg.sparePieces === true) {
animateSparePieceToSquare(a[i].piece, a[i].square, onFinish);
}
// move a piece
if (a[i].type === 'move') {
animateSquareToSquare(a[i].source, a[i].destination, a[i].piece,
onFinish);
}
}
}
// returns the distance between two squares
function squareDistance(s1, s2) {
s1 = s1.split('');
var s1x = COLUMNS.indexOf(s1[0]) + 1;
var s1y = parseInt(s1[1], 10);
s2 = s2.split('');
var s2x = COLUMNS.indexOf(s2[0]) + 1;
var s2y = parseInt(s2[1], 10);
var xDelta = Math.abs(s1x - s2x);
var yDelta = Math.abs(s1y - s2y);
if (xDelta >= yDelta) return xDelta;
return yDelta;
}
// returns an array of closest squares from square
function createRadius(square) {
var squares = [];
// calculate distance of all squares
for (var i = 0; i < 8; i++) {
for (var j = 0; j < 8; j++) {
var s = COLUMNS[i] + (j + 1);
// skip the square we're starting from
if (square === s) continue;
squares.push({
square: s,
distance: squareDistance(square, s)
});
}
}
// sort by distance
squares.sort(function(a, b) {
return a.distance - b.distance;
});
// just return the square code
var squares2 = [];
for (var i = 0; i < squares.length; i++) {
squares2.push(squares[i].square);
}
return squares2;
}
// returns the square of the closest instance of piece
// returns false if no instance of piece is found in position
function findClosestPiece(position, piece, square) {
// create array of closest squares from square
var closestSquares = createRadius(square);
// search through the position in order of distance for the piece
for (var i = 0; i < closestSquares.length; i++) {
var s = closestSquares[i];
if (position.hasOwnProperty(s) === true && position[s] === piece) {
return s;
}
}
return false;
}
// calculate an array of animations that need to happen in order to get
// from pos1 to pos2
function calculateAnimations(pos1, pos2) {
// make copies of both
pos1 = deepCopy(pos1);
pos2 = deepCopy(pos2);
var animations = [];
var squaresMovedTo = {};
// remove pieces that are the same in both positions
for (var i in pos2) {
if (pos2.hasOwnProperty(i) !== true) continue;
if (pos1.hasOwnProperty(i) === true && pos1[i] === pos2[i]) {
delete pos1[i];
delete pos2[i];
}
}
// find all the "move" animations
for (var i in pos2) {
if (pos2.hasOwnProperty(i) !== true) continue;
var closestPiece = findClosestPiece(pos1, pos2[i], i);
if (closestPiece !== false) {
animations.push({
type: 'move',
source: closestPiece,
destination: i,
piece: pos2[i]
});
delete pos1[closestPiece];
delete pos2[i];
squaresMovedTo[i] = true;
}
}
// add pieces to pos2
for (var i in pos2) {
if (pos2.hasOwnProperty(i) !== true) continue;
animations.push({
type: 'add',
square: i,
piece: pos2[i]
})
delete pos2[i];
}
// clear pieces from pos1
for (var i in pos1) {
if (pos1.hasOwnProperty(i) !== true) continue;
// do not clear a piece if it is on a square that is the result
// of a "move", ie: a piece capture
if (squaresMovedTo.hasOwnProperty(i) === true) continue;
animations.push({
type: 'clear',
square: i,
piece: pos1[i]
});
delete pos1[i];
}
return animations;
}
//------------------------------------------------------------------------------
// Control Flow
//------------------------------------------------------------------------------
function drawPositionInstant() {
// clear the board
boardEl.find('.' + CSS.piece).remove();
// add the pieces
for (var i in CURRENT_POSITION) {
if (CURRENT_POSITION.hasOwnProperty(i) !== true) continue;
$('#' + SQUARE_ELS_IDS[i]).append(buildPiece(true, CURRENT_POSITION[i]));
}
}
function drawBoard() {
boardEl.html(buildBoard(CURRENT_ORIENTATION));
drawPositionInstant();
if (cfg.sparePieces === true) {
if (CURRENT_ORIENTATION === 'white') {
sparePiecesTopEl.html(buildSparePieces('black'));
sparePiecesBottomEl.html(buildSparePieces('white'));
}
else {
sparePiecesTopEl.html(buildSparePieces('white'));
sparePiecesBottomEl.html(buildSparePieces('black'));
}
}
}
// given a position and a set of moves, return a new position
// with the moves executed
function calculatePositionFromMoves(position, moves) {
position = deepCopy(position);
for (var i in moves) {
if (moves.hasOwnProperty(i) !== true) continue;
// skip the move if the position doesn't have a piece on the source square
if (position.hasOwnProperty(i) !== true) continue;
var piece = position[i];
delete position[i];
position[moves[i]] = piece;
}
return position;
}
function setCurrentPosition(position) {
var oldPos = deepCopy(CURRENT_POSITION);
var newPos = deepCopy(position);
var oldFen = objToFen(oldPos);
var newFen = objToFen(newPos);
// do nothing if no change in position
if (oldFen === newFen) return;
// run their onChange function
if (cfg.hasOwnProperty('onChange') === true &&
typeof cfg.onChange === 'function') {
cfg.onChange(oldPos, newPos);
}
// update state
CURRENT_POSITION = position;
}
function isXYOnSquare(x, y) {
for (var i in SQUARE_ELS_OFFSETS) {
if (SQUARE_ELS_OFFSETS.hasOwnProperty(i) !== true) continue;
var s = SQUARE_ELS_OFFSETS[i];
if (x >= s.left && x < s.left + SQUARE_SIZE &&
y >= s.top && y < s.top + SQUARE_SIZE) {
return i;
}
}
return 'offboard';
}
// records the XY coords of every square into memory
function captureSquareOffsets() {
SQUARE_ELS_OFFSETS = {};
for (var i in SQUARE_ELS_IDS) {
if (SQUARE_ELS_IDS.hasOwnProperty(i) !== true) continue;
SQUARE_ELS_OFFSETS[i] = $('#' + SQUARE_ELS_IDS[i]).offset();
}
}
function removeSquareHighlights() {
boardEl.find('.' + CSS.square)
.removeClass(CSS.highlight1 + ' ' + CSS.highlight2);
}
function snapbackDraggedPiece() {
// there is no "snapback" for spare pieces
if (DRAGGED_PIECE_SOURCE === 'spare') {
trashDraggedPiece();
return;
}
removeSquareHighlights();
// animation complete
function complete() {
drawPositionInstant();
draggedPieceEl.css('display', 'none');
// run their onSnapbackEnd function
if (cfg.hasOwnProperty('onSnapbackEnd') === true &&
typeof cfg.onSnapbackEnd === 'function') {
cfg.onSnapbackEnd(DRAGGED_PIECE, DRAGGED_PIECE_SOURCE,
deepCopy(CURRENT_POSITION), CURRENT_ORIENTATION);
}
}
// get source square position
var sourceSquarePosition =
$('#' + SQUARE_ELS_IDS[DRAGGED_PIECE_SOURCE]).offset();
// animate the piece to the target square
var opts = {
duration: cfg.snapbackSpeed,
complete: complete
};
draggedPieceEl.animate(sourceSquarePosition, opts);
// set state
DRAGGING_A_PIECE = false;
}
function trashDraggedPiece() {
removeSquareHighlights();
// remove the source piece
var newPosition = deepCopy(CURRENT_POSITION);
delete newPosition[DRAGGED_PIECE_SOURCE];
setCurrentPosition(newPosition);
// redraw the position
drawPositionInstant();
// hide the dragged piece
draggedPieceEl.fadeOut(cfg.trashSpeed);
// set state
DRAGGING_A_PIECE = false;
}
function dropDraggedPieceOnSquare(square) {
removeSquareHighlights();
// update position
var newPosition = deepCopy(CURRENT_POSITION);
delete newPosition[DRAGGED_PIECE_SOURCE];
newPosition[square] = DRAGGED_PIECE;
setCurrentPosition(newPosition);
// get target square information
var targetSquarePosition = $('#' + SQUARE_ELS_IDS[square]).offset();
// animation complete
var complete = function() {
drawPositionInstant();
draggedPieceEl.css('display', 'none');
// execute their onSnapEnd function
if (cfg.hasOwnProperty('onSnapEnd') === true &&
typeof cfg.onSnapEnd === 'function') {
cfg.onSnapEnd(DRAGGED_PIECE_SOURCE, square, DRAGGED_PIECE);
}
};
// snap the piece to the target square
var opts = {
duration: cfg.snapSpeed,
complete: complete
};
draggedPieceEl.animate(targetSquarePosition, opts);
// set state
DRAGGING_A_PIECE = false;
}
function beginDraggingPiece(source, piece, x, y) {
// run their custom onDragStart function
// their custom onDragStart function can cancel drag start
if (typeof cfg.onDragStart === 'function' &&
cfg.onDragStart(source, piece,
deepCopy(CURRENT_POSITION), CURRENT_ORIENTATION) === false) {
return;
}
// set state
DRAGGING_A_PIECE = true;
DRAGGED_PIECE = piece;
DRAGGED_PIECE_SOURCE = source;
// if the piece came from spare pieces, location is offboard
if (source === 'spare') {
DRAGGED_PIECE_LOCATION = 'offboard';
}
else {
DRAGGED_PIECE_LOCATION = source;
}
// capture the x, y coords of all squares in memory
captureSquareOffsets();
// create the dragged piece
draggedPieceEl.attr('src', buildPieceImgSrc(piece))
.css({
display: '',
position: 'absolute',
left: x - (SQUARE_SIZE / 2),
top: y - (SQUARE_SIZE / 2)
});
if (source !== 'spare') {
// highlight the source square and hide the piece
$('#' + SQUARE_ELS_IDS[source]).addClass(CSS.highlight1)
.find('.' + CSS.piece).css('display', 'none');
}
}
function updateDraggedPiece(x, y) {
// put the dragged piece over the mouse cursor
draggedPieceEl.css({
left: x - (SQUARE_SIZE / 2),
top: y - (SQUARE_SIZE / 2)
});
// get location
var location = isXYOnSquare(x, y);
// do nothing if the location has not changed
if (location === DRAGGED_PIECE_LOCATION) return;
// remove highlight from previous square
if (validSquare(DRAGGED_PIECE_LOCATION) === true) {
$('#' + SQUARE_ELS_IDS[DRAGGED_PIECE_LOCATION])
.removeClass(CSS.highlight2);
}
// add highlight to new square
if (validSquare(location) === true) {
$('#' + SQUARE_ELS_IDS[location]).addClass(CSS.highlight2);
}
// run onDragMove
if (typeof cfg.onDragMove === 'function') {
cfg.onDragMove(location, DRAGGED_PIECE_LOCATION,
DRAGGED_PIECE_SOURCE, DRAGGED_PIECE,
deepCopy(CURRENT_POSITION), CURRENT_ORIENTATION);
}
// update state
DRAGGED_PIECE_LOCATION = location;
}
function stopDraggedPiece(location) {
// determine what the action should be
var action = 'drop';
if (location === 'offboard' && cfg.dropOffBoard === 'snapback') {
action = 'snapback';
}
if (location === 'offboard' && cfg.dropOffBoard === 'trash') {
action = 'trash';
}
// run their onDrop function, which can potentially change the drop action
if (cfg.hasOwnProperty('onDrop') === true &&
typeof cfg.onDrop === 'function') {
var newPosition = deepCopy(CURRENT_POSITION);
// source piece is a spare piece and position is off the board
//if (DRAGGED_PIECE_SOURCE === 'spare' && location === 'offboard') {...}
// position has not changed; do nothing
// source piece is a spare piece and position is on the board
if (DRAGGED_PIECE_SOURCE === 'spare' && validSquare(location) === true) {
// add the piece to the board
newPosition[location] = DRAGGED_PIECE;
}
// source piece was on the board and position is off the board
if (validSquare(DRAGGED_PIECE_SOURCE) === true && location === 'offboard') {
// remove the piece from the board
delete newPosition[DRAGGED_PIECE_SOURCE];
}
// source piece was on the board and position is on the board
if (validSquare(DRAGGED_PIECE_SOURCE) === true &&
validSquare(location) === true) {
// move the piece
delete newPosition[DRAGGED_PIECE_SOURCE];
newPosition[location] = DRAGGED_PIECE;
}
var oldPosition = deepCopy(CURRENT_POSITION);
var result = cfg.onDrop(DRAGGED_PIECE_SOURCE, location, DRAGGED_PIECE,
newPosition, oldPosition, CURRENT_ORIENTATION);
if (result === 'snapback' || result === 'trash') {
action = result;
}
}
// do it!
if (action === 'snapback') {
snapbackDraggedPiece();
}
else if (action === 'trash') {
trashDraggedPiece();
}
else if (action === 'drop') {
dropDraggedPieceOnSquare(location);
}
}
//------------------------------------------------------------------------------
// Public Methods
//------------------------------------------------------------------------------
// clear the board
widget.clear = function(useAnimation) {
widget.position({}, useAnimation);
};
// remove the widget from the page
widget.destroy = function() {
// remove markup
containerEl.html('');
draggedPieceEl.remove();
// remove event handlers
containerEl.unbind();
};
// shorthand method to get the current FEN
widget.fen = function() {
return widget.position('fen');
};
// flip orientation
widget.flip = function() {
return widget.orientation('flip');
};
/*
// TODO: write this, GitHub Issue #5
widget.highlight = function() {
};
*/
// move pieces
widget.move = function() {
// no need to throw an error here; just do nothing
if (arguments.length === 0) return;
var useAnimation = true;
// collect the moves into an object
var moves = {};
for (var i = 0; i < arguments.length; i++) {
// any "false" to this function means no animations
if (arguments[i] === false) {
useAnimation = false;
continue;
}
// skip invalid arguments
if (validMove(arguments[i]) !== true) {
error(2826, 'Invalid move passed to the move method.', arguments[i]);
continue;
}
var tmp = arguments[i].split('-');
moves[tmp[0]] = tmp[1];
}
// calculate position from moves
var newPos = calculatePositionFromMoves(CURRENT_POSITION, moves);
// update the board
widget.position(newPos, useAnimation);
// return the new position object
return newPos;
};
widget.orientation = function(arg) {
// no arguments, return the current orientation
if (arguments.length === 0) {
return CURRENT_ORIENTATION;
}
// set to white or black
if (arg === 'white' || arg === 'black') {
CURRENT_ORIENTATION = arg;
drawBoard();
return CURRENT_ORIENTATION;
}
// flip orientation
if (arg === 'flip') {
CURRENT_ORIENTATION = (CURRENT_ORIENTATION === 'white') ? 'black' : 'white';
drawBoard();
return CURRENT_ORIENTATION;
}
error(5482, 'Invalid value passed to the orientation method.', arg);
};
widget.position = function(position, useAnimation) {
// no arguments, return the current position
if (arguments.length === 0) {
return deepCopy(CURRENT_POSITION);
}
// get position as FEN
if (typeof position === 'string' && position.toLowerCase() === 'fen') {
return objToFen(CURRENT_POSITION);
}
// default for useAnimations is true
if (useAnimation !== false) {
useAnimation = true;
}
// start position
if (typeof position === 'string' && position.toLowerCase() === 'start') {
position = deepCopy(START_POSITION);
}
// convert FEN to position object
if (validFen(position) === true) {
position = fenToObj(position);
}
// validate position object
if (validPositionObject(position) !== true) {
error(6482, 'Invalid value passed to the position method.', position);
return;
}
if (useAnimation === true) {
// start the animations
doAnimations(calculateAnimations(CURRENT_POSITION, position),
CURRENT_POSITION, position);
// set the new position
setCurrentPosition(position);
}
// instant update
else {
setCurrentPosition(position);
drawPositionInstant();
}
};
widget.resize = function() {
// calulate the new square size
SQUARE_SIZE = calculateSquareSize();
// set board width
boardEl.css('width', '100%');
// set drag piece size
draggedPieceEl.css({
height: SQUARE_SIZE,
width: SQUARE_SIZE
});
// spare pieces
if (cfg.sparePieces === true) {
containerEl.find('.' + CSS.sparePieces)
.css('paddingLeft', (SQUARE_SIZE + BOARD_BORDER_SIZE) + 'px');
}
// redraw the board
drawBoard();
};
// set the starting position
widget.start = function(useAnimation) {
widget.position('start', useAnimation);
};
//------------------------------------------------------------------------------
// Browser Events
//------------------------------------------------------------------------------
function isTouchDevice() {
return ('ontouchstart' in document.documentElement);
}
// reference: http://www.quirksmode.org/js/detect.html
function isMSIE() {
return (navigator && navigator.userAgent &&
navigator.userAgent.search(/MSIE/) !== -1);
}
function stopDefault(e) {
e.preventDefault();
}
function mousedownSquare(e) {
// do nothing if we're not draggable
if (cfg.draggable !== true) return;
var square = $(this).attr('data-square');
if (cfg.clickMove !== true) {
// no piece on this square
if (validSquare(square) !== true ||
CURRENT_POSITION.hasOwnProperty(square) !== true) {
return;
}
beginDraggingPiece(square, CURRENT_POSITION[square], e.pageX, e.pageY);
} else {
if (validSquare(square) !== true) return;
e = e.originalEvent;
beginTOUCH(square, e.pageX, e.pageY);
}
}
function touchstartSquare(e) {
// do nothing if we're not draggable
if (cfg.draggable !== true) return;
var square = $(this).attr('data-square');
if (cfg.clickMove !== true) {
// no piece on this square
if (validSquare(square) !== true ||
CURRENT_POSITION.hasOwnProperty(square) !== true) {
return;
}
e = e.originalEvent;
beginDraggingPiece(square, CURRENT_POSITION[square],
e.changedTouches[0].pageX, e.changedTouches[0].pageY);
} else {
if (validSquare(square) !== true) return;
e = e.originalEvent;
beginTOUCH(square, e.changedTouches[0].pageX, e.changedTouches[0].pageY);
}
}
//------------------------------------------------------------------------------
// https://github.com/oakmac/chessboardjs/issues/34
// https://gist.github.com/nadeemelahi/10234719
var firstTouchMove = true;
function beginTOUCH(square, x, y){
if(firstTouchMove){
// no piece on this square
if (CURRENT_POSITION.hasOwnProperty(square) !== true) {
return; /* the first touch must be a peice */
}
var piece = CURRENT_POSITION[square];
// onDragStart function ensures correct color was touched by turn
if ( cfg.onDragStart(square, piece, deepCopy(CURRENT_POSITION), CURRENT_ORIENTATION) === false) {
return;
}
firstTouchMove = false;
// set state
DRAGGING_A_PIECE = true;
DRAGGED_PIECE = piece;
DRAGGED_PIECE_SOURCE = square;
DRAGGED_PIECE_LOCATION = square;
// capture the x, y coords of all squares in memory
captureSquareOffsets();
$('#' + SQUARE_ELS_IDS[square]).addClass(CSS.highlight1);
}
else if( square == DRAGGED_PIECE_SOURCE) {
$('#' + SQUARE_ELS_IDS[square]).removeClass(CSS.highlight1);
firstTouchMove = true;
}
else {
firstTouchMove = true;
//this will replace the touchendWindow method
stopDraggedPiece(square);
}
}
//------------------------------------------------------------------------------
function mousedownSparePiece(e) {
// do nothing if sparePieces is not enabled
if (cfg.sparePieces !== true) return;
var piece = $(this).attr('data-piece');
beginDraggingPiece('spare', piece, e.pageX, e.pageY);
}
function touchstartSparePiece(e) {
// do nothing if sparePieces is not enabled
if (cfg.sparePieces !== true) return;
var piece = $(this).attr('data-piece');
e = e.originalEvent;
beginDraggingPiece('spare', piece,
e.changedTouches[0].pageX, e.changedTouches[0].pageY);
}
function mousemoveWindow(e) {
// do nothing if we are not dragging a piece
if (DRAGGING_A_PIECE !== true) return;
updateDraggedPiece(e.pageX, e.pageY);
}
function touchmoveWindow(e) {
// do nothing if we are not dragging a piece
if (DRAGGING_A_PIECE !== true) return;
// prevent screen from scrolling
e.preventDefault();
updateDraggedPiece(e.originalEvent.changedTouches[0].pageX,
e.originalEvent.changedTouches[0].pageY);
}
function mouseupWindow(e) {
// do nothing if we are not dragging a piece
if (DRAGGING_A_PIECE !== true || cfg.clickMove === true) return;
// get the location
var location = isXYOnSquare(e.pageX, e.pageY);
stopDraggedPiece(location);
}
function touchendWindow(e) {
// do nothing if we are not dragging a piece
if (DRAGGING_A_PIECE !== true) return;
// get the location
var location = isXYOnSquare(e.originalEvent.changedTouches[0].pageX,
e.originalEvent.changedTouches[0].pageY);
stopDraggedPiece(location);
}
function mouseenterSquare(e) {
// do not fire this event if we are dragging a piece
// NOTE: this should never happen, but it's a safeguard
if (DRAGGING_A_PIECE !== false) return;
if (cfg.hasOwnProperty('onMouseoverSquare') !== true ||
typeof cfg.onMouseoverSquare !== 'function') return;
// get the square
var square = $(e.currentTarget).attr('data-square');
// NOTE: this should never happen; defensive
if (validSquare(square) !== true) return;
// get the piece on this square
var piece = false;
if (CURRENT_POSITION.hasOwnProperty(square) === true) {
piece = CURRENT_POSITION[square];
}
// execute their function
cfg.onMouseoverSquare(square, piece, deepCopy(CURRENT_POSITION),
CURRENT_ORIENTATION);
}
function mouseleaveSquare(e) {
// do not fire this event if we are dragging a piece
// NOTE: this should never happen, but it's a safeguard
if (DRAGGING_A_PIECE !== false) return;
if (cfg.hasOwnProperty('onMouseoutSquare') !== true ||
typeof cfg.onMouseoutSquare !== 'function') return;
// get the square
var square = $(e.currentTarget).attr('data-square');
// NOTE: this should never happen; defensive
if (validSquare(square) !== true) return;
// get the piece on this square
var piece = false;
if (CURRENT_POSITION.hasOwnProperty(square) === true) {
piece = CURRENT_POSITION[square];
}
// execute their function
cfg.onMouseoutSquare(square, piece, deepCopy(CURRENT_POSITION),
CURRENT_ORIENTATION);
}
//------------------------------------------------------------------------------
// Initialization
//------------------------------------------------------------------------------
function addEvents() {
// prevent browser "image drag"
$('body').on('mousedown mousemove', '.' + CSS.piece, stopDefault);
// mouse drag pieces
boardEl.on('mousedown', '.' + CSS.square, mousedownSquare);
containerEl.on('mousedown', '.' + CSS.sparePieces + ' .' + CSS.piece,
mousedownSparePiece);
// mouse enter / leave square
boardEl.on('mouseenter', '.' + CSS.square, mouseenterSquare)
.on('mouseleave', '.' + CSS.square, mouseleaveSquare);
// IE doesn't like the events on the window object, but other browsers
// perform better that way
if (isMSIE() === true) {
// IE-specific prevent browser "image drag"
document.ondragstart = function() { return false; };
$('body').on('mousemove', mousemoveWindow)
.on('mouseup', mouseupWindow);
}
else {
$(window).on('mousemove', mousemoveWindow)
.on('mouseup', mouseupWindow);
}
// touch drag pieces
if (isTouchDevice() === true) {
boardEl.on('touchstart', '.' + CSS.square, touchstartSquare);
containerEl.on('touchstart', '.' + CSS.sparePieces + ' .' + CSS.piece,
touchstartSparePiece);
$(window).on('touchmove', touchmoveWindow)
.on('touchend', touchendWindow);
}
}
function initDom() {
// create unique IDs for all the elements we will create
createElIds();
// build board and save it in memory
containerEl.html(buildBoardContainer());
boardEl = containerEl.find('.' + CSS.board);
if (cfg.sparePieces === true) {
sparePiecesTopEl = containerEl.find('.' + CSS.sparePiecesTop);
sparePiecesBottomEl = containerEl.find('.' + CSS.sparePiecesBottom);
}
// create the drag piece
var draggedPieceId = uuid();
$('body').append(buildPiece(true, 'wP', true, draggedPieceId));
draggedPieceEl = $('#' + draggedPieceId);
// get the border size
BOARD_BORDER_SIZE = parseInt(boardEl.css('borderLeftWidth'), 10);
// set the size and draw the board
widget.resize();
}
function init() {
if (checkDeps() !== true ||
expandConfig() !== true) return;
initDom();
addEvents();
}
// go time
init();
// return the widget object
return widget;
}; // end window.ChessBoard
// expose util functions
window.ChessBoard.fenToObj = fenToObj;
window.ChessBoard.objToFen = objToFen;
})(); // end anonymous wrapper
|
/**
* bootstrap.js
* Loads the configurations, setup Express, the routes, starts the database
* connection while setting up the models and starts the application.
*
* @author Jason Valdron <jason@valdron.ca>
* @package valdron
*/
(function(){
'use strict';
// Load up the depencencies.
var async = require('async'),
fs = require('fs'),
path = require('path'),
walker = require('walk');
// Export the main app function.
module.exports = function(callback){
var app = require('express')(),
server = require('http').createServer(app);
// We want to setup our logger first, then the configs.
async.series([
// Setup the Winston, our logger.
function(next){
var winston = require('winston');
// Create new transport and handlers for the logger.
var transports = [
new winston.transports.Console({
colorize: true,
timestamp: true,
level: 'info'
}),
new winston.transports.File({
filename: path.join(process.cwd(), 'log', 'debug.log'),
level: 'data',
maxsize: 2 * 1024 * 1024
})
];
var exceptionHandlers = [
new winston.transports.Console({
colorize: true,
timestamp: true
}),
new winston.transports.File({
filename: path.join(process.cwd(), 'log', 'exceptions.log'),
maxsize: 2 * 1024 * 1024
})
];
// Make sure we have a logs directory, we use synchronous because we're
// at startup, so blocking isn't a big problem.
if (!fs.existsSync(path.join(process.cwd(), 'log'))) {
fs.mkdirSync(path.join(process.cwd(), 'log'), 511); // 0777 in decimal
}
// Create our logger and make it global to the application.
app.logger = new winston.Logger({
transports: transports,
exceptionHandlers: exceptionHandlers
});
app.logger.info('Logger initialized!');
return next();
},
// Load up our configs.
function(next){
app.logger.info('Loading config files...');
if (fs.existsSync(path.join(process.cwd(), 'config', process.env.NODE_ENV + '.js'))) {
// Load the environment specific config.
app.config = require(path.join(process.cwd(), 'config', process.env.NODE_ENV))();
} else {
app.config = {};
if (process.env.DATABASE_URL) {
// Get our connection information.
var info = process.env.DATABASE_URL.match(/([A-z0-9].+):\/\/([A-z0-9\.].+):([A-z0-9\.].+)@([A-z0-9\.].+):([0-9].+?)\/(.*)/);
app.config.db = {
driver: info[1],
host: info[4],
port: info[5],
username: info[2],
password: info[3],
database: info[6],
pool: true
};
}
// Import the CDN URL from the configs.
if (process.env.CDN_URL) app.config.url = {
cdn: process.env.CDN_URL
};
}
return next();
},
], function(){
// Let's configure some stuff parallel-ly.
async.parallel([
// Favicon.
function(done){
app.logger.info('Serving up the favicon...');
// Setup our Favicon.
app.use(require('serve-favicon')(path.join(process.cwd(), 'public', 'img', 'favicon.ico')));
return done();
},
// Express configuration (Pug, view compiler).
function(done){
app.logger.info('Setting up our Pug views...');
// Setup Pug.
app.set('views', path.join(process.cwd(), 'views'));
app.set('view engine', 'pug');
app.locals.config = app.config;
app.locals.environment = process.env.NODE_ENV;
app.locals.version = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'))).version;
// Trust out the X-Forwarded-* header fields, usally required when behind a load balance.
app.enable('trust proxy');
app.disable('x-powered-by');
// View cache.
if (process.env.NODE_ENV !== 'development') {
app.logger.info('Caching up those views...');
// We want to cache our views.
app.enable('view cache');
}
return done();
},
// Parsers.
function(done){
app.logger.info('Setting up the body parser...');
// Parse forms and JSON requests.
app.use(require('body-parser').urlencoded({ extended: false }));
app.use(require('body-parser').json());
return done();
},
// LESS/JS on-the-fly compilers (middlewares).
function(done){
// Development environment configuration.
if (process.env.NODE_ENV === 'development') {
app.logger.info('Setting up LESS middleware...');
// Use the LESS middleware.
app.use(require('less-middleware')(path.join(process.cwd(), 'assets', 'css'), {
force: true,
dest: path.join(process.cwd(), 'public'),
preprocess: {
path: function(pathname, req){
return pathname.replace('/css/', '/').replace('\\css\\', '\\');
}
}
}, null, {
compress: false
}));
app.logger.info('Setting up the JavaScript merger...');
// Use the UglifyJS middleware.
app.use(require(path.join(process.cwd(), 'lib', 'middlewares', 'merge-js'))({
src: path.join(process.cwd(), 'assets'),
match: /\/js\/(.*).js/g
}));
app.logger.info('Setting up JSON middleware...');
// Use the JSON middlware for the locales.
app.use(require(path.join(process.cwd(), 'lib', 'middlewares', 'json'))({
dest: path.join(process.cwd(), 'public'),
src: path.join(process.cwd(), 'assets'),
match: /\/locales\/(.*).json/g
}));
// Serve out static files.
app.use(require('serve-static')(path.join(process.cwd(), 'public')));
}
return done();
},
function(done){
app.logger.info('Setting up ORM (Caminte)...');
var Schema = require('caminte').Schema;
// Setting up the database.
app.db = new Schema(app.config.db.driver, app.config.db);
app.logger.info('Connecting to DB ' + app.config.db.database + ' on ' + app.config.db.host + ':' + app.config.db.port + ' of type ' + app.config.db.driver + ' using ' + app.config.db.username);
return done();
}
], function(){
// Create an empty object to store the models.
app.db.models = {};
var models = [];
var walk = walker.walk(path.join(process.cwd(), 'models'));
// Loop through all the models.
walk.on('file', function(root, file, next){
// Remove the extension.
models[path.join(root, file.name)] = file.name.substr(0, file.name.indexOf('.'));
return next();
});
// Done loading the models.
walk.on('end', function(){
async.series([
function(next){
app.logger.info('Loading models...');
async.each(Object.keys(models), function(path, done){
// Load the model.
app.db.models[models[path]] = require(path).model(app.db, app);
app.logger.info('- Model %s loaded!', models[path]);
return done();
}, next);
},
function(next){
app.logger.info('Creating model associations...');
async.each(Object.keys(models), function(path, done){
// Load the model.
var model = require(path);
// Associate the model.
if (model.associate) {
model.associate.call(app.db.models[models[path]], app.db);
app.logger.info('- Model %s associated!', models[path]);
}
return done();
}, next);
},
// Load up the controllers.
function(next){
app.logger.info('Loading controllers...');
var walk = walker.walk(path.join(process.cwd(), 'controllers'));
// Loop through all the controllers.
walk.on('file', function(root, file, next){
// Load the router.
var route = require(root + '/' + file.name)(app);
app.logger.info('- Controller %s loaded!', file.name);
return next();
});
// Done loading the controllers.
walk.on('end', next);
}
], function(){
async.series([
// 404 page.
function(next){
// Setup our 404 page.
app.use(function(req, res, next){
res.status(404);
if (req.accepts('html')) return res.redirect('/#/errors/404');
if (req.accepts('json')) return res.send({ error: 'Not found' });
return res.type('txt').send('Not found');
});
return next();
}
], function(){
// Listen for incoming HTTP requests.
server.listen(process.env.PORT || 3000);
// Trigger the callback and pass the app.
return callback(app, server);
}); // ], function(){
}); // ], function(){
}); // walk.on('end', function(){
}); // ], function(){
}); // function(next){
};
})();
|
/*
Copyright (c) 2003-2016, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'div', 'en-au', {
IdInputLabel: 'Id', // MISSING
advisoryTitleInputLabel: 'Advisory Title', // MISSING
cssClassInputLabel: 'Stylesheet Classes', // MISSING
edit: 'Edit Div', // MISSING
inlineStyleInputLabel: 'Inline Style', // MISSING
langDirLTRLabel: 'Left to Right (LTR)', // MISSING
langDirLabel: 'Language Direction', // MISSING
langDirRTLLabel: 'Right to Left (RTL)', // MISSING
languageCodeInputLabel: ' Language Code', // MISSING
remove: 'Remove Div', // MISSING
styleSelectLabel: 'Style', // MISSING
title: 'Create Div Container', // MISSING
toolbar: 'Create Div Container' // MISSING
} );
|
describe("Plugins", function() {
var url = "/dump";
it("Uses a live plugin on request", function(done) {
function notVader(jacksRequest) {
// All request must have this query parameter
jacksRequest.query("iAmNot", "Vader");
}
jacks().get(url)
.query("param1", "value")
.use(notVader)
.send(function(response) {
var query = response.response.url.substring(response.response.url.indexOf("?"));
Should(query).be.exactly("?param1=value&iAmNot=Vader");
done();
});
});
it("Uses a live plugin on global", function(done) {
function yoda(jacksRequest) {
// All request must have this query parameter
jacksRequest.query("iAm", "Yoda");
}
var myJacks = jacks();
myJacks
.use(yoda)
.get(url)
.query("param1", "value")
.send(function(response) {
var query = response.response.url.substring(response.response.url.indexOf("?"));
Should(query).be.exactly("?iAm=Yoda¶m1=value");
// Try again to that the plugin is still there
myJacks
.get(url)
.query("param1", "value")
.send(function(response) {
var query = response.response.url.substring(response.response.url.indexOf("?"));
Should(query).be.exactly("?iAm=Yoda¶m1=value");
done();
});
});
});
it("Uses a configured plugin on request", function(done) {
jacks.plugin("notVader", function notVader(jacksRequest) {
// All request must have this query parameter
jacksRequest.query("iAmNot", "Vader");
});
jacks()
.get(url)
.query("param1", "value")
.use("notVader")
.send(function(response) {
var query = response.response.url.substring(response.response.url.indexOf("?"));
Should(query).be.exactly("?param1=value&iAmNot=Vader")
done();
});
});
it("Uses a configured plugin on global", function(done) {
jacks.plugin("yoda", function yoda(jacksRequest) {
// All request must have this query parameter
jacksRequest.query("iAm", "Yoda");
});
var myJacks = jacks();
myJacks
.use("yoda")
.get(url)
.query("param1", "value")
.send(function(response) {
var query = response.response.url.substring(response.response.url.indexOf("?"));
Should(query).be.exactly("?iAm=Yoda¶m1=value")
myJacks
.get(url)
.query("param1", "value")
.send(function(response) {
// Try again to that the plugin is still there
var query = response.response.url.substring(response.response.url.indexOf("?"));
Should(query).be.exactly("?iAm=Yoda¶m1=value")
done();
});
});
});
});
|
goog.require("exp.both");
goog.require("exp.nodef");
goog.require("exp.def");
exp.both();
var n = exp.both.num + exp.both.num;
exp.nodef.num;
exp.def();
|
var gulp = require('gulp'),
jshint = require('gulp-jshint'),
plumber = require('gulp-plumber');
var hintPath = [
'./client/static/app/**/*.js',
'./server/**/*.js',
'!./node_modules/**/*',
'!./client/coverage/**/*',
'!./client/static/bower_components/**/*'
];
gulp.task('jshint', function() {
return gulp.src(hintPath)
.pipe(jshint())
.pipe(plumber())
.pipe(jshint.reporter());
});
gulp.task('watch-hint-js', function() {
gulp.watch(hintPath, ['jshint']);
});
|
(function($) {
window.JST = {};
window.JST['animal-identifier'] = _.template("<div class='row'><div class='large-6 columns'><input type='number' min='0' max='999' id='animal-identifier' placeholder='Tag number' autofocus></div></div>");
window.JST['location/address'] = _.template("<div id='address-template'><div class='row'><div class='large-6 columns'><div class='row'><div class='large-12 columns'><label for='suburb'>Suburb</label><input id='suburb' name='Suburb' type='text' /></div></div><div class='row'><div class='large-12 columns'><label for='street'>Street</label><input id='street' name='Street' type='text' /></div></div></div></div>");
window.JST['location/gps'] = _.template("<div id='coordinate-template'><div class='row'><div class='large-6 columns'><div class='panel'><p><span id='gps-status'>Latitude: <%= latitude %>, Longitude: <%= longitude %></span></p></div></div></div>");
window.JST['location/pending'] = _.template("<div id='coordinate-template'><div class='row'><div class='large-6 columns'><div class='panel'><p><span id='gps-status'>Getting Location...</span></p></div></div></div>");
window.JST['submit'] = _.template("<div class='row'><div class='large-6 columns' id='image-container'><a href='#'' class='success button expand'>Submit</a></div></div>");
window.JST['image'] = _.template("\
<div class='row'> \
<div class='large-6 columns' id='image-container'> \
<input type='file' capture='camera' accept='image/*' id='camera-input' name='camera-input' style='display:none'> \
<a href='#' id='camera-select' class='button expand'>Add Photo</a> \
</div> \
</div>");
window.Position = Backbone.Model.extend({
initialize: function(options) {
_.bindAll(this, 'setAttributesFromGeoposition');
if (options !== undefined) {
if (options.geoposition !== undefined) {
this.setAttributesFromGeoposition(options.geoposition);
}
}
},
setAttributesFromGeoposition: function(geoposition) {
this.set(geoposition.coords);
this.set({ timestamp: geoposition.timestamp });
}
});
window.LocationProvider = Backbone.Model.extend({
initialize: function() {
_.bindAll(this, 'isAvailable', 'getCurrentPosition', 'onSuccess', 'onError');
if (this.isAvailable()) {
this._base = window.navigator.geolocation;
}
},
isAvailable: function() {
return 'geolocation' in window.navigator;
},
getCurrentPosition: function() {
if (this.isAvailable()) {
var options = {
enableHighAccuracy: true,
timeout: 10000,
maximumAge: 120000
};
this._base.getCurrentPosition(this.onSuccess, this.onError, options);
} else
{
this.onError();
}
},
onSuccess: function(position) {
var positionModel = new Position({ geoposition: position });
this.set('lastLocation', positionModel);
this.trigger('didUpdateLocation', positionModel);
console.log('didUpdateLocation: ', positionModel);
},
onError: function(error) {
this.trigger('didFailToUpdateLocation', error);
console.log('didFailToUpdateLocation: ', error);
}
});
window.ImageProvider = Backbone.Model.extend({
isAvailable: function() {
//return 'capture' in document.createElement('input');
if(navigator.userAgent.match(/(Android (1.0|1.1|1.5|1.6|2.0|2.1))|(Windows Phone (OS 7|8.0))|(XBLWP)|(ZuneWP)|(w(eb)?OSBrowser)|(webOS)|(Kindle\/(1.0|2.0|2.5|3.0))/)) {
return false;
} else {
return true;
}
}
});
window.Address = Backbone.Model.extend({ });
$(document).ready(function() {
window.IdentifierView = Backbone.View.extend({
template: window.JST['animal-identifier'],
initialize: function() {
_.bindAll(this, 'render');
},
render: function() {
this.$el.html(this.template());
return this;
}
});
window.ImageView = Backbone.View.extend({
events: {
'click #camera-select': 'getImage'
},
template: window.JST['image'],
initialize: function() {
_.bindAll(this, 'render', 'getImage');
},
render: function() {
this.$el.html(this.template());
return this;
},
getImage: function(event) {
event.preventDefault();
console.log('imageView el: ', this.$el.find('#camera-input'));
this.$el.find('#camera-input').click();
}
});
window.AppView = Backbone.View.extend({
tagName: 'form',
initialize: function() {
_.bindAll(this,
'render',
'renderSubview',
'initializeSubviews',
'initializeLocationView',
'initializeImageView');
this.subviews = [];
this.imageProvider = new ImageProvider();
this.locationProvider = new LocationProvider();
this.initializeSubviews();
},
render: function() {
this.subviews.forEach(this.renderSubview);
this.$el.append(JST['submit']());
return this;
},
renderSubview: function(subview, index, array) {
var el = subview.render().el;
this.$el.append(el);
},
initializeSubviews: function() {
this.subviews.push(new IdentifierView());
this.initializeLocationView();
this.initializeImageView();
},
initializeLocationView: function() {
var view = new LocationView({ locationProvider: this.locationProvider });
this.subviews.push(view);
},
initializeImageView: function() {
if (this.imageProvider.isAvailable()) {
this.subviews.push(new ImageView());
}
}
});
window.LocationView = Backbone.View.extend({
initialize: function(options) {
_.bindAll(this,
'render',
'renderCoordinateView',
'renderAddressView',
'onLocationError');
if (options !== undefined) {
this.locationProvider = options.locationProvider;
this.locationProvider.on('didFailToUpdateLocation', this.onLocationError);
}
this.coordinateView = new CoordinateView({
locationProvider: this.locationProvider
});
this.addressView = new AddressView();
},
render: function() {
if (this.locationProvider.isAvailable()) {
this.renderCoordinateView();
} else {
this.renderAddressView();
}
return this;
},
renderCoordinateView: function() {
console.log('renderCoordinateView.this ', this);
//this.coordinateView = new CoordinateView({
// locationProvider: this.locationProvider
//});
this.$el.append(this.coordinateView.render().el);
},
renderAddressView: function() {
this.addressView = new AddressView({
model: new Address()
});
this.$el.append(this.addressView.render().el);
},
onLocationError: function(e) {
console.log("ON LOCATION ERROR");
console.log("this: ", this);
this.coordinateView.remove();
this.renderAddressView();
}
});
window.CoordinateView = Backbone.View.extend({
template: window.JST['location/gps'],//$('#coordinate-template').html()),
initialize: function(options) {
_.bindAll(this, 'render', 'renderPosition');
if (options !== undefined) {
if (options.locationProvider !== undefined) {
this.locationProvider = options.locationProvider;
this.locationProvider.on('didUpdateLocation', this.renderPosition);
}
}
},
render: function() {
var lastLocation = this.locationProvider.get('lastLocation');
if (lastLocation === undefined) {
$(this.el).html(JST['location/pending']());
} else
{
this.renderPosition(lastLocation);
}
return this;
},
renderPosition: function(position) {
$(this.el).html(this.template( {latitude: position.get('latitude'), longitude: position.get('longitude')} ));
console.log('el: ', this.$el);
return this;
}
});
window.AddressView = Backbone.View.extend({
template: window.JST['location/address'],//$("#address-template").html()),
initialize: function() {
_.bindAll(this, 'render');
},
render: function() {
$(this.el).html(this.template());
return this;
}
});
window.Wingtags = Backbone.Router.extend({
routes: { '': 'home' },
initialize: function() {
this.appView = new AppView();
this.appView.locationProvider.getCurrentPosition();
},
home: function() {
$('#app-container').empty();
$('#app-container').append(this.appView.render().el);
}
});
window.App = new Wingtags();
Backbone.history.start();
});
})(jQuery);
|
// Generated on 2013-10-26 using generator-webapp 0.4.3
'use strict';
// # Globbing
// for performance reasons we're only matching one level down:
// 'test/spec/{,*/}*.js'
// use this if you want to recursively match all subfolders:
// 'test/spec/**/*.js'
module.exports = function (grunt) {
// show elapsed time at the end
require('time-grunt')(grunt);
// load all grunt tasks
require('load-grunt-tasks')(grunt);
grunt.initConfig({
// configurable paths
yeoman: {
app: 'app',
dist: 'dist'
},
watch: {
scripts: {
files: ['<%= yeoman.app %>/styles/{,*/}*.{scss,sass}'],
tasks: ['sass', 'autoprefixer']
},
styles: {
files: ['<%= yeoman.app %>/styles/{,*/}*.css'],
tasks: ['copy:styles', 'autoprefixer']
},
livereload: {
options: {
livereload: '<%= connect.options.livereload %>'
},
files: [
'<%= yeoman.app %>/*.html',
'.tmp/styles/{,*/}*.css',
'{.tmp,<%= yeoman.app %>}/scripts/{,*/}*.js',
'<%= yeoman.app %>/images/{,*/}*.{png,jpg,jpeg,gif,webp,svg}'
]
}
},
connect: {
options: {
port: 9000,
livereload: 35729,
// change this to '0.0.0.0' to access the server from outside
hostname: 'localhost'
},
livereload: {
options: {
open: true,
base: [
'.tmp',
'<%= yeoman.app %>'
]
}
},
test: {
options: {
base: [
'.tmp',
'test',
'<%= yeoman.app %>'
]
}
},
dist: {
options: {
open: true,
base: '<%= yeoman.dist %>'
}
}
},
clean: {
dist: {
files: [{
dot: true,
src: [
'.tmp',
'<%= yeoman.dist %>/*',
'!<%= yeoman.dist %>/.git*'
]
}]
},
server: '.tmp'
},
jshint: {
options: {
jshintrc: '.jshintrc'
},
all: [
'Gruntfile.js',
'<%= yeoman.app %>/scripts/{,*/}*.js',
'!<%= yeoman.app %>/scripts/vendor/*',
'test/spec/{,*/}*.js'
]
},
mocha: {
all: {
options: {
run: true,
urls: ['http://<%= connect.test.options.hostname %>:<%= connect.test.options.port %>/index.html']
}
}
},
sass: {
options: {
sourceMap: true
},
dist: {
files: {
'.tmp/styles/main.css': 'app/styles/main.scss'
}
}
},
autoprefixer: {
options: {
browsers: ['last 1 version']
},
dist: {
files: [{
expand: true,
cwd: '.tmp/styles/',
src: '{,*/}*.css',
dest: '.tmp/styles/'
}]
}
},
// not used since Uglify task does concat,
// but still available if needed
/*concat: {
dist: {}
},*/
requirejs: {
dist: {
// Options: https://github.com/jrburke/r.js/blob/master/build/example.build.js
options: {
// `name` and `out` is set by grunt-usemin
baseUrl: '<%= yeoman.app %>/scripts',
optimize: 'none',
// TODO: Figure out how to make sourcemaps work with grunt-usemin
// https://github.com/yeoman/grunt-usemin/issues/30
//generateSourceMaps: true,
// required to support SourceMaps
// http://requirejs.org/docs/errors.html#sourcemapcomments
preserveLicenseComments: false,
useStrict: true,
wrap: true
//uglify2: {} // https://github.com/mishoo/UglifyJS2
}
}
},
rev: {
dist: {
files: {
src: [
'<%= yeoman.dist %>/scripts/{,*/}*.js',
'<%= yeoman.dist %>/styles/{,*/}*.css',
'<%= yeoman.dist %>/images/{,*/}*.{png,jpg,jpeg,gif,webp}',
'<%= yeoman.dist %>/styles/fonts/{,*/}*.*'
]
}
}
},
useminPrepare: {
options: {
dest: '<%= yeoman.dist %>'
},
html: '<%= yeoman.app %>/index.html'
},
usemin: {
options: {
dirs: ['<%= yeoman.dist %>']
},
html: ['<%= yeoman.dist %>/{,*/}*.html'],
css: ['<%= yeoman.dist %>/styles/{,*/}*.css']
},
cssmin: {
// This task is pre-configured if you do not wish to use Usemin
// blocks for your CSS. By default, the Usemin block from your
// `index.html` will take care of minification, e.g.
//
// <!-- build:css({.tmp,app}) styles/main.css -->
//
// dist: {
// files: {
// '<%= yeoman.dist %>/styles/main.css': [
// '.tmp/styles/{,*/}*.css',
// '<%= yeoman.app %>/styles/{,*/}*.css'
// ]
// }
// }
},
htmlmin: {
dist: {
options: {
/*removeCommentsFromCDATA: true,
// https://github.com/yeoman/grunt-usemin/issues/44
//collapseWhitespace: true,
collapseBooleanAttributes: true,
removeAttributeQuotes: true,
removeRedundantAttributes: true,
useShortDoctype: true,
removeEmptyAttributes: true,
removeOptionalTags: true*/
},
files: [{
expand: true,
cwd: '<%= yeoman.app %>',
src: '*.html',
dest: '<%= yeoman.dist %>'
}]
}
},
// Put files not handled in other tasks here
copy: {
dist: {
files: [{
expand: true,
dot: true,
cwd: '<%= yeoman.app %>',
dest: '<%= yeoman.dist %>',
src: [
'CNAME',
'*.{ico,png,txt}',
'.htaccess',
'images/*',
'styles/fonts/{,*/}*.*',
'bower_components/bootstrap-sass/assets/fonts/bootstrap/*.*',
'bower_components/font-awesome/fonts/*.*'
]
}]
},
styles: {
expand: true,
dot: true,
cwd: '<%= yeoman.app %>/styles',
dest: '.tmp/styles/',
src: '{,*/}*.css'
}
},
concurrent: {
server: [
'sass',
'copy:styles'
],
test: [
'copy:styles'
],
dist: [
'sass',
'copy:styles',
'htmlmin'
]
},
bower: {
all: {
rjsConfig: '<%= yeoman.app %>/scripts/main.js'
}
}
});
grunt.registerTask('server', function (target) {
if (target === 'dist') {
return grunt.task.run(['build', 'connect:dist:keepalive']);
}
grunt.task.run([
'clean:server',
'concurrent:server',
'autoprefixer',
'connect:livereload',
'watch'
]);
});
grunt.registerTask('test', [
'clean:server',
'concurrent:test',
'autoprefixer',
'connect:test',
'mocha'
]);
grunt.registerTask('build', [
'clean:dist',
'useminPrepare',
'concurrent:dist',
'autoprefixer',
'requirejs',
'concat',
'cssmin',
'uglify',
'copy:dist',
'rev',
'usemin'
]);
grunt.registerTask('default', [
'jshint',
'test',
'build',
'sass'
]);
};
|
"use strict";
QUnit.test("can focus", function (assert) {
var target = $("#Form1 .if-control:not(.if-readonly)")
assert.ok(target.length > 0, "Get Target");
target.each(function (index, element) {
element.focus();
assert.equal(document.activeElement, element, "Focused");
});
});
QUnit.test("readonly cannot focus", function (assert) {
var target = $("#Form1 .if-control.if-readonly")
assert.ok(target.length > 0, "Get Target");
target.each(function (index, element) {
element.focus();
assert.notEqual(element, document.activeElement, "UnFocused(" + index + ")");
});
});
QUnit.test("has value", function (assert) {
var target = $("#Form1 .if-control")
assert.ok(target.length > 0, "Get Target");
target.each(function (index, element) {
assert.equal($(element).find(".if-value").length, 1, "HasValue(" + index + ")");
});
});
QUnit.test("has input", function (assert) {
var target = $("#Form1 .if-control:not(.if-readonly)")
assert.ok(target.length > 0, "Get Target");
target.each(function (index, element) {
assert.equal($(element).find(".if-input").length, 1, "HasInput(" + index + ")");
});
});
QUnit.test("readonly has no input", function (assert) {
var target = $(".if-control.if-readonly")
assert.ok(target.length > 0, "Get Target");
target.each(function (index, element) {
assert.equal($(element).find(".if-input").length, 0, "NoInput(" + index + ")");
});
});
QUnit.test("focused input value", function (assert) {
var target = $("#Control1")
assert.equal(target.length, 1, "Get Target");
var value = target.find(".if-value");
assert.equal(value.length, 1, "Get Value");
var input = target.find(".if-input");
assert.equal(input.length, 1, "Get Input");
target[0].focus();
assert.equal(input.val(), value.text());
target[0].blur();
value.text("foobar_name");
target[0].focus();
assert.equal(input.val(), value.text());
target[0].blur();
});
QUnit.test("if.type", function (assert) {
assert.equal($("#Control1").if("type"), "text");
assert.equal($("#Control3").if("type"), "number");
});
QUnit.test("checkbox", function (assert) {
var target = $("#Control4")
assert.equal(target.length, 1, "Get Target");
var value = target.find(".if-value");
assert.equal(value.length, 1, "Get Value");
var input = target.find(".if-input");
assert.equal(input.length, 1, "Get Input");
target[0].focus();
assert.equal(input.prop("checked"), target.data("value"));
target[0].blur();
target.data("value", !target.data("value"));
value.find("input[type=checkbox]").prop("checked", false);
target[0].focus();
assert.equal(input.prop("checked"), target.data("value"));
target[0].blur();
});
QUnit.test("checkbox_custom", function (assert) {
var target = $("#Control9")
assert.equal(target.length, 1, "Get Target");
var value = target.find(".if-value");
assert.equal(value.length, 1, "Get Value");
target.if("val", false);
target.if("val", true);
assert.equal(value.text(), "TRUE");
assert.equal(target.attr('data-value'), true);
target.if("val", false);
assert.equal(value.text(), "FALSE");
assert.equal(target.attr('data-value'), false);
});
QUnit.asyncTest("update", function (assert) {
var target = $("#Control1")
var value = target.find(".if-value");
var input = target.find(".if-input");
target[0].focus();
$("#Control1").if("val", "hogehogehoge");
$("#Control2").if("val", 12);
$("#Control3").if("val", 12);
$("#Control4").if("val", true);
target[0].blur();
expect(4);
var callback;
callback = function () {
$(".if-form").unbind("update.if", callback);
assert.equal($("#Control1").if("val"), "name_of_model_hogehoge");
assert.equal($("#Control2").if("val"), 223);
assert.equal($("#Control3").if("val"), 223);
assert.equal($("#Control4").if("val"), false);
QUnit.start();
};
$(".if-form").bind("update.if", callback);
});
QUnit.asyncTest("update from input", function (assert) {
var target = $("#Control1")
var value = target.find(".if-value");
var input = target.find(".if-input");
target[0].focus();
$("#Control1").if("val", "hogehogehoge");
$("#Control2").if("val", 12);
$("#Control3").if("val", 12);
$("#Control4").if("val", true);
input[0].focus();
input[0].blur();
expect(5);
var callback;
callback = function () {
$(".if-form").unbind("update.if", callback);
assert.equal($("#Control1").if("val"), "name_of_model_hogehoge");
assert.equal($("#Control2").if("val"), 223);
assert.equal($("#Control3").if("val"), 223);
assert.equal($("#Control4").if("val"), false);
assert.equal($("#Control7").if("val"), "name_of_other_model_hogehoge");
QUnit.start();
};
$(".if-form").bind("update.if", callback);
});
QUnit.test("if.val", function (assert) {
var target = $("#Control1")
var value = target.find(".if-value");
var input = target.find(".if-input");
value.text("test_if.val_name");
assert.equal(target.if("val"), "test_if.val_name");
target.if("val", "test_if.val_name2")
assert.equal(target.if("val"), "test_if.val_name2");
});
QUnit.test("if.val checkbox", function (assert) {
var target = $("#Control4")
var value = target.find(".if-value");
var input = target.find(".if-input");
var checkbox = value.find("input[type=checkbox]");
target.if("val", true);
assert.equal(checkbox.prop("checked"), true);
target.if("val", false);
assert.equal(checkbox.prop("checked"), false);
target.if("val", true);
assert.equal(checkbox.prop("checked"), true);
});
QUnit.test("if.val custom-checkbox", function (assert) {
var target = $("#Control5")
var value = target.find(".if-value");
var input = target.find(".if-input");
target.if("val", true);
assert.equal(value.text(), "True");
target.if("val", false);
assert.equal(value.text(), "False");
target.if("val", true);
assert.equal(value.text(), "True");
});
QUnit.test("if.val select", function (assert) {
var target = $("#Control6")
var value = target.find(".if-value");
var input = target.find(".if-input");
target.if("val", 1);
assert.equal(value.text(), "Parent1");
target.if("val", 2);
assert.equal(value.text(), "Parent2");
target.if("val", null);
assert.equal(value.text(), "Empty");
});
QUnit.test("if.val belongsTo/hasOne readonly", function (assert) {
var target = $("#Control7")
var value = target.find(".if-value");
var input = target.find(".if-input");
target.if("val", "changed1");
assert.equal(value.text(), "changed1");
target.if("val", "changed2");
assert.equal(value.text(), "changed2");
target.if("val", null);
assert.equal(value.text(), "");
});
QUnit.test("if.val null", function (assert) {
var target = $("#Control1")
var value = target.find(".if-value");
var input = target.find(".if-input");
target.if("val", null)
assert.equal(value.text(), "");
});
QUnit.test("if.val multiline", function (assert) {
var target = $("#Control8")
var value = target.find(".if-value");
var input = target.find(".if-input");
value.html("hoge<br>\nhoge");
assert.equal(target.if("val"), "hoge\nhoge");
target.if("val", "hoge\nhoge")
assert.equal(value.html(), "hoge<br>\nhoge");
});
QUnit.asyncTest("add", function (assert) {
expect(6);
var callback;
callback = function (e, data) {
$("#Form2").unbind("update.if", callback);
assert.equal(data.data.ChildModel.id, 11);
assert.equal(data.data.ChildModel.model_id, 1);
var group = $("#Form2 .if-group:not(.if-template)[data-id=11]");
assert.equal(group.length, 1);
var control = group.find(".if-control[data-field=name]");
assert.equal(control.length, 1);
assert.equal(control.data("id"), 11);
assert.equal(control.if("val"), "name_of_child_model_11_hogehoge");
QUnit.start();
};
$("#Form2").bind("update.if", callback);
$("#AddButton1").trigger("click");
});
QUnit.asyncTest("don't update with selectable readonly", function (assert) {
expect(1);
var flag = true;
var callback = function (e, data) {
$("#Form3").unbind("update.if", callback);
flag = false;
};
$("#Form3").bind("update.if", callback);
$("#Form3 .if-control")[0].focus();
$("#Form3 .if-control")[0].blur();
setTimeout(function() {
assert.ok(flag);
QUnit.start();
}, 500);
});
QUnit.asyncTest("delete", function (assert) {
expect(1);
var callback;
callback = function (e, data) {
$("#Form4").unbind("update.if", callback);
var group = $("#Form4").find(".if-group[data-id=5]");
assert.equal(group.length, 0);
QUnit.start();
};
$("#Form4").bind("update.if", callback);
$("#DeleteButton1").trigger("click");
});
|
import Ember from 'ember';
import initialize from 'ember-cli-path-inspector/initializers/inject-path-inspector';
import { module, test } from 'qunit';
var registry, application;
module('Unit | Initializer | inject path inspector', {
beforeEach() {
Ember.run(function () {
application = Ember.Application.create();
registry = application.registry;
application.deferReadiness();
});
}
});
// Replace this with your real tests.
test('it works', function (assert) {
initialize(application);
// you would normally confirm the results of the initializer here
assert.ok(true);
});
|
"use strict";
const path = require("path");
const os = require("os");
const child_process = require("child_process");
const glob = require("glob");
const chalk = require("chalk");
const welcomeScreen = `
|=======================================================|
|========= Recursive NuGet Pack Invoker by MIC =========|
|=======================================================|
`;
console.info(chalk.yellow(welcomeScreen));
const AlienProjectPattern = /thirdparty/i;
const appveyorRepoTag = process.env.APPVEYOR_REPO_TAG;
if (appveyorRepoTag === void(0) || appveyorRepoTag.toLowerCase() !== "true") {
console.info(`Not a deployment, exiting. (APPVEYOR_REPO_TAG is "${appveyorRepoTag}", should be "true")`);
} else {
glob(path.join(process.cwd(), "**/*.nuspec"), packPackages);
}
function packPackages(err, fileList) {
if (err) {
console.error(chalk.red(err));
process.exit(1);
}
console.info(chalk.green("Finding NuGet spec files..."));
const filesToPack = [];
for (const fileName of fileList) {
if (!AlienProjectPattern.test(fileName)) {
/**
* @type {string}
*/
let f = fileName.replace(/\.nuspec/i, ".csproj");
filesToPack.push(winpath(f));
}
}
let packed = 0;
for (const fileName of filesToPack) {
console.info(`Packing ${chalk.magenta(fileName)} ... (${packed + 1}/${filesToPack.length})`);
const name = path.basename(fileName);
const dir = path.dirname(fileName);
const params = [
"pack", name,
//"-Build",
"-IncludeReferencedProjects",
"-OutputDirectory", winpath(process.cwd()),
"-Prop", `Configuration=${process.env["CONFIGURATION"]};Platform=${process.env["PLATFORM"]};OutputPath=${winpath(getOutputPath(dir))}`
];
//if (process.env["Release_Suffix"]) {
// params.push("-Suffix", process.env["Release_Suffix"].replace("-", ""));
//}
const stdout = child_process.execFileSync("nuget", params, {
cwd: dir,
env: process.env
}, (proc_err) => {
if (proc_err) {
console.error(chalk.red(proc_err));
}
});
console.log(chalk.grey(stdout));
++packed;
}
/**
* @param {string} p
*/
function winpath(p) {
return os.platform() === "win32" ? p.replace(/\//g, "\\") : p;
}
/**
* @param {string} basePath
*/
function getOutputPath(basePath) {
const configuration = process.env["CONFIGURATION"];
const platform = process.env["PLATFORM"];
const plat = platform.toLowerCase();
if (plat === "anycpu" || plat === "any cpu") {
return path.join(basePath, "bin", configuration);
} else {
return path.join(basePath, "bin", platform, configuration);
}
}
}
|
import { assert } from 'chai';
import request from 'superagent';
describe('GET /projects/{repo}/validate', function() {
let server;
before(async () => {
require('src/projects/helpers/sync').default.syncProjectWorkspace = () => true;
server = require('src/api').default.listen(3000);
});
after(() => {
server.close();
});
it('should return 200 for valid projects', async () => {
try {
const res = await request.get(
'localhost:3000/projects/good-rest-provider/validate?rev=master'
);
assert.equal(res.statusCode, 200);
} catch (err) {
assert.deepEqual(err, {}, "shouldn't throw an error.");
}
});
it('should return 500 for invalid projects', async () => {
try {
await request.get('localhost:3000/projects/non-existing-repo/validate?rev=master');
} catch (err) {
assert.equal(err.status, 500);
}
});
});
describe('GET /projects/{repo}/sync', function() {
let server;
before(async () => {
require('src/projects/helpers/sync').default.syncProjectWorkspace = () => true;
server = require('src/api').default.listen(3000);
});
after(() => {
server.close();
});
it('should return 200 for valid projects', async () => {
try {
const res = await request.get('localhost:3000/projects/good-rest-provider/sync');
assert.equal(res.statusCode, 200);
} catch (err) {
assert.deepEqual(err, {}, "shouldn't throw an error.");
}
});
it('should return 500 for invalid projects', async () => {
try {
await request.get('localhost:3000/projects/non-existing-repo/sync');
} catch (err) {
assert.equal(err.status, 500);
}
});
});
|
module.exports = function(grunt) {
grunt.loadNpmTasks('grunt-contrib-jshint');
grunt.config('jshint', {
options: grunt.file.readJSON('.jshintrc'),
src: [
'Gruntfile.js',
'build/tasks/**/*.js'
]
});
};
|
const { relative } = require('path');
const { writeFile } = require('fildes');
const bundle = require('./bundle');
const minifyStyles = require('./minify');
const { size } = require('../log/index');
module.exports = ({ src, dest, assets, fonts, minify = true }) => {
return bundle({ src, dest, assets, fonts }).then(result => {
return Promise.all([
writeFile(dest, result.css),
writeFile(dest + '.map', result.map)
]).then(() => {
if (!minify) {
return Promise.resolve(result.css);
}
const destmin = dest.replace(/\.css$/, '.min.css');
return minifyStyles({ result, src: dest, dest: destmin }).then(min => {
return Promise.all([
writeFile(destmin, min.css),
writeFile(destmin + '.map', min.map)
])
.then(() => {
size({
title: relative(process.cwd(), dest),
results: {
Bundle: result.css,
minified: min.css
}
});
})
.then(() => min.css);
});
});
});
};
|
import React, { Component } from 'react'
import * as ACTIONS from 'actions'
import { connect } from 'react-redux'
import { bindActionCreators } from 'redux'
import AdminHeader from 'components/generics/admin-header/AdminHeader'
import AdminNavigation from 'components/admin/admin-navigation/AdminNavigation'
import Refinements from 'components/admin/refinements/Refinements'
import t from 'translations'
class AdminRefinements extends Component {
componentWillMount() {
const {
actions
} = this.props
actions.getRefinements()
}
render() {
return (
<div>
<AdminHeader />
<AdminNavigation />
<Refinements />
</div>
)
}
}
const mapDispatchToProps = (dispatch) => {
const actions = ACTIONS
const actionMap = { actions: bindActionCreators(actions, dispatch) }
return actionMap
}
export default connect(null, mapDispatchToProps)(AdminRefinements)
|
(function($){
$.fn.caret = function(s, e) {
var setPosition = function(el, start, end) {
if (el.setSelectionRange) {
el.focus();
el.setSelectionRange(start, end);
}
else if(el.createTextRange) {
var range = el.createTextRange();
range.collapse(true);
range.moveEnd('character', end);
range.moveStart('character', start);
range.select();
}
};
if (s != null && e != null) { //setting range
return this.each(function() {
setPosition(this, s, e);
});
}
else if (s != null) { //setting position
return this.each(function() {
setPosition(this, s, s);
});
}
else { //getting
var el = this[0];
if (el.createTextRange) {
var r = document.selection.createRange().duplicate();
var end = el.value.lastIndexOf(r.text) + r.text.length;
r.moveEnd('character', el.value.length);
var start = (r.text == '') ? el.value.length : el.value.lastIndexOf(r.text);
return [start, end];
}
else {
return [el.selectionStart, el.selectionEnd];
}
}
};
})(jQuery);
|
'use strict'
// Based on:
// <http://jaketrent.com/post/testing-react-with-jsdom/>
// <https://github.com/jesstelford/react-testing-mocha-jsdom>
const jsdom = require('jsdom')
global.document = jsdom.jsdom('<html><body><div id="app"></div></body></html>', {})
global.window = document.defaultView
// Add fetch polyfill
window.fetch = global.fetch
// from mocha-jsdom https://github.com/rstacruz/mocha-jsdom/blob/master/index.js#L80
for (const key in window) {
if (!window.hasOwnProperty(key)) {
continue
}
if (key in global) {
continue
}
global[key] = window[key]
}
|
var $ = require('jquery');
var _ = require('underscore');
var Backbone = require('backbone');
var urlDS = Backbone.Collection.extend({
generate : function (longUrl) {
var d = new Date();
this.add({ token : String(d.getTime()) , long : longUrl });
return d.getTime();
}
});
module.exports = new urlDS();
|
#!/usr/bin/env node
'use strict';
var Slouch = require('./scripts'),
utils = require('./test/utils'),
slouch = new Slouch(utils.couchDBURL());
slouch.system.reset();
|
/*!
* Module dependencies.
*/
var _ = require('underscore'),
util = require('util'),
super_ = require('../Type');
var REGEXP_LNGLAT = /^\s*(\-?\d+(?:\.\d+)?)\s*\,\s*(\-?\d+(?:\.\d+)?)\s*$/;
/**
* Geo FieldType Constructor
* @extends Field
* @api public
*/
function geopoint(list, path, options) {
this._fixedSize = 'medium';
// TODO: implement filtering, hard-coded as disabled for now
options.nofilter = true;
geopoint.super_.call(this, list, path, options);
}
/*!
* Inherit from Field
*/
util.inherits(geopoint, super_);
/**
* Registers the field on the List's Mongoose Schema.
*
* Adds a 2dsphere indexed lat/lng pair
*
* @api public
*/
geopoint.prototype.addToSchema = function() {
this.list.schema.path(this.path, _.defaults({ type: [Number], index: '2dsphere' }, this.options));
this.bindUnderscoreMethods();
};
/**
* Gets the field's data from an Item, as used by the React components
*/
geopoint.prototype.getData = function(item) {
var points = item.get(this.path);
return (points && points.length === 2) ? points : [];
};
/**
* Formats the field value
*
* @api public
*/
geopoint.prototype.format = function(item) {
return item.get(this.path).join(', ');
};
/**
* Validates that a value for this field has been provided in a data object
*
* @api public
*/
geopoint.prototype.validateInput = function(data, required, item) {
// Input is valid if the field is not required, and not present
if (!(this.path in data) && !required) return true;
var values = data[this.path];
if (_.isArray(values)) {
values = _.compact(values).join(',');
}
if (values === '' && !required) return true;
return REGEXP_LNGLAT.test(values);
};
/**
* Updates the value for this field in the item from a data object
*
* @api public
*/
geopoint.prototype.updateItem = function(item, data) {
if (!_.isObject(data)) return;
if (this.path in data && _.isString(data[this.path])) {
// Value should be formatted lng,lat
var values = REGEXP_LNGLAT.exec(data[this.path]);
if (values) {
item.set(this.path, [values[1], values[2]]);
} else {
item.set(this.path, undefined);
}
} else if (this.path in data && _.isArray(data[this.path])) {
var values = data[this.path];
if (values.length === 2 && REGEXP_LNGLAT.test(_.compact(values).join(','))) {
item.set(this.path, values);
} else {
item.set(this.path, undefined);
}
}
};
/*!
* Export class
*/
exports = module.exports = geopoint;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.