code stringlengths 2 1.05M |
|---|
const { equal, deepEqual } = require("assert")
const builds = ["es6", "es5"]
builds.forEach((buildName) => {
const generator = require(`../dist/${buildName}.umd`)
describe(`[${buildName}] Generator`, () => {
it("works with for/of", () => {
const expected = [
[],
[ "a" ],
[ "b" ],
[ "a", "b" ],
[ "c" ],
[ "a", "c" ],
[ "b", "c" ],
[ "a", "b", "c" ]
]
const actual = []
for (const subset of generator(["a", "b", "c"])) {
actual.push(subset)
}
deepEqual(actual, expected)
})
it("works with spread operator", () => {
const expected = [
[], [ "a" ], [ "b" ], [ "a", "b" ]
]
const actual = [...generator([ "a", "b" ])]
deepEqual(actual, expected)
})
it("works with Array.from", () => {
const expected = [
[], [ "a" ], [ "b" ], [ "a", "b" ]
]
const actual = Array.from(generator([ "a", "b" ]))
deepEqual(actual, expected)
})
it("can use a map function", () => {
for (const actual of generator(["a", "b", "c"], () => "test")) {
equal(actual, "test")
}
})
it("can map indexes", () => {
const expected = [
[],
[ "a" ],
[ "b" ],
[ "a", "b" ],
[ "c" ],
[ "a", "c" ],
[ "b", "c" ],
[ "a", "b", "c" ]
]
const actual = []
let c = 0
for (const [index, subset] of generator(["a", "b", "c"], (value, i) => [i, value])) {
equal(index, c++)
actual.push(subset)
}
deepEqual(actual, expected)
})
it("can manipulate generated results", () => {
const expected = [
[ "x" ],
[ "a", "x" ],
[ "b", "x" ],
[ "a", "b", "x" ],
[ "c", "x" ],
[ "a", "c", "x" ],
[ "b", "c", "x" ],
[ "a", "b", "c", "x" ]
]
const actual = []
let c = 0
const map = (value, i) => {
value.push("x")
return [i.toString(2), value]
}
for (const [mask, subset] of generator(["a", "b", "c"], map)) {
equal(mask, c.toString(2))
actual.push(subset)
c++
}
deepEqual(actual, expected)
})
})
})
|
import React from "react";
import ReactDOM from "react-dom";
import injectTapEventPlugin from 'react-tap-event-plugin';
import App from "./components/app";
injectTapEventPlugin();
ReactDOM.render(<App />, document.getElementById("root")); |
function getChild(model, db, row) {
"use strict";
var res = {
row: undefined,
model: undefined
};
if (model.extendedBy) {
if (model.extendedBy.some(function(ext) {
if (db[ext.model.tableName].get(row[ext.localField])) {
res.model = ext.model;
res.row = db[ext.model.tableName].get(row[ext.localField]);
return true;
}
})) {
return res;
}
}
}
module.exports = getChild;
|
import React from 'react'
import { shallow } from 'enzyme'
import Checkbox from '../Checkbox'
describe('Checkbox', () => {
let wrapper
beforeEach(() => {
wrapper = shallow(<Checkbox />)
})
it('renders proper defaults if none passed', () => {
expect(wrapper.prop('type')).toEqual('checkbox')
expect(wrapper.prop('property')).toEqual('checked')
})
it('assumes props passed', () => {
wrapper.setProps({
name: 'nameFoo',
type: 'typeFoo',
})
expect(wrapper.prop('name')).toEqual('nameFoo')
expect(wrapper.prop('type')).toEqual('typeFoo')
})
it('passes extra props', () => {
wrapper.setProps({
label: 'some label',
})
expect(wrapper.prop('label')).toEqual('some label')
})
})
|
'use strict';
var moment = require('moment');
/**
* Logger-specific configuration
*/
module.exports = {
express_format: ':date EXPRESS [:remote-addr] ":method :url HTTP/:http-version" :status ":referrer" ":user-agent"',
custom_tokens: [{
token: ':date',
replacement: function() {
return moment().format('YYYY-MM-DD HH:mm:ss.SSS');
}
}]
};
|
var pipeworks = require('pipeworks');
var StepRunner = module.exports = function(subject) {
this.subject = subject;
this.state = 'fresh'; // 'fresh', 'ready', 'done'
this.pipeline = pipeworks();
};
StepRunner.prototype.run = function(cb) {
if (this.state === 'fresh') {
var self = this;
this.subject.steps.forEach(function(step) {
self.pipeline.fit(function(context, next) {
self.subject[step].call(self.subject, function(err) {
if (err) {
cb(err);
} else {
next(context);
}
});
});
});
this.state = 'ready'
}
if (cb) {
this.pipeline.fit(function() { cb(); });
}
var self = this;
this.pipeline.fit(function() {
self.status = 'done';
});
this.pipeline.flow();
};
|
const TM1637Display = require("../");
const Clk = 21;
const DIO = 20;
const t = new TM1637Display(Clk, DIO);
const g = [
[0, 1, 2, 3],
[1, 2, 3, 4],
[2, 3, 4, 5],
[5, 6, 7, 8],
[6, 7, 8, 9],
[7, 8, 9, 10],
[8, 9, 10, 11],
[9, 10, 11, 12],
[10, 11, 12, 13],
[11, 12, 13, 14],
[12, 13, 14, 15],
[13, 14, 15, 0],
[14, 15, 0, 1],
[15, 0, 1, 2],
];
// t.sendData([1, 2, 3, "a"]);
let count = 0;
setInterval(function() {
let arr = g[count % g.length];
t.sendData(arr, count % 2);
count++;
}, 1000);
|
Ext.widget({
xtype: 'mz-form-entity',
title: 'Email',
items: [
{
fieldLabel: 'Email Subject',
xtype: 'textfield',
name: 'subject'
},
{
fieldLabel: 'Header html 1',
xtype: 'taco-htmleditor',
name: 'html_1'
},
{
fieldLabel: 'Header html 2',
xtype: 'taco-htmleditor',
name: 'html_2'
}
]
}); |
/**
* @fileoverview Provides constants.
*
*/
goog.provide('ajs.constants');
ajs.constants.millisecondsInASecond = 1000;
ajs.constants.daysInAYear = 365;
ajs.constants.whiteSpace = " "; |
const path = require( "path" );
const UglifyJSPlugin = require( "uglifyjs-webpack-plugin" );
const isProduction = false;
const common = {
output: {
path: path.join( __dirname, "public/js" ),
filename: "[name].js",
chunkFilename: "[name].chunk.js"
},
plugins: [
new UglifyJSPlugin( { sourceMap: true, uglifyOptions: { mangle: isProduction } } )
],
devtool: "source-map",
module: {
rules: [
{ test: /\.jsx?$/, loader: "babel-loader" },
],
},
resolve: {
extensions: [ ".js", ".jsx" ],
alias: {
"react": path.resolve( __dirname, "src/js/ui/react-proxy" ), // eslint-disable-line quote-props
"react-dom": path.resolve( __dirname, "src/js/ui/react-dom-proxy" )
}
}
};
module.exports = [
{ lib: [ "./src/js/lib.js", "./src/js/polly.js" ] },
{ ui: "./src/js/ui/index.js" },
{ main: "./src/js/console/main.js" }
].map( entry => Object.assign( { entry }, common ) );
|
/*
Template data:
- item_type
- item_show_type
- item_model
*/
Template.show.helpers({
'show_item': function() {
return Template[this.item_type](this.item_model);
}
});
|
const _ = require('lodash');
/**
* Validation helper which checks is value a number. In case it's not, throws error.
* Otherwise does nothing.
*
* @throws {Error} - throws exception if validation failed
*
* @param {any} value - value received from json
*/
function shouldBeNumber(value) {
checkType(value, 'number');
}
/**
* Validation helper which checks is value a string. In case it's not, throws error.
* Otherwise does nothing.
*
* @throws {Error} - throws exception if validation failed
*
* @param {any} value - value received from json
*/
function shouldBeString(value) {
checkType(value, 'string');
}
/**
* Validation helper which checks is value a boolean. In case it's not, throws error.
* Otherwise does nothing.
*
* @throws {Error} - throws exception if validation failed
*
* @param {any} value - value received from json
*/
function shouldBeBoolean(value) {
checkType(value, 'boolean');
}
function checkType(value, type) {
const valueType = typeof value;
if (valueType !== type) {
throw new Error(`Value ${value} must be a ${type}, got ${valueType}`);
}
}
/**
* Validation helper designed for `viewableBy` meta property. Checks is value equal
* 1 of 3 options: `everybody`, `signed_in_users` or `staff`. If check failed, throws an error.
* Otherwise does nothing
*
* @throws {Error} - throws exception if validation failed
*
* @param {any} value - value received from json
*/
function validateViewableBy(value) {
validateOptionsValue(
value,
'string',
['everybody', 'signed_in_users', 'staff']
);
}
/**
* Validation helper designed for `manageableBy` meta property. Checks is value equals
* `staff` or `mangers`. If check failed, throws an error.
* Otherwise does nothing
*
* @throws {Error} - throws exception if validation failed
*
* @param {any} value - value received from json
*/
function validateManageableBy(value) {
validateOptionsValue(
value,
'string',
['staff', 'managers']
);
}
function validateOptionsValue(value, type, options) {
checkType(value, type);
if (!_.includes(options, value)) {
throw new Error(`Value must be ${options.join(' or ')}`);
}
}
function validateLabels(value) {
if (!Array.isArray(value) && typeof value !== 'string') {
throw new Error('Value must be either Array or string!');
}
}
module.exports = {
shouldBeNumber,
shouldBeString,
shouldBeBoolean,
validateViewableBy,
validateManageableBy,
validateLabels
};
|
/*
* Copyright (c) 2014 Adobe Systems Incorporated. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/*jslint nomen:true, vars:true*/
/*global window, console, define, brackets, $, Mustache, PathUtils*/
define(function (require, exports, module) {
"use strict";
var Compiler = require("Compiler"),
SourceMapManager = require("SourceMapManager");
// Load commonly used modules from Brackets
var _ = brackets.getModule("thirdparty/lodash"),
Async = brackets.getModule("utils/Async"),
DocumentManager = brackets.getModule("document/DocumentManager"),
FileSystem = brackets.getModule("filesystem/FileSystem"),
FileUtils = brackets.getModule("file/FileUtils"),
Inspector = brackets.getModule("LiveDevelopment/Inspector/Inspector"),
LiveDevelopment = brackets.getModule("LiveDevelopment/LiveDevelopment");
var server,
mapSourceURLs = {};
function _setStatus(status, err) {
// HACK expose LiveDevelopment._setStatus()
LiveDevelopment.status = status;
window.$(LiveDevelopment).triggerHandler("statusChange", [status, err]);
}
function _docChangeHandler(data) {
// Show out of sync while we wait for SASS to compile
_setStatus(LiveDevelopment.STATUS_OUT_OF_SYNC);
var sourceMapPromise = SourceMapManager.getSourceMap(data.cssFile);
sourceMapPromise.then(function (sourceMap) {
return Compiler.preview(sourceMap.sassFile, data.docs).then(function (css) {
Inspector.CSS.setStyleSheetText(data.header.styleSheetId, css);
// TODO look for added/removed docs?
// FIXME This will clobber other status (e.g. HTML live preview)
_setStatus(LiveDevelopment.STATUS_ACTIVE);
});
}, function (err) {
// TODO show errors in gutter
console.log(err);
_setStatus(LiveDevelopment.STATUS_SYNC_ERROR);
});
}
function _installSourceDocumentChangeHandlers(cssFile, sourceURL, header) {
var docs = [],
sourceMapPromise = SourceMapManager.getSourceMap(cssFile),
docsPromise;
docsPromise = sourceMapPromise.then(function (sourceMap) {
return Async.doInParallel(sourceMap._localSources, function (file) {
return DocumentManager.getDocumentForPath(file.fullPath).done(function (doc) {
docs.push(doc);
});
});
});
// Install change event handlers for source SCSS/SASS files
docsPromise.always(function () {
var data = {
cssFile: cssFile,
header: header,
docs: docs
};
var changeCallback = function (event, doc, res) {
_docChangeHandler(data);
};
_.each(docs, function (doc) {
doc.addRef();
$(doc).on("change.sass", changeCallback);
});
mapSourceURLs[sourceURL] = data;
});
}
function _styleSheetAdded(event, sourceURL, header) {
var existing = mapSourceURLs[sourceURL];
// detect duplicates
if (existing && existing.styleSheetId === header.styleSheetId) {
return;
}
if (header.sourceMapURL) {
var cssPath = server.urlToPath(sourceURL),
cssFile = cssPath && FileSystem.getFileForPath(cssPath),
sourceMapURL = sourceURL.replace(new RegExp(PathUtils.parseUrl(sourceURL).filename + "$"), header.sourceMapURL),
sourceMapPath = server.urlToPath(sourceMapURL),
sourceMapFile = sourceMapPath && FileSystem.getFileForPath(sourceMapPath);
SourceMapManager.setSourceMapFile(cssFile, sourceMapFile);
_installSourceDocumentChangeHandlers(cssFile, sourceURL, header);
}
}
function _styleSheetRemoved(event, sourceURL) {
var data = mapSourceURLs[sourceURL];
delete mapSourceURLs[sourceURL];
if (!data) {
return;
}
_.each(data.docs, function (doc) {
doc.releaseRef();
$(doc).off(".sass");
});
}
function _statusChangeHandler(event, status, reason) {
var $CSSAgent = $(LiveDevelopment.agents.css);
if (status <= LiveDevelopment.STATUS_INACTIVE) {
$CSSAgent.off(".sass");
_.each(Object.keys(mapSourceURLs), function (sourceURL) {
_styleSheetRemoved(null, sourceURL);
});
Compiler.deleteTempFiles();
server = null;
} else if (!server) {
$CSSAgent.on("styleSheetAdded.sass", _styleSheetAdded);
$CSSAgent.on("styleSheetRemoved.sass", _styleSheetRemoved);
server = LiveDevelopment._getServer();
}
}
$(LiveDevelopment).on("statusChange", _statusChangeHandler);
});
|
/**
* Image loading
* @class ImageLoader
* @param {Object} options
* @param {Object} defaults
* @constructor
*/
function ImageLoader(options, defaults) {
var scope = this;
/**
* Unique ID
* @type {number}
*/
scope.id;
/**
* Src attribute
* @type {String}
*/
scope.src;
/**
* Allow cancel of image loading
* @type {boolean}
*/
scope.fullRepeal = false;
/**
* Is currently paused
* @type {boolean}
*/
scope.isPaused = false;
/**
* Callback in case of successful image loading
* @type {Function}
*/
scope.onSuccess = null;
/**
* Callback in case of error
* @type {Function}
*/
scope.onError = null;
/**
* Callback on all opertions is over
* @type {Function}
*/
scope.onResolve = null;
/**
* Maximum redowloads of image
* @type {number}
*/
scope.maxDownloads = 1;
/**
* Redownload counter
* @type {number}
*/
scope.currentDownloads = 0;
/**
* HTML Image element
* @type {Object}
*/
scope.image;
/**
* Is image loading completed
* @type {boolean}
*/
scope.completed = false;
/**
* Is image loading was started
* @type {boolean}
*/
scope.isLoadingStarted = false;
/**
* Constructor
* @param {Object} options
* @param {Object} defaults
* @public
*/
function _initialize(options, defaults) {
scope.id = _.getInPath(options, 'id', 0);
if (scope.id === 0) {
_cfgDebug && console.warn('ImageLoader->constructor() - ID is empty');
}
scope.src = _.getInPath(options, 'src', '');
if (!scope.src || scope.src.length < 5) {
_cfgDebug && console.warn('ImageLoader->constructor() - SRC is empty');
}
scope.fullRepeal = _.getInPath(options, 'fullRepeal', defaults.fullRepeal);
scope.onSuccess = _.getInPath(options, 'onSuccess', defaults.onSuccess);
scope.onError = _.getInPath(options, 'onError', defaults.onError);
scope.onResolve = _.getInPath(options, 'onResolve', defaults.onResolve);
scope.maxDownloads = _.toNumber(
_.getInPath(options, 'maxDownloads', defaults.maxDownloads),
defaults.maxDownloads,
1
);
scope.isPaused = _.getInPath(options, 'isPaused', defaults.isPaused);
}
_initialize(options, defaults);
/**
* Dispatch image loading
* @return {boolean}
* @public
*/
scope.dispatchLoading = function () {
if (scope.isPaused) {
return false;
}
scope.isLoadingStarted = true;
if (ImageHelper.isCached(scope.src)) {
_cfgDebug && console.info('ImageLoader->dispatchLoading() - Image is already in cache: ' + scope.src);
scope.onLoad();
return true;
}
scope.initImage();
return true;
};
/**
* Initialize image
* @public
*/
scope.initImage = function () {
if (!scope.fullRepeal) {
scope.image = new Image();
scope.image.src = scope.src;
scope.image.onload = scope.onLoad.bind(scope);
scope.image.onerror = scope.onFailed.bind(scope);
} else {
scope.image.src = scope.src;
scope.image = new ImageCancellableLoader();
scope.image.load(scope.src, scope.onLoad.bind(scope), scope.onFailed.bind(scope));
}
};
/**
* Return basic information about image
* @return {Object}
* @public
*/
scope.getImageinfo = function () {
return {
id: scope.id,
src: scope.src,
completed: scope.completed
};
};
/**
* Called when image loaded
* @public
*/
scope.onLoad = function () {
scope.completed = true;
scope.image = null;
_cfgDebug && console.info('ImageLoader->onLoad() - Image is loaded: ' + scope.src);
_cfgDebug && console.dir(scope);
_.call(scope.onSuccess, [scope.getImageinfo()]);
_.call(scope.onComplete, [scope]);
};
/**
* Called when image load failed
* @public
*/
scope.onFailed = function () {
scope.completed = false;
scope.currentDownloads += 1;
if (scope.currentDownloads >= scope.maxDownloads) {
_cfgDebug && console.info('ImageLoader->onFailed() - Image is not loaded' +
(scope.maxDownloads > 1 ? '. Attempts were made: ' + scope.currentDownloads : ''));
_cfgDebug && console.dir(scope);
_.call(scope.onError, [scope.getImageinfo()]);
_.call(scope.onComplete, [scope]);
} else {
_cfgDebug && console.info('ImageLoader->onFailed() - ' +
'Image is not loaded. Attempt ' + scope.currentDownloads + '/' + scope.maxDownloads);
_cfgDebug && console.dir(scope);
scope.initImage();
}
};
/**
* Called when image loading completed
* @public
*/
scope.onComplete = function () {
_cfgDebug && console.warn('ImageLoader->onComplete() - Warning! This is dummy function!');
_cfgDebug && console.dir(scope);
_.call(scope.onResolve, [scope.getImageinfo()]);
};
/**
* Called when image loading quits
* @public
*/
scope.onDrop = function () {
_cfgDebug && console.info('ImageLoader->onDrop() - Image loading completed');
_cfgDebug && console.dir(scope);
if (scope.fullRepeal) {
scope.image.destructor();
}
}
}
|
Animal = function() {}
Animal.prototype.poop = function () {
console.log('💩');
};
module.exports = Animal;
|
import reactRenderer from '../index';
test('it loads', () => {
expect(reactRenderer.name).toBe('react');
});
|
import React from 'react';
import _ from 'lodash';
import util from 'util';
import ReplContext from '../common/ReplContext';
import repl from 'repl';
import {EOL} from 'os';
import shell from 'shell';
import ReplSuggestionActions from '../actions/ReplSuggestionActions';
import ReplActions from '../actions/ReplActions';
import ReplConstants from '../constants/ReplConstants';
import ReplType from '../common/ReplType';
import ReplCommon from '../common/ReplCommon';
import ReplDOMEvents from '../common/ReplDOMEvents';
import ReplDOM from '../common/ReplDOM';
import ReplUndo from '../common/ReplUndo';
import ReplActiveInputStore from '../stores/ReplActiveInputStore';
import ReplOutput from '../common/ReplOutput';
import ReplInput from '../common/ReplInput';
import ReplLanguages from '../languages/ReplLanguages';
export default class ReplActiveInput extends React.Component {
constructor(props) {
super(props);
this.history = {
// read-only
log: this.props.history,
idx: this.props.historyIndex,
staged: this.props.historyStaged
};
_.each([
'onTabCompletion', 'autoComplete', 'onKeyDown', 'onClick',
'onKeyUp', 'onStoreChange', 'prompt', 'setDebouncedComplete',
'addEntry', 'removeSuggestion', 'onBlur', 'addEntryAction',
'onUndoRedo', 'onKeyPress', 'autoFillCharacters', 'insertCharacter',
'shouldTranspile', 'talkToREPL', 'transpileAndExecute', 'ignoreCharacters'
], (field) => {
this[field] = this[field].bind(this);
});
this.activeSuggestion = ReplActiveInputStore.getStore().activeSuggestion;
this.commandReady = false;
this.setDebouncedComplete();
this.undoManager = new ReplUndo();
}
componentDidMount() {
this.unsubscribe = ReplActiveInputStore.listen(this.onStoreChange);
this.element = React.findDOMNode(this);
this.focus();
let cli = ReplLanguages.getREPL();
//set desired repl mode
cli.replMode = repl[`REPL_MODE_${global.Mancy.session.mode.toUpperCase()}`];
//bind write handle
cli.output.write = this.addEntry.bind(this);
//scroll to bottom
ReplDOM.scrollToEnd(this.element);
//Hack: override display prompt
this.displayPrompt = cli.displayPrompt;
cli.displayPrompt = this.prompt;
}
componentWillUnmount() {
this.unsubscribe();
let cli = ReplLanguages.getREPL();
cli.output.write = () => {};
cli.displayPrompt = this.displayPrompt;
}
setDebouncedComplete() {
this.debouncedComplete = _.debounce(
() => this.complete(this.autoComplete),
global.Mancy.preferences.suggestionDelay
);
}
focus() {
// focus
ReplDOM.focusOn(this.element);
ReplDOM.setCursorPositionRelativeTo(this.props.cursor || 0, this.element);
}
onBlur() {
setTimeout(() => this.removeSuggestion(), 200);
}
onClick() {
setTimeout(() => this.removeSuggestion(), 200);
}
onUndoRedo({undo, redo}, type) {
let {html, cursor} = type === ReplUndo.Undo ? undo : redo;
this.removeSuggestion();
this.element.innerHTML = html;
ReplDOM.setCursorPositionRelativeTo(cursor, this.element);
}
onStoreChange() {
let { now, activeSuggestion, breakPrompt,
format, stagedCommands, autoComplete } = ReplActiveInputStore.getStore();
this.activeSuggestion = activeSuggestion;
this.setDebouncedComplete();
if(autoComplete) {
this.complete(this.autoComplete);
return;
}
if(format) {
const text = this.element.innerText;
if(text.length) {
const formattedCode = ReplCommon.format(this.element.innerText);
this.reloadPrompt(formattedCode, formattedCode.length);
}
return;
}
if(breakPrompt) {
let cli = ReplLanguages.getREPL();
cli.input.emit('data', '.break');
cli.input.emit('data', EOL);
this.reloadPrompt('', 0);
return;
}
if(stagedCommands.length) {
let cli = ReplLanguages.getREPL();
this.promptInput = stagedCommands[0];
let {local, output, input} = ReplInput.transform(stagedCommands[0]);
cli.$lastExpression = ReplOutput.none();
cli.context = ReplContext.getContext();
if(local) {
this.addEntryAction(output, true, input, stagedCommands[0]);
ReplActiveInputStore.tailStagedCommands();
return;
}
this.replFeed = output;
cli.input.emit('data', this.replFeed);
cli.input.emit('data', EOL);
return;
}
if(now && activeSuggestion) {
this.onSelectTabCompletion(activeSuggestion.input + activeSuggestion.expect);
return;
}
}
addEntryAction(formattedOutput, status, command, plainCode, transpiledOutput) {
ReplActions.addEntry({
formattedOutput,
status,
command,
plainCode,
transpiledOutput
});
this.removeSuggestion();
this.promptInput = this.replFeed = null;
this.commandReady = false;
}
prompt(preserveCursor) {
this.element.className = 'repl-active-input';
let cli = ReplLanguages.getREPL();
let addEntryAction = (formattedOutput, error, text) => {
this.addEntryAction(formattedOutput, !error, ReplCommon.highlight(text), text);
};
let playStagedCommand = () => {
let {stagedCommands} = ReplActiveInputStore.getStore();
if(stagedCommands.length) {
ReplActiveInputStore.tailStagedCommands();
}
};
if(cli.bufferedCommand.indexOf(this.replFeed) != -1 && global.Mancy.REPLError) {
let {formattedOutput} = cli.$lastExpression.highlight(global.Mancy.REPLError.stack);
addEntryAction(formattedOutput, true, this.promptInput);
playStagedCommand();
}
else if(cli.bufferedCommand.length === 0 && this.commandReady) {
let {formattedOutput, error} = cli.$lastExpression.highlight(this.commandOutput);
if(!this.replFeed) {
ReplActions.overrideLastOutput(formattedOutput, !error);
return;
}
addEntryAction(formattedOutput, error, this.promptInput);
playStagedCommand();
} else {
// $console.error('unhandled', this, cli.bufferedCommand);
}
}
addEntry(buf) {
let output = buf.toString() || '';
if(output.length === 0 || output.indexOf('at REPLServer.complete') !== -1) { return; }
this.commandOutput = null;
if(output.trim() !== '<<response>>') {
this.commandOutput = output;
}
if(!this.promptInput && this.commandOutput) {
console.error(new Error(this.commandOutput));
this.commandOutput = null;
} else {
this.commandReady = true;
}
}
autoComplete(__, completion, kinds) {
let completeEntry = (suggestions, text) => {
return suggestions.length != 1 || !text.endsWith(suggestions[0].text);
};
let [list, completeOn] = completion;
let suggestions = _.chain(_.zip(ReplCommon.sortTabCompletion(ReplLanguages.getREPL().context, list), kinds))
.filter((zipped) => {
return zipped[0] && zipped[0].length !== 0;
})
.map((zipped) => {
return {
type: ReplType.typeOf(zipped[1] ? zipped[1] : zipped[0]),
text: zipped[0].replace(/^.*\./, ''),
completeOn: completeOn.replace(/^.*\./, '')
};
})
.value();
if(!document.activeElement.isSameNode(this.element)) { return; }
const text = this.element.innerText;
let cursor = ReplDOM.getCursorPositionRelativeTo(this.element);
let code = text.substring(0, cursor);
if(suggestions.length && completeEntry(suggestions, code)) {
if(code === '.') {
suggestions.push({
type: ReplType.typeOf('source'),
text: 'source',
completeOn: ""
});
}
ReplSuggestionActions.addSuggestion({suggestions: suggestions, input: code});
} else {
this.removeSuggestion();
}
}
removeSuggestion() {
setTimeout(() => ReplSuggestionActions.removeSuggestion(), 200);
}
reloadPrompt(cmd, cursor, idx = -1, staged = '') {
ReplActions.reloadPrompt({
command: cmd,
cursor: cursor,
historyIndex: idx,
historyStaged: (idx === -1 ? cmd : staged)
});
}
onTabCompletion(__, completion) {
let [list, input] = completion;
if(list.length === 0) {
const text = this.element.innerText;
let cursor = ReplDOM.getCursorPositionRelativeTo(this.element);
let [lcode, rcode] = ReplCommon.divide(text, cursor);
let command = lcode + ReplCommon.times(ReplConstants.TAB_WIDTH, ' ') + rcode;
this.reloadPrompt(command, cursor + ReplConstants.TAB_WIDTH);
this.removeSuggestion();
} else if(list.length === 1) {
this.onSelectTabCompletion(list[0]);
} else {
this.autoComplete(__, completion);
}
}
onSelectTabCompletion(suggestion) {
let breakReplaceWord = (word) => {
let length = word.length;
let rword = ReplCommon.reverseString(word);
//extract prefix
let escapedKeys = ReplCommon.escapseRegExp(suggestion.replace(/[\w\s]+/g, ''));
let pattern = new RegExp(`^[\\w${escapedKeys}]+`);
let prefix = ReplCommon.reverseString(rword.replace(pattern, ''));
return { prefix: prefix, suffix: word.substring(prefix.length) };
}
const text = this.element.innerText.replace(/\s*$/, '');
let cursorPosition = ReplDOM.getCursorPositionRelativeTo(this.element);
let [left, right] = ReplCommon.divide(text, cursorPosition);
let {prefix, suffix} = breakReplaceWord(left);
left = prefix + suggestion.substring(suggestion.indexOf(suffix));
this.reloadPrompt(left + right, left.length);
this.removeSuggestion();
}
insertCharacter(pos, ch) {
let text = this.element.innerText;
this.element.innerText = text.slice(0, pos) + ch + text.slice(pos);
}
autoFillCharacters(e, pos) {
if(!pos || !ReplDOMEvents.hasAutoFillCharacters(e)) { return; }
let text = this.element.innerText;
let ch = text[pos - 1];
let open = ['[', '(', '{'];
let close = [']', ')', '}'];
let idx = open.indexOf(ch);
if(idx !== -1) { this.insertCharacter(pos, close[idx]); }
else if(pos === 1 || text[pos - 2] !== ch) { this.insertCharacter(pos, ch); }
}
ignoreCharacters(e) {
let pos = ReplDOM.getCursorPositionRelativeTo(this.element);
let text = this.element.innerText;
let ignoreList = [ ']', ')', '}', "'", '"', '`' ];
if(!pos || ignoreList.indexOf(text[pos]) === -1 || text.length === pos) { return false; }
let open = text[pos - 1];
let close = text[pos];
if(ReplDOMEvents.autoFillPairCharacters[open] !== close) { return false; }
if(ReplDOMEvents.autoFillKeyIdentifiers[close] === e.nativeEvent.keyIdentifier) {
e.preventDefault();
e.stopPropagation();
ReplDOM.setCursorPositionRelativeTo(pos + 1, this.element);
return true;
}
if(ReplDOMEvents.isBackSpace(e)) {
this.element.innerText = text.substring(0, pos - 1) + text.substring(pos + 1);
ReplDOM.setCursorPositionRelativeTo(pos - 1, this.element);
return true;
}
return false;
}
shouldTranspile() {
return global.Mancy.preferences.transpile &&
(global.Mancy.session.lang !== 'js' ||
(global.Mancy.session.lang === 'js' && global.Mancy.preferences.babel))
}
transpileAndExecute(err, result) {
let text = this.promptInput;
if(err) {
this.addEntryAction(ReplOutput.some(err).highlight(),
!err, ReplCommon.highlight(text), text);
} else {
ReplCommon.runInContext(result, (err, output) => {
let formattedOutput = ReplOutput.some(err || output).highlight();
let transpiledOutput = err ? null : ReplOutput.transpile(result);
this.addEntryAction(formattedOutput, !err, ReplCommon.highlight(text), text, transpiledOutput);
});
}
}
talkToREPL() {
let cli = ReplLanguages.getREPL();
// managed by us (no react)
this.element.className += ' repl-active-input-running';
setTimeout(() => {
const text = this.element.innerText.replace(/\s{1,2}$/, '');
const transpile = this.shouldTranspile();
if(cli.bufferedCommand.length) {
cli.input.emit('data', '.break');
cli.input.emit('data', EOL);
}
cli.$lastExpression = ReplOutput.none();
cli.context = ReplContext.getContext();
this.promptInput = text;
let {local, output, input} = ReplInput.transform(text, transpile);
if(local) {
return this.addEntryAction(output, true, input, text);
}
if(transpile && !text.match(/^\s*\.load/)) {
if(global.Mancy.session.lang !== 'js') {
cli.transpile(output, cli.context, this.transpileAndExecute);
} else {
this.transpileAndExecute(_.isError(output), output);
}
return;
}
this.replFeed = output;
cli.input.emit('data', this.replFeed);
cli.input.emit('data', EOL);
}, 17);
}
onKeyUp(e) {
if((e.keyCode == 16) || e.ctrlKey || e.metaKey || e.altKey || (e.keyCode == 93) || (e.keyCode == 91)) { return; }
if( ReplDOMEvents.isKeyup(e)
|| ReplDOMEvents.isKeydown(e)
) {
if(this.activeSuggestion) {
e.preventDefault();
return;
};
}
if(ReplDOMEvents.isTab(e)
|| ReplDOMEvents.isEscape(e)
|| ReplDOMEvents.isNavigation(e)
) {
if(!ReplDOMEvents.isTab(e)) { this.removeSuggestion(); }
e.preventDefault();
return;
}
if(!ReplDOMEvents.isEnter(e) && this.element.innerText === this.lastText) { return; }
this.lastText = this.element.innerText;
if(ReplDOMEvents.isEnter(e)) {
this.removeSuggestion();
if (!e.shiftKey && global.Mancy.preferences.toggleShiftEnter) return;
let activeSuggestion = ReplActiveInputStore.getStore().activeSuggestion;
if(activeSuggestion && global.Mancy.preferences.autoCompleteOnEnter) {
e.preventDefault();
return;
}
// allow user to code some more
ReplDOM.scrollToEnd();
if(e.shiftKey && !global.Mancy.preferences.toggleShiftEnter) { return; }
this.talkToREPL();
} else {
if((!global.Mancy.preferences.toggleAutomaticAutoComplete &&
ReplCommon.shouldTriggerAutoComplete(e) &&
this.element.innerText.trim()) ||
ReplActiveInputStore.getStore().activeSuggestion) {
this.debouncedComplete();
} else {
this.removeSuggestion();
}
let pos = ReplDOM.getCursorPositionRelativeTo(this.element);
this.autoFillCharacters(e, pos);
if(!this.keyPressFired) { return; }
this.element.innerHTML = ReplCommon.highlight(this.element.innerText);
this.undoManager.add({
undo: { html: this.lastEdit || '', cursor: this.lastCursorPosition || 0},
redo: { html: this.element.innerHTML, cursor: pos},
}, this.onUndoRedo);
ReplDOM.setCursorPositionRelativeTo(pos, this.element);
this.lastCursorPosition = pos;
this.lastEdit = this.element.innerHTML;
}
}
onKeyPress(e) {
this.keyPressFired = true;
}
onKeyDown(e) {
if(this.keyPressFired && ((e.metaKey && !e.ctrlKey) || (!e.metaKey && e.ctrlKey)) && e.keyCode == 90) {
// undo
e.shiftKey ? this.undoManager.redo() : this.undoManager.undo();
e.preventDefault();
e.stopPropagation();
return;
}
this.keyPressFired = false;
if((e.keyCode == 16) || e.ctrlKey || e.metaKey || e.altKey || (e.keyCode == 93) || (e.keyCode == 91)) { return; }
let activeSuggestion = ReplActiveInputStore.getStore().activeSuggestion;
if(ReplDOMEvents.isEnter(e) && activeSuggestion && global.Mancy.preferences.autoCompleteOnEnter) {
e.stopPropagation();
e.preventDefault();
this.onSelectTabCompletion(activeSuggestion.input + activeSuggestion.expect);
return;
}
if( ReplDOMEvents.isKeyup(e)
|| (ReplDOMEvents.isKeydown(e))
) {
if(this.activeSuggestion) {
e.preventDefault();
return;
};
let up = ReplDOMEvents.isKeyup(e);
let elementText = this.element.innerText;
let pos = ReplDOM.getCursorPositionRelativeTo(this.element);
let [left, right] = ReplCommon.divide(elementText, pos);
let str = up ? left : right;
if(str.indexOf(EOL) === -1) {
this.traverseHistory(up);
e.preventDefault();
}
return;
}
if(ReplDOMEvents.isEnter(e) && (
(!e.shiftKey && !global.Mancy.preferences.toggleShiftEnter) ||
(e.shiftKey && global.Mancy.preferences.toggleShiftEnter)
)) {
const text = this.element.innerText;
if(text.trim().length === 0) {
e.preventDefault();
return;
}
if(text.indexOf(EOL) === -1) {
// move cursor to end before talk to REPL
ReplDOM.setCursorPositionRelativeTo(text.length, this.element);
}
return;
}
if(this.ignoreCharacters(e) || !ReplDOMEvents.isTab(e)) { return; }
e.preventDefault();
if(activeSuggestion) {
this.onSelectTabCompletion(activeSuggestion.input + activeSuggestion.expect);
} else if(this.element.innerText.length){
this.complete(this.onTabCompletion);
}
}
traverseHistory(up) {
let len = this.history.log.length;
if(!len) { return; }
let idx = this.history.idx;
if(idx === -1) {
this.history.staged = this.element.innerText;
idx = len;
}
idx = idx + (up ? -1 : 1);
let navigateHistory = (up, cmd, pos) => {
let code = cmd.trim();
let cursorPosition = !up ? cmd.indexOf(EOL) : code.length;
if(cursorPosition < 0) { cursorPosition = 0; }
this.reloadPrompt(code, cursorPosition, pos,(pos === -1 ? '' : this.history.staged));
};
(len <= idx || idx < 0)
? navigateHistory(up, this.history.staged, -1)
: navigateHistory(up, this.history.log[idx].plainCode, idx);
}
complete(callback) {
if(!document.activeElement.isSameNode(this.element)) { return; }
let text = this.element.innerText || '';
let cursor = ReplDOM.getCursorPositionRelativeTo(this.element);
let code = text.substring(0, cursor);
let cli = ReplLanguages.getREPL();
ReplSuggestionActions.removeSuggestion();
if(ReplCommon.shouldTriggerAutoComplete(code.slice(code.length - 1))) {
cli.complete(code, callback);
}
}
render() {
return (
<div className='repl-active-input' tabIndex="-1" contentEditable={true}
onKeyUp={this.onKeyUp}
onClick={this.onClick}
onKeyDown={this.onKeyDown}
onKeyPress={this.onKeyPress}
onBlur={this.onBlur} dangerouslySetInnerHTML={{__html:ReplCommon.highlight(this.props.command)}}>
</div>
);
}
}
|
"use strict";
class Lexer {
constructor() {
this.tokenFactories = [];
}
registerFactory(tokenFactory) {
this.tokenFactories.push(tokenFactory);
}
createToken(index, value) {
var tf = this.tokenFactories[index];
if (tf) {
return tf.create(value);
}
throw "Token factory not found";
}
getPatterns() {
return this.tokenFactories.map(function (n) {
return n.compilePattern();
});
}
tokenize(expression) {
let tokens = [];
let pattern = new RegExp('(' + this.getPatterns().join(')|(') + ')', 'g');
let matches;
while (matches = pattern.exec(expression)) {
for (var i = 0; i < this.tokenFactories.length; i++) {
if (matches[i + 1]) {
tokens.push(this.createToken(i, matches[i + 1]));
break;
}
}
}
return tokens;
}
}
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Lexer;
//# sourceMappingURL=Lexer.js.map |
angular
.module( 'site.home', [
'ui.router'
])
.config(function config( $stateProvider ) {
$stateProvider.state( 'home', {
url: '/home',
views: {
"header": {
controller: 'TopBarCtrl',
templateUrl: 'topbar/topbar.tpl.html'
},
"content": {
controller: 'HomeCtrl',
templateUrl: 'home/home.tpl.html'
},
"footer": {
controller: 'FooterCtrl',
templateUrl: 'footer/footer.tpl.html'
}
},
data:{ pageTitle: 'Home' }
});
})
.controller( 'HomeCtrl', function HomeController( $scope ) {
});
|
(function (Mnemonic) {
describe('Mnemonic', function () {
it('creates mnemonics of 32*n bits', function () {
var m;
m = new Mnemonic(32);
expect(m.seed.length).toEqual(1);
m = new Mnemonic(64);
expect(m.seed.length).toEqual(2);
m = new Mnemonic(); // Default 96bits
expect(m.seed.length).toEqual(3);
m = new Mnemonic(256);
expect(m.seed.length).toEqual(8);
var illegal = function () {
return new Mnemonic(42);
};
expect(illegal).toThrow();
});
it('produces the right words', function () {
var m;
m = new Mnemonic(32);
m.seed[0] = 0;
expect(m.toWords()).toEqual(['like', 'like', 'like']); // First word 3 times
m.seed[0] = Mnemonic.wc - 1;
expect(m.toWords()).toEqual(['weary', 'weary', 'weary']); // Last word 3 times
m.seed[0] = Math.pow(2,32) - 1;
expect(m.toWords()).toEqual(['fail', 'husband', 'howl']);
});
it('produces the right hex', function () {
var m;
m = new Mnemonic(32);
m.seed[0] = 0;
expect(m.toHex()).toEqual('00000000'); // First word 3 times
m.seed[0] = Mnemonic.wc - 1;
expect(m.toHex()).toEqual('00000659'); // Last word 3 times
m.seed[0] = Math.pow(2,32) - 1;
expect(m.toHex()).toEqual('ffffffff');
});
it('can be constructed from a Uint32 array', function () {
var arr, m2, m1 = new Mnemonic();
arr = m1.seed;
m2 = new Mnemonic(arr);
expect(m1.seed).toEqual(m2.seed);
});
it('can be reconstructed from words', function () {
var m2, m1 = new Mnemonic();
m2 = Mnemonic.fromWords(m1.toWords());
expect(m1.seed).toEqual(m2.seed);
});
it('can be reconstructed from hex', function () {
var m2, m1 = new Mnemonic();
m2 = Mnemonic.fromHex(m1.toHex());
expect(m1.seed).toEqual(m2.seed);
});
});
})(this.Mnemonic);
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const error_code_1 = require("../error_code");
const transaction_1 = require("./transaction");
class BlockExecutor {
constructor(options) {
this.m_storage = options.storage;
this.m_handler = options.handler;
this.m_block = options.block;
this.m_externContext = options.externContext;
this.m_logger = options.logger;
Object.defineProperty(this.m_externContext, 'logger', {
writable: false,
value: this.m_logger
});
this.m_globalOptions = options.globalOptions;
}
get externContext() {
return this.m_externContext;
}
_newTransactionExecutor(l, tx) {
return new transaction_1.TransactionExecutor(l, tx, this.m_logger);
}
_newEventExecutor(l) {
return new transaction_1.EventExecutor(l, this.m_logger);
}
async execute() {
return await this._execute(this.m_block);
}
async verify() {
let oldBlock = this.m_block;
this.m_block = this.m_block.clone();
let err = await this.execute();
if (err) {
return { err };
}
return { err: error_code_1.ErrorCode.RESULT_OK,
valid: this.m_block.hash === oldBlock.hash };
}
async _execute(block) {
this.m_logger.info(`begin execute block ${block.number}`);
this.m_storage.createLogger();
let err = await this._executePreBlockEvent();
if (err) {
this.m_logger.error(`blockexecutor execute begin_event failed,errcode=${err},blockhash=${block.hash}`);
return err;
}
let ret = await this._executeTx();
if (ret.err) {
this.m_logger.error(`blockexecutor execute method failed,errcode=${ret.err},blockhash=${block.hash}`);
return ret.err;
}
err = await this._executePostBlockEvent();
if (err) {
this.m_logger.error(`blockexecutor execute end_event failed,errcode=${err},blockhash=${block.hash}`);
return err;
}
let receipts = ret.value;
// 票据
block.content.setReceipts(receipts);
// 更新块信息
await this.updateBlock(block);
return error_code_1.ErrorCode.RESULT_OK;
}
async _executePreBlockEvent() {
if (this.m_block.number === 0) {
// call initialize
if (this.m_handler.genesisListener) {
let exec = this._newEventExecutor(this.m_handler.genesisListener);
let ret = await exec.execute(this.m_block.header, this.m_storage, this.m_externContext);
if (ret.err || ret.returnCode) {
this.m_logger.error(`handler's genesisListener execute failed`);
return error_code_1.ErrorCode.RESULT_EXCEPTION;
}
}
}
let listeners = await this.m_handler.getPreBlockListeners(this.m_block.number);
for (let l of listeners) {
let exec = this._newEventExecutor(l);
let ret = await exec.execute(this.m_block.header, this.m_storage, this.m_externContext);
if (ret.err) {
return ret.err;
}
}
return error_code_1.ErrorCode.RESULT_OK;
}
async _executePostBlockEvent() {
let listeners = await this.m_handler.getPostBlockListeners(this.m_block.number);
for (let l of listeners) {
let exec = this._newEventExecutor(l);
let ret = await exec.execute(this.m_block.header, this.m_storage, this.m_externContext);
if (ret.err) {
return ret.err;
}
}
return error_code_1.ErrorCode.RESULT_OK;
}
async _executeTx() {
let receipts = [];
// 执行tx
for (let tx of this.m_block.content.transactions) {
let listener = this.m_handler.getListener(tx.method);
if (!listener) {
this.m_logger.error(`not find listener,method name=${tx.method}`);
return { err: error_code_1.ErrorCode.RESULT_NOT_SUPPORT };
}
let exec = this._newTransactionExecutor(listener, tx);
let ret = await exec.execute(this.m_block.header, this.m_storage, this.m_externContext);
if (ret.err) {
return { err: ret.err };
}
receipts.push(ret.receipt);
}
return { err: error_code_1.ErrorCode.RESULT_OK, value: receipts };
}
async updateBlock(block) {
// 写回数据库签名
block.header.storageHash = (await this.m_storage.messageDigest()).value;
block.header.updateContent(block.content);
block.header.updateHash();
}
}
exports.BlockExecutor = BlockExecutor;
|
var gulp = require('gulp'),
requireDir = require('require-dir'),
tasks = requireDir('./gulp-data', {recurse: true}),
runSequence = require('run-sequence'),
livereload = require('gulp-livereload');
//Default
gulp.task('default', ["build"]);
//Clean
gulp.task('clean', ["clean:all"]);
//Copy
gulp.task('copy', function(cb){
runSequence(
"clean",
["copy:fonts", "copy:img", "copy:server"],
cb);
});
//Build
gulp.task('build', function(cb){
runSequence(
["clean", "copy"],
["build:html", "build:css", "build:js"],
cb);
});
//Watch
gulp.task('watch', function () {
livereload.listen();
gulp.watch(['src/**/*.html'], ['build:html']);
gulp.watch(['src/**/*.{css,scss}'], ['build:css']);
gulp.watch(['src/**/*.{js,coffee}'], ['build:js']);
gulp.watch(['src/**/*.{jpg,png}'], ['copy:img']);
gulp.watch(['src/**/*.{php}'], ['copy:server']);
});
|
import React from 'react';
import ReactTestUtils from 'react/lib/ReactTestUtils';
import ReactDOM from 'react-dom';
import Button from './../../src/components/Button';
import { BUTTON_WARNING_LABEL_MISSING } from './../../src/components/Button';
describe('<Button>', () => {
it('Should be element type button', () => {
let instance = ReactTestUtils.renderIntoDocument(
<Button />
);
let el = ReactDOM.findDOMNode(instance);
expect(el.nodeName).equal('BUTTON');
});
it('Should default prop className be correct', () => {
let instance = ReactTestUtils.renderIntoDocument(
<Button />
);
expect(instance.props.className).equal(Button.DEFAULT);
});
it('Should default prop label be correct', () => {
let instance = ReactTestUtils.renderIntoDocument(
<Button />
);
expect(instance.props.label).equal('');
});
it('Should be "trash" button', () => {
let instance = ReactTestUtils.renderIntoDocument(
<Button icon={Button.TRASH} />
);
expect(instance.props.icon).equal(Button.TRASH);
let el = ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'span');
expect(el.getAttribute('class')).contain('glyphicon');
expect(el.getAttribute('class')).contain('glyphicon-trash');
});
it('Should be "edit" button', () => {
let instance = ReactTestUtils.renderIntoDocument(
<Button icon={Button.EDIT} />
);
expect(instance.props.icon).equal(Button.EDIT);
let el = ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'span');
expect(el.getAttribute('class')).contain('glyphicon');
expect(el.getAttribute('class')).contain('glyphicon-pencil');
});
it('Should be labeled button', () => {
const label = 'Add new item';
let instance = ReactTestUtils.renderIntoDocument(
<Button label={label} />
);
let el = ReactTestUtils.findRenderedDOMComponentWithTag(instance, 'span');
expect(el.textContent).equal(label);
});
it('Should be labeled + icon button', () => {
const label = 'Add new item';
let instance = ReactTestUtils.renderIntoDocument(
<Button label={label} icon={Button.EDIT} />
);
const spans = ReactTestUtils.scryRenderedDOMComponentsWithTag(instance, 'span');
expect(spans[0].textContent).equal(label);
expect(spans[1].getAttribute('class')).contain('glyphicon');
expect(spans[1].getAttribute('class')).contain('glyphicon-pencil');
});
it('Should be capture onClick event on button', (done) => {
let onClick = () => {
done();
};
let instance = ReactTestUtils.renderIntoDocument(
<Button icon={Button.TRASH} onClick={onClick}/>
);
ReactTestUtils.Simulate.click(ReactDOM.findDOMNode(instance));
});
});
|
(function (angular) {
"use strict";
angular
.module("app.category")
.controller("CategoryEditController", CategoryEditController);
CategoryEditController.$inject = ["categoryService", "$state", "$stateParams", "$window"];
function CategoryEditController(categoryService, $state, $stateParams, $window) {
var viewModel = this;
viewModel.categoryId = $stateParams.categoryId;
viewModel.editedCategory = {};
viewModel.editedCategory.name = "";
viewModel.editCategory = editCategory;
categoryService
.getCategoryById(viewModel.categoryId)
.then(function (response) {
if (response.status == 200) {
var category = response.data;
viewModel.editedCategory.name = category.name;
}
});
function editCategory(isValid) {
if (isValid) {
categoryService
.editCategory(viewModel.categoryId, viewModel.editedCategory.name)
.then(function (response) {
if (response.status == 200 || response.status == 204) {
$window.alert("Category is edited.");
$state.go("category-detail", {categoryId: viewModel.categoryId});
}
}, function (response) {
if (response.status == 404) {
$window.alert("Category is not edited because it does not exists.");
$state.go("category-list");
}
else {
$window.alert("Category is not edited.");
}
});
}
}
}
} (angular));
|
const assert = require('assert');
const request = require('supertest');
const when = require('after');
const helper = require('./helper');
describe('subsequent access(with cookie)', () => {
it('should load session from cookie sid', (done) => {
const app = helper.createApp();
let count = 0;
app.use((req, resp, next) => {
req.session.n = req.session.n || ++count;
resp.end(`session ${req.session.n}`);
});
const req = request.agent(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'session 1', (err) => {
if (err) return done(err);
req.get('/').expect(helper.shouldNotSetCookies()).expect(200, 'session 1', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
done();
});
});
});
it('should save the empty session and not create new session', (done) => {
const app = helper.createApp();
app.use((req, resp, next) => {
resp.end('hello');
});
const req = request.agent(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'hello', (err) => {
if (err) return done(err);
req.get('/').expect(helper.shouldNotSetCookies()).expect(200, 'hello', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
done();
});
});
});
it('should not remove cookie when destroy', (done) => {
const app = helper.createApp();
let count = 0;
app.use((req, resp, next) => {
if (req.url === '/') {
req.session.n = req.session.n || ++count;
resp.end(`session ${req.session.n}`);
} else if (req.url === '/destroy') {
req.session.destroy();
}
});
const req = request.agent(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'session 1', (err, resp) => {
if (err) return done(err);
const oldCookieId = helper.getCookie(resp, 'use.sid');
req.get('/destroy').expect(404, (err, res) => {
if (err) return done(err);
const newCookieId = helper.getCookie(res, 'use.sid');
assert.notEqual(newCookieId, oldCookieId);
// helper.cookies(res);
// assert.equal(res.cookies.length, 1);
// assert.equal(app.store.length, 0);
// assert.equal(res.cookies[0].Expires, 'Thu, 01 Jan 1970 00:00:00 GMT');
req.get('/').expect(200, 'session 2', done);
});
});
});
it('should not set cookie if req.session id not changed', (done) => {
let count = 0;
const app = helper.createApp();
app.use((req, resp, next) => {
if (req.url === '/') {
req.session.a = ++count;
resp.end(`count ${req.session.a}`);
} else if (req.url === '/nochange') {
req.session.b = 1;
req.session.b = undefined;
resp.end(`count ${req.session.a}`);
}
});
const req = request.agent(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'count 1', (err) => {
if (err) return done(err);
req.get('/nochange').expect(helper.shouldNotSetCookies()).expect(200, 'count 1', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
req.get('/b').expect(helper.shouldNotSetCookies()).expect(404, done);
});
});
});
it('should not set cookie if req.session modified', (done) => {
let count = 0;
const app = helper.createApp();
app.use((req, resp, next) => {
req.session.a = ++count;
resp.end(`count ${req.session.a}`);
});
const req = request.agent(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'count 1', (err) => {
if (err) return done(err);
req.get('/').expect(helper.shouldNotSetCookies()).expect(200, 'count 2', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
req.get('/').expect(helper.shouldNotSetCookies()).expect(200, 'count 3', done);
});
});
});
it('should save the new data when remove a req.session property', (done) => {
const app = helper.createApp();
app.use((req, resp, next) => {
if (req.url === '/1') {
req.session.n = 1;
} else {
delete req.session.n;
}
resp.end(`${req.session.n}`);
});
const req = request.agent(app.server);
req.get('/1').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, '1', (err) => {
if (err) return done(err);
req.get('/2').expect(helper.shouldNotSetCookies()).expect(200, 'undefined', (err) => {
if (err) return done(err);
const sess = helper.firstSession(app.store);
assert.equal(sess.data.n, undefined);
done();
});
});
});
it('should generate new session when cookie id not properly signed', (done) => {
let count = 0;
const app = helper.createApp();
app.use((req, resp, next) => {
req.session.n = req.session.n || ++count;
resp.end(`session ${req.session.n}`);
});
const req = request(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'session 1', (err, resp) => {
if (err) return done(err);
req.get('/').set('Cookie', `use.sid=${resp.cookieId}`)
.expect(helper.shouldNotSetCookies()).expect(200, 'session 1', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
req.get('/').set('Cookie', `${resp.cookieId}1`)
.expect(helper.shouldSetCookie('use.sid')).expect(200, 'session 2', done);
});
});
});
it('should generate new session when session is expired', (done) => {
let count = 0;
const app = helper.createApp({ ttl: '50ms' });
app.use((req, resp, next) => {
req.session.n = req.session.n || ++count;
resp.end(`session ${req.session.n}`);
});
const req = request.agent(app.server);
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'session 1', (err) => {
if (err) return done(err);
req.get('/').expect(helper.shouldNotSetCookies()).expect(200, 'session 1', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
setTimeout(() => {
req.get('/').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, 'session 2', done);
}, 50);
});
});
});
it('should has no req.session when cookie path not match', (done) => {
let count = 0;
const app = helper.createApp({ cookie: { path: '/session' } });
app.on('error', (err) => {
assert.equal(err.message, "Cannot read property 'n' of undefined");
});
app.use((req, resp, next) => {
req.session.n = req.session.n || ++count;
resp.end(`session ${req.session.n}`);
});
const req = request.agent(app.server);
req.get('/session').expect(helper.shouldHasSession(app.store, 'use.sid', '/session')).expect(200, 'session 1', (err) => {
if (err) return done(err);
const cb = when(3, done);
req.get('/session/1').expect(helper.shouldNotSetCookies()).expect(200, 'session 1', cb);
req.get('/session1').expect(helper.shouldNotSetCookies()).expect(200, 'session 1', cb);
req.get('/nosession').expect(helper.shouldNotSetCookies()).expect(500, cb);
});
});
it('should work when destroy session after writeHead()');
describe('touch', () => {
it('should always touch when through session middleware ', (done) => {
const app = helper.createApp();
app.use((req, resp, next) => {
if (req.url === '/1') {
req.session.n = 1;
resp.end(`${req.session.n}`);
} else resp.end('2');
});
const req = request.agent(app.server);
req.get('/1').expect(helper.shouldHasSession(app.store, 'use.sid')).expect(200, '1', (err) => {
if (err) return done(err);
const sess = helper.firstSession(app.store);
req.get('/2').expect(helper.shouldNotSetCookies()).expect(200, '2', (err) => {
if (err) return done(err);
assert.equal(app.store.length, 1);
const newSess = helper.firstSession(app.store);
assert.equal(newSess.id, sess.id);
assert.notEqual(newSess.start, sess.start);
done();
});
});
});
});
});
|
'use strict';
angular.module("ngLocale", [], ["$provide", function($provide) {
var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
$provide.value("$locale", {
"DATETIME_FORMATS": {
"AMPMS": [
"vm.",
"nm."
],
"DAY": [
"Sondag",
"Maandag",
"Dinsdag",
"Woensdag",
"Donderdag",
"Vrydag",
"Saterdag"
],
"ERANAMES": [
"voor Christus",
"na Christus"
],
"ERAS": [
"v.C.",
"n.C."
],
"FIRSTDAYOFWEEK": 6,
"MONTH": [
"Januarie",
"Februarie",
"Maart",
"April",
"Mei",
"Junie",
"Julie",
"Augustus",
"September",
"Oktober",
"November",
"Desember"
],
"SHORTDAY": [
"So",
"Ma",
"Di",
"Wo",
"Do",
"Vr",
"Sa"
],
"SHORTMONTH": [
"Jan.",
"Feb.",
"Mrt.",
"Apr",
"Mei",
"Jun",
"Jul",
"Aug",
"Sep",
"Okt",
"Nov",
"Des"
],
"WEEKENDRANGE": [
5,
6
],
"fullDate": "EEEE, dd MMMM y",
"longDate": "dd MMMM y",
"medium": "dd MMM y h:mm:ss a",
"mediumDate": "dd MMM y",
"mediumTime": "h:mm:ss a",
"short": "y-MM-dd h:mm a",
"shortDate": "y-MM-dd",
"shortTime": "h:mm a"
},
"NUMBER_FORMATS": {
"CURRENCY_SYM": "R",
"DECIMAL_SEP": ",",
"GROUP_SEP": "\u00a0",
"PATTERNS": [
{
"gSize": 3,
"lgSize": 3,
"maxFrac": 3,
"minFrac": 0,
"minInt": 1,
"negPre": "-",
"negSuf": "",
"posPre": "",
"posSuf": ""
},
{
"gSize": 3,
"lgSize": 3,
"maxFrac": 2,
"minFrac": 2,
"minInt": 1,
"negPre": "\u00a4-",
"negSuf": "",
"posPre": "\u00a4",
"posSuf": ""
}
]
},
"id": "af",
"pluralCat": function(n, opt_precision) { if (n == 1) { return PLURAL_CATEGORY.ONE; } return PLURAL_CATEGORY.OTHER;}
});
}]);
|
import { registerComponent } from 'nornj';
import Skeleton from 'antd/lib/skeleton';
registerComponent({
'ant-Skeleton': Skeleton
});
export default Skeleton; |
QUnit.module("DataWatcher");
//Node support
if (typeof module === "object") {
var DataWatcher = require("../DataWatcher");
}
QUnit.test("Simple object", function() {
expect(16);
var struct = {
foo: 1,
bar: 2
},
w = new DataWatcher(struct),
data = w.getData();
w.watch("*", function (e) {
if (e.path[0] === "foo") {
deepEqual(e.path, ["foo"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "bar") {
deepEqual(e.path, ["bar"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else if (e.path[0] === "baz") {
deepEqual(e.path, ["baz"]);
strictEqual(e.oldValue, undefined);
strictEqual(e.newValue, 4);
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
w.watch("foo", function (e) {
deepEqual(e.path, ["foo"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
data.foo = 3;
delete data.bar;
data.baz = 4;
});
QUnit.test("Simple array", function() {
expect(16);
var struct = [1, 2],
w = new DataWatcher(struct),
data = w.getData(),
testPush = false;
w.watch("*", function (e) {
if (e.path[0] === "0") {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (!testPush) {
deepEqual(e.path, ["1"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else {
deepEqual(e.path, ["1"]);
strictEqual(e.oldValue, undefined);
strictEqual(e.newValue, 4);
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
w.watch("0", function (e) {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
data[0] = 3;
data.pop();
testPush = true;
data.push(4);
});
QUnit.test("Types", function() {
expect(3);
var toString = Object.prototype.toString,
dataArray = new DataWatcher([1]).getData(),
dataObject = new DataWatcher({a: 1}).getData();
strictEqual(toString.call(dataArray), "[object Array]");
ok(Array.isArray(dataArray));
strictEqual(toString.call(dataObject), "[object Object]");
});
QUnit.test("Shorthand operators", function() {
expect(8);
var struct = {
foo: "test",
bar: 0
},
w = new DataWatcher(struct),
data = w.getData();
w.watch("*", function (e) {
if (e.path[0] === "foo") {
deepEqual(e.path, ["foo"]);
strictEqual(e.oldValue, "test");
strictEqual(e.newValue, "testtest");
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["bar"]);
strictEqual(e.oldValue, 0);
strictEqual(e.newValue, 1);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
data.foo += "test";
data.bar++;
});
QUnit.test("Nested objects", function() {
expect(36);
var struct = {
people: {
Jack: {age: 20},
Peter: {age: 30},
Jessy: {age: 40}
}
},
w = new DataWatcher(struct),
data = w.getData();
w.watch("people", function (e) {
if (e.type === DataWatcher.type.DELETED) {
deepEqual(e.path, ["people", "Jessy"]);
deepEqual(e.oldValue, {age: 40});
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else {
deepEqual(e.path, ["people", "Mary"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, {age: 50});
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
w.watch("people.Jack.age", function (e) {
deepEqual(e.path, ["people", "Jack", "age"]);
strictEqual(e.oldValue, 20);
strictEqual(e.newValue, 25);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
w.watch("people.*", function (e) {
if (e.type === DataWatcher.type.DELETED) {
deepEqual(e.path, ["people", "Jessy"]);
deepEqual(e.oldValue, {age: 40});
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else if (e.type === DataWatcher.type.ADDED) {
deepEqual(e.path, ["people", "Mary"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, {age: 50});
strictEqual(e.type, DataWatcher.type.ADDED);
} else if (e.path[1] === "Jack") {
deepEqual(e.path, ["people", "Jack", "age"]);
strictEqual(e.oldValue, 20);
strictEqual(e.newValue, 25);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["people", "Peter", "age"]);
strictEqual(e.oldValue, 30);
strictEqual(e.newValue, 35);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
w.watch("people.*.age.", function (e) {
if (e.path[1] === "Jack") {
deepEqual(e.path, ["people", "Jack", "age"]);
strictEqual(e.oldValue, 20);
strictEqual(e.newValue, 25);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["people", "Peter", "age"]);
strictEqual(e.oldValue, 30);
strictEqual(e.newValue, 35);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
data.people.Jack.age = 25;
data.people.Peter.age = 35;
delete data.people.Jessy;
data.people.Mary = {age: 50};
});
QUnit.test("Array of objects", function() {
expect(40);
var struct = {
people: [
{name: "Jack", age: 20},
{name: "Peter", age: 30},
{name: "Jessy", age: 40}
]
},
w = new DataWatcher(struct),
data = w.getData();
w.watch("people", function (e) {
if (e.type === DataWatcher.type.DELETED) {
deepEqual(e.path, ["people", "2"]);
deepEqual(e.oldValue, {name: "Jessy", age: 40});
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else {
deepEqual(e.path, ["people", "2"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, {name: "Mary", age: 50});
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
w.watch("people[2]", function (e) {
if (e.type === DataWatcher.type.DELETED) {
deepEqual(e.path, ["people", "2"]);
deepEqual(e.oldValue, {name: "Jessy", age: 40});
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else {
deepEqual(e.path, ["people", "2"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, {name: "Mary", age: 50});
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
w.watch("people.*", function (e) {
if (e.type === DataWatcher.type.DELETED) {
deepEqual(e.path, ["people", "2"]);
deepEqual(e.oldValue, {name: "Jessy", age: 40});
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
} else if (e.type === DataWatcher.type.ADDED) {
deepEqual(e.path, ["people", "2"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, {name: "Mary", age: 50});
strictEqual(e.type, DataWatcher.type.ADDED);
} else if (e.path[1] === "0") {
deepEqual(e.path, ["people", "0", "name"]);
strictEqual(e.oldValue, "Jack");
strictEqual(e.newValue, "John");
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["people", "1", "age"]);
strictEqual(e.oldValue, 30);
strictEqual(e.newValue, 35);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
w.watch("people.*.name", function (e) {
deepEqual(e.path, ["people", "0", "name"]);
strictEqual(e.oldValue, "Jack");
strictEqual(e.newValue, "John");
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
w.watch("people.*[age]", function (e) {
deepEqual(e.path, ["people", "1", "age"]);
strictEqual(e.oldValue, 30);
strictEqual(e.newValue, 35);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
data.people[0].name = "John";
data.people[1].age = 35;
data.people.pop();
data.people.push({name: "Mary", age: 50});
});
QUnit.test("Watch added data", function() {
expect(12);
var struct = {
foo: "test"
},
w = new DataWatcher(struct),
data = w.getData();
w.watch("foo", function (e) {
if (e.path.length === 1) {
deepEqual(e.path, ["foo"]);
strictEqual(e.oldValue, "test");
deepEqual(e.newValue, {bar: "bar"});
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["foo", "bar"]);
strictEqual(e.oldValue, "bar");
strictEqual(e.newValue, "baz");
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
w.watch("foo.bar", function (e) {
deepEqual(e.path, ["foo", "bar"]);
strictEqual(e.oldValue, "bar");
strictEqual(e.newValue, "baz");
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
data.foo = {bar: "bar"};
data.foo.bar = "baz";
});
QUnit.test("Object iteration", function() {
expect(8);
var struct = {
foo: "fooVal",
bar: "barVal",
baz: "bazVal"
},
w = new DataWatcher(struct),
data = w.getData(),
keys = Object.keys(data),
counter = 0;
deepEqual(keys, ["foo", "bar", "baz"]);
deepEqual(data, struct);
for (var prop in data) {
strictEqual(prop, keys[counter]);
strictEqual(data[prop], keys[counter] + "Val");
counter++;
}
});
QUnit.test("Array iteration", function() {
expect(5);
var struct = ["foo", "bar", "baz"],
w = new DataWatcher(struct),
data = w.getData();
deepEqual(data, struct);
strictEqual(data.length, 3);
for (var i = 0; i < data.length; i++) {
strictEqual(data[i], struct[i]);
}
});
QUnit.test("Escaped path selectors", function() {
expect(8);
var struct = {
"*": 1,
"a[b]c": 2
},
w = new DataWatcher(struct),
data = w.getData();
w.watch("[*]", function (e) {
deepEqual(e.path, ["*"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
w.watch("[a\\[b\\]c]", function (e) {
deepEqual(e.path, ["a[b]c"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, 4);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
data["*"] = 3;
data["a[b]c"] = 4;
});
QUnit.test("Empty selector", function() {
expect(4);
var struct = {
foo: 1,
bar: {
baz : 1
}
},
w = new DataWatcher(struct),
data = w.getData();
data.dontCach = true;
w.watch("", function (e) {
deepEqual(e.path, ["foo"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 2);
strictEqual(e.type, DataWatcher.type.MODIFIED);
});
data.foo = 2;
data.bar.baz = 2;
});
QUnit.test("Invalid data", function() {
expect(4);
var tests = ["string", 1, function(){}, null];
tests.forEach(function (data) {
throws(function () {
new DataWatcher(data);
});
});
});
QUnit.test("Array.fill", function() {
expect(9);
var struct = [1, 2],
w = new DataWatcher(struct),
data = w.getData(),
counter = 0;
w.watch(function (e) {
if (!counter) {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["1"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
counter++;
});
data.fill(3);
deepEqual(data, [3, 3]);
});
QUnit.test("Array.reverse", function() {
expect(17);
var struct = [1, 2, 3, 4],
w = new DataWatcher(struct),
data = w.getData();
w.watch(function (e) {
if (e.path[0] === "0") {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 4);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "1") {
deepEqual(e.path, ["1"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "2") {
deepEqual(e.path, ["2"]);
strictEqual(e.oldValue, 3);
strictEqual(e.newValue, 2);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "3") {
deepEqual(e.path, ["3"]);
strictEqual(e.oldValue, 4);
strictEqual(e.newValue, 1);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
data.reverse();
deepEqual(data, [4, 3, 2, 1]);
});
QUnit.test("Array.shift", function() {
expect(14);
var struct = [1, 2, 3],
w = new DataWatcher(struct),
data = w.getData();
w.watch(function (e) {
if (e.path[0] === "0") {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 2);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "1") {
deepEqual(e.path, ["1"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "2") {
deepEqual(e.path, ["2"]);
strictEqual(e.oldValue, 3);
strictEqual(e.newValue, undefined);
strictEqual(e.type, DataWatcher.type.DELETED);
}
});
strictEqual(data.shift(), 1);
deepEqual(data, [2, 3]);
});
QUnit.test("Array.unshift", function() {
expect(14);
var struct = [1, 2],
w = new DataWatcher(struct),
data = w.getData();
w.watch(function (e) {
if (e.path[0] === "0") {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, 1);
strictEqual(e.newValue, 3);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "1") {
deepEqual(e.path, ["1"]);
strictEqual(e.oldValue, 2);
strictEqual(e.newValue, 1);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "2") {
deepEqual(e.path, ["2"]);
strictEqual(e.oldValue, undefined);
strictEqual(e.newValue, 2);
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
strictEqual(data.unshift(3), 3);
deepEqual(data, [3, 1, 2]);
});
QUnit.test("Array.splice", function() {
expect(14);
var struct = [1, 2, 3, 4],
w = new DataWatcher(struct),
data = w.getData();
w.watch(function (e) {
if (e.path[0] === "2") {
deepEqual(e.path, ["2"]);
strictEqual(e.oldValue, 3);
strictEqual(e.newValue, 5);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "3") {
deepEqual(e.path, ["3"]);
strictEqual(e.oldValue, 4);
strictEqual(e.newValue, 6);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[0] === "4") {
deepEqual(e.path, ["4"]);
strictEqual(e.oldValue, undefined);
strictEqual(e.newValue, 7);
strictEqual(e.type, DataWatcher.type.ADDED);
}
});
deepEqual(data.splice(2, 2, 5, 6, 7), [3, 4]);
deepEqual(data, [1, 2, 5, 6, 7]);
});
QUnit.test("Array.sort", function() {
expect(1);
var struct = [4, 3, 2, 1],
w = new DataWatcher(struct),
data = w.getData();
data.sort();
deepEqual(data, [1, 2, 3, 4]);
});
QUnit.test("Proxies interaction", function() {
expect(12);
var struct1 = [],
struct2 = {foo: "foo"},
w1 = new DataWatcher(struct1),
w2 = new DataWatcher(struct2),
data1 = w1.getData(),
data2 = w2.getData();
w1.watch(function (e) {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, struct2);
strictEqual(e.type, DataWatcher.type.ADDED);
});
w1.watch("*", function (e) {
if (e.type === DataWatcher.type.ADDED) {
deepEqual(e.path, ["0"]);
strictEqual(e.oldValue, undefined);
deepEqual(e.newValue, struct2);
strictEqual(e.type, DataWatcher.type.ADDED);
} else {
deepEqual(e.path, ["0", "foo"]);
strictEqual(e.oldValue, "foo");
deepEqual(e.newValue, "bar");
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
});
data1.push(data2);
data1[0].foo = "bar";
});
QUnit.test("Deep value comparison", function() {
expect(21);
var struct = {
arr: [1, 2],
obj: {a: 1, b: 2}
},
called = false,
w = new DataWatcher(struct),
data = w.getData();
w.watch("*", function (e) {
called = true;
if (e.path[0] === "arr") {
if (e.path.length === 1) {
deepEqual(e.path, ["arr"]);
deepEqual(e.oldValue, [1, 2]);
deepEqual(e.newValue, [3, [4, 5]]);
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["arr", "1"]);
deepEqual(e.oldValue, [4, 5]);
deepEqual(e.newValue, [6]);
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
} else {
if (e.path.length === 1) {
deepEqual(e.path, ["obj"]);
deepEqual(e.oldValue, {a: 1, b: 2});
deepEqual(e.newValue, {a: {c: 3}, b: {d: 4}});
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else if (e.path[1] === "a") {
deepEqual(e.path, ["obj", "a"]);
deepEqual(e.oldValue, {c: 3});
deepEqual(e.newValue, {e: 5});
strictEqual(e.type, DataWatcher.type.MODIFIED);
} else {
deepEqual(e.path, ["obj", "b"]);
deepEqual(e.oldValue, {d: 4});
deepEqual(e.newValue, {d: 4, f: 6});
strictEqual(e.type, DataWatcher.type.MODIFIED);
}
}
});
data.arr = [1, 2];
data.obj = {a: 1, b: 2};
strictEqual(called, false);
data.arr = [3, [4, 5]];
data.obj = {a: {c: 3}, b: {d: 4}};
data.arr[1] = [6];
data.obj.a = {e: 5};
data.obj.b = {d: 4, f: 6};
});
QUnit.test("Readonly properties", function() {
expect(5);
var struct = {};
Object.defineProperty(struct, "foo", {
enumerable: true,
writable: false,
value: "bar"
});
var w = new DataWatcher(struct),
called = false,
data = w.getData();
w.watch("*", function (e) {
if (e.type !== "add") {
called = true;
}
});
data.foo = "baz";
strictEqual(data.foo, "bar");
delete data.foo;
strictEqual(data.foo, "bar");
Object.defineProperty(data, "foo2", {
enumerable: true,
writable: false,
value: "bar"
});
data.foo2 = "baz";
strictEqual(data.foo, "bar");
delete data.foo2;
strictEqual(data.foo, "bar");
strictEqual(called, false);
});
QUnit.test("Check support", function() {
ok(DataWatcher.supported());
}); |
export default {
settings: {
test: {
node: {
entry: undefined,
tests: {
pattern: '**/*.test.js',
path: 'tests',
},
src: {
path: 'src',
pattern: '**/*.js',
},
},
},
},
};
|
'use strict';
require('./gulp');
|
'use strict';
describe('Directive: oauthButtons', function() {
// load the directive's module and view
beforeEach(module('angularFullstackApp'));
beforeEach(module('components/oauth-buttons/oauth-buttons.html'));
var element, parentScope, elementScope;
var compileDirective = function(template) {
inject(function($compile) {
element = angular.element(template);
element = $compile(element)(parentScope);
parentScope.$digest();
elementScope = element.isolateScope();
});
};
beforeEach(inject(function($rootScope) {
parentScope = $rootScope.$new();
}));
it('should contain anchor buttons', function() {
compileDirective('<oauth-buttons></oauth-buttons>');
expect(element.find('a.btn.btn-social')
.length)
.to.be.at.least(1);
});
it('should evaluate and bind the classes attribute to scope.classes', function() {
parentScope.scopedClass = 'scopedClass1';
compileDirective('<oauth-buttons classes="testClass1 {{scopedClass}}"></oauth-buttons>');
expect(elementScope.classes)
.to.equal('testClass1 scopedClass1');
});
it('should bind scope.classes to class names on the anchor buttons', function() {
compileDirective('<oauth-buttons></oauth-buttons>');
// Add classes
elementScope.classes = 'testClass1 testClass2';
elementScope.$digest();
expect(element.find('a.btn.btn-social.testClass1.testClass2')
.length)
.to.be.at.least(1);
// Remove classes
elementScope.classes = '';
elementScope.$digest();
expect(element.find('a.btn.btn-social.testClass1.testClass2')
.length)
.to.equal(0);
});
});
|
function last() {
var my_id = document.getElementById('my_id').value;
var u_id = document.getElementById('u_id').value;
//var lst_id = $(".chip").attr();
$.ajax({
url: "http://chat.com/last",
type: 'POST',
data: {'my_id': my_id, 'u_id': u_id},
success: function(data) {
var arr = $.parseJSON(data);
//console.log(data);
arr.forEach(function(item, i, arr) { // Цикл
//console.log(item);
if (item.reciever == my_id) {
var obj = "<div class='recipient'>\
<div class='chip my-chip' data-id="+item.msg_id+">\
<img src='http://chat.com/assets/img/"+item.image+"' title="+item.firstname+">\
"+item.text_msg+"<br>\
<small><small><i>"+item.created_date+"</i></small>\
</div>\
</div>";
$(".mssgs-container").append(obj);
}
if (item.reciever == u_id) {
var obj = "<div class='sender'>\
<div class='chip my-chip' data-id="+item.msg_id+">\
<img src='http://chat.com/assets/img/"+item.image+"' title="+item.firstname+">\
"+item.text_msg+"<br>\
<small><small><i>"+item.created_date+"</i></small>\
</div>\
</div>";
$(".mssgs-container").append(obj);
}
});
var h = $(".mssgs-container").height();
var math = Math.sqrt(parseInt(h)) * 100;
$(".mssgs-container").scrollTop(math);
}
});
}
function update() {
var my_id = document.getElementById('my_id').value,
u_id = document.getElementById('u_id').value;
last_id = document.getElementById('last_id').value;
$.ajax({
url: "http://chat.com/update",
type: 'POST',
data: {'my_id': my_id, 'u_id': u_id, 'last_id': last_id},
success: function(data) {
var msg = $.parseJSON(data);
document.getElementById('last_id').value = msg[msg.length - 1].msg_id;
msg.forEach(function(item, i, msg) { // Цикл
if (item.reciever == my_id) {
var obj = "<div class='recipient' data-id="+item.msg_id+">\
<div class='chip my-chip'>\
<img src='http://chat.com/assets/img/"+item.image+"' title="+item.firstname+">\
"+item.text_msg+"<br>\
<small><small><i>"+item.created_date+"</i></small>\
</div>\
</div>";
$(".mssgs-container").append(obj);
}
if (item.reciever == u_id) {
var obj = "<div class='sender' data-id="+item.msg_id+">\
<div class='chip my-chip'>\
<img src='http://chat.com/assets/img/"+item.image+"' title="+item.firstname+">\
"+item.text_msg+"<br>\
<small><small><i>"+item.created_date+"</i></small>\
</div>\
</div>";
$(".mssgs-container").append(obj);
}
});
var h = $(".mssgs-container").height();
var math = Math.sqrt(parseInt(h)) * 100;
$(".mssgs-container").scrollTop(math);
}
});
}
// update();
setInterval("update()", 1000);
|
$(document).ready(function(){
$(document).knot(model);
progress.init('#progressui');
editor.init();
filetray.init('#filetrayui');
filetray.listFiles();
});
var model = {
files: [
/*{name: 'file1', ext: 'png'},
{name: 'file2', ext: 'jpg'},
{name: 'file3', ext: 'cs'},
{name: 'folder1', ext: ''},*/
],
}
|
var mongoose = require('mongoose');
module.exports = function(app) {
var users = require('../../app/controllers/users');
var bios = require('../../app/controllers/bios');
var projects = require('../../app/controllers/projects');
var jobs = require('../../app/controllers/jobs');
var stories = require('../../app/controllers/stories');
//routes to read in data from json file
app.route('/init')
.get(function(req, res) {
mongoose.connection.db.dropDatabase();
bios.init(req, res);
projects.init(req, res);
jobs.init(req, res);
stories.init(req, res);
res.jsonp('success');
});
};
|
$(document).on('page:change', function(event) {
$(document).ready(function() {
$(document).on('click', '.reveal', function() {
var $this = $(this);
$this.fadeOut('fast', function() {
$this.closest('td').find('.reward').fadeIn('slow').show();
$this.replaceWith();
});
});
});
$(document).ready(function() {
$('.reveal_all').on('click', function() {
$('.reveal').fadeOut('slow').replaceWith();
$('.reward').fadeIn('slow').show();
});
});
$(document).ready(function() {
$('.scores').tooltip({
title: 'Not Yet Scored, Be Patient!',
placement: 'left'
});
$('.rewards').tooltip({
title: 'Not Yet Rewarded, Be Patient!',
placement: 'left'
});
});
});
|
import Logger from 'ember-metal/logger';
import { deprecate } from 'ember-metal/debug';
import { registerHandler as genericRegisterHandler, invoke } from 'ember-debug/handlers';
export function registerHandler(handler) {
genericRegisterHandler('warn', handler);
}
registerHandler(function logWarning(message, options) {
Logger.warn('WARNING: ' + message);
if ('trace' in Logger) {
Logger.trace();
}
});
export let missingOptionsDeprecation = 'When calling `Ember.warn` you ' +
'must provide an `options` hash as the third parameter. ' +
'`options` should include an `id` property.';
export let missingOptionsIdDeprecation = 'When calling `Ember.warn` you must provide `id` in options.';
/**
Display a warning with the provided message. Ember build tools will
remove any calls to `Ember.warn()` when doing a production build.
@method warn
@param {String} message A warning to display.
@param {Boolean} test An optional boolean. If falsy, the warning
will be displayed.
@public
*/
export default function warn(message, test, options) {
if (!options) {
deprecate(
missingOptionsDeprecation,
false,
{
id: 'ember-debug.warn-options-missing',
until: '3.0.0',
url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
}
);
}
if (options && !options.id) {
deprecate(
missingOptionsIdDeprecation,
false,
{
id: 'ember-debug.warn-id-missing',
until: '3.0.0',
url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options'
}
);
}
invoke('warn', ...arguments);
}
|
// Copyright 2011 Joshua Wang, MIT License
/**
* @fileoverview class Stock
* @author sharkman.jw@gmail.com (Joshua Wang)
*/
function Stock(symbol, exchange, name, name) {
this.symbol = symbol; // string
this.exchange = exchange; // string
this.name = name; // string
this.type = name; // string
this.keyTicker = null; // string - exchange:symbol
};
Stock.prototype.generateKeyTicker = function() {
this.keyTicker = this.exchange + ':' + this.symbol;
return this.keyTicker;
};
Stock.prototype.toString = function() {
return '[stock ' + this.keyTicker + ']';
};
|
import { setData } from '@progress/kendo-angular-intl';
setData({
name: "ko",
likelySubtags: {
ko: "ko-Kore-KR"
},
identity: {
language: "ko"
},
territory: "KR",
numbers: {
symbols: {
decimal: ".",
group: ",",
list: ";",
percentSign: "%",
plusSign: "+",
minusSign: "-",
exponential: "E",
superscriptingExponent: "×",
perMille: "‰",
infinity: "∞",
nan: "NaN",
timeSeparator: ":"
},
decimal: {
patterns: [
"n"
],
groupSize: [
3
]
},
scientific: {
patterns: [
"nEn"
],
groupSize: []
},
percent: {
patterns: [
"n%"
],
groupSize: [
3
]
},
currency: {
patterns: [
"$n"
],
groupSize: [
3
],
"unitPattern-count-other": "n $"
},
accounting: {
patterns: [
"$n",
"($n)"
],
groupSize: [
3
]
}
}
});
|
/* ************************************************************************
Copyright: 2013 Hericus Software, LLC
License: The MIT License (MIT)
Authors: Steven M. Cherry
************************************************************************ */
/**
* This class is the base class for all of our Hub Unit/Gui testing. We
* create a full application of the hub inside the testrunner framework so that
* all of our trees/dialogs/editors/etc. will function as normal. When the
* tests are all done, we tear down the hub application and return control
* to the testrunner application.
*
* We also have a series of methods that make it easier to find items in the
* tree(s) and execute various standard activities within the application.
*
*/
qx.Class.define("dev.test.HelixTest",
{
extend : qx.dev.unit.TestCase,
type : "abstract",
construct : function() {
this.base(arguments);
},
properties: {
ServerHost : {init : "viazos19", check : "String" },
ServerPort : {init : "6311", check : "String" },
ServerUser : {init : "SMC", check : "String" },
ServerPass : {init : "SMC", check : "String" }
},
members :
{
_lastTest : false,
/**
* This function is executed prior to each of the test* methods defined
* below.
*/
setUp : function() {
// construct our dev Application so we can test it
this.getRoot();
},
/**
* This function is executed after each of the test* methods defined
* below.
*/
tearDown : function() {
if (this._lastTest === true) {
this.getRoot().removeAll();
var cls = dev.test.HubTest;
if (cls._app) {
this._disposeObjects( cls._app );
cls._app = null;
qx.core.Init.getApplication = cls._oldGetApp;
}
// Support re-running without re-loading
this._lastTest = false;
}
},
getRoot : function() {
var cls = dev.test.HubTest;
if(cls._app){
return cls._app.getRoot();
}
cls._app = new dev.Application( document );
cls._oldApplication = qx.core.Init.getApplication();
cls._oldGetApp = qx.core.Init.getApplication;
qx.core.Init.getApplication = function() {
return cls._app;
}
cls._app.main();
return cls._app.getRoot();
},
/*
---------------------------------------------------------------------------
TESTS
---------------------------------------------------------------------------
*/
/**
* Set our server connection to viazos19, 6311, SMC by default. Override
* this test method if you want to use a different server connection.
*/
test0000_setServer: function() {
qx.core.Init.getApplication().addListener( "appInitialized", function() {
dev.test.TestStatics.SetServerConnection(this.getServerHost(), this.getServerPort(),
this.getServerUser(), this.getServerPass());
// sleep for 3 seconds to give the app a little more time to initialize:
qx.event.Timer.once( function() { this.resume(); }, this, 3000 );
}, this );
this.wait( 10000 );
},
/**
* Set the properties for this test case
*/
test0001_setProps: function () {
this.populateProperties();
},
/**
* The last test in this class will simply set the _lastTest boolean
* to true. This will trigger our tearDown function to get rid of our
* testing application.
*/
test9999_LastTest: function() {
this._lastTest = true;
},
/** Use this to do a "Refresh" on the browse tree and the catalog tree.
*/
doTreeRefresh : function() {
qx.core.Init.getApplication().fillTree();
},
/** Use this in order to find/open a given node in the browse tree. Use slashes
* to separate the levels: i.e. "Data Sources/VSAM_LDS/VIASQL".
*/
getBrowseTreeNode : function(treePath, callBack, rootNode){
this.treePath = treePath.split("/");
this.treePathCallback = callBack;
if(rootNode){
var browseRoot = rootNode;
} else {
var browseRoot = qx.core.Init.getApplication().browseTreeRoot;
}
this.assertNotNull( browseRoot, "Application browse tree root is null.");
this.assertNotUndefined( browseRoot, "Application browse tree root is null.");
this.expectantParent = browseRoot;
this.treePathIdx = 0;
this.childFound();
},
/** Use this in order to find/open a given node in the normal tree. Use slashes
* to separate the levels: i.e. "Tables/HWRD/AUTHORS".
*/
getFileTreeNode : function(treePath, callBack, rootNode){
this.treePath = treePath.split("/");
this.treePathCallback = callBack;
if(rootNode){
var treeRoot = rootNode;
} else {
var treeRoot = qx.core.Init.getApplication().treeRoot;
}
this.assertNotNull( treeRoot, "Application tree root is null.");
this.assertNotUndefined( treeRoot, "Application tree root is null.");
this.expectantParent = treeRoot;
this.treePathIdx = 0;
this.childFound();
},
/** This method is used by the getBrowseTreeNode, and getFileTreeNode. Do not use
* this method directly.
*/
childFound : function() {
// Find the next level child:
var children = this.expectantParent.getChildren();
var childName = this.treePath[ this.treePathIdx ];
var childNode = null;
for(var j = 0, m = children.length; j < m; j++){
if(children[ j ].getLabel().indexOf( childName ) === 0){ // use this instead of startsWith
childNode = children[ j ];
break;
}
}
if(childNode === null){
throw "Unknown child node: " + childName + " in browse tree.";
}
if(this.treePathIdx === (this.treePath.length - 1) ){
// we're done. call the callback:
this.treePathCallback.call( this, childNode );
return;
}
// otherwise, keep looking for the next level down:
if(!childNode.isOpen()){
childNode.toggleOpen();
}
this.treePathIdx ++;
// wait for the childNode to open up and fill up its children:
this.expectantParent = childNode;
this.waitForChildren();
},
/** This method is used by the getBrowseTreeNode, and getFileTreeNode. Do not use
* this method directly.
*/
waitForChildren : function() {
if(this.expectantParent.getChildren().length !== 0){
this.childFound(); // children found
return;
}
// otherwise wait for 1/2 second and check again:
qx.event.Timer.once( this.waitForChildren, this, 100 );
},
/** This fires the double-click event on the given widget.
*/
doubleClick : function( widg ) {
widg.fireEvent( "dblclick", qx.event.type.Mouse, [{}, widg, widg, false, true] );
},
/** This method will find a given tab name, or return null if
* it doesn't exist.
*/
findTab : function(tabName) {
var app = qx.core.Init.getApplication();
var pages = app.tabView.getChildren();
for(var i = 0, l = pages.length; i < l; i++){
if(pages[i].getLabel() === tabName ||
pages[i].getLabel() === "*" + tabName
){
// Found it. Ensure that it is fully loaded and ready:
return pages[i];
}
}
// Didn't find anything
return null;
},
/** This method will wait for an editor with the given tab name.
*/
waitForEditor : function(editorName, callBack) {
// Check to see if the editor is present:
var page = this.findTab( editorName );
if(page !== null){
// Found it. Ensure that it is fully loaded and ready:
var editor = page.getChildren()[0];
if(editor.isEditorLoaded()){
callBack.call( this, editor );
} else {
editor.addListener("editorLoaded", function() {
callBack.call( this, editor );
}, this );
}
return;
}
// If not, then wait for 1/2 second and try again:
qx.event.Timer.once( function() {
this.waitForEditor( editorName, callBack );
}, this, 100 );
},
/**
* Finds and presses the named button on the editor toolbar. We do this directly
* through the editor toolbar and save button. This ensures that all events and actions
* are wired up together properly.
*/
pressEditorToolbar : function( editor, buttonName ) {
var child1 = editor.getChildren()[ 0 ];
if(child1 instanceof qx.ui.toolbar.ToolBar){
var part1 = child1.getChildren()[ 0 ];
if(part1 instanceof qx.ui.toolbar.Part){
var children = part1.getChildren();
for(var i = 0, l = children.length; i < l; i++){
if(children[i] instanceof qx.ui.toolbar.Separator) { continue; }
if(children[i].getLabel().indexOf( buttonName ) === 0 ){
// found the named button.
children[i].execute();
return;
}
}
// If we get to here, there was no button with the given label on the toolbar.
throw "No '" + buttonName + "' button found on editor toolbar.";
} else {
throw "First toolbar child is not a toolbar.Part";
}
} else {
throw "First child is not a toolbar";
}
},
/**
* Finds and presses the "Save" Button on the toolbar. We do this directly through
* the editor toolbar and save button. This ensures that all events and actions
* are wired up together properly.
*/
pressSave : function () {
this.pressEditorToolbar( this._editor, "Save" );
},
/** This function closes the named tab. This does its work directly through the
* tab view and presses the close button on the tab directly. This way all associated
* events and actions should fire correctly
*/
closeTab : function(tabName) {
var page = this.findTab( tabName );
if(page === null){
throw "Tab named " + tabName + " is not open.";
}
page.getButton().fireDataEvent("close", page.getButton() );
},
/** This method will wait for a named tab to close
*/
waitForTabToClose : function(tabName, callBack) {
// Check to see if the editor is present:
var page = this.findTab( tabName );
if(page === null){
// It's closed. Call the callback
callBack.call( this );
return;
} else {
// If not, then wait for 1/2 second and try again:
qx.event.Timer.once( function() {
this.waitForTabToClose( tabName, callBack );
}, this, 100 );
}
},
/**
* This function uses the data defined in _propData to drive the population
* of our properties.
*/
populateProperties : function () {
if(this._propData === null || this._propData === undefined){
return;
}
var single = dev.Singleton.getInstance();
var props = single.getSystemProperties();
for(var i = 0, l = this._propData.length; i < l; i ++ ){
var field = this._propData[i];
props[field.name] = field.value;
}
},
/**
* This function uses the data defined in _testData to drive the population
* of all of our form fields. We'll switch tabs as required to get each one
* populated.
*/
populateFormFields : function () {
if(this._testData === null || this._testData === undefined){
throw "No _testData defined to populate form fields.";
}
for(var i = 0, l = this._testData.length; i < l; i ++ ){
var field = this._testData[i];
this.populateOneField( field );
}
},
/** This handles populating one field in the form based on the given input field
* hash information. The field has should look like this:
* {name: "FieldWidgetName", value: "ValueForField" }
*/
populateOneField: function( field ) {
var widget = this._editor[ field.name ];
if(widget === null || widget === undefined){
throw String("_testData field " + field.name + " is not found in the editor.");
}
if(widget instanceof qx.ui.form.TextField ||
widget instanceof qx.ui.form.PasswordField ||
widget instanceof qx.ui.form.TextArea ||
widget instanceof qx.ui.form.ComboBox
){
widget.setValue( field.value );
} else if(widget instanceof qx.ui.form.SelectBox ){
dev.Statics.setDropDownByLabel( widget, field.value );
} else if(widget instanceof qx.ui.form.CheckBox ||
widget instanceof qx.ui.form.RadioButton ||
widget instanceof qx.ui.groupbox.CheckGroupBox ||
widget instanceof qx.ui.groupbox.RadioGroupBox
){
widget.setValue( field.value === "true" ? true : false );
} else if (widget instanceof qx.ui.table.Table) {
//widget.getTableModel().setData(field.value);
} else {
throw String("Unknown field type for field: " + field.name );
}
},
/**
* This function uses the data defined in _testData to check any fields that
* have default data in them. If no default value is defined for a field, that
* field is skipped.
*/
checkDefaultData : function () {
if(this._testData === null || this._testData === undefined){
throw "No _testData defined.";
}
for(var i = 0, l = this._testData.length; i < l; i ++ ){
var field = this._testData[i];
if(field.defaultValue === null || field.defaultValue === undefined){
continue; // skip this field.
}
var widget = this._editor[ field.name ];
if(widget === null || widget === undefined){
throw String("_testData field " + field.name + " is not found in the editor.");
}
this.checkOneField( widget, field.defaultValue, field.name);
}
},
/**
* This function uses the data defined in _testData to check all standard field data.
*/
checkData : function (phase) {
if(this._testData === null || this._testData === undefined){
throw "No _testData defined.";
}
for(var i = 0, l = this._testData.length; i < l; i ++ ){
var field = this._testData[i];
var widget = this._editor[ field.name ];
if(widget === null || widget === undefined){
throw String("_testData field " + field.name + " is not found in the editor.");
}
if(phase === "AfterSave"){
if(field.valueAfterSave !== null && field.valueAfterSave !== undefined){
this.checkOneField( widget, field.valueAfterSave, field.name);
} else {
this.checkOneField( widget, field.value, field.name); // use the normal value
}
} else if(phase === "AfterReload"){
if(field.valueAfterReload !== null && field.valueAfterReload !== undefined){
this.checkOneField( widget, field.valueAfterReload, field.name);
} else {
this.checkOneField( widget, field.value, field.name); // use the normal value
}
} else {
this.checkOneField( widget, field.value, field.name); // use the normal value
}
}
},
/**
* This function checks the data in a single field against a given value to
* ensure that it is correct.
*/
checkOneField : function(widget, value, name){
var err = "Field " + name + " value is incorrect.";
if(widget instanceof qx.ui.form.TextField ||
widget instanceof qx.ui.form.PasswordField ||
widget instanceof qx.ui.form.TextArea ||
widget instanceof qx.ui.form.ComboBox
){
this.assertEquals(value, widget.getValue(), err)
} else if(widget instanceof qx.ui.form.SelectBox ){
this.assertEquals(value, widget.getSelection()[0].getLabel(), err);
} else if(widget instanceof qx.ui.form.CheckBox ||
widget instanceof qx.ui.form.RadioButton ||
widget instanceof qx.ui.groupbox.CheckGroupBox ||
widget instanceof qx.ui.groupbox.RadioGroupBox
){
this.assertEquals( value === "true" ? true : false, widget.getValue(), err );
} else if (widget instanceof qx.ui.table.Table) {
this.checkTableValues(widget, value, name);
//this.assertJsonEquals(value, widget.getTableModel().getData(), err);
} else {
throw String("Unknown field type for field: " + name );
}
},
/** This function walks through a list of table values and compares them against
* the actual cells in the live table.
*/
checkTableValues : function(tableWidget, value, name) {
for(var i = 0, l = value.length; i < l; i++){
var cellCheck = value[i];
this.checkTableCellValue(
tableWidget, cellCheck.row, cellCheck.col, cellCheck.value, name);
}
},
/** This function compares row/column data in a table against a given value.
*/
checkTableCellValue: function(tableWidget, row, col, value, name){
var tableCellVal = tableWidget.getTableModel().getValue( col, row );
this.assertEquals( value, tableCellVal,
"Table (" + name + ") value at row (" + row + ") col (" + col +
") does not match. Expected (" + value + ") actual (" + tableCellVal + ")"
);
}
},
statics :
{
},
destruct : function () {
}
});
|
(function (window, undefined) {
var CallbackList = function () {
var state,
list = [];
var exec = function ( context , args ) {
if ( list ) {
args = args || [];
state = state || [ context , args ];
for ( var i = 0 , il = list.length ; i < il ; i++ ) {
list[ i ].apply( state[ 0 ] , state[ 1 ] );
}
list = [];
}
};
this.add = function () {
for ( var i = 0 , il = arguments.length ; i < il ; i ++ ) {
list.push( arguments[ i ] );
}
if ( state ) {
exec();
}
return this;
};
this.execute = function () {
exec( this , arguments );
return this;
};
};
var Deferred = function ( func ) {
var state = 'progress',
actions = [
[ 'resolve' , 'done' , new CallbackList() , 'resolved' ],
[ 'reject' , 'fail' , new CallbackList() , 'rejected' ],
[ 'notify' , 'progress' , new CallbackList() ],
],
deferred = {},
promise = {
state: function () {
return state;
},
then: function ( /* doneHandler , failedHandler , progressHandler */ ) {
var handlers = arguments;
return Deferred(function ( newDefer ) {
actions.forEach(function ( action , i ) {
var handler = handlers[ i ];
deferred[ action[ 1 ] ]( typeof handler === 'function' ?
function () {
var returned = handler.apply( this , arguments );
if ( returned && typeof returned.promise === 'function' ) {
returned.promise()
.done( newDefer.resolve )
.fail( newDefer.reject )
.progress( newDefer.notify );
}
} : newDefer[ action[ 0 ] ]
);
});
}).promise();
},
promise: function ( obj ) {
if ( obj ) {
Object.keys( promise )
.forEach(function ( key ) {
obj[ key ] = promise[ key ];
});
return obj;
}
return promise;
}
};
actions.forEach(function ( action , i ) {
var list = action[ 2 ],
actionState = action[ 3 ];
promise[ action[ 1 ] ] = list.add;
if ( actionState ) {
list.add(function () {
state = actionState;
});
}
deferred[ action[ 0 ] ] = list.execute;
});
promise.promise( deferred );
if ( func ) {
func.call( deferred , deferred );
}
return deferred;
};
if ( typeof define === 'function' && define.amd ) {
define(function () { return Deferred; });
} else {
window.Deferred = Deferred;
}
})(window);
|
module.exports = class {
onFileClick(e) {
e.preventDefault();
const dataset = Object.keys(e.target.dataset).length ? e.target.dataset : Object.keys(e.target.parentNode.dataset).length ? e.target.parentNode.dataset : Object.keys(e.target.parentNode.parentNode.dataset).length ? e.target.parentNode.parentNode.dataset : {};
this.emit("file-click", {
name: dataset.name,
dir: dataset.dir !== undefined
});
}
onCheckboxChange(e) {
const event = Object.keys(e.target.dataset).length ? {
dataset: e.target.dataset,
state: e.target.checked
} : Object.keys(e.target.parentNode.dataset).length ? {
dataset: e.target.parentNode.dataset,
state: e.target.parentNode.checked
} : Object.keys(e.target.parentNode.parentNode.dataset).length ? {
dataset: e.target.parentNode.parentNode.dataset,
state: e.target.parentNode.parentNode.checked
} : {};
this.emit("checkbox-change", {
id: event.dataset.id,
state: event.state
});
}
};
|
// @flow
import _ from 'lodash-es';
import React from 'react';
import { Field, FieldArray, Fields, FormSection, reduxForm } from 'redux-form';
import { mapConditions } from '~/enums/conditions';
import { type Lookups } from '../../modules/spotEdit';
import { SchoolsField } from './SchoolsField';
import { PhotosField } from './PhotosField';
import { LogoField } from './LogoField';
import {
Checkbox,
Button,
Col,
Row,
Form,
FormGroup,
ControlLabel,
FormControl,
HelpBlock,
Panel,
Tab,
Tabs,
} from 'react-bootstrap';
import SpotMonthlyDistributionField from './SpotMonthlyDistributionField';
import { MapCenterField } from './MapCenterField';
const notBlank = function (x: string): ?string {
if (!x) {
return 'Required';
}
};
const isLat = function (x: string): ?string {
if (!/^(-|\+)?([0-9]+(\.[0-9]+)?)$/.test(x)) {
return 'Is not a number';
}
const number = parseFloat(x);
if (number < -90) {
return 'Should be between -90 at 90';
}
if (number > 90) {
return 'Should be between -90 at 90';
}
};
const isLng = function (x: string): ?string {
if (!/^(-|\+)?([0-9]+(\.[0-9]+)?)$/.test(x)) {
return 'Is not a number';
}
const number = parseFloat(x);
if (number < -180) {
return 'Should be between -90 at 90';
}
if (number > 180) {
return 'Should be between -90 at 90';
}
};
const renderField = ({ input, label, meta }: { input: any, label: string, meta: any }): React$Element<any> => (
<FormGroup controlId='formBasicText' validationState={meta.touched ? meta.error ? 'error' : 'success' : null}>
<ControlLabel>{label}</ControlLabel>
<FormControl {...input} value={input.value} placeholder='Enter text' />
<FormControl.Feedback />
{meta.touched && meta.error && <HelpBlock>{meta.error}</HelpBlock>}
</FormGroup>
);
const renderCheckbox = ({ input, label, meta }: { input: any, label: string, meta: any }): React$Element<any> => {
return (
<Checkbox {...input} checked={!!input.value} inline>
{label}
</Checkbox>
);
};
const activities: { [string]: string } = {
sailing: 'Sailing',
surfing: 'Surfing',
snowkiting: 'Snow Kiting',
kitesurfing: 'Kite Surfing',
windsurfing: 'Wind Surfing',
};
type Props = {|
lookups: Lookups,
onRotateLeft: ({ path: string, filename: string }) => void,
onRotateRight: ({ path: string, filename: string }) => void,
handleSubmit: Function,
onCancel: Function,
reset: Function,
submitting: boolean,
error: ?string,
|};
const SimpleForm = (props: Props) => {
const { handleSubmit, onCancel, error, submitting, lookups, onRotateLeft, onRotateRight } = props;
return (
<Form onSubmit={handleSubmit}>
<Field label='Logo' name='logo' component={LogoField} />
<Field label='Spot' name='name' validate={[notBlank]} component={renderField} type='text' />
<Field label='Country' name='country' component={renderField} type='text' />
<Field label='Region' name='region' component={renderField} type='text' />
<Field label='Rating' name='rating' component={renderField} type='number' min={0} max={10000} />
<Row>
<FormGroup>
<Col sm={6}>
<Field label='Latitude' name='lat' validate={[isLat]} component={renderField} type='text' />
<Field label='Longitude' name='lng' validate={[isLng]} component={renderField} type='text' />
</Col>
<Col sm={6}>
<Fields names={['lat', 'lng']} component={MapCenterField} />
</Col>
</FormGroup>
</Row>
<Row>
<Tabs defaultActiveKey='sailing'>
{_.map(activities, (title: string, activity: string) => (
<Tab eventKey={activity} title={title}>
<ControlLabel>Click to change</ControlLabel>
<Field name={`monthly_distribution.${activity}`} component={SpotMonthlyDistributionField} />
</Tab>
))}
</Tabs>
</Row>
{mapConditions(
({ name, label, labels }: { name: string, label: string, labels: { [string]: string } }, index: number) => (
<FormSection name={`${name}_type`}>
<FormGroup>
<h4>{label}</h4>
{_.map(labels, (label: string, key: string) => (
<Field label={label} name={key} normalize={(x: string) => !!x} component={renderCheckbox} />
))}
</FormGroup>
</FormSection>
),
)}
<Panel header='schools'>
<FieldArray name='schools' schoolsList={lookups.schools} component={SchoolsField} />
</Panel>
<Panel header='photos'>
<FieldArray onRotateLeft={onRotateLeft} onRotateRight={onRotateRight} name='photos' component={PhotosField} />
</Panel>
{error && <p style={{ color: 'red', fontSize: 20, textAlign: 'center' }}>{error}</p>}
<FormGroup>
<Button type='submit' bsStyle='primary' bsSize='large' disabled={submitting}>Save</Button>
<Button type='button' bsSize='large' disabled={submitting} onClick={onCancel}>
Cancel
</Button>
</FormGroup>
</Form>
);
};
export default reduxForm({ form: 'spot' })(SimpleForm);
|
'use strict'
var ejs = require('ejs')
var heredoc = require('heredoc')
var tpl = heredoc(function() {/*
<xml>
<ToUserName><![CDATA[<%= toUserName %>]]></ToUserName>
<FromUserName><![CDATA[<%= fromUserName %>]]></FromUserName>
<CreateTime><%= createTime %></CreateTime>
<MsgType><![CDATA[<%= msgType %>]]></MsgType>
<% if (msgType === 'text') {%>
<Content><![CDATA[ <%= content %>]]></Content>
<% } else if (msgType === 'image') {%>
<Image>
<MediaId><![CDATA[<%= content.mediaId %>]]></MediaId>
</Image>
<% } else if (msgType === 'voice') {%>
<Voice>
<MediaId><![CDATA[<%= content.mediaId %>]]></MediaId>
</Voice>
<% } else if (msgType === 'video') {%>
<Video>
<MediaId><![CDATA[<%= content.mediaId %>]]></MediaId>
<Title><![CDATA[<%= content.title %>]]></Title>
<Description><![CDATA[<%= content.description %>]]></Description>
</Video>
<% } else if (msgType === 'music') {%>
<Music>
<Title><![CDATA[<%= content.title %>]]></Title>
<Description><![CDATA[<%= content.description %>]]></Description>
<MusicUrl><![CDATA[<%= content.musicUrl %>]]></MusicUrl>
<HQMusicUrl><![CDATA[<%= content.hqMusicUrl %>]]></HQMusicUrl>
<ThumbMediaId><![CDATA[<%= content.thumbMediaId %>]]></ThumbMediaId>
</Music>
<% } else if (msgType === 'news') {%>
<ArticleCount><%= content.length %></ArticleCount>
<Articles>
<% content.forEach(function(item){%>
<item>
<Title><![CDATA[<%= item.title %>]]></Title>
<Description><![CDATA[<%= item.description %>]]></Description>
<PicUrl><![CDATA[<%= item.picurl %>]]></PicUrl>
<Url><![CDATA[<%= item.url %>]]></Url>
</item>
<% }) %>
</Articles>
<% } %>
</xml>
*/})
var compiled = ejs.compile(tpl)
exports = module.exports = {
compiled : compiled
} |
/* jshint node: true */
'use strict';
var BowerJson = require('./bower-json.js'),
PackageJson = require('./package-json.js');
function ConfigJsonFactory() {}
ConfigJsonFactory.prototype = (function () {
/**
* Creates a new ConfigJson.
* It will be a instance of BowerJson or PackageJson, depending on the specified
* packageManager.
* @param {String} filePath Path to package dir or json file
* @param {String} packageManager 'npm' or 'bower'
* @return {ConfigJson} The ConfigJson which wraps the json file related to path
*/
var createConfigJson = function createConfigJson(filePath, packageManager) {
var ConfigClass,
jsonObject;
if (packageManager === 'bower') {
ConfigClass = BowerJson;
} else if (packageManager === 'npm') {
ConfigClass = PackageJson;
}
/*
tree.js validates this:
if (ConfigClass === null) {
return false;
}
*/
jsonObject = new ConfigClass({
path: filePath
});
/*
Readability upgrade:
- instance.has.keyword()
- instance.has.not.keyword()
*/
jsonObject.has = {
keyword: function (k) { return jsonObject.hasKeyword(k); },
not: {
keyword: function (k) { return !jsonObject.hasKeyword(k); }
}
};
return jsonObject;
};
return {
createConfigJson: createConfigJson
};
}());
module.exports = new ConfigJsonFactory(); |
var io, socket
let p5App = new window.p5(app)
function app(p){
const size = 500
let controller = newController(size,p)
let padding = 20
//p5 calls setup automatically (once)
p.setup = () => {
let canvas = p.windowWidth < size + 2 * padding? (
controller.setSize(p.windowWidth - padding),
p.createCanvas(p.windowWidth - padding, p.windowWidth - padding)
) : (
controller.setSize(size),
p.createCanvas(size + 1, size + 1)
)
canvas.parent('wrapper__canvas')
canvas.class('wrapper__canvas__p5')
//attempts to connect to server
console.log('waiting for network connection')
let waitForNetwork = window.setInterval(() => {
console.count('connection attempts')
if(io){
console.log('network connected')
start()
window.clearInterval(waitForNetwork)
}
},100)
}
function start(){
const isPrivate = location.href.indexOf('/private')
socket = isPrivate > 0 ? io('/private') : io('/public')
//hopefully alerts the server which room socket should join
const room = window.location.pathname.slice(-40)
p.noStroke()
p.stroke('#111111')
p.strokeWeight(1)
p.strokeCap(p.SQUARE)
p.background("#000")
p.windowResized = () => {
p.windowWidth < size + 2 * padding? (
controller.setSize(p.windowWidth - padding),
p.resizeCanvas(p.windowWidth - padding, p.windowWidth - padding)
) : (
controller.setSize(size),
p.resizeCanvas(size + 1, size + 1)
)
}
socket.emit('init',room)//tell server you've connected to room
const terminal = document.querySelector('.terminal__input'),
dollar = document.querySelector('.terminal__dollar'),
warningMsg = document.querySelector('.warning')
socket.on('colorAssignment', colorIndex => {
const terminalColor = controller.getColor(colorIndex)
dollar.style.color = terminalColor
terminal.style.color = terminalColor
})
socket.on('updateBoard', board => {
controller.update(board)
})
socket.on('removeInputfield', warning => {
dollar.remove()
terminal.remove()
warningMsg.textContent = warning
})
addKeyPressListener(socket,room,controller.onEnter)
}
//p5 calls draw (animation loop) automatically
p.draw = () => {
controller.animate()
}
}
function addKeyPressListener(s,r,callback){
const timePerCall = 500
document.addEventListener('keydown', function(event) {
throttle(callback(s,r,event.keyCode), timePerCall)
}, false)
}
function throttle(func, ms){
var last = 0;
return function(){
var a = arguments, t = this, now = +(new Date);
//b/c last = 0 will still run the first time called
if(now >= last + ms){
last = now;
func.apply(t, a);
}
}
}
|
// Generated by CoffeeScript 1.6.3
(function() {
var addersubber, enders, flatSplat, helpers, inDir, inLib, misc, moment, momentous, oneRand, partial2, path, predicates, printem, randDates, randoms, reverse2, selectors, sorters, starters, toStrings, _, _ref,
__slice = [].slice;
moment = require("moment");
_ = require("underscore");
path = require("path");
_ref = require(path.join(__dirname, "lib/util.js")), reverse2 = _ref.reverse2, partial2 = _ref.partial2, flatSplat = _ref.flatSplat, inDir = _ref.inDir;
inLib = inDir(path.join(__dirname, "lib"));
momentous = {};
predicates = require(inLib("predicates.js"));
_.extend(momentous, predicates);
selectors = require(inLib("selectors.js"));
_.extend(momentous, selectors);
addersubber = require(inLib("addersubber.js"));
_.extend(momentous, addersubber);
starters = require(inLib("starters.js"));
_.extend(momentous, starters);
enders = require(inLib("enders.js"));
_.extend(momentous, enders);
sorters = require(inLib("sorters.js"));
momentous.sort = sorters.ascending;
_.extend(momentous.sort, sorters);
helpers = require(inLib("helpers.js"));
_.extend(momentous, helpers);
randoms = require(inLib("random.js"));
_.extend(momentous, randoms);
misc = require(inLib("misc.js"));
oneRand = (function() {
var fiveYears, now, _diff;
now = moment();
fiveYears = momentous.add.years(now, 5);
_diff = misc.absDiff(now, fiveYears);
return function() {
var diffAmt, sign, _diffAmt, _rnd;
_rnd = Math.random();
diffAmt = _diff * _rnd;
sign = Math.random();
if (sign < 0.5) {
_diffAmt = _diffAmt * -1;
}
return momentous.add(now, diffAmt);
};
})();
randDates = function(dateCount) {
var _outs;
if (dateCount == null) {
dateCount = 12;
}
_outs = [];
while (dateCount--) {
_outs.push(oneRand());
}
return _outs;
};
toStrings = function() {
var dateList, _strung;
dateList = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
if (_.isArray(dateList[0])) {
dateList = dateList[0];
}
_strung = _.map(dateList, function(oneDate) {
return oneDate.format();
});
return _strung;
};
printem = function(dateList) {
return console.log(toStrings(eList));
};
module.exports = momentous;
}).call(this);
|
module.exports = function (config) {
config.set({
basePath: './',
frameworks: ['jasmine'],
files: [
'app/**/*.spec.js',
'app/app.module.js',
'app/**/*.html'
],
reporters: ['progress'],
logLevel: config.LOG_INFO,
autoWatch: false,
browsers: ['PhantomJS'/*, 'Chrome'*/],
singleRun: true,
preprocessors: {
'app/**/*.spec.js': ['webpack', 'sourcemap'],
'app/app.module.js': ['webpack', 'sourcemap'],
'app/**/*.html': 'ng-html2js'
},
webpack: {
devtool: 'inline-source-map',
module: {
loaders: [
{
test: /\.js/,
loader: 'babel',
exclude: /node_modules/,
query: {
presets: ['es2015']
}
}
]
}
},
webpackServer: {
noInfo: true
}
});
};
|
define(['backbone', 'core/router'], function (Backbone, Router) {
describe('Router', function () {
it('→ exits', function () {
expect(new Router()).not.toBeUndefined();
});
describe('→ is passed model', function () {
it('→ exits', function () {
expect((new Router()).model).not.toBeUndefined();
});
it('→ same as passed in', function () {
var model = new Backbone.Model();
expect((new Router({model: model})).model).toBe(model);
});
});
describe('→ navigate changes model', function () {
it('→ goes to the number for page', function () {
var router = new Router();
router.slide('123');
expect(router.model.get('slide')).toBe(123);
});
});
});
});
|
//! TWIGGER - Backend - MIT Licence - Copyright (c) 2017 Mesbah Mowlavi <http://m.mowlavi.ca/>
const Sanitize = require('./sanitize')
const IS_OPTIONAL_CHAR = '~'
const IS_REQUIRED_CHAR = '*'
class APIExpect {
constructor (options) {
options = options || {}
this.defaultOptional = options.defaultOptional || false
this.validators = Object.assign({}, Validators, options.validators || {})
}
addValidator (name, validator) {
this.validators[name] = validator
}
addValidators (obj) {
for (var name in obj) {
this.validators[name] = obj[name]
}
}
compile (obj) {
var tpl = {}
for (var field in obj) {
tpl[field] = this._compileParseField(field, obj[field])
}
return tpl
}
_compileParseField (field, val) {
// Short-hand string based '~VALIDATOR:param...'
if (typeof val === 'string') {
let required
if (this.defaultOptional) {
required = val.charAt(0) === IS_REQUIRED_CHAR
if (required) val = val.substring(1)
} else {
required = val.charAt(0) !== IS_OPTIONAL_CHAR
if (!required) val = val.substring(1)
}
let parts = val.split(':')
let validator = this.validators[parts[0]]
if (!validator) throw new Error('Invalid validator name ' + parts[0])
parts[0] = required
return validator.apply(this, parts)
// Short-hand array [...]
} else if (Array.isArray(val)) {
if (typeof val[0] !== 'boolean') val.unshift(!this.defaultOptional)
val[1] = this._compileParseField(field, val[1])
return this.validators.array.apply(this, val)
// Object-form { 'VALIDATOR': [isRequired, param...] }
} else if (typeof val === 'object') {
let vname = Object.keys(val)[0]
if (!vname) throw new Error('No validator found for field ' + field)
let validator = this.validators[vname]
if (!validator) throw new Error('Invalid validator name ' + vname)
// Params should always be arrays, but can be skipped for the object validator
let params = val[vname]
if (!Array.isArray(params)) {
if (vname === 'object') params = [!this.defaultOptional, params]
else throw new Error('Parameters for field ' + field + ' must be an array.')
}
// First parameter is always 'isRequired'; insert the default if not included
if (typeof params[0] !== 'boolean') params.unshift(!this.defaultOptional)
// Recursive compiling for array (need 1 validator) and object (needs complete template)
if (vname === 'array') params[1] = this._compileParseField(params[1])
if (vname === 'object') params[1] = this.compile(params[1])
return validator.apply(this, params)
// Some other maddness
} else {
throw new Error('Invalid expect field ' + field + ': ' + val)
}
}
exec (tpl, data, opts) {
data = data || {}
opts = opts || {}
var promises = []
// Compile list of promises from validators
for (var field in tpl) {
promises.push(tpl[field](data[field], field))
}
// Wait for all promises to complete, then return results
return Promise.all(promises).then((results) => {
var output = {}
var error = false
var messages = []
var failedFields = []
for (var i = 0; i < results.length; i++) {
let result = results[i]
if (result.e) {
// IgnoreUndefined Mode (ignore errors from undefined fields)
if (opts.ignoreUndefined && data[result.f] === undefined) {
continue
}
error = true
if (result.msgs) messages.push(...result.msgs)
else messages.push(result.msg)
failedFields.push(result.f)
}
if (result.v === undefined) continue
if (result.fields) {
for (var j = 0; j < result.fields.length; j++) {
let newField = result.fields[j]
if (result.v[newField] === undefined) continue
output[newField] = result.v[newField]
}
} else {
output[result.f] = result.v
}
}
return { output, error, messages, failedFields }
})
}
middleware (template, source, options) {
options = options || {}
var dest = options.inPlace ? source : options.destination || options.dest || 'data'
source = source || 'body'
template = options.skipCompile ? template : this.compile(template)
var _this = this
return (req, res, next) => {
_this.exec(template, req[source] || {}, options)
.then((result) => {
// On validation error, return 400 status
if (result.error) {
return next({ error: result.messages.join(' '), fields: result.failedFields, status: 400 })
}
// Proceed to next middleware
var rd = (req[dest] = req[dest] || {})
for (var f in result.output) {
rd[f] = result.output[f]
}
return next()
})
.catch((err) => {
console.error(err)
next(err)
})
}
}
body (template, options) { return this.middleware(template, 'body', options) }
query (template, options) { return this.middleware(template, 'query', options) }
params (template, options) { return this.middleware(template, 'params', options) }
}
var Validators = {}
Validators.object = function (req, tpl) {
return (v, f) => {
return this.exec(tpl, v).then((result) => {
return { v: result.error ? null : result.output, e: req && result.error, f, msgs: result.messages }
})
}
}
Validators.array = function (req, validator, min, max) {
min = min || 0
max = max || Infinity
return (v, f) => {
if (!Array.isArray(v)) return { v: req ? null : [], e: req, f, msg: 'The ' + f + ' must be an array.' }
if (v.length < min || v.length > max) return { v: req ? null : [], e: req, f, msg: 'The ' + f + ' must have between ' + min + ' and ' + max + ' values.' }
var promises = []
for (var i = 0; i < v.length; i++) {
promises.push(validator(v[i], f))
}
return Promise.all(promises).then((results) => {
var output = []
var fields = null
var error = false
var messages = []
// The validator must never switch between mulit-field and single-field results
if (results[0].fields) {
output = {}
fields = results[0].fields
}
for (var i = 0; i < results.length; i++) {
var result = results[i]
if (result.e) {
error = true
messages.push(result.msg)
}
if (result.v === undefined) continue
if (fields) {
for (var j = 0; j < fields.length; j++) {
let newField = fields[j]
if (result.v[newField] === undefined) continue
output[newField] = output[newField] || []
output[newField].push(result.v[newField])
}
} else {
output.push(result.v)
}
}
error = req && error
return { v: error ? [] : output, e: error, f, fields, msgs: messages }
})
}
}
const STRING_MIN_LENGTH = 1
const STRING_MAX_LENGTH = Infinity
Validators.string = function (req, min, max, def) {
min = Number(min) || STRING_MIN_LENGTH
max = Number(max) || STRING_MAX_LENGTH
var msg = 'must be between ' + min + (max !== Infinity ? ' ' + max : '') + ' characters long.'
return (v, f) => {
v = Sanitize.plainText(v)
var err = v.length < min || v.length > max
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + msg
}
}
}
Validators.plaintext = Validators.string
Validators.html = function (req, min, max, def) {
min = Number(min) || STRING_MIN_LENGTH
max = Number(max) || STRING_MAX_LENGTH
return (v, f) => {
v = Sanitize.html(v)
var err = v.length < min || v.length > max
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + ' must be between ' + min + ' and ' + max + ' characters long.'
}
}
}
const EMAIL_REGEX = /^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/
Validators.email = function (req, def) {
return (v, f) => {
v = String(v)
var err = EMAIL_REGEX.exec(v) == null
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + ' must be between a valid email address.'
}
}
}
const URI_REGEX = /^(http:\/\/|https:\/\/)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,63}\b([-a-zA-Z0-9@:%_ \+.~#?&//=]*)$/g
Validators.uri = function (req, def) {
return (v, f) => {
v = String(v)
var err = URI_REGEX.exec(v) == null
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + ' must be between a valid URI.'
}
}
}
Validators.url = Validators.uri
Validators.bool = function (req, def) {
if (def === 'true') def = true
if (def === 'false') def = false
if (typeof def !== 'boolean') def = undefined
return (v, f) => {
var err = false
if (typeof v !== 'boolean') {
if (v === 'true') v = true
else if (v === 'false') v = false
else if (v === 0 || v === 1) v = Boolean(v)
else err = true
}
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + ' must be a valid boolean.'
}
}
}
Validators.boolean = Validators.bool
Validators.number = function (req, min, max, def) {
min = Number(min)
max = Number(max)
def = Number(def)
if (isNaN(min)) min = -Infinity
if (isNaN(max)) max = Infinity
if (isNaN(def)) def = undefined
if (min >= max) throw new Error('Invalid number validator parameters. Min (' + min + ') must be smaller than max (' + max + ')')
var msg = ' must be a number between ' + min + ' and ' + max + '.'
return (v, f) => {
v = Number(v)
var err = isNaN(v) || (min != null && v < min) || (max != null && v > max)
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + msg
}
}
}
Validators.index = function (req, array, min, def) {
if (!array) throw new Error('Array for index validator must be defined.')
return Validators.number(req, min == null ? 0 : min, array.length - 1, def)
}
Validators.date = function (req, min, max, def) {
if ((min != null && isNaN(min)) || (max != null && isNaN(max))) throw new Error('Invalid values for min and max in date validator.')
var msg = ' must be a valid date'
if (min) {
msg += ' before ' + min.toString()
min = min.getTime()
}
if (max) {
msg += (min ? ' and' : '') + ' after ' + max.toString()
max = max.getTime()
}
msg += '.'
return (v, f) => {
v = new Date(v)
var err = isNaN(v.getTime()) || (min != null && v.getTime() < min) || (max != null && v.getTime() > max)
return {
v: !err ? v : def,
e: req && err,
f,
msg: 'The ' + f + msg
}
}
}
module.exports = APIExpect
|
!function(e){"use strict";e.fn.select2.locales.ro={formatNoMatches:function(){return"Nu a fost g\u0103sit nimic"},formatInputTooShort:function(e,t){var n=t-e.length;return"V\u0103 rug\u0103m s\u0103 introduce\u021bi inc\u0103 "+n+" caracter"+(1==n?"":"e")},formatInputTooLong:function(e,t){var n=e.length-t;return"V\u0103 rug\u0103m s\u0103 introduce\u021bi mai pu\u021bin de "+n+" caracter"+(1==n?"":"e")},formatSelectionTooBig:function(e){return"Ave\u021bi voie s\u0103 selecta\u021bi cel mult "+e+" element"+(1==e?"":"e")},formatLoadMore:function(){return"Se \xeencarc\u0103\u2026"},formatSearching:function(){return"C\u0103utare\u2026"}},e.extend(e.fn.select2.defaults,e.fn.select2.locales.ro)}(jQuery); |
/**
* @ngdoc service
* @name patternfly.notification.Notification
* @requires $rootScope
*
* @description
* Notification service used to notify user about important events in the application.
*
* ## Configuring the service
*
* You can configure the service with: setDelay, setVerbose and setPersist.
*
* ### Notifications.setDelay
* Set the delay after which the notification is dismissed. The argument of this method expects miliseconds. Default
* delay is 5000 ms.
*
* ### Notifications.setVerbose
* Set the verbose mode to on (default) or off. During the verbose mode, each notification is printed in the console,
* too. This is done using the default angular.js $log service.
*
* ### Notifications.setPersist
* Sets persist option for particular modes. Notification with persistent mode won't be dismissed after delay, but has
* to be closed manually with the close button. By default, the "error" and "httpError" modes are set to persistent.
* The input is an object in format {mode: persistValue}.
*
* ## Configuration Example
* ```js
* angular.module('myApp', []).config(function (NotificationsProvider) {
* NotificationsProvider.setDelay(10000).setVerbose(false).setPersist({'error': true, 'httpError': true, 'warn': true});
* });
* ```
* @example
<example module="patternfly.notification">
<file name="index.html">
<div ng-controller="NotificationDemoCtrl">
<pf-notification-list></pf-notification-list>
<form class="form-horizontal">
<div class="form-group">
<label class="col-sm-2 control-label" for="message">Message:</label>
<div class="col-sm-10">
<input type="text" class="form-control" ng-model="message" id="message"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label" for="type">Type:</label>
<div class="col-sm-10">
<div class="btn-group" uib-dropdown>
<button type="button" uib-dropdown-toggle class="btn btn-default">
{{type}}
<span class="caret"></span>
</button>
<ul uib-dropdown-menu class="dropdown-menu-right" role="menu">
<li ng-repeat="item in types" ng-class="{'selected': item === type}">
<a role="menuitem" tabindex="-1" ng-click="updateType(item)">
{{item}}
</a>
</li>
</ul>
</div>
</div>
</div>
<div class="form-group">
<div class="col-sm-12">
<button ng-click="notify()">Add notification</button>
</div>
</div>
</form>
</div>
</file>
<file name="script.js">
angular.module( 'patternfly.notification' ).controller( 'NotificationDemoCtrl', function( $scope, Notifications ) {
var typeMap = { 'Info': Notifications.info,
'Success': Notifications.success,
'Warning': Notifications.warn,
'Danger': Notifications.error };
$scope.types = Object.keys(typeMap);
$scope.type = $scope.types[0];
$scope.updateType = function(item) {
$scope.type = item;
};
$scope.message = 'Default notification message.';
$scope.notify = function () {
typeMap[$scope.type]($scope.message);
}
});
</file>
</example>
*/
angular.module('patternfly.notification').provider('Notifications', function () {
'use strict';
// time (in ms) the notifications are shown
this.delay = 8000;
this.verbose = true;
this.notifications = {};
this.notifications.data = [];
this.persist = {'error': true, 'httpError': true};
this.setDelay = function (delay) {
this.delay = delay;
return this;
};
this.setVerbose = function (verbose) {
this.verbose = verbose;
return this;
};
this.setPersist = function (persist) {
this.persist = persist;
};
this.$get = ['$timeout', '$log', function ($timeout, $log) {
var delay = this.delay;
var notifications = this.notifications;
var verbose = this.verbose;
var persist = this.persist;
var modes = {
info: { type: 'info', header: 'Info!', log: 'info'},
success: { type: 'success', header: 'Success!', log: 'info'},
error: { type: 'danger', header: 'Error!', log: 'error'},
warn: { type: 'warning', header: 'Warning!', log: 'warn'}
};
if (!notifications) {
notifications.data = [];
}
notifications.message = function (type, header, message, isPersistent, closeCallback, actionTitle, actionCallback, menuActions) {
var notification = {
type : type,
header: header,
message : message,
isPersistent: isPersistent,
closeCallback: closeCallback,
actionTitle: actionTitle,
actionCallback: actionCallback,
menuActions: menuActions
};
notification.show = true;
notifications.data.push(notification);
if (!notification.isPersistent) {
notification.viewing = false;
$timeout(function () {
notification.show = false;
if (!notification.viewing) {
notifications.remove(notification);
}
}, delay);
}
};
function createNotifyMethod (mode) {
return function (message, header, persistent, closeCallback, actionTitle, actionCallback, menuActions) {
if (angular.isUndefined(header)) {
header = modes[mode].header;
}
if (angular.isUndefined(persistent)) {
persistent = persist[mode];
}
notifications.message(modes[mode].type, header, message, persistent, closeCallback, actionTitle, actionCallback, menuActions);
if (verbose) {
$log[modes[mode].log](message);
}
};
}
angular.forEach(modes, function (mode, index) {
notifications[index] = createNotifyMethod(index);
});
notifications.httpError = function (message, httpResponse) {
message += ' (' + (httpResponse.data.message || httpResponse.data.cause || httpResponse.data.cause || httpResponse.data.errorMessage) + ')';
notifications.message('danger', 'Error!', message, persist.httpError);
if (verbose) {
$log.error(message);
}
};
notifications.remove = function (notification) {
var index = notifications.data.indexOf(notification);
if (index !== -1) {
notifications.removeIndex(index);
}
};
notifications.removeIndex = function (index) {
//notifications.remove(index);
notifications.data.splice(index, 1);
};
notifications.setViewing = function (notification, viewing) {
notification.viewing = viewing;
if (!viewing && !notification.show) {
notifications.remove(notification);
}
};
return notifications;
}];
});
/**
* @ngdoc directive
* @name patternfly.notification.directive:pfNotificationList
* @restrict E
*
* @description
* Using this component automatically creates a list of notifications generated by the {@link api/patternfly.notification.Notification notification} service.
*
* @example
<example module="patternfly.notification">
<file name="index.html">
<div ng-controller="NotificationDemoCtrl">
<pf-notification-list></pf-notification-list>
<form class="form-horizontal">
<div class="form-group">
<label class="col-sm-2 control-label" for="type">Type:</label>
<div class="col-sm-10">
<div class="btn-group" uib-dropdown>
<button type="button" uib-dropdown-toggle class="btn btn-default">
{{type}}
<span class="caret"></span>
</button>
<ul uib-dropdown-menu class="dropdown-menu-right" role="menu">
<li ng-repeat="item in types" ng-class="{'selected': item === type}">
<a role="menuitem" tabindex="-1" ng-click="updateType(item)">
{{item}}
</a>
</li>
</ul>
</div>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label" for="message">Message:</label>
<div class="col-sm-10">
<input type="text" class="form-control" ng-model="message" id="message"/>
</div>
</div>
<div class="form-group">
<div class="col-sm-12">
<button ng-click="notify()">Add notification - Click me several times</button>
</div>
</div>
</form>
</div>
</file>
<file name="script.js">
angular.module('patternfly.notification').controller( 'NotificationDemoCtrl', function( $scope, Notifications ) {
$scope.message = 'Default Message.';
var typeMap = { 'Info': Notifications.info,
'Success': Notifications.success,
'Warning': Notifications.warn,
'Danger': Notifications.error };
$scope.types = Object.keys(typeMap);
$scope.type = $scope.types[0];
$scope.message = 'Default notification message.';
$scope.updateType = function(item) {
$scope.type = item;
};
$scope.notify = function () {
typeMap[$scope.type]($scope.message);
}
});
</file>
</example>
*/
angular.module('patternfly.notification').component('pfNotificationList', {
templateUrl: 'notification/notification-list.html',
controller: function (Notifications) {
'use strict';
var ctrl = this;
ctrl.$onInit = function () {
ctrl.notifications = Notifications;
};
}
});
|
"use strict";
const ROUND_DURATION = 10000;
const WAIT_DURATION = 2000;
const TRIVIA_FILE = "data/trivia.json";
const TriviaManager = require("../trivia-manager");
exports.game = "trivia";
exports.aliases = ["triv"];
const Trivia = new TriviaManager(TRIVIA_FILE);
class TriviaGame extends Rooms.botGame {
constructor(room, scorecap) {
super(room);
this.scorecap = Math.abs(parseInt(scorecap) || 5);
this.gameId = "trivia";
this.gameName = "Trivia";
this.answers = [];
this.question = null;
this.answered = false;
this.round = 0;
this.onInit();
}
onInit() {
if (Trivia.isEmpty()) {
this.sendRoom("There are no trivia questions loaded. Game automatically ended.");
return this.onEnd();
}
this.sendRoom(`A new game of Trivia is starting! Use \`\`${this.room.commandCharacter[0]}join\`\` to join the game. First to ${this.scorecap} points win!`);
this.onInitRound();
}
onInitRound() {
let entry = Trivia.getQuestion();
this.question = entry.question;
this.answers = entry.answers;
this.round++;
this.answered = false;
clearTimeout(this.timer);
this.sendRoom(`Round ${this.round} | ${this.question}`);
this.timer = setTimeout(() => {
this.sendRoom(`Time's up! The correct answer${(this.answers.length > 1 ? "s are" : " is")}: ${this.answers.join(", ")}`);
this.timer = setTimeout(() => this.onInitRound(), WAIT_DURATION);
}, ROUND_DURATION);
}
onGuess(user, target) {
target = toId(target);
if (!this.answers.map(p => toId(p)).includes(target) || this.answered) return;
clearTimeout(this.timer);
this.answered = true;
if (!(user.userid in this.users)) {
this.users[user.userid] = new Rooms.botGamePlayer(user);
this.users[user.userid].points = 0;
this.userList.push(user.userid);
}
let player = this.users[user.userid];
player.points++;
this.sendRoom(`${user.name} got the right answer and has ${player.points} points!${this.answers.length > 1 ? ` Possible Answers: ${this.answers.join(", ")}` : ""}`);
if (this.scorecap <= player.points) {
this.onEnd(player);
} else {
this.timer = setTimeout(() => this.onInitRound(), WAIT_DURATION);
}
}
onEnd(winner) {
if (winner) {
this.sendRoom(`Congratulations to ${winner.name} for winning the game of Trivia!`);
Leaderboard.onWin("trivia", this.room, winner.userid, this.scorecap);
}
this.destroy();
}
getScoreBoard() {
return "Points: " + Object.keys(this.users).sort().map((u) => {
return this.users[u].name + " (" + this.users[u].points + ")";
}).join(", ");
}
}
exports.commands = {
trivia: function (target, room, user) {
if (!room || !this.can("games")) return false;
if (room.game) return this.send("There is already a game going on in this room! (" + room.game.gameName + ")");
room.game = new TriviaGame(room, target);
},
triviarepost: function (target, room, user) {
if (!room || !this.can("games") || !room.game || room.game.gameId !== "statspread") return false;
this.send(`Round ${room.game.round} | ${room.game.question}`);
},
triviaskip: function (target, room, user) {
if (!room || !this.can("games") || !room.game || room.game.gameId !== "trivia") return false;
this.send(`The correct answer${(room.game.answers.length > 1 ? "s are" : " is")}: ${room.game.answers.join(", ")}`);
room.game.onInitRound();
},
addtrivia: function (target, room, user) {
if (!user.hasBotRank("+")) return false;
let [question, answers] = target.split("|").map(p => p.trim());
if (!question || !answers) return this.send("Invalid question/answer pair.");
answers = answers.split(",").map(p => p.trim());
if (answers.some(a => !toId(a))) return this.send("All answers must have alphanumeric characters.");
if (Trivia.findQuestion(question)) return this.send("The question already exists.");
Trivia.addQuestion(question, answers).write();
this.send("Added!");
},
deletetrivia: function (target, room, user) {
if (!user.hasBotRank("%")) return false;
if (!Trivia.findQuestion(target)) return this.send("The question does not exist.");
Trivia.removeQuestion(target).write();
this.send("Deleted.");
},
trivialist: function (target, room, user) {
if (!user.hasBotRank("~")) return false;
let questions = Trivia.allQuestions();
Tools.uploadToHastebin(questions.map(q => `Question: ${q.question}\nAnswer(s): ${q.answers.join(", ")}`).join("\n\n"),
link => user.sendTo(`${questions.length} questions - ${link}`));
},
} |
var MongoClient = require('mongodb').MongoClient;
var db = null;
MongoClient.connect("mongodb://localhost:27017/voting-app", function(err, database) {
if (err) throw err;
console.log("Successfully connected to the database.");
db = database;
});
module.exports = {
getDB : function () {
if (db) {
return db;
} else {
throw ("The application is not connected to the database.")
}
}
} |
'use strict';
//Orgs service used to communicate Orgs REST endpoints
angular.module('orgs').factory('Orgs', ['$resource',
function($resource) {
return $resource('orgs/:orgId', { orgId: '@_id'
}, {
update: {
method: 'PUT'
}
});
}
]); |
let _ = require('lodash')
let missingSupport = require('./missing-support')
let Detector = require('./detect-feature-use')
function doiuse (options) {
let browserQuery = options.browsers
let onFeatureUsage = options.onFeatureUsage
if (!browserQuery) {
browserQuery = doiuse['default'].slice()
}
let cb = onFeatureUsage ? onFeatureUsage : function () {}
let {browsers, features} = missingSupport(browserQuery)
let detector = new Detector(_.keys(features))
return {
info () {
return {
browsers: browsers,
features: features
}
},
postcss (css) {
return detector.process(css, function ({feature, usage}) {
let loc = usage.source
loc.original = css.prevMap ? {
start: css.prevMap.consumer().originalPositionFor(loc.start),
end: css.prevMap.consumer().originalPositionFor(loc.end)
} : {
start: loc.start,
end: loc.end
}
let message = (loc.original.start.source || loc.input.file || loc.input.from) + ':' +
loc.original.start.line + ':' + loc.original.start.column + ': ' +
features[feature].title + ' not supported by: ' + features[feature].missing
return cb({
feature: feature,
featureData: features[feature],
usage: usage,
message: message
})
})
}
}
}
doiuse['default'] = [
'> 1%',
'last 2 versions',
'Firefox ESR',
'Opera 12.1'
]
module.exports = doiuse
|
Router.configure({
layoutTemplate: 'layout',
notFoundTemplate: 'notFound',
loadingTemplate: 'loading',
});
|
/*!
* UI development toolkit for HTML5 (OpenUI5)
* (c) Copyright 2009-2015 SAP SE or an SAP affiliate company.
* Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
*/
// Provides control sap.ui.core.HTML.
sap.ui.define(['jquery.sap.global', './Control', './RenderManager', './library'],
function(jQuery, Control, RenderManager, library) {
"use strict";
// local shortcut
var RenderPrefixes = library.RenderPrefixes;
/**
* Constructor for a new HTML.
*
* @param {string} [sId] id for the new control, generated automatically if no id is given
* @param {object} [mSettings] initial settings for the new control
*
* @class
* Embeds standard HTML in a SAPUI5 control tree.
*
* Security Hint: By default, the HTML content (property 'content') is not sanitized and therefore
* open to XSS attacks. Applications that want to show user defined input in an HTML control, should
* either sanitize the content on their own or activate automatic sanitizing through the
* {@link #setSanitizeContent sanitizeContent} property.
*
* Although this control inherits the <code>tooltip</code> aggregation/property and the
* <code>hasStyleClass</code>, <code>addStyleClass</code>, <code>removeStyleClass</code> and
* <code>toggleStyleClass</code> methods from its base class, it doesn't support them.
* Instead, the defined HTML content can contain a tooltip (title attribute) or custom CSS classes.
*
* For further hints about usage restrictions for this control, see also the documentation of the
* <code>content</code> property.
*
* @extends sap.ui.core.Control
*
* @author SAP SE
* @version 1.32.10
*
* @constructor
* @public
* @alias sap.ui.core.HTML
* @ui5-metamodel This control/element also will be described in the UI5 (legacy) designtime metamodel
*/
var HTML = Control.extend("sap.ui.core.HTML", /** @lends sap.ui.core.HTML.prototype */ { metadata : {
library : "sap.ui.core",
properties : {
/**
* HTML content to be displayed, defined as a string.
*
* The content is converted to DOM nodes with a call to <code>new jQuery(content)</code>, so any
* restrictions for the jQuery constructor apply to the content of the HTML control as well.
*
* Some of these restrictions (there might be others!) are:
* <ul>
* <li>the content must be enclosed in tags, pure text is not supported. </li>
* <li>if the content contains script tags, they will be executed but they will not appear in the
* resulting DOM tree. When the contained code tries to find the corresponding script tag,
* it will fail.</li>
* </ul>
*
* Please consider to consult the jQuery documentation as well.
*
* The HTML control currently doesn't prevent the usage of multiple root nodes in its DOM content
* (e.g. setContent("<div/><div/>")), but this is not a guaranteed feature. The accepted content
* might be restricted to single root nodes in future versions. To notify applications about this
* fact, a warning is written in the log when multiple root nodes are used.
*
* @SecSink {,XSS} The content of the 'content' property is rendered 1:1 to allow the full
* flexibility of HTML in UI5 applications. Applications therefore must ensure, that they don't
* set malicious content (e.g. derived from user input). UI5 does not provide an HTML validation
* function. jQuery.sap.encodeHTML will encode any HTML relevant character, but this is in
* nearly all cases not what applications want here.
*/
content : {type : "string", group : "Misc", defaultValue : null},
/**
* Whether existing DOM content is preferred over the given content string.
*
* There are two scenarios where this flag is relevant (when set to true):
* <ul>
* <li>for the initial rendering: when an HTML control is added to an UIArea for the first time
* and if the root node of that UIArea contained DOM content with the same id as the HTML
* control, then that content will be used for rendering instead of any specified string
* content</li>
* <li>any follow-up rendering: when an HTML control is rendered for the second or any later
* time and the preferDOM flag is set, then the DOM from the first rendering is preserved
* and not replaced by the string content</li>
* </ul>
*
* As preserving the existing DOM is the most common use case of the HTML control, the default value is true.
*/
preferDOM : {type : "boolean", group : "Misc", defaultValue : true},
/**
* Whether to run the HTML sanitizer once the content (HTML markup) is applied or not.
*
* To configure allowed URLs please use the whitelist API via jQuery.sap.addUrlWhitelist.
*/
sanitizeContent : {type : "boolean", group : "Misc", defaultValue : false},
/**
* Specifies whether the control is visible. Invisible controls are not rendered.
*/
visible : {type : "boolean", group : "Appearance", defaultValue : true}
},
events : {
/**
* Fired after the HTML control has been rendered. Allows to manipulate the resulting DOM.
*
* When the control doesn't have string content and no preserved DOM existed for this control,
* then this event will fire, but there won't be a DOM node for this control.
*/
afterRendering : {
parameters : {
/**
* Whether the current DOM of the control has been preserved (true) or not (e.g.
* rendered from content property or it is an empty HTML control).
*/
isPreservedDOM : {type : "boolean"}
}
}
}
}});
/**
* @param {string} [sSuffix=''] Suffix of the Element to be retrieved or empty
* @return {Element} The element's DOM reference or null
* @public
*/
HTML.prototype.getDomRef = function(sSuffix) {
var sId = sSuffix ? this.getId() + "-" + sSuffix : this.getId();
return jQuery.sap.domById(RenderPrefixes.Dummy + sId) || jQuery.sap.domById(sId);
};
HTML.prototype.setContent = function(sContent) {
function parseHTML(s) {
if ( jQuery.parseHTML ) {
var a = jQuery.parseHTML(s);
if ( a ) {
var start = 0, end = a.length;
while ( start < end && a[start].nodeType != 1 ) {
start++;
}
while ( start < end && a[end - 1].nodeType != 1 ) {
end--;
}
if ( start > 0 || end < a.length ) {
a = a.slice(start, end);
}
return jQuery(a);
}
}
return jQuery(s);
}
if ( this.getSanitizeContent() ) {
jQuery.sap.log.trace("sanitizing HTML content for " + this);
sContent = jQuery.sap._sanitizeHTML(sContent);
}
this.setProperty("content", sContent, true);
if ( /* sContent && */ this.getDomRef() ) {
var $newContent = parseHTML(this.getContent()); // TODO what if content is not HTML (e.g. #something)?
jQuery(this.getDomRef()).replaceWith($newContent);
this._postprocessNewContent($newContent);
} else {
this.invalidate();
}
return this;
};
HTML.prototype.setSanitizeContent = function(bSanitizeContent) {
this.setProperty("sanitizeContent", bSanitizeContent, true);
// if sanitizeContent has been enabled, set the content again to enable sanitizing on current content
if (bSanitizeContent) {
this.setContent(this.getContent());
}
return this;
};
HTML.prototype.onBeforeRendering = function() {
if (this.getPreferDOM() && this.getDomRef() && !RenderManager.isPreservedContent(this.getDomRef())) {
RenderManager.preserveContent(this.getDomRef(), /* bPreserveRoot */ true, /* bPreserveNodesWithId */ false);
}
};
/**
* If the HTML doesn't contain own content, it tries to reproduce existing content
*/
HTML.prototype.onAfterRendering = function() {
if (!this.getVisible()) {
// Just leave the placeholder there
return;
}
var $placeholder = jQuery(jQuery.sap.domById(RenderPrefixes.Dummy + this.getId()));
var $oldContent = RenderManager.findPreservedContent(this.getId());
var $newContent;
var isPreservedDOM = false;
if ( /*this.getContent() && */ (!this.getPreferDOM() || $oldContent.size() == 0) ) {
// remove old, preserved content
$oldContent.remove();
// replace placeholder with content string
$newContent = new jQuery(this.getContent()); // TODO what if content is not HTML (e.g. #something)?
$placeholder.replaceWith($newContent);
} else if ( $oldContent.size() > 0 ) {
// replace dummy with old content
$placeholder.replaceWith($oldContent);
$newContent = $oldContent;
isPreservedDOM = true;
} else {
$placeholder.remove();
}
this._postprocessNewContent($newContent);
this.fireAfterRendering({isPreservedDOM : isPreservedDOM});
};
HTML.prototype._postprocessNewContent = function($newContent) {
if ( $newContent && $newContent.size() > 0 ) {
if ( $newContent.length > 1 ) {
jQuery.sap.log.warning("[Unsupported Feature]: " + this + " has rendered " + $newContent.length + " root nodes!");
} else {
var sContentId = $newContent.attr("id");
if (sContentId && sContentId != this.getId()) {
jQuery.sap.log.warning("[Unsupported Feature]: Id of HTML Control '" + this.getId() + "' does not match with content id '" + sContentId + "'!");
}
}
// set a marker that identifies all root nodes in $newContent as 'to-be-preserved'
RenderManager.markPreservableContent($newContent, this.getId());
// and if no node has the control id, search the first without an id and set it
if ( $newContent.find("#" + this.getId().replace(/(:|\.)/g,'\\$1')).length === 0 ) {
$newContent.filter(":not([id])").first().attr("id", this.getId());
}
} else {
jQuery.sap.log.debug("" + this + " is empty after rendering, setting bOutput to false");
this.bOutput = false; // clean up internal rendering bookkeeping
}
};
/**
* Sets some new DOM content for this HTML control. The content will replace the existing content
* after the next rendering. Properties are not modified, but preferDOM should be set to true.
*
* @param {Element} oDom the new DOM content
* @return {sap.ui.core.HTML} <code>this</code> to facilitate method chaining
* @public
*/
HTML.prototype.setDOMContent = function(oDom) {
var $newContent = jQuery(oDom);
if ( this.getDomRef() ) {
jQuery(this.getDomRef()).replaceWith($newContent);
this._postprocessNewContent($newContent);
} else {
$newContent.appendTo(RenderManager.getPreserveAreaRef());
if ( this.getUIArea() ) {
this.getUIArea().invalidate();
} // TODO fix issue with Control.rerender()
this._postprocessNewContent($newContent); // CHECK is it okay to set bOutput to false for empty content?
}
return this;
};
HTML.prototype.setTooltip = function() {
jQuery.sap.log.warning("The sap.ui.core.HTML control doesn't support tooltips. Add the tooltip to the HTML content instead.");
return Control.prototype.setTooltip.apply(this, arguments);
};
jQuery.each("hasStyleClass addStyleClass removeStyleClass toggleStyleClass".split(" "), function(method) {
HTML.prototype[method] = function() {
jQuery.sap.log.warning("The sap.ui.core.HTML control doesn't support custom style classes. Manage custom CSS classes in the HTML content instead.");
return Control.prototype[method].apply(this, arguments);
};
});
return HTML;
});
|
/* eslint-disable no-undef */
import {
GraphQLObjectType,
GraphQLNonNull,
GraphQLList,
GraphQLID,
GraphQLString,
GraphQLInt
} from 'graphql';
import * as ArticleServices from './ArticleServices';
import { ArticleStatusEnum } from './ArticleEnums';
const CollectionType = new GraphQLObjectType({
name: 'Collection',
description: 'A collection of articles',
fields: () => ({
name: { type: new GraphQLNonNull(GraphQLString) },
articles: { type: new GraphQLList(ArticleType) }
})
});
const ArticleType = new GraphQLObjectType({
name: 'Article',
description: 'An article with slug, title, and body.',
fields: () => ({
id: {
type: new GraphQLNonNull(GraphQLID),
description: 'unique content item id'
},
slug: {
type: new GraphQLNonNull(GraphQLString),
description: 'unique slug'
},
title: {
type: new GraphQLNonNull(GraphQLString),
description: 'the title of the article, aka the headline'
},
body: {
type: GraphQLString,
description: 'the article\'s body'
},
status: {
type: new GraphQLNonNull(ArticleStatusEnum),
description: 'the current status of the article, live, working, deleted'
},
relatedArticles: {
type: new GraphQLList(ArticleType),
description: 'articles marked as related to this article (with optional limit)',
args: { limit: { type: GraphQLInt } },
resolve: (article, { limit }) => { return ArticleServices.getMultipleById(article.relatedArticleIds, limit); }
}
// inCollections: {
// type: new GraphQLList(CollectionType),
// description: 'the collections that contain this article'
// resolve: (article) => {
// ArticleServices.
// }
// }
})
});
export default {
ArticleType: ArticleType,
CollectionType: CollectionType
};
/* eslint-enable */
|
import { Meteor } from 'meteor/meteor';
import { Template } from 'meteor/templating';
import { Session } from 'meteor/session';
import { Tracker } from 'meteor/tracker';
import _ from 'underscore';
import Tables from '/imports/collections/tables';
import {
addUserMessage,
createErrorDiv,
initDraggables,
activateInput,
updateValues,
toggleRowVisibilty,
getHTMLTitleBase,
} from '/imports/api/client/utilities';
import {
newValues,
} from '/imports/api/utilities';
import {
appFlavor,
} from '/imports/utilities';
Session.setDefault('showActiveTablesOnly', true);
Template.home.onCreated(function() {
document.title = getHTMLTitleBase();
Session.set('tablesShowNew', false);
Session.set('tablesEditingId', null);
Session.set('reorderRows', false);
});
Template.home.onDestroyed(function() {
Session.set('tablesShowNew', false);
Session.set('tablesEditingId', null);
Session.set('reorderRows', false);
});
Template.notLoggedIn.helpers({
appFlavor: function() {
return appFlavor();
},
});
Template.tableOpts.events({
'click #tables-show-create': function(evt, tmpl) {
Session.set('tablesShowNew', true);
Tracker.flush();
},
'click #reorderRows': function(evt, tmpl) {
var isReorder = !Session.get('reorderRows');
Session.set('reorderRows', isReorder);
if (isReorder) {
tmpl.sortables = _.map($('.sortables'), function(v){
return initDraggables(v, '.moveTableHandle', Tables);
});
} else {
tmpl.sortables.forEach(function(v) { return v.destroy();});
}
toggleRowVisibilty(isReorder, $('.moveTableHandle'));
},
});
Template.volumesList.helpers({
getMonographs: function() {
let query = {},
opts = {fields: {'volumeNumber': 1}, sort: {'volumeNumber': -1}};
if(Session.get('showActiveTablesOnly')){
query.activeTable = true;
}
return _.chain(Tables.find(query, opts).fetch())
.pluck('volumeNumber')
.uniq()
.value();
},
getMonographAgents: function(volumeNumber){
let query = {volumeNumber: volumeNumber};
if(Session.get('showActiveTablesOnly')){
query.activeTable = true;
}
return _.chain(Tables.find(query).fetch())
.pluck('monographAgent')
.sort()
.uniq(true)
.value()
.join(', ');
},
showNew: function() {
return Session.get('tablesShowNew');
},
});
Template.volumeTableList.onCreated(function() {
document.title = `Volume ${this.data.volumeNumber} | ${getHTMLTitleBase()}`;
});
Template.volumeTableList.helpers({
getMonographAgents: function() {
let query = {volumeNumber: this.volumeNumber},
opts = {sort: {'monographAgent': 1}};
if(Session.get('showActiveTablesOnly')){
query.activeTable = true;
}
var tbls = Tables.find(query, opts).fetch();
return _.chain(tbls)
.pluck('monographAgent')
.uniq()
.value();
},
getTables: function(volumeNumber, monographAgent) {
let query = {
volumeNumber,
monographAgent,
};
if(Session.get('showActiveTablesOnly')){
query.activeTable = true;
}
return Tables.find(query, {sort: {'sortIdx': 1}}).fetch();
},
showNew: function() {
return Session.get('tablesShowNew');
},
isEditing: function() {
return Session.equals('tablesEditingId', this._id);
},
});
Template.tableItem.helpers({
getStatusColorClass: function(tbl) {
return tbl.getStatusColorClass();
},
getActiveTableClass: function(){
return (this.activeTable)? '': 'hiddenRow';
},
});
Template.tableItem.events({
'click #tables-show-edit': function(evt, tmpl) {
Session.set('tablesEditingId', this._id);
Tracker.flush();
},
'click #clone': function(evt, tmpl){
return Meteor.call('cloneTable', this._id, function(err, response) {
let msg;
if (err) {
console.error(err);
msg = `<b>Table clone failed:</b> ${err.reason}`;
addUserMessage(msg, 'danger');
} else {
msg = `Table "${tmpl.data.name}" successfully cloned!`;
addUserMessage(msg, 'success');
}
});
},
});
var getUserPermissionsObject = function(tmpl) {
var ids = {},
results = [],
user_id;
['projectManagers', 'teamMembers', 'reviewers'].forEach(function(role){
tmpl.findAll('.' + role + ' li').forEach(function(li){
user_id = $(li).data('user_id');
if (ids[user_id] === undefined){
results.push({'user_id': user_id, 'role': role});
ids[user_id] = true;
}
});
});
return results;
};
Template.tablesForm.helpers({
getTblTypeOptions: function() {
return Tables.typeOptions;
},
getStatusOptions: function() {
return _.keys(Tables.statusOptions);
},
getDeleteIcon: function(){
return (this.activeTable)? 'fa-trash': 'fa-undo';
},
});
Template.tablesForm.events({
'click #tables-create': function(evt, tmpl) {
var errorDiv, isValid, obj;
obj = newValues(tmpl.find('#tablesForm'));
obj['activeTable'] = true;
obj['user_roles'] = getUserPermissionsObject(tmpl);
delete obj['projectManagers'];
delete obj['teamMembers'];
delete obj['reviewers'];
isValid = Tables.simpleSchema()
.namedContext()
.validate(obj);
if (isValid) {
Tables.insert(obj);
return Session.set('tablesShowNew', false);
} else {
errorDiv = createErrorDiv(Tables.simpleSchema().namedContext());
return $(tmpl.find('#errors')).html(errorDiv);
}
},
'click #tables-create-cancel': function(evt, tmpl) {
return Session.set('tablesShowNew', false);
},
'click #tables-update': function(evt, tmpl) {
var errorDiv, isValid, modifier, vals;
vals = updateValues(tmpl.find('#tablesForm'), this);
vals['user_roles'] = getUserPermissionsObject(tmpl);
delete vals['projectManagers'];
delete vals['teamMembers'];
delete vals['reviewers'];
modifier = {$set: vals};
isValid = Tables.simpleSchema()
.namedContext()
.validate(modifier, {modifier: true});
if (isValid) {
Tables.update(this._id, modifier);
return Session.set('tablesEditingId', null);
} else {
errorDiv = createErrorDiv(Tables.simpleSchema().namedContext());
return $(tmpl.find('#errors')).html(errorDiv);
}
},
'click #tables-update-cancel': function(evt, tmpl) {
return Session.set('tablesEditingId', null);
},
'click #tables-delete': function(evt, tmpl) {
let modifier = {$set: {activeTable: !this.activeTable}};
Tables.update(this._id, modifier);
return Session.set('tablesEditingId', null);
},
});
Template.tablesForm.onRendered(function() {
activateInput(this.find('input[name=volumeNumber]'));
});
|
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
/**
* Created by twi18192 on 26/08/15.
*/
/**
* Created by twi18192 on 25/08/15.
*/
var React = require('react');
var ReactPanels = require('react-panels');
var Panel = ReactPanels.Panel;
var Tab = ReactPanels.Tab;
var Toolbar = ReactPanels.Toolbar;
var Content = ReactPanels.Content;
var Footer = ReactPanels.Content;
var ToggleButton = ReactPanels.ToggleButton;
var Button = ReactPanels.Button;
var MainPane = React.createClass({displayName: "MainPane",
render: function() {
return(
React.createElement("div", null, React.createElement(Panel, {theme: "flexbox", useAvailableHeight: true, buttons: [
React.createElement(ToggleButton, {title: "Toggle Footer", onChange: this.handleFooterToggle},
React.createElement("i", {className: "fa fa-wrench"})
)
]},
React.createElement(Tab, {title: "View"},
React.createElement(Content, null, "Content of View Tab",
React.createElement("div", {id: "resize"}, React.createElement("img", {src: "http://www.devbattles.com/en/images/upload/1427973218.png"}))
),
React.createElement(Footer, null, React.createElement("div", {id: "blockDock"},
React.createElement("div", {id: "buttonContainer"}
)))
),
React.createElement(Tab, {title: "Design", icon: "fa fa-fire"},
React.createElement(Content, null, React.createElement("div", {id: "mainTabContent"}, "Secondary main view - graph of position data ", React.createElement("br", null),
"Contains a graph of the current position data, also has some buttons at the bottom to launch subscreens"
)),
React.createElement(Footer, null, React.createElement("div", {id: "blockDock"},
React.createElement("div", {id: "buttonContainer"}
)
))
)
))
)
}
});
React.render(React.createElement(MainPane, null),
document.getElementById('mainPaneContainer'));
},{"react":176,"react-panels":3}],2:[function(require,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) {
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');
};
// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
},{}],3:[function(require,module,exports){
/*
* react-panels
* https://github.com/Theadd/react-panels
*
* Copyright (c) 2015 R.Beltran https://github.com/Theadd
* Licensed under the MIT license.
*/
var React = require('react/addons');
var flexbox2Skin = function (skin) {
switch (skin || "") {
default:
return {
tabColor: "#b0b0b0",
tabIconColor: "#b0b0b0",
activeTabColor: "#daaf64",
tabTextShadow: "#000000",
activeTabTextShadow: "#000000",
titleTextShadow: "#a6a6a6",
iconTextShadow: "#000000",
iconColor: "#daaf64",
titleColor: "#daaf64",
buttonBackgroundColor: "rgba(104, 226, 207, 0.15)",
hoverButtonBackgroundColor: "rgba(104, 226, 207, 0.3)",
activeButtonBackgroundColor: "rgba(131, 247, 220, 0.33)",
buttonColor: "#eaeaea",
hoverButtonColor: "#ffffff",
activeButtonColor: "#daaf64",
buttonTextShadow: "#7F7F7F",
highlightedButtonBoxShadow: "rgba(255, 255, 255, 0.6)",
tabBackgroundColor: "rgba(104, 226, 207, 0.15)",
activeTabBackgroundColor: "rgba(131, 247, 220, 0.33)",
hoverTabBackgroundColor: "rgba(104, 226, 207, 0.3)",
toolbarBackgroundColor: "rgba(171, 255, 220, 0.2)",
contentBackgroundColor: "rgba(171, 255, 220, 0.34)",
footerBackgroundColor: "rgba(171, 255, 220, 0.2)",
borderColor: "#000000"
};
}
}
var flexbox2Style = function (_opts, skin) {
var colors,
opts = React.addons.update({
skin: "default",
renderPanelBorder: true,
activeTabHeaderBorder: true
}, {$merge: _opts}),
isSafari = /Safari/.test(window.navigator.userAgent) && /Apple Computer/.test(window.navigator.vendor);
skin = skin || opts.skin;
if (typeof skin === "object") {
colors = React.addons.update(flexbox2Skin(), {$merge: skin});
} else {
colors = flexbox2Skin(skin);
}
return {
PanelWrapper: {
config: {
autocompact: false
}
},
Panel: {
style: {
borderTop: (opts.renderPanelBorder) ? "1px solid " + colors.borderColor : "0 none",
borderRight: (opts.renderPanelBorder) ? "1px solid " + colors.borderColor : "0 none"
},
header: {
style: {
backgroundColor: "transparent",
display: isSafari ? "-webkit-flex" : "flex",
minWidth: "100%",
marginBottom: "-2px"
}
},
tabsStart: {
style: {
width: 0
}
},
tabsEnd: {
style: {
width: 0
}
},
tabs: {
style: {
float: "none",
WebkitFlex: "1",
flex: 1,
display: isSafari ? "-webkit-flex" : "flex",
overflow: "hidden"
}
},
icon: {
style: {
color: colors.iconColor,
textShadow: "2px 2px 2px " + colors.iconTextShadow,
float: "left"
}
},
box: {
style: {
float: "left"
}
},
title: {
style: {
color: colors.titleColor,
textShadow: "1px 1px 1px " + colors.titleTextShadow
}
},
group: {
style: {
padding: 0,
display: "inline-block",
height: "100%",
margin: 0
}
},
body: {
style: {
borderLeft: (opts.renderPanelBorder) ? "1px solid " + colors.borderColor : "0 none",
height: "calc(100% - " + Utils.pixelsOf(opts.headerHeight - 2) + ")"
}
}
},
TabButton: {
style: {
borderBottom: "1px solid " + colors.borderColor,
borderRight: "1px solid " + colors.borderColor,
backgroundColor: colors.tabBackgroundColor,
height: opts.headerHeight - 1,
margin: "0",
position: "inherit",
float: "none",
overflow: "hidden",
WebkitFlex: "1",
flex: "1 0 0px",
opacity: 1
},
state: {
hover: {
style: {
backgroundColor: colors.hoverTabBackgroundColor
}
}
},
mods: {
active: {
style: {
borderBottom: "1px solid " + (opts.activeTabHeaderBorder ? colors.borderColor : colors.activeTabBackgroundColor),
backgroundColor: colors.activeTabBackgroundColor
},
state: {
hover: {
style: {
borderBottom: "1px solid " + (opts.activeTabHeaderBorder ? colors.borderColor : colors.activeTabBackgroundColor),
backgroundColor: colors.activeTabBackgroundColor
},
icon: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
title: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
}
}
},
icon: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
title: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
}
},
last: {
style: {
borderRight: "0 none"
}
}
},
icon: {
style: {
color: colors.tabIconColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow,
opacity: 1
}
},
title: {
style: {
color: colors.tabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
box: {
style: {
marginRight: 0,
maxWidth: "calc(100% - " + Utils.pixelsOf(opts.headerHeight) + ")",
opacity: 1
}
}
},
Tab: {
toolbar: {
style: {
minHeight: 0,
lineHeight: "inherit",
padding: "0",
display: "block",
position: "relative",
marginTop: "1px"
},
children: {
style: {
padding: "10px",
lineHeight: Utils.pixelsOf(opts.headerHeight),
position: "relative",
backgroundColor: colors.toolbarBackgroundColor
}
}
},
content: {
style: {
backgroundColor: colors.contentBackgroundColor,
boxShadow: "0px 0px 29px rgba(0, 0, 0, 0.7) inset",
borderTop: "1px solid " + colors.borderColor,
position: "relative"
},
children: {
style: {
position: "relative"
}
}
},
footer: {
style: {
backgroundColor: colors.footerBackgroundColor,
borderTop: "1px solid " + colors.borderColor,
position: "relative"
},
children: {
style: {
position: "relative"
}
}
}
},
Button: {
style: {
height: Utils.pixelsOf(opts.headerHeight - 1),
backgroundColor: colors.buttonBackgroundColor,
borderBottom: "1px solid " + colors.borderColor,
borderLeft: "1px solid " + colors.borderColor
},
children: {
style: {
color: colors.buttonColor,
textShadow: "1px 1px 1px " + colors.buttonTextShadow
}
},
state: {
hover: {
style: {
backgroundColor: colors.hoverButtonBackgroundColor
},
children: {
style: {
color: colors.hoverButtonColor
}
}
}
},
mods: {
active: {
style: {
backgroundColor: colors.activeButtonBackgroundColor
},
children: {
style: {
color: colors.activeButtonColor
}
}
},
highlighted: {
style: {
boxShadow: "0 0 9px " + colors.highlightedButtonBoxShadow + " inset"
}
},
disabled: {
style: {
pointerEvents: "none",
opacity: 0.5
}
}
}
}
};
};
var flexboxStyle = function (opts, skin) {
var colors,
isSafari = /Safari/.test(window.navigator.userAgent) && /Apple Computer/.test(window.navigator.vendor);
skin = skin || opts.skin;
switch (skin) {
case "fiery":
colors = {
tabColor: "#b0b0b0",
tabIconColor: "#616161",
activeTabColor: "#f72121",
tabTextShadow: "#000000",
activeTabTextShadow: "#000000",
titleTextShadow: "#a6a6a6",
iconTextShadow: "#000000",
iconColor: "#ffffff",
titleColor: "#ffffff",
buttonBackgroundColor: "#202020",
hoverButtonBackgroundColor: "#342828",
activeButtonBackgroundColor: "#4d2c2c",
buttonColor: "#eaeaea",
hoverButtonColor: "#ffffff",
activeButtonColor: "#f72121",
buttonTextShadow: "#7F7F7F",
tabBackgroundColor: "#202020",
activeTabBackgroundColor: "#2e2e2e",
hoverTabBackgroundColor: "#342828",
toolbarBackgroundColor: "#4d2c2c",
contentBackgroundColor: "#3e3e3e",
footerBackgroundColor: "#4e4e4e"
};
break;
default:
colors = {
tabColor: "#b0b0b0",
tabIconColor: "#616161",
activeTabColor: "#ffffff",
tabTextShadow: "#000000",
activeTabTextShadow: "#7F7F7F",
titleTextShadow: "#a6a6a6",
iconTextShadow: "#a6a6a6",
iconColor: "#ffffff",
titleColor: "#ffffff",
buttonBackgroundColor: "#202020",
hoverButtonBackgroundColor: "#2a2a2a",
activeButtonBackgroundColor: "#4e4e4e",
buttonColor: "#eaeaea",
hoverButtonColor: "#ffffff",
activeButtonColor: "#ffffff",
buttonTextShadow: "#7F7F7F",
tabBackgroundColor: "#202020",
activeTabBackgroundColor: "#2e2e2e",
hoverTabBackgroundColor: "#2a2a2a",
toolbarBackgroundColor: "#4e4e4e",
contentBackgroundColor: "#3e3e3e",
footerBackgroundColor: "#4e4e4e"
};
break;
}
return {
PanelWrapper: {
config: {
autocompact: false
}
},
Panel: {
style: {
backgroundColor: "black",
padding: "1px 1px 0 0"
},
header: {
style: {
backgroundColor: "transparent",
display: isSafari ? "-webkit-flex" : "flex",
minWidth: "100%"
}
},
tabsStart: {
style: {
width: 0
}
},
tabsEnd: {
style: {
width: 0
}
},
tabs: {
style: {
float: "none",
WebkitFlex: "1",
flex: 1,
display: isSafari ? "-webkit-flex" : "flex",
overflow: "hidden"
}
},
icon: {
style: {
color: colors.iconColor,
textShadow: "2px 2px 2px " + colors.iconTextShadow,
float: "left"
}
},
box: {
style: {
float: "left"
}
},
title: {
style: {
color: colors.titleColor,
textShadow: "1px 1px 1px " + colors.titleTextShadow
}
},
group: {
style: {
padding: 0,
display: "inline-block",
height: "100%",
margin: 0
}
},
body: {
style: {
marginLeft: "1px"
}
}
},
TabButton: {
style: {
backgroundColor: colors.tabBackgroundColor,
height: opts.headerHeight - 1,
margin: "0 0 1px 1px",
position: "inherit",
float: "none",
overflow: "hidden",
WebkitFlex: "1",
flex: "1 0 0px"
},
state: {
hover: {
style: {
backgroundColor: colors.hoverTabBackgroundColor
}
}
},
mods: {
active: {
style: {
backgroundColor: colors.activeTabBackgroundColor
},
state: {
hover: {
style: {
backgroundColor: colors.activeTabBackgroundColor
},
icon: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
title: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
}
}
},
icon: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
title: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
}
}
},
icon: {
style: {
color: colors.tabIconColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
title: {
style: {
color: colors.tabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
box: {
style: {
marginRight: 0,
maxWidth: "calc(100% - " + Utils.pixelsOf(opts.headerHeight) + ")"
}
}
},
Tab: {
toolbar: {
style: {
minHeight: 0,
lineHeight: "inherit",
padding: "0",
display: "block",
position: "relative",
top: "-1px"
},
children: {
style: {
padding: "10px",
lineHeight: Utils.pixelsOf(opts.headerHeight),
position: "relative",
marginTop: "1px",
backgroundColor: colors.toolbarBackgroundColor
}
}
},
content: {
style: {
backgroundColor: colors.contentBackgroundColor,
marginBottom: "1px"
}
},
footer: {
style: {
backgroundColor: colors.footerBackgroundColor,
marginBottom: "1px"
}
}
},
Button: {
style: {
height: Utils.pixelsOf(opts.headerHeight - 1),
backgroundColor: colors.buttonBackgroundColor,
marginLeft: "1px"
},
children: {
style: {
color: colors.buttonColor,
textShadow: "1px 1px 1px " + colors.buttonTextShadow
}
},
state: {
hover: {
style: {
backgroundColor: colors.hoverButtonBackgroundColor
},
children: {
style: {
color: colors.hoverButtonColor
}
}
}
},
mods: {
active: {
style: {
backgroundColor: colors.activeButtonBackgroundColor
},
children: {
style: {
color: colors.activeButtonColor
}
}
}
}
}
};
};
var chemicalStyle = function (opts, skin) {
var colors;
skin = skin || opts.skin;
switch (skin) {
case "blueish":
colors = {
tabColor: "rgba(0, 0, 0, 0.8)",
activeTabColor: "rgba(0, 0, 0, 0.9)",
tabTextShadow: "#bbbbbb",
activeTabTextShadow: "#999999",
activeTabBackgroundColor: "rgba(102, 143, 182, 0.25)",
activeTabBorderColor: "rgba(0, 0, 0, 0.5)",
titleTextShadow: "#a6a6a6",
iconTextShadow: "rgba(0, 0, 0, 0.9)",
iconColor: "rgba(0, 0, 0, 0.8)",
titleColor: "rgba(0, 0, 0, 0.8)",
toolbarBoxShadow: "rgba(0, 0, 0, 0.1)",
contentBackgroundColorWithToolbar: "rgba(102, 143, 182, 0.25)",
footerBackgroundColor: "rgba(165, 165, 165, 0.32)",
hoverTabBackgroundColor: "rgba(224, 230, 240, 0.65)",
buttonBackgroundColor: "rgba(224, 230, 240, 0.65)",
hoverButtonBackgroundColor: "rgba(102, 143, 182, 0.25)",
activeButtonBackgroundColor: "rgba(102, 143, 182, 0.25)"
};
break;
default:
colors = {
tabColor: "#ffffff",
activeTabColor: "rgba(0, 0, 0, 0.9)",
tabTextShadow: "#bbbbbb",
activeTabTextShadow: "#999999",
activeTabBackgroundColor: "rgba(255, 255, 255, 0.9)",
activeTabBorderColor: "rgba(0, 0, 0, 0.5)",
titleTextShadow: "#a6a6a6",
iconTextShadow: "rgba(0, 0, 0, 0.9)",
iconColor: "#ffffff",
titleColor: "#ffffff",
toolbarBoxShadow: "rgba(0, 0, 0, 0.1)",
contentBackgroundColorWithToolbar: "rgba(255, 255, 255, 0.85)",
footerBackgroundColor: "rgba(224, 230, 240, 0.8)",
hoverTabBackgroundColor: "rgba(224, 230, 240, 0.65)",
buttonBackgroundColor: "rgba(255, 255, 255, 0.2)",
hoverButtonBackgroundColor: "rgba(255, 255, 255, 0.9)",
activeButtonBackgroundColor: "rgba(255, 255, 255, 0.9)"
};
break;
}
return {
Panel: {
header: {
style: {
backgroundColor: "transparent",
paddingRight: Utils.pixelsOf(opts.headerHeight)
}
},
tabsStart: {
style: {
width: 50,
float: "left"
}
},
tabsEnd: {
style: {
width: 10,
float: "right"
}
},
tabs: {
style: {
float: "left"
}
},
icon: {
style: {
color: colors.iconColor,
textShadow: "2px 2px 2px " + colors.iconTextShadow,
float: "left"
}
},
box: {
style: {
float: "left"
}
},
title: {
style: {
color: colors.titleColor,
textShadow: "1px 1px 1px " + colors.titleTextShadow
}
},
body: {
style: {
backgroundColor: "transparent",
borderColor: "rgba(0, 0, 0, 0.5)"
}
}
},
TabButton: {
style: {
borderRadius: "2px 2px 0 0",
marginLeft: 1
},
state: {
hover: {
style: {
backgroundColor: colors.hoverTabBackgroundColor
},
icon: {
style: {
color: "rgba(0, 0, 0, 0.9)",
textShadow: "1px 1px 1px #999999"
}
},
title: {
style: {
color: "rgba(0, 0, 0, 0.9)",
textShadow: "1px 1px 1px #999999"
}
}
}
},
mods: {
active: {
style: {
borderColor: colors.activeTabBorderColor,
backgroundColor: colors.activeTabBackgroundColor
},
state: {
hover: {
style: {
backgroundColor: colors.activeTabBackgroundColor
},
icon: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
},
title: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
}
}
},
icon: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
},
title: {
style: {
color: colors.activeTabColor,
textShadow: "1px 1px 1px " + colors.activeTabTextShadow
}
}
}
},
icon: {
style: {
color: colors.tabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
},
title: {
style: {
color: colors.tabColor,
textShadow: "1px 1px 1px " + colors.tabTextShadow
}
}
},
Tab: {
mods: {
withToolbar: {
content: {
style: {
backgroundColor: colors.contentBackgroundColorWithToolbar
}
}
}
},
toolbar: {
style: {
backgroundColor: colors.activeTabBackgroundColor,
borderBottom: "0 none",
marginBottom: "1px",
borderRadius: "2px",
boxShadow: "0 -2px 0 " + colors.toolbarBoxShadow + " inset"
}
},
content: {
style: {
backgroundColor: colors.activeTabBackgroundColor,
borderBottom: "0 none",
marginBottom: "1px",
borderRadius: "2px"
}
},
footer: {
style: {
backgroundColor: colors.footerBackgroundColor,
borderRadius: "2px"
}
}
},
Button: {
style: {
borderRadius: "2px 2px 0 0",
backgroundColor: colors.buttonBackgroundColor,
marginLeft: "1px"
},
state: {
hover: {
style: {
backgroundColor: colors.hoverButtonBackgroundColor
},
children: {
style: {
color: "rgba(0, 0, 0, 0.9)",
textShadow: "1px 1px 1px #ffffff"
}
}
}
},
mods: {
active: {
style: {
backgroundColor: colors.activeButtonBackgroundColor
}
}
},
children: {
style: {
color: "#ffffff",
textShadow: "1px 1px 1px rgba(0, 0, 0, 0.9)"
}
}
}
};
};
var buildStyle = function (opts) {
opts = opts || {};
opts = {
theme: opts.theme || "base",
skin: opts.skin || "default",
headerHeight: opts.headerHeight || 32,
headerFontSize: opts.headerFontSize || 14,
borderRadius: opts.borderRadius || 3,
maxTitleWidth: opts.maxTitleWidth || 130,
useAvailableHeight: opts.useAvailableHeight || false,
renderPanelBorder: (typeof opts.renderPanelBorder === "boolean") ? opts.renderPanelBorder : true,
activeTabHeaderBorder: (typeof opts.activeTabHeaderBorder === "boolean") ? opts.activeTabHeaderBorder : true
};
var isSafari = /Safari/.test(window.navigator.userAgent) && /Apple Computer/.test(window.navigator.vendor);
var styles = {
base: {
PanelWrapper: {
style: {},
config: {
autocompact: true
}
},
Panel: {
style: {
height: (opts.useAvailableHeight) ? "100%" : "inherit"
},
header: {
style: {
display: "block",
fontSize: Utils.pixelsOf(opts.headerFontSize),
height: opts.headerHeight
}
},
tabsStart: {
style: {
width: 20,
height: "100%"
}
},
tabsEnd: {
style: {
width: 20,
height: "100%"
}
},
tabs: {
style: {
height: opts.headerHeight,
float: "right",
display: "inline-block",
margin: 0,
minWidth: Utils.pixelsOf(opts.headerHeight),
padding: 0
}
},
icon: {
style: {
display: "block",
float: "left",
fontSize: "125%",
height: opts.headerHeight,
lineHeight: Utils.pixelsOf(opts.headerHeight - 4),
marginRight: -6,
textAlign: "center",
width: opts.headerHeight - 2
}
},
box: {
style: {
marginLeft: 10,
height: "100%",
display: "inline-block",
position: "relative",
maxWidth: Utils.pixelsOf(opts.maxTitleWidth)
}
},
title: {
style: {
overflow: "hidden",
textOverflow: "ellipsis",
whiteSpace: "nowrap",
letterSpacing: 0,
lineHeight: Utils.pixelsOf(opts.headerHeight),
width: "auto"
}
},
group: {
style: {
padding: "0 5px",
backgroundColor: "transparent"
}
},
body: {
style: {
height: (opts.useAvailableHeight) ? "calc(100% - " + opts.headerHeight + "px)" : "inherit"
}
}
},
TabButton: {
style: {
position: "relative",
float: "left",
display: "block",
listStyle: "none",
padding: "0 5px",
height: opts.headerHeight,
fontSize: "0.95em",
cursor: "pointer"
},
mods: {
untitled: {
box: {
style: {
marginLeft: 0
}
}
},
active: {
style: {
cursor: "default"
}
}
},
icon: {
style: {
display: "block",
float: "left",
fontSize: "125%",
height: opts.headerHeight,
textAlign: "center",
width: opts.headerHeight - 2,
lineHeight: Utils.pixelsOf(opts.headerHeight - 2),
marginRight: -9,
marginLeft: -3,
opacity: 0.85
}
},
box: {
style: {
lineHeight: Utils.pixelsOf(opts.headerHeight),
marginRight: 6,
opacity: 0.85,
marginLeft: 10,
height: "100%",
display: "inline-block",
position: "relative",
maxWidth: Utils.pixelsOf(opts.maxTitleWidth)
}
},
title: {
style: {
overflow: "hidden",
textOverflow: "ellipsis",
whiteSpace: "nowrap",
letterSpacing: 0,
lineHeight: Utils.pixelsOf(opts.headerHeight),
width: "auto"
}
}
},
Tab: {
style: {
display: "none"
},
mods: {
active: {
style: {
display: (opts.useAvailableHeight) ? (isSafari ? "-webkit-flex" : "flex") : "block",
minHeight: (opts.useAvailableHeight) ? "100%" : "inherit",
WebkitFlexDirection: (opts.useAvailableHeight) ? "column" : "inherit",
flexDirection: (opts.useAvailableHeight) ? "column" : "inherit",
height: "100%"
},
content: {
style: (opts.useAvailableHeight) ? {
WebkitFlex: 1,
flex: 1,
position: "relative"
} : {},
children: {
style: (opts.useAvailableHeight) ? {
padding: "10px",
position: "absolute",
height: "100%",
width: "100%"
} : { }
}
}
},
withToolbar: {
toolbar: {
style: { }
}
}
},
toolbar: {
style: {
minHeight: Utils.pixelsOf(opts.headerHeight),
lineHeight: Utils.pixelsOf(opts.headerHeight)
},
children: {
style: {
padding: "10px"
}
}
},
content: {
style: { },
children: {
style: {
padding: "10px"
}
}
},
footer: {
style: {
minHeight: Utils.pixelsOf(opts.headerHeight),
lineHeight: Utils.pixelsOf(opts.headerHeight),
padding: "10px"
},
children: {
style: {}
}
}
},
Button: {
style: {
float: "right",
height: Utils.pixelsOf(opts.headerHeight),
minWidth: Utils.pixelsOf(opts.headerHeight),
display: "inline-block",
lineHeight: Utils.pixelsOf(opts.headerHeight),
margin: 0,
padding: 0,
textAlign: "center",
cursor: "pointer",
WebkitUserSelect: "none",
MozUserSelect: "none",
msUserSelect: "none",
userSelect: "none"
},
mods: {
disabled: {
style: {
cursor: "default",
pointerEvents: "none",
opacity: 0.5
}
},
hidden: {
style: {
display: "none"
}
},
highlighted: {
style: {}
}
},
children: {
style: {}
}
}
},
/* THEME: Chemical */
chemical: chemicalStyle,
flexbox: flexboxStyle,
flexbox2: flexbox2Style
};
var theme = (opts.theme != "base") ? styles[opts.theme](opts) : {};
return Utils.merge(styles.base, theme);
};
var createSheet = (function (opts) {
var _sheet = buildStyle(opts),
_skin = {};
return function (target, mods, alter) {
var using = _sheet;
mods = mods || [];
alter = alter || {}
if (alter.skin || false) {
if (!(_skin[alter.skin] || false)) {
_skin[alter.skin] = buildStyle(React.addons.update(opts, {$merge: {skin: alter.skin}}));
}
using = _skin[alter.skin];
}
if (!mods.length) return using[target];
var sheet = React.addons.update(using[target], {$merge: {}}),
i;
for (i = 0; i < mods.length; ++i) {
if ((sheet.mods || false) && (sheet.mods[mods[i]] || false)) {
sheet = Utils.merge(sheet, sheet.mods[mods[i]]);
}
}
return sheet;
}
});
var Utils = {
pixelsOf: function (value) {
var val = parseInt(value) || 0
return (val) ? String(val) + "px" : "0";
},
/* Copyright (c) 2012 Nicholas Fisher (MIT License) https://github.com/KyleAMathews/deepmerge */
merge: function (target, src) {
var array = Array.isArray(src);
var dst = array && [] || {};
if (array) {
target = target || [];
dst = dst.concat(target);
src.forEach(function(e, i) {
if (typeof dst[i] === 'undefined') {
dst[i] = e;
} else if (typeof e === 'object') {
dst[i] = Utils.merge(target[i], e);
} else {
if (target.indexOf(e) === -1) {
dst.push(e);
}
}
});
} else {
if (target && typeof target === 'object') {
Object.keys(target).forEach(function (key) {
dst[key] = target[key];
})
}
Object.keys(src).forEach(function (key) {
if (typeof src[key] !== 'object' || !src[key]) {
dst[key] = src[key];
}
else {
if (!target[key]) {
dst[key] = src[key];
} else {
dst[key] = Utils.merge(target[key], src[key]);
}
}
});
}
return dst;
}
};
var DragAndDropHandler = function (opts, callback) {
var self = this;
if (!(self instanceof DragAndDropHandler)) return new DragAndDropHandler(opts, callback);
/** Not yet implemented. */
this.opt = Utils.merge({
detachOnLeave: true,
/** If true, the tab button being dragged will be rendered by
* cloning an existing tab of the target panel. */
cloakInGroup: false,
onDragStart: false,
onDragEnd: false
}, opts || {});
this.ctx = {
sortable: true,
dragging: false,
parentId: false
};
this._member = [];
this._callback = callback || function () {};
};
DragAndDropHandler.prototype.trigger = function (event, data) {
switch (event) {
case 'onDragEnd':
return this._callback(data);
default:
throw new Error("Not implemented");
}
};
DragAndDropHandler.prototype.addMember = function (component) {
return this._member.push(component) - 1;
};
DragAndDropHandler.prototype.setParentOfToken = function (memberId) {
if (this.ctx.parentId !== false) {
this._member[this.ctx.parentId].releaseToken();
}
this.ctx.parentId = memberId;
};
var Mixins = {
Styleable: {
getInitialState: function () {
this.__ssv = {};
this.__ssvh = false;
this.__ssa = {target: '', mods: [], alter: {}};
return {};
},
contextTypes: {
sheet: React.PropTypes.func
},
getSheet: function (target, mods, alter) {
var rebuild = false, i;
mods = (typeof this['getSheetMods'] === "function") ? this['getSheetMods'](mods || []) : mods || [];
alter = alter || {}
if (target != this.__ssa.target) rebuild = true;
else {
if (mods.length != this.__ssa.mods.length) rebuild = true;
else if (mods.length != 0) {
for (i = mods.length; --i >= 0;) {
if (this.__ssa.mods.indexOf(mods[i]) == -1) {
rebuild = true;
break;
}
}
}
// TODO: check if alter has changed
}
if (rebuild) {
this.__ssv = this.context.sheet(target, mods, alter);
this.__ssvh = false;
this.__ssa = {
target: target,
mods: Utils.merge(mods, []),
alter: Utils.merge(alter, {})
};
}
if ((typeof this.state._hover === "boolean")) {
if (this.state._hover) {
if (this.__ssvh || false) {
return this.__ssvh;
}
if ((this.__ssv.state || false) && (this.__ssv.state.hover || false)) {
this.__ssvh = Utils.merge(this.__ssv, this.__ssv.state.hover);
return this.__ssvh;
}
}
}
return this.__ssv;
}
},
Transitions: {
propTypes: {
transitionName: React.PropTypes.string,
transitionEnter: React.PropTypes.bool,
transitionLeave: React.PropTypes.bool,
transitionAppear: React.PropTypes.bool,
/** React.addons.CSSTransitionGroup might not work well in some scenarios,
* use this to specify another component.
*
* @see https://github.com/Khan/react-components/blob/master/js/timeout-transition-group.jsx
* */
transitionComponent: React.PropTypes.any,
/** Additional props specific to transitionComponent. */
transitionCustomProps: React.PropTypes.object
},
getTransitionProps: function (pcType) {
pcType = pcType || this.props.panelComponentType;
var props = {},
globals = (this.context && this.context.globals && this.context.globals[pcType]) ?
this.context.globals[pcType] : {},
transitionName = (typeof this.props.transitionName === "string") ?
this.props.transitionName : globals.transitionName || "";
if (transitionName.length) {
props = {
transitionName: transitionName,
transitionEnter: (typeof this.props.transitionEnter === "boolean") ?
this.props.transitionEnter : globals.transitionEnter || false,
transitionLeave: (typeof this.props.transitionLeave === "boolean") ?
this.props.transitionLeave : globals.transitionLeave || false,
transitionAppear: (typeof this.props.transitionAppear === "boolean") ?
this.props.transitionAppear : globals.transitionAppear || false,
transitionComponent: (typeof this.props.transitionComponent !== "undefined") ?
this.props.transitionComponent : globals.transitionComponent || React.addons.CSSTransitionGroup,
transitionCustomProps: this.props.transitionCustomProps || globals.transitionCustomProps || {}
};
} else {
props = {
transitionName: "none",
transitionEnter: false,
transitionLeave: false,
transitionAppear: false,
transitionComponent: React.addons.CSSTransitionGroup,
transitionCustomProps: {}
};
}
return props;
}
},
Toolbar: {
getDefaultProps: function () {
return {
panelComponentType: "Toolbar"
};
}
},
Content: {
getDefaultProps: function () {
return {
panelComponentType: "Content"
};
}
},
Footer: {
getDefaultProps: function () {
return {
panelComponentType: "Footer"
};
}
}
};
Mixins.StyleableWithEvents = {
mixins: [Mixins.Styleable],
getDefaultProps: function () {
return {
onMouseEnter: false,
onMouseLeave: false
};
},
getInitialState: function () {
this.listeners = {
onMouseEnter: this.handleMouseEnter,
onMouseLeave: this.handleMouseLeave
};
return {
_hover: false,
_focus: false
};
},
handleMouseEnter: function (ev) {
if (typeof this.props['onMouseEnter'] === "function") this.props['onMouseEnter'](ev);
this.setState({
_hover: true
});
},
handleMouseLeave: function (ev) {
if (typeof this.props['onMouseLeave'] === "function") this.props['onMouseLeave'](ev);
this.setState({
_hover: false
});
}
};
Mixins.PanelWrapper = {
propTypes: {
transitionName: React.PropTypes.string,
transitionEnter: React.PropTypes.bool,
transitionLeave: React.PropTypes.bool,
transitionAppear: React.PropTypes.bool,
globals: React.PropTypes.object,
/** React.addons.CSSTransitionGroup might not work well in some scenarios,
* use this to specify another component.
*
* @see https://github.com/Khan/react-components/blob/master/js/timeout-transition-group.jsx
* */
transitionComponent: React.PropTypes.any,
/** Additional props specific to transitionComponent. */
transitionCustomProps: React.PropTypes.object,
dragAndDropHandler: React.PropTypes.oneOfType([
React.PropTypes.object,
React.PropTypes.bool
])
},
getDefaultProps: function () {
return {
"icon": false,
"title": "",
"selectedIndex": 0,
/** Triggered before a change tab event propagated from within the Panel (e.g., user's click).
* Optionally, return false to stop it.
*/
"onTabChange": null,
"buttons": [],
"globals": {}
};
},
getInitialState: function () {
var opts = {
theme: this.props.theme,
skin: this.props.skin,
headerHeight: this.props.headerHeight,
headerFontSize: this.props.headerFontSize,
borderRadius: this.props.borderRadius,
maxTitleWidth: this.props.maxTitleWidth,
useAvailableHeight: this.props.useAvailableHeight,
renderPanelBorder: this.props.renderPanelBorder,
activeTabHeaderBorder: this.props.activeTabHeaderBorder
};
this._sheet = createSheet(opts);
this.config = this._sheet("PanelWrapper").config;
return {
selectedIndex: parseInt(this.props.selectedIndex)
};
},
childContextTypes: {
selectedIndex: React.PropTypes.number,
sheet: React.PropTypes.func,
onTabChange: React.PropTypes.func,
globals: React.PropTypes.object,
numTabs: React.PropTypes.number
},
getChildContext: function () {
return {
selectedIndex: this.state.selectedIndex,
sheet: this._sheet,
onTabChange: this.handleTabChange,
globals: this.props.globals,
numTabs: React.Children.count(this.props.children)
};
},
handleTabChange: function (index) {
if (typeof this.props.onTabChange === "function") {
if (this.props.onTabChange(index, this) !== false) {
this.setSelectedIndex(index);
}
} else {
this.setSelectedIndex(index);
}
},
getSelectedIndex: function () {
return this.state.selectedIndex;
},
setSelectedIndex: function (index, callback) {
this.setState({selectedIndex: parseInt(index)});
this.forceUpdate(function () {
if (typeof callback === "function") {
callback();
}
});
},
componentWillReceiveProps: function (nextProps) {
var sIndex = this.state.selectedIndex,
resetIndex = false,
numTabs = React.Children.count(nextProps.children);
if (nextProps.selectedIndex != this.props.selectedIndex) {
sIndex = nextProps.selectedIndex;
resetIndex = true;
}
if (sIndex >= numTabs) {
sIndex = Math.max(numTabs - 1, 0);
resetIndex = true;
}
if (resetIndex) {
this.setState({selectedIndex: parseInt(sIndex)});
}
}
};
Mixins.TabWrapper = {
observedProps: ['selectedIndex', 'index'],
propTypes: {
tabKey: React.PropTypes.any
},
getDefaultProps: function () {
return {
panelComponentType: "TabWrapper",
icon: "",
title: "",
pinned: false,
showToolbar: true,
showFooter: true
};
},
childContextTypes: {
index: React.PropTypes.number,
tabKey: React.PropTypes.any
},
getChildContext: function () {
return {
index: this.props.index,
tabKey: this.props.tabKey
};
},
contextTypes: {
selectedIndex: React.PropTypes.number
}
};
Mixins.Button = {
mixins: [Mixins.StyleableWithEvents],
getDefaultProps: function () {
return {
name: "default",
title: "",
visible: true,
enabled: true,
active: false,
highlighted: false,
onClick: false,
onDoubleClick: false,
onContextMenu: false,
onChange: false
};
},
getInitialState: function () {
this.listeners.onClick = this._handleClick;
this.listeners.onDoubleClick = this._handleDoubleClick;
this.listeners.onContextMenu = this._handleContextMenu;
return {
visible: this.props.visible,
enabled: this.props.enabled,
active: this.props.active,
highlighted: this.props.highlighted
};
},
childContextTypes: {
btnTitle: React.PropTypes.string,
btnVisible: React.PropTypes.bool,
btnEnabled: React.PropTypes.bool,
btnActive: React.PropTypes.bool
},
getChildContext: function () {
return {
btnTitle: this.props.title,
btnVisible: this.state.visible,
btnEnabled: this.state.enabled,
btnActive: this.state.active
};
},
contextTypes: {
selectedIndex: React.PropTypes.number
},
getSheetMods: function (otherMods) {
var mods = otherMods || []; //np
if (this.state.active && mods.indexOf('active') == -1) mods.push('active');
if (!this.state.visible && mods.indexOf('hidden') == -1) mods.push('hidden');
if (!this.state.enabled && mods.indexOf('disabled') == -1) mods.push('disabled');
if (this.state.highlighted && mods.indexOf('highlighted') == -1) mods.push('highlighted');
return mods;
},
_handleDoubleClick: function (ev) {
if (typeof this.props.onDoubleClick === "function" && this.props.onDoubleClick(ev, this) === false) return;
if (typeof this['handleDoubleClick'] === "function") {
return this['handleDoubleClick'](ev);
}
},
_handleClick: function (ev) {
if (typeof this.props.onClick === "function" && this.props.onClick(ev, this) === false) return;
if (typeof this['handleClick'] === "function") {
return this['handleClick'](ev);
}
},
_handleContextMenu: function (ev) {
if (typeof this.props.onContextMenu === "function" && this.props.onContextMenu(ev, this) === false) return;
if (typeof this['handleContextMenu'] === "function") {
return this['handleContextMenu'](ev);
}
}
};
var FloatingPanel = React.createClass({
displayName: 'FloatingPanel',
mixins: [Mixins.PanelWrapper],
propTypes: {
left:React.PropTypes.number,
top:React.PropTypes.number,
width:React.PropTypes.number,
style:React.PropTypes.object,
onClick:React.PropTypes.func,
},
getDefaultProps: function () {
return {
"left": 0,
"top": 0,
"width": 420,
"style": {}
};
},
getInitialState: function () {
this.skipUpdate = false;
return {
left: parseInt(this.props.left),
top: parseInt(this.props.top),
width: parseInt(this.props.width)
};
},
componentWillReceiveProps:function(nextProps) {
this.setState({width:nextProps.width});
},
dragStart: function (e) {
this.panelBounds = {
startLeft: this.state.left,
startTop: this.state.top,
startPageX: e.pageX,
startPageY: e.pageY
};
try {
var img = document.createElement("img");
img.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAABmJLR0QA/wD/AP+gvaeTAAAADUlEQVQI12NgYGBgAAAABQABXvMqOgAAAABJRU5ErkJggg==";
img.width = 1;
e.dataTransfer.setData('text/plain', "Panel");
e.dataTransfer.setDragImage(img, -1000, -1000);
} catch (err) { /* Fix for IE */ }
window.addEventListener('dragover', this.dragOver);
},
dragEnd: function() {
delete this.panelBounds;
window.removeEventListener('dragover', this.dragOver);
if (this.props.onBoundsChange) {
var height=this.getDOMNode().offsetHeight;
this.props.onBoundsChange({left:this.state.left, top:this.state.top, width:this.state.width, height:height});
}
},
dragOver: function(e) {
if (this.panelBounds || false) {
var left = this.panelBounds.startLeft + (e.pageX - this.panelBounds.startPageX),
top = this.panelBounds.startTop + (e.pageY - this.panelBounds.startPageY);
this.skipUpdate = true;
this.setState({ left: left, top: top });
}
},
handleMouseClick: function (e) {
if (typeof this.props.onClick === "function") {
this.props.onClick(e);
}
},
render: function() {
var transform = "translate3d(" + Utils.pixelsOf(this.state.left) + ", " + Utils.pixelsOf(this.state.top) + ", 0)",
wrapperStyle = React.addons.update({
WebkitTransform: transform,
MozTransform: transform,
msTransform: transform,
transform: transform,
width: Utils.pixelsOf(this.state.width),
position: "absolute"
}, {$merge: this.props.style});
if (!this.skipUpdate) {
var props = React.addons.update({
onDragStart: this.dragStart,
onDragEnd: this.dragEnd,
floating: true
}, {$merge: this.config}),
keys = Object.keys(this.props);
for (var i = keys.length; --i >= 0;) {
if (["children", "left", "top", "width", "style"].indexOf(keys[i]) != -1) continue;
props[keys[i]] = this.props[keys[i]];
}
this.inner = (
React.createElement(ReactPanel, props,
this.props.children
)
);
} else {
this.skipUpdate = false;
}
return React.createElement("div", {style:wrapperStyle, onClick:this.handleMouseClick}, this.inner);
}
});
var Panel = React.createClass({
displayName: 'Panel',
mixins: [Mixins.PanelWrapper],
render: function() {
var props = React.addons.update({}, {$merge: this.config}),
keys = Object.keys(this.props);
for (var i = keys.length; --i >= 0;) {
if (["children"].indexOf(keys[i]) != -1) continue;
props[keys[i]] = this.props[keys[i]];
}
return React.createElement(ReactPanel, props,
this.props.children
);
}
});
var ReactPanel = React.createClass({
displayName: 'ReactPanel',
mixins: [Mixins.Styleable, Mixins.Transitions],
getDefaultProps: function () {
return {
"icon": false,
"title": "",
"autocompact": true,
"floating": false,
"onDragStart": null,
"onDragEnd": null,
"maxTitleWidth": 130,
"buttons": []
};
},
propTypes: {
dragAndDropHandler: React.PropTypes.oneOfType([
React.PropTypes.object,
React.PropTypes.bool
])
},
getInitialState: function () {
return {
compacted: (this.props.autocompact)
};
},
contextTypes: {
selectedIndex: React.PropTypes.number,
sheet: React.PropTypes.func,
onTabChange: React.PropTypes.func,
globals: React.PropTypes.object
},
getSelectedIndex: function () {
return this.context.selectedIndex;
},
handleClick: function (event, index) {
this.context.onTabChange(parseInt(index));
},
componentDidMount: function () {
if (this.props.autocompact) {
var tabsStart = this.refs['tabs-start'].getDOMNode(),
tabsEnd = this.refs['tabs-end'].getDOMNode(),
using = this.refs.tabs.getDOMNode().offsetWidth,
total = tabsEnd.offsetLeft - (tabsStart.offsetLeft + tabsStart.offsetWidth);
if (using * 2 <= total) { // TODO: ... * 2 is obviously not what it should be
this.setState({compacted: false});
}
}
},
componentWillReceiveProps: function(nextProps) {
if (this.props.autocompact) {
var childs = React.Children.count(this.props.children),
next_childs = React.Children.count(nextProps.children);
if (next_childs > childs && this.props.autocompact && !this.state.compacted) {
var tabsStart = this.refs['tabs-start'].getDOMNode(),
tabsEnd = this.refs['tabs-end'].getDOMNode(),
using = this.refs.tabs.getDOMNode().offsetWidth,
total = tabsEnd.offsetLeft - (tabsStart.offsetLeft + tabsStart.offsetWidth),
maxTabWidth = this.props.maxTitleWidth + 35;
if (using + maxTabWidth >= total) {
this.setState({compacted: true});
}
} else {
// TODO
}
}
},
handleDragStart: function (e) {
if (typeof this.props.onDragStart === "function") {
this.props.onDragStart(e);
}
},
handleDragEnd: function () {
if (typeof this.props.onDragEnd === "function") {
this.props.onDragEnd();
}
},
_getGroupedButtons: function () {
var len = this.props.buttons.length,
i, j, item, group = [], groups = [];
for (i = 0; i < len; ++i) {
item = this.props.buttons[i];
if (typeof item === "object" && item instanceof Array) {
if (group.length) {
groups.push(group);
group = [];
}
for (j = 0; j < item.length; ++j) {
group.push(React.addons.cloneWithProps(item[j], {key: j}));
}
if (group.length) {
groups.push(group);
group = [];
}
} else {
group.push(React.addons.cloneWithProps(item, {key: i}));
}
}
if (group.length) {
groups.push(group);
}
return groups;
},
render: function() {
var self = this,
draggable = (this.props.floating) ? "true" : "false",
sheet = this.getSheet("Panel"),
transitionProps = this.getTransitionProps("Panel");
var icon = (this.props.icon) ? (
React.createElement("span", {style:sheet.icon.style},
React.createElement("i", {className:this.props.icon})
)
) : null,
title = (this.props.title.length) ? (
React.createElement("div", {style:sheet.box.style},
React.createElement("div", {style:sheet.title.style},
this.props.title
)
)
) : null;
var tabIndex = 0,
selectedIndex = this.getSelectedIndex(),
tabButtons = [],
tabs = [],
groupIndex = 0;
React.Children.forEach(self.props.children, function(child) {
var ref = "tabb-" + tabIndex,
tabKey = (typeof child.key !== "undefined" && child.key != null) ? child.key : ref,
showTitle = true,
props = {
"icon": child.props.icon,
"title": child.props.title,
"pinned": child.props.pinned
};
if (self.state.compacted) {
if (!(props.pinned || selectedIndex == tabIndex)) {
showTitle = false;
}
}
tabButtons.push({
key: tabKey, title: props.title, icon: props.icon, index: tabIndex, ref: ref, showTitle: showTitle,
onClick: self.handleClick, "data-index": tabIndex, "data-key": tabKey
});
tabs.push(
React.addons.cloneWithProps(child, {
key: tabKey,
tabKey: tabKey,
selectedIndex: selectedIndex,
index: tabIndex
})
);
++tabIndex;
});
return (
React.createElement("div", {style: sheet.style},
React.createElement("header", {draggable: draggable, onDragEnd: self.handleDragEnd,
onDragStart: self.handleDragStart, ref: "header", style: sheet.header.style},
icon, title,
React.createElement("div", {style: sheet.tabsStart.style, ref: "tabs-start"}),
React.createElement(TabGroup, {
style: sheet.tabs.style, ref: "tabs", data: tabButtons,
dragAndDropHandler: this.props.dragAndDropHandler || false,
transitionProps: transitionProps
}),
React.createElement("div", {style: sheet.tabsEnd.style, ref: "tabs-end"}),
this._getGroupedButtons().map(function (group) {
return React.createElement("ul", {style: sheet.group.style, key: groupIndex++}, group );
})
),
React.createElement("div", {style: sheet.body.style}, tabs )
)
);
}
});
var TabGroup = React.createClass({
displayName: 'TabGroup',
propTypes: {
style: React.PropTypes.object.isRequired,
data: React.PropTypes.array.isRequired,
transitionProps: React.PropTypes.object.isRequired,
dragAndDropHandler: React.PropTypes.oneOfType([
React.PropTypes.object,
React.PropTypes.bool
])
},
contextTypes: {
selectedIndex: React.PropTypes.number,
sheet: React.PropTypes.func,
onTabChange: React.PropTypes.func,
globals: React.PropTypes.object
},
componentWillMount: function () {
this.tabKeys = [];
this._index = false;
var globals = (this.context && this.context.globals) ? this.context.globals.Panel || {} : {};
this.handler = this.props.dragAndDropHandler || globals.dragAndDropHandler || false;
this.ctx = this.handler ? this.handler.ctx : {
sortable: false,
dragging: false
};
for (var i = 0; i < this.props.data.length; ++i) {
this.tabKeys.push(this.props.data[i]["data-key"]);
}
this.keyMap = this.tabKeys.slice(0);
this.constKeyMap = this.tabKeys.slice(0); //req. don't try to merge
},
componentDidMount: function () {
if (this.ctx.sortable && this.handler) {
this.memberId = this.handler.addMember(this);
}
},
componentWillUpdate: function (nextProps) {
if (!this.ctx.dragging) {
this.tabKeys = [];
for (var i = 0; i < nextProps.data.length; ++i) {
this.tabKeys.push(nextProps.data[i]["data-key"]);
}
this.keyMap = this.tabKeys.slice(0);
this.constKeyMap = this.tabKeys.slice(0);
}
},
handleDragStartOnTab: function(e, clone, target) {
this.ctx.draggedKey = target.dataset.key;
this.ctx.keySequence = 0;
this.ctx.dragging = false; //
this.ctx.draggedElement = clone;
this.ctx.dragging = true;
this._index = this.tabKeys.indexOf(this.ctx.draggedKey);
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData("text/html", target);
e.dataTransfer.setDragImage(target, -15, -15);
},
handleDragStart: function(e) {
if (this.ctx.sortable) {
var node = this.getDOMNode(),
tabWidth = node.offsetWidth / this.tabKeys.length,
distance = e.pageX - node.getBoundingClientRect().left,
index = parseInt(distance / tabWidth),
targetKey = this.tabKeys[index] || false;
if (targetKey !== false) {
var tabComponent = this.refs[targetKey + "-tabbref"] || false;
if (tabComponent !== false) {
this.ctx.ownerId = this.ctx.parentId = this.memberId || false;
var clone = React.cloneElement(tabComponent.render(), {
key: "tabbph-clone",
onMouseEnter: false,
onMouseLeave: false
});
this.keyMap.splice(index, 1);
this.acquireToken(e); //
this.handleDragStartOnTab(e, clone, tabComponent.getDOMNode());
}
}
}
},
handleDragOver: function(e) {
if (this.ctx.dragging) {
e.preventDefault();
var nextIndex;
if (this.ctx.parentId != this.memberId) {
//tab not present in this panel
nextIndex = this.acquireToken(e);
this._index = false;
this.handler.setParentOfToken(this.memberId);
} else {
var distance = e.pageX - this.getDOMNode().getBoundingClientRect().left;
nextIndex = parseInt(distance / this.tabWidth);
}
if (this._index !== nextIndex) {
this.ctx.keySequence++;
if (this._index !== false) {
this.tabKeys.splice(this._index, 1);
}
this.tabKeys.splice(nextIndex, 0, this.ctx.draggedKey);
this._index = nextIndex;
this.ctx.targetKey = this.keyMap[Math.min(this._index, this.keyMap.length - 1)] || false;
this.ctx.placement = this._index >= this.keyMap.length ? "after" : "before";
this.forceUpdate();
}
}
},
handleDragEnd: function(e) {
if (this.ctx.dragging) {
this.ctx.dragging = false;
this._index = this._index || this.acquireToken(e);
this.handler.trigger('onDragEnd', {
element: this.ctx.draggedKey,
target: this.ctx.targetKey,
placement: this.ctx.placement
});
}
},
/* TODO: proper name. */
acquireToken: function (e) {
var node = this.getDOMNode(),
numTabsMod = this.ctx.ownerId == this.memberId ? 0 : 1,
tabWidth = node.offsetWidth / (this.tabKeys.length + numTabsMod),
distance = e.pageX - node.getBoundingClientRect().left,
index = parseInt(distance / tabWidth);
this.tabWidth = tabWidth;
return index;
},
releaseToken: function () {
this._index = false;
//TODO: Something is missing here.
},
/* Should be used by opts.cloakInGroup once implemented. */
cloneTabComponent: function (e) {
var tabComponent = this.refs[(this.tabKeys[index] || false) + "-tabbref"] || false;
if (tabComponent !== false) {
this.ctx.draggedElement = React.cloneElement(tabComponent.render(), {
key: "tabbph-clone",
onMouseEnter: false,
onMouseLeave: false
});
}
},
createTabElement: function (tabKey) {
if (this.ctx.dragging) {
if (this.ctx.draggedKey === tabKey) {
return React.cloneElement(this.ctx.draggedElement, {
key: tabKey + "-tabbph" + this.ctx.keySequence,
draggable: false
});
}
}
var tabProps = this.props.data[this.constKeyMap.indexOf(tabKey)] || false;
return (tabProps === false) ? null : React.createElement(
TabButton, React.__spread(tabProps, {ref: tabKey + "-tabbref"})
);
},
render: function () {
var tp = this.props.transitionProps,
sp = (this.ctx.sortable || false) ? {
draggable: true,
onDragEnd: this.handleDragEnd,
onDragStart: this.handleDragStart,
onDragOver: this.handleDragOver,
"data-key": "get-target-stop"
} : {};
if (!this.ctx.dragging) {
this.tabKeys = [];
for (var i = 0; i < this.props.data.length; ++i) {
this.tabKeys.push(this.props.data[i]["data-key"]);
}
}
var tabs = this.tabKeys.map(function (tabKey) {
return this.createTabElement(tabKey);
}.bind(this));
return (
React.createElement(tp.transitionComponent, React.__spread({component: "ul",
style: this.props.style, transitionName: tp.transitionName,
transitionAppear: tp.transitionAppear, transitionEnter: tp.transitionEnter,
transitionLeave: tp.transitionLeave}, tp.transitionCustomProps, sp),
tabs
)
);
}
});
var TabButton = React.createClass({displayName: "TabButton",
mixins: [Mixins.StyleableWithEvents],
propTypes: {
"data-index": React.PropTypes.number.isRequired,
"data-key": React.PropTypes.string.isRequired
},
getDefaultProps: function () {
return {
"icon": "",
"title": "",
"index": 0,
"showTitle": true
};
},
contextTypes: {
selectedIndex: React.PropTypes.number,
numTabs: React.PropTypes.number
},
handleClick: function (event) {
event.preventDefault();
this.props.onClick(event, this.props.index);
},
render: function() {
var icon = null,
title = "",
mods = (this.context.selectedIndex == this.props.index) ? ['active'] : [];
if (!(this.props.showTitle && this.props.title.length)) mods.push('untitled');
if (this.props.index == this.context.numTabs - 1) mods.push('last');
var sheet = this.getSheet("TabButton", mods, {});
if (this.props.showTitle && this.props.title.length) {
title = React.createElement("div", {style:sheet.title.style},this.props.title);
}
if (this.props.icon) {
icon = (
React.createElement("div", {style:sheet.icon.style},
React.createElement("i", {className:this.props.icon})
)
);
}
return (
React.createElement("li", React.__spread({
onClick: this.handleClick,
style: sheet.style,
"data-index": this.props["data-index"],
"data-key": this.props["data-key"]
},
this.listeners),
React.createElement("div", {title: this.props.title},
icon, React.createElement("div", {style: sheet.box.style}, title)
)
)
);
}
});
var Tab = React.createClass({
displayName: 'Tab',
mixins: [Mixins.Styleable, Mixins.Transitions],
propTypes: {
onActiveChanged: React.PropTypes.func,
maxContentHeight: React.PropTypes.number
},
getDefaultProps: function () {
return {
"icon": "",
"title": "",
"pinned": false,
"showToolbar": true,
"showFooter": true,
"panelComponentType": "Tab",
"automount": false,
"maxContentHeight": 0
};
},
contextTypes: {
selectedIndex: React.PropTypes.number,
index: React.PropTypes.number,
globals: React.PropTypes.object
},
componentDidMount: function () {
this._doEvents();
},
componentDidUpdate: function () {
this._doEvents();
},
_doEvents: function () {
if (typeof this.props.onActiveChanged === "function") {
this.wasActive = this.wasActive || false;
var active = this.isActive();
if (this.wasActive != active) {
this.props.onActiveChanged(this, active);
this.wasActive = active;
}
}
},
getValue: function (name) {
switch (name) {
case "index":
return (typeof this.props.index !== "undefined") ? this.props.index : this.context.index;
case "selectedIndex":
return this.context.selectedIndex;
case "showToolbar":
return this.props.showToolbar;
case "showFooter":
return this.props.showFooter;
case "active":
return this.isActive();
case "hasToolbar":
return this.hasToolbar || false;
case "hasFooter":
return this.hasFooter || false;
case "mounted":
return this.mounted || false;
case "automount":
return this.props.automount;
case "numChilds":
return React.Children.count(this.props.children);
case "tabKey":
return (typeof this.props.tabKey !== "undefined") ? this.props.tabKey : this.context.tabKey;
}
},
isActive: function () {
if (typeof this.props.index !== "undefined") {
return (this.props.index == this.context.selectedIndex);
} else {
return (this.context.index == this.context.selectedIndex);
}
},
render: function() {
var self = this,
numChilds = React.Children.count(this.props.children),
active = this.isActive(),
tp = this.getTransitionProps(),
mods = (active) ? ['active'] : [],
sheet = {};
this.mounted = (this.mounted || false) || this.props.automount || active;
this.hasToolbar=this.hasFooter=false;
var innerContent = (this.mounted) ? React.Children.map(self.props.children, function(child, i) {
var type = (i == 0 && numChilds >= 2) ? 0 : 1; // 0: Toolbar, 1: Content, 2: Footer
if (React.isValidElement(child) && (typeof child.props.panelComponentType !== "undefined")) {
switch (String(child.props.panelComponentType)) {
case "Toolbar": type = 0; break;
case "Content": type = 1; break;
case "Footer": type = 2; break;
}
}
if (i == 0) {
if (type == 0) {
this.hasToolbar = true;
if (self.props.showToolbar) mods.push('withToolbar');
}
sheet = self.getSheet("Tab", mods);
}
if (i == self.props.children.length-1 && type == 2) {
this.hasFooter = true;
if (self.props.showFooter) {
mods.push('withFooter');
sheet = self.getSheet("Tab", mods);
}
}
switch (type) {
case 0:
return (self.props.showToolbar) ? (
React.createElement("div", {key: i, style: sheet.toolbar.style},
React.createElement("div", {className: "tab-toolbar", style: sheet.toolbar.children.style},
child
)
)
) : null;
case 1:
var contentStyle = React.addons.update({
maxHeight : this.props.maxContentHeight || "none",
overflowX :"hidden",
overflowY : this.props.maxContentHeight?"auto":"hidden"
}, {$merge: sheet.content.style});
return (
React.createElement("div", {key: i, style: contentStyle},
React.createElement("div", {className: "tab-content", style: sheet.content.children.style},
child
)
)
);
case 2:
return (self.props.showFooter) ? (
React.createElement("div", {key: i, style: sheet.footer.style},
React.createElement("div", {className: "tab-footer", style: sheet.footer.children.style},
child
)
)
) : null;
}
}.bind(this)) : null;
return (
React.createElement(tp.transitionComponent, React.__spread({component: "div", style: sheet.style,
transitionName: tp.transitionName, transitionAppear: tp.transitionAppear && active,
transitionEnter: tp.transitionEnter && active, transitionLeave: tp.transitionLeave && active},
tp.transitionCustomProps),
innerContent
)
);
}
});
var ToggleButton = React.createClass({
displayName: 'ToggleButton',
mixins: [Mixins.Button],
handleClick: function (ev) {
var self = this;
this.setState({active: !this.state.active});
this.forceUpdate(function () {
if (typeof self.props.onChange === "function") {
self.props.onChange(this);
}
});
},
render: function () {
var sheet = this.getSheet('Button');
//JSX source: https://github.com/Theadd/react-panels/blob/v2/src/jsx/buttons.jsx#L21-L25
return (
React.createElement("li", React.__spread({style: sheet.style}, this.listeners, {title: this.props.title}),
React.createElement("span", {style: sheet.children.style},
this.props.children
)
)
);
}
});
var Button = React.createClass({
displayName: 'Button',
mixins: [Mixins.Button],
propTypes: {
onButtonClick: React.PropTypes.func
},
handleClick: function (ev) {
if (typeof this.props.onButtonClick === "function") {
this.props.onButtonClick(this, ev);
}
},
render: function () {
var sheet = this.getSheet('Button');
return (
React.createElement("li", React.__spread({style: sheet.style}, this.listeners, {title: this.props.title}),
React.createElement("span", {style: sheet.children.style},
this.props.children
)
)
);
}
});
var Toolbar = React.createClass({
displayName: 'Toolbar',
mixins: [Mixins.Toolbar],
render: function () {
return React.createElement("div", {}, this.props.children );
}
});
var Content = React.createClass({
displayName: 'Content',
mixins: [Mixins.Content],
render: function () {
return React.createElement("div", {}, this.props.children );
}
});
var Footer = React.createClass({
displayName: 'Footer',
mixins: [Mixins.Footer],
render: function () {
return React.createElement("div", {}, this.props.children );
}
});
var PanelAddons = {};
var ReactPanels = {
Panel: Panel,
FloatingPanel: FloatingPanel,
ReactPanel: ReactPanel,
Tab: Tab,
Mixins: Mixins,
Toolbar: Toolbar,
Content: Content,
Footer: Footer,
ToggleButton: ToggleButton,
Button: Button,
addons: PanelAddons,
DragAndDropHandler: DragAndDropHandler
};
module.exports = ReactPanels;
},{"react/addons":4}],4:[function(require,module,exports){
module.exports = require('./lib/ReactWithAddons');
},{"./lib/ReactWithAddons":104}],5:[function(require,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 AutoFocusMixin
* @typechecks static-only
*/
'use strict';
var focusNode = require("./focusNode");
var AutoFocusMixin = {
componentDidMount: function() {
if (this.props.autoFocus) {
focusNode(this.getDOMNode());
}
}
};
module.exports = AutoFocusMixin;
},{"./focusNode":138}],6:[function(require,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 BeforeInputEventPlugin
* @typechecks static-only
*/
'use strict';
var EventConstants = require("./EventConstants");
var EventPropagators = require("./EventPropagators");
var ExecutionEnvironment = require("./ExecutionEnvironment");
var FallbackCompositionState = require("./FallbackCompositionState");
var SyntheticCompositionEvent = require("./SyntheticCompositionEvent");
var SyntheticInputEvent = require("./SyntheticInputEvent");
var keyOf = require("./keyOf");
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
) {
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
);
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
) {
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
);
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
) {
return [
extractCompositionEvent(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent
),
extractBeforeInputEvent(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent
)
];
}
};
module.exports = BeforeInputEventPlugin;
},{"./EventConstants":19,"./EventPropagators":24,"./ExecutionEnvironment":25,"./FallbackCompositionState":26,"./SyntheticCompositionEvent":110,"./SyntheticInputEvent":114,"./keyOf":161}],7:[function(require,module,exports){
(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 CSSCore
* @typechecks
*/
var invariant = require("./invariant");
/**
* The CSSCore module specifies the API (and implements most of the methods)
* that should be used when dealing with the display of elements (via their
* CSS classes and visibility on screen. It is an API focused on mutating the
* display and not reading it as no logical state should be encoded in the
* display of elements.
*/
var CSSCore = {
/**
* Adds the class passed in to the element if it doesn't already have it.
*
* @param {DOMElement} element the element to set the class on
* @param {string} className the CSS className
* @return {DOMElement} the element passed in
*/
addClass: function(element, className) {
("production" !== process.env.NODE_ENV ? invariant(
!/\s/.test(className),
'CSSCore.addClass takes only a single class name. "%s" contains ' +
'multiple classes.', className
) : invariant(!/\s/.test(className)));
if (className) {
if (element.classList) {
element.classList.add(className);
} else if (!CSSCore.hasClass(element, className)) {
element.className = element.className + ' ' + className;
}
}
return element;
},
/**
* Removes the class passed in from the element
*
* @param {DOMElement} element the element to set the class on
* @param {string} className the CSS className
* @return {DOMElement} the element passed in
*/
removeClass: function(element, className) {
("production" !== process.env.NODE_ENV ? invariant(
!/\s/.test(className),
'CSSCore.removeClass takes only a single class name. "%s" contains ' +
'multiple classes.', className
) : invariant(!/\s/.test(className)));
if (className) {
if (element.classList) {
element.classList.remove(className);
} else if (CSSCore.hasClass(element, className)) {
element.className = element.className
.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)', 'g'), '$1')
.replace(/\s+/g, ' ') // multiple spaces to one
.replace(/^\s*|\s*$/g, ''); // trim the ends
}
}
return element;
},
/**
* Helper to add or remove a class from an element based on a condition.
*
* @param {DOMElement} element the element to set the class on
* @param {string} className the CSS className
* @param {*} bool condition to whether to add or remove the class
* @return {DOMElement} the element passed in
*/
conditionClass: function(element, className, bool) {
return (bool ? CSSCore.addClass : CSSCore.removeClass)(element, className);
},
/**
* Tests whether the element has the class specified.
*
* @param {DOMNode|DOMWindow} element the element to set the class on
* @param {string} className the CSS className
* @return {boolean} true if the element has the class, false if not
*/
hasClass: function(element, className) {
("production" !== process.env.NODE_ENV ? invariant(
!/\s/.test(className),
'CSS.hasClass takes only a single class name.'
) : invariant(!/\s/.test(className)));
if (element.classList) {
return !!className && element.classList.contains(className);
}
return (' ' + element.className + ' ').indexOf(' ' + className + ' ') > -1;
}
};
module.exports = CSSCore;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],8:[function(require,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 = {
boxFlex: true,
boxFlexGroup: true,
columnCount: true,
flex: true,
flexGrow: true,
flexShrink: true,
fontWeight: true,
lineClamp: true,
lineHeight: true,
opacity: true,
order: true,
orphans: true,
widows: true,
zIndex: true,
zoom: true,
// SVG-related properties
fillOpacity: true,
strokeOpacity: 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: {
backgroundImage: true,
backgroundPosition: true,
backgroundRepeat: true,
backgroundColor: 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
}
};
var CSSProperty = {
isUnitlessNumber: isUnitlessNumber,
shorthandPropertyExpansions: shorthandPropertyExpansions
};
module.exports = CSSProperty;
},{}],9:[function(require,module,exports){
(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 = require("./CSSProperty");
var ExecutionEnvironment = require("./ExecutionEnvironment");
var camelizeStyleName = require("./camelizeStyleName");
var dangerousStyleValue = require("./dangerousStyleValue");
var hyphenateStyleName = require("./hyphenateStyleName");
var memoizeStringOnly = require("./memoizeStringOnly");
var warning = require("./warning");
var processStyleName = memoizeStringOnly(function(styleName) {
return hyphenateStyleName(styleName);
});
var styleFloatAccessor = 'cssFloat';
if (ExecutionEnvironment.canUseDOM) {
// IE8 only supports accessing cssFloat (standard) as styleFloat
if (document.documentElement.style.cssFloat === undefined) {
styleFloatAccessor = 'styleFloat';
}
}
if ("production" !== process.env.NODE_ENV) {
// '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;
("production" !== process.env.NODE_ENV ? warning(
false,
'Unsupported style property %s. Did you mean %s?',
name,
camelizeStyleName(name)
) : null);
};
var warnBadVendoredStyleName = function(name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
("production" !== process.env.NODE_ENV ? warning(
false,
'Unsupported vendor-prefixed style property %s. Did you mean %s?',
name,
name.charAt(0).toUpperCase() + name.slice(1)
) : null);
};
var warnStyleValueWithSemicolon = function(name, value) {
if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
return;
}
warnedStyleValues[value] = true;
("production" !== process.env.NODE_ENV ? warning(
false,
'Style property values shouldn\'t contain a semicolon. ' +
'Try "%s: %s" instead.',
name,
value.replace(badStyleValueWithSemicolonPattern, '')
) : null);
};
/**
* @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 ("production" !== process.env.NODE_ENV) {
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 ("production" !== process.env.NODE_ENV) {
warnValidStyle(styleName, styles[styleName]);
}
var styleValue = dangerousStyleValue(styleName, styles[styleName]);
if (styleName === 'float') {
styleName = styleFloatAccessor;
}
if (styleValue) {
style[styleName] = styleValue;
} else {
var expansion = 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] = '';
}
}
}
}
};
module.exports = CSSPropertyOperations;
}).call(this,require('_process'))
},{"./CSSProperty":8,"./ExecutionEnvironment":25,"./camelizeStyleName":125,"./dangerousStyleValue":132,"./hyphenateStyleName":152,"./memoizeStringOnly":163,"./warning":175,"_process":2}],10:[function(require,module,exports){
(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 = require("./PooledClass");
var assign = require("./Object.assign");
var invariant = require("./invariant");
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
callbacks.length === contexts.length,
'Mismatched list of contexts in callback queue'
) : invariant(callbacks.length === contexts.length));
this._callbacks = null;
this._contexts = null;
for (var i = 0, l = callbacks.length; i < l; 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;
}).call(this,require('_process'))
},{"./Object.assign":32,"./PooledClass":33,"./invariant":154,"_process":2}],11:[function(require,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 ChangeEventPlugin
*/
'use strict';
var EventConstants = require("./EventConstants");
var EventPluginHub = require("./EventPluginHub");
var EventPropagators = require("./EventPropagators");
var ExecutionEnvironment = require("./ExecutionEnvironment");
var ReactUpdates = require("./ReactUpdates");
var SyntheticEvent = require("./SyntheticEvent");
var isEventSupported = require("./isEventSupported");
var isTextInputElement = require("./isTextInputElement");
var keyOf = require("./keyOf");
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) {
return (
elem.nodeName === 'SELECT' ||
(elem.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
);
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();
}
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'
);
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 === '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) {
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
);
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
}
}
if (handleEventFunc) {
handleEventFunc(
topLevelType,
topLevelTarget,
topLevelTargetID
);
}
}
};
module.exports = ChangeEventPlugin;
},{"./EventConstants":19,"./EventPluginHub":21,"./EventPropagators":24,"./ExecutionEnvironment":25,"./ReactUpdates":103,"./SyntheticEvent":112,"./isEventSupported":155,"./isTextInputElement":157,"./keyOf":161}],12:[function(require,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;
},{}],13:[function(require,module,exports){
(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 = require("./Danger");
var ReactMultiChildUpdateTypes = require("./ReactMultiChildUpdateTypes");
var setTextContent = require("./setTextContent");
var invariant = require("./invariant");
/**
* 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`.
parentNode.insertBefore(
childNode,
parentNode.childNodes[index] || null
);
}
/**
* 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;
("production" !== process.env.NODE_ENV ? invariant(
updatedChild,
'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(updatedChild));
initialChildren = initialChildren || {};
initialChildren[parentID] = initialChildren[parentID] || [];
initialChildren[parentID][updatedIndex] = updatedChild;
updatedChildren = updatedChildren || [];
updatedChildren.push(updatedChild);
}
}
var renderedMarkup = Danger.dangerouslyRenderMarkup(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.TEXT_CONTENT:
setTextContent(
update.parentNode,
update.textContent
);
break;
case ReactMultiChildUpdateTypes.REMOVE_NODE:
// Already removed by the for-loop above.
break;
}
}
}
};
module.exports = DOMChildrenOperations;
}).call(this,require('_process'))
},{"./Danger":16,"./ReactMultiChildUpdateTypes":82,"./invariant":154,"./setTextContent":169,"_process":2}],14:[function(require,module,exports){
(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
*/
/*jslint bitwise: true */
'use strict';
var invariant = require("./invariant");
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.
*
* 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 Properties = domPropertyConfig.Properties || {};
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) {
("production" !== process.env.NODE_ENV ? invariant(
!DOMProperty.isStandardName.hasOwnProperty(propName),
'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(!DOMProperty.isStandardName.hasOwnProperty(propName)));
DOMProperty.isStandardName[propName] = true;
var lowerCased = propName.toLowerCase();
DOMProperty.getPossibleStandardName[lowerCased] = propName;
if (DOMAttributeNames.hasOwnProperty(propName)) {
var attributeName = DOMAttributeNames[propName];
DOMProperty.getPossibleStandardName[attributeName] = propName;
DOMProperty.getAttributeName[propName] = attributeName;
} else {
DOMProperty.getAttributeName[propName] = lowerCased;
}
DOMProperty.getPropertyName[propName] =
DOMPropertyNames.hasOwnProperty(propName) ?
DOMPropertyNames[propName] :
propName;
if (DOMMutationMethods.hasOwnProperty(propName)) {
DOMProperty.getMutationMethod[propName] = DOMMutationMethods[propName];
} else {
DOMProperty.getMutationMethod[propName] = null;
}
var propConfig = Properties[propName];
DOMProperty.mustUseAttribute[propName] =
checkMask(propConfig, DOMPropertyInjection.MUST_USE_ATTRIBUTE);
DOMProperty.mustUseProperty[propName] =
checkMask(propConfig, DOMPropertyInjection.MUST_USE_PROPERTY);
DOMProperty.hasSideEffects[propName] =
checkMask(propConfig, DOMPropertyInjection.HAS_SIDE_EFFECTS);
DOMProperty.hasBooleanValue[propName] =
checkMask(propConfig, DOMPropertyInjection.HAS_BOOLEAN_VALUE);
DOMProperty.hasNumericValue[propName] =
checkMask(propConfig, DOMPropertyInjection.HAS_NUMERIC_VALUE);
DOMProperty.hasPositiveNumericValue[propName] =
checkMask(propConfig, DOMPropertyInjection.HAS_POSITIVE_NUMERIC_VALUE);
DOMProperty.hasOverloadedBooleanValue[propName] =
checkMask(propConfig, DOMPropertyInjection.HAS_OVERLOADED_BOOLEAN_VALUE);
("production" !== process.env.NODE_ENV ? invariant(
!DOMProperty.mustUseAttribute[propName] ||
!DOMProperty.mustUseProperty[propName],
'DOMProperty: Cannot require using both attribute and property: %s',
propName
) : invariant(!DOMProperty.mustUseAttribute[propName] ||
!DOMProperty.mustUseProperty[propName]));
("production" !== process.env.NODE_ENV ? invariant(
DOMProperty.mustUseProperty[propName] ||
!DOMProperty.hasSideEffects[propName],
'DOMProperty: Properties that have side effects must use property: %s',
propName
) : invariant(DOMProperty.mustUseProperty[propName] ||
!DOMProperty.hasSideEffects[propName]));
("production" !== process.env.NODE_ENV ? invariant(
!!DOMProperty.hasBooleanValue[propName] +
!!DOMProperty.hasNumericValue[propName] +
!!DOMProperty.hasOverloadedBooleanValue[propName] <= 1,
'DOMProperty: Value can be one of boolean, overloaded boolean, or ' +
'numeric value, but not a combination: %s',
propName
) : invariant(!!DOMProperty.hasBooleanValue[propName] +
!!DOMProperty.hasNumericValue[propName] +
!!DOMProperty.hasOverloadedBooleanValue[propName] <= 1));
}
}
};
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',
/**
* Checks whether a property name is a standard property.
* @type {Object}
*/
isStandardName: {},
/**
* Mapping from lowercase property names to the properly cased version, used
* to warn in the case of missing properties.
* @type {Object}
*/
getPossibleStandardName: {},
/**
* Mapping from normalized names to attribute names that differ. Attribute
* names are used when rendering markup or with `*Attribute()`.
* @type {Object}
*/
getAttributeName: {},
/**
* Mapping from normalized names to properties on DOM node instances.
* (This includes properties that mutate due to external factors.)
* @type {Object}
*/
getPropertyName: {},
/**
* Mapping from normalized names to mutation methods. This will only exist if
* mutation cannot be set simply by the property or `setAttribute()`.
* @type {Object}
*/
getMutationMethod: {},
/**
* Whether the property must be accessed and mutated as an object property.
* @type {Object}
*/
mustUseAttribute: {},
/**
* Whether the property must be accessed and mutated using `*Attribute()`.
* (This includes anything that fails `<propName> in <element>`.)
* @type {Object}
*/
mustUseProperty: {},
/**
* Whether or not setting a value causes side effects such as triggering
* resources to be loaded or text selection changes. We must ensure that
* the value is only set if it has changed.
* @type {Object}
*/
hasSideEffects: {},
/**
* Whether the property should be removed when set to a falsey value.
* @type {Object}
*/
hasBooleanValue: {},
/**
* Whether the property must be numeric or parse as a
* numeric and should be removed when set to a falsey value.
* @type {Object}
*/
hasNumericValue: {},
/**
* Whether the property must be positive numeric or parse as a positive
* numeric and should be removed when set to a falsey value.
* @type {Object}
*/
hasPositiveNumericValue: {},
/**
* 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.
* @type {Object}
*/
hasOverloadedBooleanValue: {},
/**
* 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;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],15:[function(require,module,exports){
(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 = require("./DOMProperty");
var quoteAttributeValueForBrowser = require("./quoteAttributeValueForBrowser");
var warning = require("./warning");
function shouldIgnoreValue(name, value) {
return value == null ||
(DOMProperty.hasBooleanValue[name] && !value) ||
(DOMProperty.hasNumericValue[name] && isNaN(value)) ||
(DOMProperty.hasPositiveNumericValue[name] && (value < 1)) ||
(DOMProperty.hasOverloadedBooleanValue[name] && value === false);
}
if ("production" !== process.env.NODE_ENV) {
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.
("production" !== process.env.NODE_ENV ? warning(
standardName == null,
'Unknown DOM property %s. Did you mean %s?',
name,
standardName
) : null);
};
}
/**
* 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);
},
/**
* 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) {
if (DOMProperty.isStandardName.hasOwnProperty(name) &&
DOMProperty.isStandardName[name]) {
if (shouldIgnoreValue(name, value)) {
return '';
}
var attributeName = DOMProperty.getAttributeName[name];
if (DOMProperty.hasBooleanValue[name] ||
(DOMProperty.hasOverloadedBooleanValue[name] && value === true)) {
return attributeName;
}
return attributeName + '=' + quoteAttributeValueForBrowser(value);
} else if (DOMProperty.isCustomAttribute(name)) {
if (value == null) {
return '';
}
return name + '=' + quoteAttributeValueForBrowser(value);
} else if ("production" !== process.env.NODE_ENV) {
warnUnknownProperty(name);
}
return null;
},
/**
* Sets the value for a property on a node.
*
* @param {DOMElement} node
* @param {string} name
* @param {*} value
*/
setValueForProperty: function(node, name, value) {
if (DOMProperty.isStandardName.hasOwnProperty(name) &&
DOMProperty.isStandardName[name]) {
var mutationMethod = DOMProperty.getMutationMethod[name];
if (mutationMethod) {
mutationMethod(node, value);
} else if (shouldIgnoreValue(name, value)) {
this.deleteValueForProperty(node, name);
} else if (DOMProperty.mustUseAttribute[name]) {
// `setAttribute` with objects becomes only `[object]` in IE8/9,
// ('' + value) makes it output the correct toString()-value.
node.setAttribute(DOMProperty.getAttributeName[name], '' + value);
} else {
var propName = DOMProperty.getPropertyName[name];
// Must explicitly cast values for HAS_SIDE_EFFECTS-properties to the
// property type before comparing; only `value` does and is string.
if (!DOMProperty.hasSideEffects[name] ||
('' + node[propName]) !== ('' + value)) {
// Contrary to `setAttribute`, object properties are properly
// `toString`ed by IE8/9.
node[propName] = value;
}
}
} else if (DOMProperty.isCustomAttribute(name)) {
if (value == null) {
node.removeAttribute(name);
} else {
node.setAttribute(name, '' + value);
}
} else if ("production" !== process.env.NODE_ENV) {
warnUnknownProperty(name);
}
},
/**
* Deletes the value for a property on a node.
*
* @param {DOMElement} node
* @param {string} name
*/
deleteValueForProperty: function(node, name) {
if (DOMProperty.isStandardName.hasOwnProperty(name) &&
DOMProperty.isStandardName[name]) {
var mutationMethod = DOMProperty.getMutationMethod[name];
if (mutationMethod) {
mutationMethod(node, undefined);
} else if (DOMProperty.mustUseAttribute[name]) {
node.removeAttribute(DOMProperty.getAttributeName[name]);
} else {
var propName = DOMProperty.getPropertyName[name];
var defaultValue = DOMProperty.getDefaultValueForProperty(
node.nodeName,
propName
);
if (!DOMProperty.hasSideEffects[name] ||
('' + node[propName]) !== defaultValue) {
node[propName] = defaultValue;
}
}
} else if (DOMProperty.isCustomAttribute(name)) {
node.removeAttribute(name);
} else if ("production" !== process.env.NODE_ENV) {
warnUnknownProperty(name);
}
}
};
module.exports = DOMPropertyOperations;
}).call(this,require('_process'))
},{"./DOMProperty":14,"./quoteAttributeValueForBrowser":167,"./warning":175,"_process":2}],16:[function(require,module,exports){
(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
*/
/*jslint evil: true, sub: true */
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
var createNodesFromMarkup = require("./createNodesFromMarkup");
var emptyFunction = require("./emptyFunction");
var getMarkupWrap = require("./getMarkupWrap");
var invariant = require("./invariant");
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) {
("production" !== process.env.NODE_ENV ? invariant(
ExecutionEnvironment.canUseDOM,
'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' +
'thread. Make sure `window` and `document` are available globally ' +
'before requiring React when unit testing or use ' +
'React.renderToString for server rendering.'
) : invariant(ExecutionEnvironment.canUseDOM));
var nodeName;
var markupByNodeName = {};
// Group markup by `nodeName` if a wrap is necessary, else by '*'.
for (var i = 0; i < markupList.length; i++) {
("production" !== process.env.NODE_ENV ? invariant(
markupList[i],
'dangerouslyRenderMarkup(...): Missing markup.'
) : invariant(markupList[i]));
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);
("production" !== process.env.NODE_ENV ? invariant(
!resultList.hasOwnProperty(resultIndex),
'Danger: Assigning to an already-occupied result index.'
) : invariant(!resultList.hasOwnProperty(resultIndex)));
resultList[resultIndex] = renderNode;
// This should match resultList.length and markupList.length when
// we're done.
resultListAssignmentCount += 1;
} else if ("production" !== process.env.NODE_ENV) {
console.error(
'Danger: Discarding unexpected node:',
renderNode
);
}
}
}
// Although resultList was populated out of order, it should now be a dense
// array.
("production" !== process.env.NODE_ENV ? invariant(
resultListAssignmentCount === resultList.length,
'Danger: Did not assign to every index of resultList.'
) : invariant(resultListAssignmentCount === resultList.length));
("production" !== process.env.NODE_ENV ? invariant(
resultList.length === markupList.length,
'Danger: Expected markup to render %s nodes, but rendered %s.',
markupList.length,
resultList.length
) : invariant(resultList.length === markupList.length));
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) {
("production" !== process.env.NODE_ENV ? invariant(
ExecutionEnvironment.canUseDOM,
'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a ' +
'worker thread. Make sure `window` and `document` are available ' +
'globally before requiring React when unit testing or use ' +
'React.renderToString for server rendering.'
) : invariant(ExecutionEnvironment.canUseDOM));
("production" !== process.env.NODE_ENV ? invariant(markup, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : invariant(markup));
("production" !== process.env.NODE_ENV ? invariant(
oldChild.tagName.toLowerCase() !== 'html',
'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 React.renderToString().'
) : invariant(oldChild.tagName.toLowerCase() !== 'html'));
var newChild = createNodesFromMarkup(markup, emptyFunction)[0];
oldChild.parentNode.replaceChild(newChild, oldChild);
}
};
module.exports = Danger;
}).call(this,require('_process'))
},{"./ExecutionEnvironment":25,"./createNodesFromMarkup":130,"./emptyFunction":133,"./getMarkupWrap":146,"./invariant":154,"_process":2}],17:[function(require,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 DefaultEventPluginOrder
*/
'use strict';
var keyOf = require("./keyOf");
/**
* 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}),
keyOf({AnalyticsEventPlugin: null}),
keyOf({MobileSafariClickEventPlugin: null})
];
module.exports = DefaultEventPluginOrder;
},{"./keyOf":161}],18:[function(require,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 EnterLeaveEventPlugin
* @typechecks static-only
*/
'use strict';
var EventConstants = require("./EventConstants");
var EventPropagators = require("./EventPropagators");
var SyntheticMouseEvent = require("./SyntheticMouseEvent");
var ReactMount = require("./ReactMount");
var keyOf = require("./keyOf");
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) {
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, to;
if (topLevelType === topLevelTypes.topMouseOut) {
from = topLevelTarget;
to =
getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||
win;
} else {
from = win;
to = topLevelTarget;
}
if (from === to) {
// Nothing pertains to our managed components.
return null;
}
var fromID = from ? ReactMount.getID(from) : '';
var toID = to ? ReactMount.getID(to) : '';
var leave = SyntheticMouseEvent.getPooled(
eventTypes.mouseLeave,
fromID,
nativeEvent
);
leave.type = 'mouseleave';
leave.target = from;
leave.relatedTarget = to;
var enter = SyntheticMouseEvent.getPooled(
eventTypes.mouseEnter,
toID,
nativeEvent
);
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;
},{"./EventConstants":19,"./EventPropagators":24,"./ReactMount":80,"./SyntheticMouseEvent":116,"./keyOf":161}],19:[function(require,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 EventConstants
*/
'use strict';
var keyMirror = require("./keyMirror");
var PropagationPhases = keyMirror({bubbled: null, captured: null});
/**
* Types of raw signals from the browser caught at the top level.
*/
var topLevelTypes = keyMirror({
topBlur: 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,
topError: null,
topFocus: null,
topInput: null,
topKeyDown: null,
topKeyPress: null,
topKeyUp: null,
topLoad: null,
topMouseDown: null,
topMouseMove: null,
topMouseOut: null,
topMouseOver: null,
topMouseUp: null,
topPaste: null,
topReset: null,
topScroll: null,
topSelectionChange: null,
topSubmit: null,
topTextInput: null,
topTouchCancel: null,
topTouchEnd: null,
topTouchMove: null,
topTouchStart: null,
topWheel: null
});
var EventConstants = {
topLevelTypes: topLevelTypes,
PropagationPhases: PropagationPhases
};
module.exports = EventConstants;
},{"./keyMirror":160}],20:[function(require,module,exports){
(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
*/
var emptyFunction = require("./emptyFunction");
/**
* 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) {
if ("production" !== process.env.NODE_ENV) {
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
};
} else {
target.addEventListener(eventType, callback, true);
return {
remove: function() {
target.removeEventListener(eventType, callback, true);
}
};
}
},
registerDefault: function() {}
};
module.exports = EventListener;
}).call(this,require('_process'))
},{"./emptyFunction":133,"_process":2}],21:[function(require,module,exports){
(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 = require("./EventPluginRegistry");
var EventPluginUtils = require("./EventPluginUtils");
var accumulateInto = require("./accumulateInto");
var forEachAccumulated = require("./forEachAccumulated");
var invariant = require("./invariant");
/**
* 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.
* @private
*/
var executeDispatchesAndRelease = function(event) {
if (event) {
var executeDispatch = EventPluginUtils.executeDispatch;
// Plugins can provide custom behavior when dispatching events.
var PluginModule = EventPluginRegistry.getPluginModuleForEvent(event);
if (PluginModule && PluginModule.executeDispatch) {
executeDispatch = PluginModule.executeDispatch;
}
EventPluginUtils.executeDispatchesInOrder(event, executeDispatch);
if (!event.isPersistent()) {
event.constructor.release(event);
}
}
};
/**
* - `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;
("production" !== process.env.NODE_ENV ? invariant(
valid,
'InstanceHandle not injected before use!'
) : invariant(valid));
}
/**
* 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 ("production" !== process.env.NODE_ENV) {
validateInstanceHandle();
}
},
getInstanceHandle: function() {
if ("production" !== process.env.NODE_ENV) {
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) {
("production" !== process.env.NODE_ENV ? invariant(
!listener || typeof listener === 'function',
'Expected %s listener to be a function, instead got type %s',
registrationName, typeof listener
) : invariant(!listener || typeof listener === 'function'));
var bankForRegistrationName =
listenerBank[registrationName] || (listenerBank[registrationName] = {});
bankForRegistrationName[id] = 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 bankForRegistrationName = listenerBank[registrationName];
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) {
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) {
var events;
var plugins = EventPluginRegistry.plugins;
for (var i = 0, l = plugins.length; i < l; 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
);
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() {
// Set `eventQueue` to null before processing it so that we can tell if more
// events get enqueued while processing.
var processingEventQueue = eventQueue;
eventQueue = null;
forEachAccumulated(processingEventQueue, executeDispatchesAndRelease);
("production" !== process.env.NODE_ENV ? invariant(
!eventQueue,
'processEventQueue(): Additional events were enqueued while processing ' +
'an event queue. Support for this has not yet been implemented.'
) : invariant(!eventQueue));
},
/**
* These are needed for tests only. Do not use!
*/
__purge: function() {
listenerBank = {};
},
__getListenerBank: function() {
return listenerBank;
}
};
module.exports = EventPluginHub;
}).call(this,require('_process'))
},{"./EventPluginRegistry":22,"./EventPluginUtils":23,"./accumulateInto":122,"./forEachAccumulated":139,"./invariant":154,"_process":2}],22:[function(require,module,exports){
(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 = require("./invariant");
/**
* 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);
("production" !== process.env.NODE_ENV ? invariant(
pluginIndex > -1,
'EventPluginRegistry: Cannot inject event plugins that do not exist in ' +
'the plugin ordering, `%s`.',
pluginName
) : invariant(pluginIndex > -1));
if (EventPluginRegistry.plugins[pluginIndex]) {
continue;
}
("production" !== process.env.NODE_ENV ? invariant(
PluginModule.extractEvents,
'EventPluginRegistry: Event plugins must implement an `extractEvents` ' +
'method, but `%s` does not.',
pluginName
) : invariant(PluginModule.extractEvents));
EventPluginRegistry.plugins[pluginIndex] = PluginModule;
var publishedEvents = PluginModule.eventTypes;
for (var eventName in publishedEvents) {
("production" !== process.env.NODE_ENV ? invariant(
publishEventForPlugin(
publishedEvents[eventName],
PluginModule,
eventName
),
'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.',
eventName,
pluginName
) : invariant(publishEventForPlugin(
publishedEvents[eventName],
PluginModule,
eventName
)));
}
}
}
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName),
'EventPluginHub: More than one plugin attempted to publish the same ' +
'event name, `%s`.',
eventName
) : invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName)));
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) {
("production" !== process.env.NODE_ENV ? invariant(
!EventPluginRegistry.registrationNameModules[registrationName],
'EventPluginHub: More than one plugin attempted to publish the same ' +
'registration name, `%s`.',
registrationName
) : invariant(!EventPluginRegistry.registrationNameModules[registrationName]));
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) {
("production" !== process.env.NODE_ENV ? invariant(
!EventPluginOrder,
'EventPluginRegistry: Cannot inject event plugin ordering more than ' +
'once. You are likely trying to load more than one copy of React.'
) : invariant(!EventPluginOrder));
// 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) {
("production" !== process.env.NODE_ENV ? invariant(
!namesToPlugins[pluginName],
'EventPluginRegistry: Cannot inject two different event plugins ' +
'using the same name, `%s`.',
pluginName
) : invariant(!namesToPlugins[pluginName]));
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;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],23:[function(require,module,exports){
(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 = require("./EventConstants");
var invariant = require("./invariant");
/**
* 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 ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? invariant(
InjectedMount && InjectedMount.getNode,
'EventPluginUtils.injection.injectMount(...): Injected Mount module ' +
'is missing getNode.'
) : invariant(InjectedMount && InjectedMount.getNode));
}
}
};
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 ("production" !== process.env.NODE_ENV) {
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;
("production" !== process.env.NODE_ENV ? invariant(
idsIsArr === listenersIsArr && IDsLen === listenersLen,
'EventPluginUtils: Invalid `event`.'
) : invariant(idsIsArr === listenersIsArr && IDsLen === listenersLen));
};
}
/**
* Invokes `cb(event, listener, id)`. Avoids using call if no scope is
* provided. The `(listener,id)` pair effectively forms the "dispatch" but are
* kept separate to conserve memory.
*/
function forEachEventDispatch(event, cb) {
var dispatchListeners = event._dispatchListeners;
var dispatchIDs = event._dispatchIDs;
if ("production" !== process.env.NODE_ENV) {
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.
cb(event, dispatchListeners[i], dispatchIDs[i]);
}
} else if (dispatchListeners) {
cb(event, dispatchListeners, dispatchIDs);
}
}
/**
* Default implementation of PluginModule.executeDispatch().
* @param {SyntheticEvent} SyntheticEvent to handle
* @param {function} Application-level callback
* @param {string} domID DOM id to pass to the callback.
*/
function executeDispatch(event, listener, domID) {
event.currentTarget = injection.Mount.getNode(domID);
var returnValue = listener(event, domID);
event.currentTarget = null;
return returnValue;
}
/**
* Standard/simple iteration through an event's collected dispatches.
*/
function executeDispatchesInOrder(event, cb) {
forEachEventDispatch(event, cb);
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 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 ("production" !== process.env.NODE_ENV) {
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 ("production" !== process.env.NODE_ENV) {
validateEventDispatches(event);
}
var dispatchListener = event._dispatchListeners;
var dispatchID = event._dispatchIDs;
("production" !== process.env.NODE_ENV ? invariant(
!Array.isArray(dispatchListener),
'executeDirectDispatch(...): Invalid `event`.'
) : invariant(!Array.isArray(dispatchListener)));
var res = dispatchListener ?
dispatchListener(event, dispatchID) :
null;
event._dispatchListeners = null;
event._dispatchIDs = null;
return res;
}
/**
* @param {SyntheticEvent} event
* @return {bool} 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,
executeDispatch: executeDispatch,
executeDispatchesInOrder: executeDispatchesInOrder,
executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
hasDispatches: hasDispatches,
injection: injection,
useTouchEvents: false
};
module.exports = EventPluginUtils;
}).call(this,require('_process'))
},{"./EventConstants":19,"./invariant":154,"_process":2}],24:[function(require,module,exports){
(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 = require("./EventConstants");
var EventPluginHub = require("./EventPluginHub");
var accumulateInto = require("./accumulateInto");
var forEachAccumulated = require("./forEachAccumulated");
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 ("production" !== process.env.NODE_ENV) {
if (!domID) {
throw new Error('Dispatching id must not be null');
}
}
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 can not 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
);
}
}
/**
* 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 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,
accumulateDirectDispatches: accumulateDirectDispatches,
accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
};
module.exports = EventPropagators;
}).call(this,require('_process'))
},{"./EventConstants":19,"./EventPluginHub":21,"./accumulateInto":122,"./forEachAccumulated":139,"_process":2}],25:[function(require,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
*/
/*jslint evil: true */
"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;
},{}],26:[function(require,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 FallbackCompositionState
* @typechecks static-only
*/
'use strict';
var PooledClass = require("./PooledClass");
var assign = require("./Object.assign");
var getTextContentAccessor = require("./getTextContentAccessor");
/**
* 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, {
/**
* 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;
},{"./Object.assign":32,"./PooledClass":33,"./getTextContentAccessor":149}],27:[function(require,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 HTMLDOMPropertyConfig
*/
/*jslint bitwise: true*/
'use strict';
var DOMProperty = require("./DOMProperty");
var ExecutionEnvironment = require("./ExecutionEnvironment");
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 AutoFocusMixin
// autoFocus: HAS_BOOLEAN_VALUE,
autoPlay: HAS_BOOLEAN_VALUE,
cellPadding: null,
cellSpacing: null,
charSet: 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,
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,
href: null,
hrefLang: null,
htmlFor: null,
httpEquiv: null,
icon: null,
id: MUST_USE_PROPERTY,
label: null,
lang: null,
list: MUST_USE_ATTRIBUTE,
loop: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
manifest: MUST_USE_ATTRIBUTE,
marginHeight: null,
marginWidth: null,
max: null,
maxLength: MUST_USE_ATTRIBUTE,
media: MUST_USE_ATTRIBUTE,
mediaGroup: null,
method: null,
min: null,
multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
name: null,
noValidate: HAS_BOOLEAN_VALUE,
open: HAS_BOOLEAN_VALUE,
pattern: null,
placeholder: null,
poster: null,
preload: null,
radioGroup: null,
readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
rel: null,
required: HAS_BOOLEAN_VALUE,
role: MUST_USE_ATTRIBUTE,
rows: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,
rowSpan: null,
sandbox: null,
scope: null,
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,
srcSet: MUST_USE_ATTRIBUTE,
start: HAS_NUMERIC_VALUE,
step: null,
style: 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,
/**
* Non-standard Properties
*/
// autoCapitalize and autoCorrect are supported in Mobile Safari for
// keyboard hints.
autoCapitalize: null,
autoCorrect: 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,
// property is supported for OpenGraph in meta tags.
property: null
},
DOMAttributeNames: {
acceptCharset: 'accept-charset',
className: 'class',
htmlFor: 'for',
httpEquiv: 'http-equiv'
},
DOMPropertyNames: {
autoCapitalize: 'autocapitalize',
autoComplete: 'autocomplete',
autoCorrect: 'autocorrect',
autoFocus: 'autofocus',
autoPlay: 'autoplay',
// `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;
},{"./DOMProperty":14,"./ExecutionEnvironment":25}],28:[function(require,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 LinkedStateMixin
* @typechecks static-only
*/
'use strict';
var ReactLink = require("./ReactLink");
var ReactStateSetters = require("./ReactStateSetters");
/**
* A simple mixin around ReactLink.forState().
*/
var LinkedStateMixin = {
/**
* Create a ReactLink that's linked to part of this component's state. The
* ReactLink will have the current value of this.state[key] and will call
* setState() when a change is requested.
*
* @param {string} key state key to update. Note: you may want to use keyOf()
* if you're using Google Closure Compiler advanced mode.
* @return {ReactLink} ReactLink instance linking to the state.
*/
linkState: function(key) {
return new ReactLink(
this.state[key],
ReactStateSetters.createStateKeySetter(this, key)
);
}
};
module.exports = LinkedStateMixin;
},{"./ReactLink":78,"./ReactStateSetters":97}],29:[function(require,module,exports){
(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 = require("./ReactPropTypes");
var invariant = require("./invariant");
var hasReadOnlyValue = {
'button': true,
'checkbox': true,
'image': true,
'hidden': true,
'radio': true,
'reset': true,
'submit': true
};
function _assertSingleLink(input) {
("production" !== process.env.NODE_ENV ? invariant(
input.props.checkedLink == null || input.props.valueLink == null,
'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(input.props.checkedLink == null || input.props.valueLink == null));
}
function _assertValueLink(input) {
_assertSingleLink(input);
("production" !== process.env.NODE_ENV ? invariant(
input.props.value == null && input.props.onChange == null,
'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(input.props.value == null && input.props.onChange == null));
}
function _assertCheckedLink(input) {
_assertSingleLink(input);
("production" !== process.env.NODE_ENV ? invariant(
input.props.checked == null && input.props.onChange == null,
'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(input.props.checked == null && input.props.onChange == null));
}
/**
* @param {SyntheticEvent} e change event to handle
*/
function _handleLinkedValueChange(e) {
/*jshint validthis:true */
this.props.valueLink.requestChange(e.target.value);
}
/**
* @param {SyntheticEvent} e change event to handle
*/
function _handleLinkedCheckChange(e) {
/*jshint validthis:true */
this.props.checkedLink.requestChange(e.target.checked);
}
/**
* Provide a linked `value` attribute for controlled forms. You should not use
* this outside of the ReactDOM controlled form components.
*/
var LinkedValueUtils = {
Mixin: {
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
}
},
/**
* @param {ReactComponent} input Form component
* @return {*} current value of the input either from value prop or link.
*/
getValue: function(input) {
if (input.props.valueLink) {
_assertValueLink(input);
return input.props.valueLink.value;
}
return input.props.value;
},
/**
* @param {ReactComponent} input Form component
* @return {*} current checked status of the input either from checked prop
* or link.
*/
getChecked: function(input) {
if (input.props.checkedLink) {
_assertCheckedLink(input);
return input.props.checkedLink.value;
}
return input.props.checked;
},
/**
* @param {ReactComponent} input Form component
* @return {function} change callback either from onChange prop or link.
*/
getOnChange: function(input) {
if (input.props.valueLink) {
_assertValueLink(input);
return _handleLinkedValueChange;
} else if (input.props.checkedLink) {
_assertCheckedLink(input);
return _handleLinkedCheckChange;
}
return input.props.onChange;
}
};
module.exports = LinkedValueUtils;
}).call(this,require('_process'))
},{"./ReactPropTypes":89,"./invariant":154,"_process":2}],30:[function(require,module,exports){
(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 LocalEventTrapMixin
*/
'use strict';
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var accumulateInto = require("./accumulateInto");
var forEachAccumulated = require("./forEachAccumulated");
var invariant = require("./invariant");
function remove(event) {
event.remove();
}
var LocalEventTrapMixin = {
trapBubbledEvent:function(topLevelType, handlerBaseName) {
("production" !== process.env.NODE_ENV ? invariant(this.isMounted(), 'Must be mounted to trap events') : invariant(this.isMounted()));
// 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.
var node = this.getDOMNode();
("production" !== process.env.NODE_ENV ? invariant(
node,
'LocalEventTrapMixin.trapBubbledEvent(...): Requires node to be rendered.'
) : invariant(node));
var listener = ReactBrowserEventEmitter.trapBubbledEvent(
topLevelType,
handlerBaseName,
node
);
this._localEventListeners =
accumulateInto(this._localEventListeners, listener);
},
// trapCapturedEvent would look nearly identical. We don't implement that
// method because it isn't currently needed.
componentWillUnmount:function() {
if (this._localEventListeners) {
forEachAccumulated(this._localEventListeners, remove);
}
}
};
module.exports = LocalEventTrapMixin;
}).call(this,require('_process'))
},{"./ReactBrowserEventEmitter":36,"./accumulateInto":122,"./forEachAccumulated":139,"./invariant":154,"_process":2}],31:[function(require,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 MobileSafariClickEventPlugin
* @typechecks static-only
*/
'use strict';
var EventConstants = require("./EventConstants");
var emptyFunction = require("./emptyFunction");
var topLevelTypes = EventConstants.topLevelTypes;
/**
* 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.
*
* This particular plugin works around the bug by attaching an empty click
* listener on `touchstart` (which does fire on every element).
*/
var MobileSafariClickEventPlugin = {
eventTypes: 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 {*} An accumulation of synthetic events.
* @see {EventPluginHub.extractEvents}
*/
extractEvents: function(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent) {
if (topLevelType === topLevelTypes.topTouchStart) {
var target = nativeEvent.target;
if (target && !target.onclick) {
target.onclick = emptyFunction;
}
}
}
};
module.exports = MobileSafariClickEventPlugin;
},{"./EventConstants":19,"./emptyFunction":133}],32:[function(require,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;
},{}],33:[function(require,module,exports){
(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 = require("./invariant");
/**
* 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 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;
("production" !== process.env.NODE_ENV ? invariant(
instance instanceof Klass,
'Trying to release an instance into a pool of a different type.'
) : invariant(instance instanceof Klass));
if (instance.destructor) {
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,
fiveArgumentPooler: fiveArgumentPooler
};
module.exports = PooledClass;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],34:[function(require,module,exports){
(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 React
*/
/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/
'use strict';
var EventPluginUtils = require("./EventPluginUtils");
var ReactChildren = require("./ReactChildren");
var ReactComponent = require("./ReactComponent");
var ReactClass = require("./ReactClass");
var ReactContext = require("./ReactContext");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactElement = require("./ReactElement");
var ReactElementValidator = require("./ReactElementValidator");
var ReactDOM = require("./ReactDOM");
var ReactDOMTextComponent = require("./ReactDOMTextComponent");
var ReactDefaultInjection = require("./ReactDefaultInjection");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var ReactMount = require("./ReactMount");
var ReactPerf = require("./ReactPerf");
var ReactPropTypes = require("./ReactPropTypes");
var ReactReconciler = require("./ReactReconciler");
var ReactServerRendering = require("./ReactServerRendering");
var assign = require("./Object.assign");
var findDOMNode = require("./findDOMNode");
var onlyChild = require("./onlyChild");
ReactDefaultInjection.inject();
var createElement = ReactElement.createElement;
var createFactory = ReactElement.createFactory;
var cloneElement = ReactElement.cloneElement;
if ("production" !== process.env.NODE_ENV) {
createElement = ReactElementValidator.createElement;
createFactory = ReactElementValidator.createFactory;
cloneElement = ReactElementValidator.cloneElement;
}
var render = ReactPerf.measure('React', 'render', ReactMount.render);
var React = {
Children: {
map: ReactChildren.map,
forEach: ReactChildren.forEach,
count: ReactChildren.count,
only: onlyChild
},
Component: ReactComponent,
DOM: ReactDOM,
PropTypes: ReactPropTypes,
initializeTouchEvents: function(shouldUseTouch) {
EventPluginUtils.useTouchEvents = shouldUseTouch;
},
createClass: ReactClass.createClass,
createElement: createElement,
cloneElement: cloneElement,
createFactory: createFactory,
createMixin: function(mixin) {
// Currently a noop. Will be used to validate and trace mixins.
return mixin;
},
constructAndRenderComponent: ReactMount.constructAndRenderComponent,
constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,
findDOMNode: findDOMNode,
render: render,
renderToString: ReactServerRendering.renderToString,
renderToStaticMarkup: ReactServerRendering.renderToStaticMarkup,
unmountComponentAtNode: ReactMount.unmountComponentAtNode,
isValidElement: ReactElement.isValidElement,
withContext: ReactContext.withContext,
// Hook for JSX spread, don't use this for anything else.
__spread: assign
};
// Inject the runtime into a devtools global hook regardless of browser.
// Allows for debugging when the hook is injected on the page.
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 ("production" !== process.env.NODE_ENV) {
var ExecutionEnvironment = require("./ExecutionEnvironment");
if (ExecutionEnvironment.canUseDOM && window.top === window.self) {
// If we're in Chrome, look for the devtools marker and provide a download
// link if not installed.
if (navigator.userAgent.indexOf('Chrome') > -1) {
if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
console.debug(
'Download the React DevTools for a better development experience: ' +
'http://fb.me/react-devtools'
);
}
}
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: ' +
'http://fb.me/react-warning-polyfills'
);
break;
}
}
}
}
React.version = '0.13.1';
module.exports = React;
}).call(this,require('_process'))
},{"./EventPluginUtils":23,"./ExecutionEnvironment":25,"./Object.assign":32,"./ReactChildren":40,"./ReactClass":41,"./ReactComponent":42,"./ReactContext":47,"./ReactCurrentOwner":48,"./ReactDOM":49,"./ReactDOMTextComponent":60,"./ReactDefaultInjection":63,"./ReactElement":66,"./ReactElementValidator":67,"./ReactInstanceHandles":75,"./ReactMount":80,"./ReactPerf":85,"./ReactPropTypes":89,"./ReactReconciler":92,"./ReactServerRendering":95,"./findDOMNode":136,"./onlyChild":164,"_process":2}],35:[function(require,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 ReactBrowserComponentMixin
*/
'use strict';
var findDOMNode = require("./findDOMNode");
var ReactBrowserComponentMixin = {
/**
* Returns the DOM node rendered by this component.
*
* @return {DOMElement} The root node of this component.
* @final
* @protected
*/
getDOMNode: function() {
return findDOMNode(this);
}
};
module.exports = ReactBrowserComponentMixin;
},{"./findDOMNode":136}],36:[function(require,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 ReactBrowserEventEmitter
* @typechecks static-only
*/
'use strict';
var EventConstants = require("./EventConstants");
var EventPluginHub = require("./EventPluginHub");
var EventPluginRegistry = require("./EventPluginRegistry");
var ReactEventEmitterMixin = require("./ReactEventEmitterMixin");
var ViewportMetrics = require("./ViewportMetrics");
var assign = require("./Object.assign");
var isEventSupported = require("./isEventSupported");
/**
* 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 = {
topBlur: 'blur',
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',
topFocus: 'focus',
topInput: 'input',
topKeyDown: 'keydown',
topKeyPress: 'keypress',
topKeyUp: 'keyup',
topMouseDown: 'mousedown',
topMouseMove: 'mousemove',
topMouseOut: 'mouseout',
topMouseOver: 'mouseover',
topMouseUp: 'mouseup',
topPaste: 'paste',
topScroll: 'scroll',
topSelectionChange: 'selectionchange',
topTextInput: 'textInput',
topTouchCancel: 'touchcancel',
topTouchEnd: 'touchend',
topTouchMove: 'touchmove',
topTouchStart: 'touchstart',
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, l = dependencies.length; i < l; 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
});
module.exports = ReactBrowserEventEmitter;
},{"./EventConstants":19,"./EventPluginHub":21,"./EventPluginRegistry":22,"./Object.assign":32,"./ReactEventEmitterMixin":70,"./ViewportMetrics":121,"./isEventSupported":155}],37:[function(require,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.
*
* @typechecks
* @providesModule ReactCSSTransitionGroup
*/
'use strict';
var React = require("./React");
var assign = require("./Object.assign");
var ReactTransitionGroup = React.createFactory(
require("./ReactTransitionGroup")
);
var ReactCSSTransitionGroupChild = React.createFactory(
require("./ReactCSSTransitionGroupChild")
);
var ReactCSSTransitionGroup = React.createClass({
displayName: 'ReactCSSTransitionGroup',
propTypes: {
transitionName: React.PropTypes.string.isRequired,
transitionAppear: React.PropTypes.bool,
transitionEnter: React.PropTypes.bool,
transitionLeave: React.PropTypes.bool
},
getDefaultProps: function() {
return {
transitionAppear: false,
transitionEnter: true,
transitionLeave: true
};
},
_wrapChild: function(child) {
// We need to provide this childFactory so that
// ReactCSSTransitionGroupChild can receive updates to name, enter, and
// leave while it is leaving.
return ReactCSSTransitionGroupChild(
{
name: this.props.transitionName,
appear: this.props.transitionAppear,
enter: this.props.transitionEnter,
leave: this.props.transitionLeave
},
child
);
},
render: function() {
return (
ReactTransitionGroup(
assign({}, this.props, {childFactory: this._wrapChild})
)
);
}
});
module.exports = ReactCSSTransitionGroup;
},{"./Object.assign":32,"./React":34,"./ReactCSSTransitionGroupChild":38,"./ReactTransitionGroup":101}],38:[function(require,module,exports){
(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
* @providesModule ReactCSSTransitionGroupChild
*/
'use strict';
var React = require("./React");
var CSSCore = require("./CSSCore");
var ReactTransitionEvents = require("./ReactTransitionEvents");
var onlyChild = require("./onlyChild");
var warning = require("./warning");
// We don't remove the element from the DOM until we receive an animationend or
// transitionend event. If the user screws up and forgets to add an animation
// their node will be stuck in the DOM forever, so we detect if an animation
// does not start and if it doesn't, we just call the end listener immediately.
var TICK = 17;
var NO_EVENT_TIMEOUT = 5000;
var noEventListener = null;
if ("production" !== process.env.NODE_ENV) {
noEventListener = function() {
("production" !== process.env.NODE_ENV ? warning(
false,
'transition(): tried to perform an animation without ' +
'an animationend or transitionend event after timeout (' +
'%sms). You should either disable this ' +
'transition in JS or add a CSS animation/transition.',
NO_EVENT_TIMEOUT
) : null);
};
}
var ReactCSSTransitionGroupChild = React.createClass({
displayName: 'ReactCSSTransitionGroupChild',
transition: function(animationType, finishCallback) {
var node = this.getDOMNode();
var className = this.props.name + '-' + animationType;
var activeClassName = className + '-active';
var noEventTimeout = null;
var endListener = function(e) {
if (e && e.target !== node) {
return;
}
if ("production" !== process.env.NODE_ENV) {
clearTimeout(noEventTimeout);
}
CSSCore.removeClass(node, className);
CSSCore.removeClass(node, activeClassName);
ReactTransitionEvents.removeEndEventListener(node, endListener);
// Usually this optional callback is used for informing an owner of
// a leave animation and telling it to remove the child.
if (finishCallback) {
finishCallback();
}
};
ReactTransitionEvents.addEndEventListener(node, endListener);
CSSCore.addClass(node, className);
// Need to do this to actually trigger a transition.
this.queueClass(activeClassName);
if ("production" !== process.env.NODE_ENV) {
noEventTimeout = setTimeout(noEventListener, NO_EVENT_TIMEOUT);
}
},
queueClass: function(className) {
this.classNameQueue.push(className);
if (!this.timeout) {
this.timeout = setTimeout(this.flushClassNameQueue, TICK);
}
},
flushClassNameQueue: function() {
if (this.isMounted()) {
this.classNameQueue.forEach(
CSSCore.addClass.bind(CSSCore, this.getDOMNode())
);
}
this.classNameQueue.length = 0;
this.timeout = null;
},
componentWillMount: function() {
this.classNameQueue = [];
},
componentWillUnmount: function() {
if (this.timeout) {
clearTimeout(this.timeout);
}
},
componentWillAppear: function(done) {
if (this.props.appear) {
this.transition('appear', done);
} else {
done();
}
},
componentWillEnter: function(done) {
if (this.props.enter) {
this.transition('enter', done);
} else {
done();
}
},
componentWillLeave: function(done) {
if (this.props.leave) {
this.transition('leave', done);
} else {
done();
}
},
render: function() {
return onlyChild(this.props.children);
}
});
module.exports = ReactCSSTransitionGroupChild;
}).call(this,require('_process'))
},{"./CSSCore":7,"./React":34,"./ReactTransitionEvents":100,"./onlyChild":164,"./warning":175,"_process":2}],39:[function(require,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 ReactChildReconciler
* @typechecks static-only
*/
'use strict';
var ReactReconciler = require("./ReactReconciler");
var flattenChildren = require("./flattenChildren");
var instantiateReactComponent = require("./instantiateReactComponent");
var shouldUpdateReactComponent = require("./shouldUpdateReactComponent");
/**
* 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) {
var children = flattenChildren(nestedChildNodes);
for (var name in children) {
if (children.hasOwnProperty(name)) {
var child = children[name];
// The rendered children must be turned into instances as they're
// mounted.
var childInstance = instantiateReactComponent(child, null);
children[name] = childInstance;
}
}
return children;
},
/**
* Updates the rendered children and returns a new set of children.
*
* @param {?object} prevChildren Previously initialized set of children.
* @param {?object} nextNestedChildNodes Nested child maps.
* @param {ReactReconcileTransaction} transaction
* @param {object} context
* @return {?object} A new set of child instances.
* @internal
*/
updateChildren: function(
prevChildren,
nextNestedChildNodes,
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.
var nextChildren = flattenChildren(nextNestedChildNodes);
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 (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) {
var renderedChild = renderedChildren[name];
ReactReconciler.unmountComponent(renderedChild);
}
}
};
module.exports = ReactChildReconciler;
},{"./ReactReconciler":92,"./flattenChildren":137,"./instantiateReactComponent":153,"./shouldUpdateReactComponent":171}],40:[function(require,module,exports){
(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 ReactChildren
*/
'use strict';
var PooledClass = require("./PooledClass");
var ReactFragment = require("./ReactFragment");
var traverseAllChildren = require("./traverseAllChildren");
var warning = require("./warning");
var twoArgumentPooler = PooledClass.twoArgumentPooler;
var threeArgumentPooler = PooledClass.threeArgumentPooler;
/**
* 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.forEachFunction = forEachFunction;
this.forEachContext = forEachContext;
}
PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);
function forEachSingleChild(traverseContext, child, name, i) {
var forEachBookKeeping = traverseContext;
forEachBookKeeping.forEachFunction.call(
forEachBookKeeping.forEachContext, child, i);
}
/**
* 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, mapFunction, mapContext) {
this.mapResult = mapResult;
this.mapFunction = mapFunction;
this.mapContext = mapContext;
}
PooledClass.addPoolingTo(MapBookKeeping, threeArgumentPooler);
function mapSingleChildIntoContext(traverseContext, child, name, i) {
var mapBookKeeping = traverseContext;
var mapResult = mapBookKeeping.mapResult;
var keyUnique = !mapResult.hasOwnProperty(name);
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
keyUnique,
'ReactChildren.map(...): 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
) : null);
}
if (keyUnique) {
var mappedChild =
mapBookKeeping.mapFunction.call(mapBookKeeping.mapContext, child, i);
mapResult[name] = mappedChild;
}
}
/**
* Maps children that are typically specified as `props.children`.
*
* The provided mapFunction(child, key, index) will be called for each
* leaf child.
*
* TODO: This may likely break any calls to `ReactChildren.map` that were
* previously relying on the fact that we guarded against null children.
*
* @param {?*} children Children tree container.
* @param {function(*, int)} mapFunction.
* @param {*} mapContext Context for mapFunction.
* @return {object} Object containing the ordered map of results.
*/
function mapChildren(children, func, context) {
if (children == null) {
return children;
}
var mapResult = {};
var traverseContext = MapBookKeeping.getPooled(mapResult, func, context);
traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
MapBookKeeping.release(traverseContext);
return ReactFragment.create(mapResult);
}
function forEachSingleChildDummy(traverseContext, child, name, i) {
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);
}
var ReactChildren = {
forEach: forEachChildren,
map: mapChildren,
count: countChildren
};
module.exports = ReactChildren;
}).call(this,require('_process'))
},{"./PooledClass":33,"./ReactFragment":72,"./traverseAllChildren":173,"./warning":175,"_process":2}],41:[function(require,module,exports){
(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 = require("./ReactComponent");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactElement = require("./ReactElement");
var ReactErrorUtils = require("./ReactErrorUtils");
var ReactInstanceMap = require("./ReactInstanceMap");
var ReactLifeCycle = require("./ReactLifeCycle");
var ReactPropTypeLocations = require("./ReactPropTypeLocations");
var ReactPropTypeLocationNames = require("./ReactPropTypeLocationNames");
var ReactUpdateQueue = require("./ReactUpdateQueue");
var assign = require("./Object.assign");
var invariant = require("./invariant");
var keyMirror = require("./keyMirror");
var keyOf = require("./keyOf");
var warning = require("./warning");
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 = [];
/**
* 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 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 ("production" !== process.env.NODE_ENV) {
validateTypeDef(
Constructor,
childContextTypes,
ReactPropTypeLocations.childContext
);
}
Constructor.childContextTypes = assign(
{},
Constructor.childContextTypes,
childContextTypes
);
},
contextTypes: function(Constructor, contextTypes) {
if ("production" !== process.env.NODE_ENV) {
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 ("production" !== process.env.NODE_ENV) {
validateTypeDef(
Constructor,
propTypes,
ReactPropTypeLocations.prop
);
}
Constructor.propTypes = assign(
{},
Constructor.propTypes,
propTypes
);
},
statics: function(Constructor, statics) {
mixStaticSpecIntoComponent(Constructor, statics);
}
};
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__
("production" !== process.env.NODE_ENV ? 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
) : null);
}
}
}
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)) {
("production" !== process.env.NODE_ENV ? invariant(
specPolicy === SpecPolicy.OVERRIDE_BASE,
'ReactClassInterface: You are attempting to override ' +
'`%s` from your class specification. Ensure that your method names ' +
'do not overlap with React methods.',
name
) : invariant(specPolicy === SpecPolicy.OVERRIDE_BASE));
}
// Disallow defining methods more than once unless explicitly allowed.
if (proto.hasOwnProperty(name)) {
("production" !== process.env.NODE_ENV ? invariant(
specPolicy === SpecPolicy.DEFINE_MANY ||
specPolicy === SpecPolicy.DEFINE_MANY_MERGED,
'ReactClassInterface: You are attempting to define ' +
'`%s` on your component more than once. This conflict may be due ' +
'to a mixin.',
name
) : invariant(specPolicy === SpecPolicy.DEFINE_MANY ||
specPolicy === SpecPolicy.DEFINE_MANY_MERGED));
}
}
/**
* Mixin helper which handles policy validation and reserved
* specification keys when building React classses.
*/
function mixSpecIntoComponent(Constructor, spec) {
if (!spec) {
return;
}
("production" !== process.env.NODE_ENV ? invariant(
typeof spec !== 'function',
'ReactClass: You\'re attempting to ' +
'use a component class as a mixin. Instead, just use a regular object.'
) : invariant(typeof spec !== 'function'));
("production" !== process.env.NODE_ENV ? invariant(
!ReactElement.isValidElement(spec),
'ReactClass: You\'re attempting to ' +
'use a component as a mixin. Instead, just use a regular object.'
) : invariant(!ReactElement.isValidElement(spec)));
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 markedDontBind = property && property.__reactDontBind;
var isFunction = typeof property === 'function';
var shouldAutoBind =
isFunction &&
!isReactClassMethod &&
!isAlreadyDefined &&
!markedDontBind;
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
("production" !== process.env.NODE_ENV ? invariant(
isReactClassMethod && (
(specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)
),
'ReactClass: Unexpected spec policy %s for key %s ' +
'when mixing in component specs.',
specPolicy,
name
) : invariant(isReactClassMethod && (
(specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)
)));
// 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 ("production" !== process.env.NODE_ENV) {
// 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;
("production" !== process.env.NODE_ENV ? invariant(
!isReserved,
'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(!isReserved));
var isInherited = name in Constructor;
("production" !== process.env.NODE_ENV ? invariant(
!isInherited,
'ReactClass: You are attempting to define ' +
'`%s` on your component more than once. This conflict may be ' +
'due to a mixin.',
name
) : invariant(!isInherited));
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) {
("production" !== process.env.NODE_ENV ? invariant(
one && two && typeof one === 'object' && typeof two === 'object',
'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'
) : invariant(one && two && typeof one === 'object' && typeof two === 'object'));
for (var key in two) {
if (two.hasOwnProperty(key)) {
("production" !== process.env.NODE_ENV ? invariant(
one[key] === undefined,
'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(one[key] === 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 ("production" !== process.env.NODE_ENV) {
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 args=[],$__0=1,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);
// 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) {
("production" !== process.env.NODE_ENV ? warning(
false,
'bind(): React component methods may only be bound to the ' +
'component instance. See %s',
componentName
) : null);
} else if (!args.length) {
("production" !== process.env.NODE_ENV ? 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
) : null);
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,
ReactErrorUtils.guard(
method,
component.constructor.displayName + '.' + autoBindKey
)
);
}
}
}
var typeDeprecationDescriptor = {
enumerable: false,
get: function() {
var displayName = this.displayName || this.name || 'Component';
("production" !== process.env.NODE_ENV ? warning(
false,
'%s.type is deprecated. Use %s directly to access the class.',
displayName,
displayName
) : null);
Object.defineProperty(this, 'type', {
value: this
});
return this;
}
};
/**
* 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) {
ReactUpdateQueue.enqueueReplaceState(this, newState);
if (callback) {
ReactUpdateQueue.enqueueCallback(this, callback);
}
},
/**
* Checks whether or not this composite component is mounted.
* @return {boolean} True if mounted, false otherwise.
* @protected
* @final
*/
isMounted: function() {
if ("production" !== process.env.NODE_ENV) {
var owner = ReactCurrentOwner.current;
if (owner !== null) {
("production" !== process.env.NODE_ENV ? 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'
) : null);
owner._warnedAboutRefsInRender = true;
}
}
var internalInstance = ReactInstanceMap.get(this);
return (
internalInstance &&
internalInstance !== ReactLifeCycle.currentlyMountingInstance
);
},
/**
* 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) {
ReactUpdateQueue.enqueueSetProps(this, partialProps);
if (callback) {
ReactUpdateQueue.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) {
ReactUpdateQueue.enqueueReplaceProps(this, newProps);
if (callback) {
ReactUpdateQueue.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) {
// This constructor is overridden by mocks. The argument is used
// by mocks to assert on what gets mounted.
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
this instanceof Constructor,
'Something is calling a React component directly. Use a factory or ' +
'JSX instead. See: http://fb.me/react-legacyfactory'
) : null);
}
// Wire up auto-binding
if (this.__reactAutoBindMap) {
bindAutoBindMethods(this);
}
this.props = props;
this.context = context;
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 ("production" !== process.env.NODE_ENV) {
// 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;
}
}
("production" !== process.env.NODE_ENV ? invariant(
typeof initialState === 'object' && !Array.isArray(initialState),
'%s.getInitialState(): must return an object or null',
Constructor.displayName || 'ReactCompositeComponent'
) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));
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 ("production" !== process.env.NODE_ENV) {
// 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 = {};
}
}
("production" !== process.env.NODE_ENV ? invariant(
Constructor.prototype.render,
'createClass(...): Class specification must implement a `render` method.'
) : invariant(Constructor.prototype.render));
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? 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'
) : null);
}
// Reduce time spent doing lookups by setting these on the prototype.
for (var methodName in ReactClassInterface) {
if (!Constructor.prototype[methodName]) {
Constructor.prototype[methodName] = null;
}
}
// Legacy hook
Constructor.type = Constructor;
if ("production" !== process.env.NODE_ENV) {
try {
Object.defineProperty(Constructor, 'type', typeDeprecationDescriptor);
} catch (x) {
// IE will fail on defineProperty (es5-shim/sham too)
}
}
return Constructor;
},
injection: {
injectMixin: function(mixin) {
injectedMixins.push(mixin);
}
}
};
module.exports = ReactClass;
}).call(this,require('_process'))
},{"./Object.assign":32,"./ReactComponent":42,"./ReactCurrentOwner":48,"./ReactElement":66,"./ReactErrorUtils":69,"./ReactInstanceMap":76,"./ReactLifeCycle":77,"./ReactPropTypeLocationNames":87,"./ReactPropTypeLocations":88,"./ReactUpdateQueue":102,"./invariant":154,"./keyMirror":160,"./keyOf":161,"./warning":175,"_process":2}],42:[function(require,module,exports){
(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 ReactUpdateQueue = require("./ReactUpdateQueue");
var invariant = require("./invariant");
var warning = require("./warning");
/**
* Base class helpers for the updating state of a component.
*/
function ReactComponent(props, context) {
this.props = props;
this.context = context;
}
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
typeof partialState === 'object' ||
typeof partialState === 'function' ||
partialState == null,
'setState(...): takes an object of state variables to update or a ' +
'function which returns an object of state variables.'
) : invariant(typeof partialState === 'object' ||
typeof partialState === 'function' ||
partialState == null));
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
partialState != null,
'setState(...): You passed an undefined or null state object; ' +
'instead, use forceUpdate().'
) : null);
}
ReactUpdateQueue.enqueueSetState(this, partialState);
if (callback) {
ReactUpdateQueue.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) {
ReactUpdateQueue.enqueueForceUpdate(this);
if (callback) {
ReactUpdateQueue.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 ("production" !== process.env.NODE_ENV) {
var deprecatedAPIs = {
getDOMNode: 'getDOMNode',
isMounted: 'isMounted',
replaceProps: 'replaceProps',
replaceState: 'replaceState',
setProps: 'setProps'
};
var defineDeprecationWarning = function(methodName, displayName) {
try {
Object.defineProperty(ReactComponent.prototype, methodName, {
get: function() {
("production" !== process.env.NODE_ENV ? warning(
false,
'%s(...) is deprecated in plain JavaScript React classes.',
displayName
) : null);
return undefined;
}
});
} catch (x) {
// IE will fail on defineProperty (es5-shim/sham too)
}
};
for (var fnName in deprecatedAPIs) {
if (deprecatedAPIs.hasOwnProperty(fnName)) {
defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
}
}
}
module.exports = ReactComponent;
}).call(this,require('_process'))
},{"./ReactUpdateQueue":102,"./invariant":154,"./warning":175,"_process":2}],43:[function(require,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 ReactComponentBrowserEnvironment
*/
/*jslint evil: true */
'use strict';
var ReactDOMIDOperations = require("./ReactDOMIDOperations");
var ReactMount = require("./ReactMount");
/**
* 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;
},{"./ReactDOMIDOperations":53,"./ReactMount":80}],44:[function(require,module,exports){
(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 = require("./invariant");
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) {
("production" !== process.env.NODE_ENV ? invariant(
!injected,
'ReactCompositeComponent: injectEnvironment() can only be called once.'
) : invariant(!injected));
ReactComponentEnvironment.unmountIDFromEnvironment =
environment.unmountIDFromEnvironment;
ReactComponentEnvironment.replaceNodeWithMarkupByID =
environment.replaceNodeWithMarkupByID;
ReactComponentEnvironment.processChildrenUpdates =
environment.processChildrenUpdates;
injected = true;
}
}
};
module.exports = ReactComponentEnvironment;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],45:[function(require,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 ReactComponentWithPureRenderMixin
*/
'use strict';
var shallowEqual = require("./shallowEqual");
/**
* If your React component's render function is "pure", e.g. it will render the
* same result given the same props and state, provide this Mixin for a
* considerable performance boost.
*
* Most React components have pure render functions.
*
* Example:
*
* var ReactComponentWithPureRenderMixin =
* require('ReactComponentWithPureRenderMixin');
* React.createClass({
* mixins: [ReactComponentWithPureRenderMixin],
*
* render: function() {
* return <div className={this.props.className}>foo</div>;
* }
* });
*
* Note: This only checks shallow equality for props and state. If these contain
* complex data structures this mixin may have false-negatives for deeper
* differences. Only mixin to components which have simple props and state, or
* use `forceUpdate()` when you know deep data structures have changed.
*/
var ReactComponentWithPureRenderMixin = {
shouldComponentUpdate: function(nextProps, nextState) {
return !shallowEqual(this.props, nextProps) ||
!shallowEqual(this.state, nextState);
}
};
module.exports = ReactComponentWithPureRenderMixin;
},{"./shallowEqual":170}],46:[function(require,module,exports){
(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 = require("./ReactComponentEnvironment");
var ReactContext = require("./ReactContext");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactElement = require("./ReactElement");
var ReactElementValidator = require("./ReactElementValidator");
var ReactInstanceMap = require("./ReactInstanceMap");
var ReactLifeCycle = require("./ReactLifeCycle");
var ReactNativeComponent = require("./ReactNativeComponent");
var ReactPerf = require("./ReactPerf");
var ReactPropTypeLocations = require("./ReactPropTypeLocations");
var ReactPropTypeLocationNames = require("./ReactPropTypeLocationNames");
var ReactReconciler = require("./ReactReconciler");
var ReactUpdates = require("./ReactUpdates");
var assign = require("./Object.assign");
var emptyObject = require("./emptyObject");
var invariant = require("./invariant");
var shouldUpdateReactComponent = require("./shouldUpdateReactComponent");
var warning = require("./warning");
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 '';
}
/**
* ------------------ 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._isTopLevel = false;
// 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(this._currentElement._context);
var Component = ReactNativeComponent.getComponentClassForElement(
this._currentElement
);
// Initialize the public class
var inst = new Component(publicProps, publicContext);
if ("production" !== process.env.NODE_ENV) {
// This will throw later in _renderValidatedComponent, but add an early
// warning now to help debugging
("production" !== process.env.NODE_ENV ? warning(
inst.render != null,
'%s(...): No `render` method found on the returned component ' +
'instance: you may have forgotten to define `render` in your ' +
'component or you may have accidentally tried to render an element ' +
'whose type is a function that isn\'t a React component.',
Component.displayName || Component.name || 'Component'
) : null);
}
// 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;
this._instance = inst;
// Store a reference from the instance back to the internal representation
ReactInstanceMap.set(inst, this);
if ("production" !== process.env.NODE_ENV) {
this._warnIfContextsDiffer(this._currentElement._context, context);
}
if ("production" !== process.env.NODE_ENV) {
// 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.
("production" !== process.env.NODE_ENV ? 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'
) : null);
("production" !== process.env.NODE_ENV ? warning(
!inst.propTypes,
'propTypes was defined as an instance property on %s. Use a static ' +
'property to define propTypes instead.',
this.getName() || 'a component'
) : null);
("production" !== process.env.NODE_ENV ? warning(
!inst.contextTypes,
'contextTypes was defined as an instance property on %s. Use a ' +
'static property to define contextTypes instead.',
this.getName() || 'a component'
) : null);
("production" !== process.env.NODE_ENV ? 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')
) : null);
}
var initialState = inst.state;
if (initialState === undefined) {
inst.state = initialState = null;
}
("production" !== process.env.NODE_ENV ? invariant(
typeof initialState === 'object' && !Array.isArray(initialState),
'%s.state: must be set to an object or null',
this.getName() || 'ReactCompositeComponent'
) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));
this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;
var renderedElement;
var previouslyMounting = ReactLifeCycle.currentlyMountingInstance;
ReactLifeCycle.currentlyMountingInstance = this;
try {
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);
}
}
renderedElement = this._renderValidatedComponent();
} finally {
ReactLifeCycle.currentlyMountingInstance = previouslyMounting;
}
this._renderedComponent = this._instantiateReactComponent(
renderedElement,
this._currentElement.type // The wrapping type
);
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) {
var previouslyUnmounting = ReactLifeCycle.currentlyUnmountingInstance;
ReactLifeCycle.currentlyUnmountingInstance = this;
try {
inst.componentWillUnmount();
} finally {
ReactLifeCycle.currentlyUnmountingInstance = previouslyUnmounting;
}
}
ReactReconciler.unmountComponent(this._renderedComponent);
this._renderedComponent = null;
// Reset pending fields
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;
// 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;
},
/**
* Schedule a partial update to the props. Only used for internal testing.
*
* @param {object} partialProps Subset of the next props.
* @param {?function} callback Called after props are updated.
* @final
* @internal
*/
_setPropsInternal: function(partialProps, callback) {
// This is a deoptimized path. We optimize for always having an element.
// This creates an extra internal element.
var element = this._pendingElement || this._currentElement;
this._pendingElement = ReactElement.cloneAndReplaceProps(
element,
assign({}, element.props, partialProps)
);
ReactUpdates.enqueueUpdate(this, callback);
},
/**
* Filters the context object to only contain keys specified in
* `contextTypes`
*
* @param {object} context
* @return {?object}
* @private
*/
_maskContext: function(context) {
var maskedContext = null;
// This really should be getting the component class for the element,
// but we know that we're not going to need it for built-ins.
if (typeof this._currentElement.type === 'string') {
return emptyObject;
}
var contextTypes = this._currentElement.type.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 ("production" !== process.env.NODE_ENV) {
var Component = ReactNativeComponent.getComponentClassForElement(
this._currentElement
);
if (Component.contextTypes) {
this._checkPropTypes(
Component.contextTypes,
maskedContext,
ReactPropTypeLocations.context
);
}
}
return maskedContext;
},
/**
* @param {object} currentContext
* @return {object}
* @private
*/
_processChildContext: function(currentContext) {
var inst = this._instance;
var childContext = inst.getChildContext && inst.getChildContext();
if (childContext) {
("production" !== process.env.NODE_ENV ? invariant(
typeof inst.constructor.childContextTypes === 'object',
'%s.getChildContext(): childContextTypes must be defined in order to ' +
'use getChildContext().',
this.getName() || 'ReactCompositeComponent'
) : invariant(typeof inst.constructor.childContextTypes === 'object'));
if ("production" !== process.env.NODE_ENV) {
this._checkPropTypes(
inst.constructor.childContextTypes,
childContext,
ReactPropTypeLocations.childContext
);
}
for (var name in childContext) {
("production" !== process.env.NODE_ENV ? invariant(
name in inst.constructor.childContextTypes,
'%s.getChildContext(): key "%s" is not defined in childContextTypes.',
this.getName() || 'ReactCompositeComponent',
name
) : invariant(name in inst.constructor.childContextTypes));
}
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 ("production" !== process.env.NODE_ENV) {
var Component = ReactNativeComponent.getComponentClassForElement(
this._currentElement
);
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.
("production" !== process.env.NODE_ENV ? invariant(
typeof propTypes[propName] === 'function',
'%s: %s type `%s` is invalid; it must be a function, usually ' +
'from React.PropTypes.',
componentName || 'React class',
ReactPropTypeLocationNames[location],
propName
) : invariant(typeof propTypes[propName] === 'function'));
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
// React.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
("production" !== process.env.NODE_ENV ? warning(
false,
'Failed Composite propType: %s%s',
error.message,
addendum
) : null);
} else {
("production" !== process.env.NODE_ENV ? warning(
false,
'Failed Context Types: %s%s',
error.message,
addendum
) : null);
}
}
}
}
},
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) {
if ("production" !== process.env.NODE_ENV) {
ReactElementValidator.checkAndWarnForMutatedProps(
this._currentElement
);
}
this.updateComponent(
transaction,
this._currentElement,
this._currentElement,
this._context,
this._context
);
}
},
/**
* Compare two contexts, warning if they are different
* TODO: Remove this check when owner-context is removed
*/
_warnIfContextsDiffer: function(ownerBasedContext, parentBasedContext) {
ownerBasedContext = this._maskContext(ownerBasedContext);
parentBasedContext = this._maskContext(parentBasedContext);
var parentKeys = Object.keys(parentBasedContext).sort();
var displayName = this.getName() || 'ReactCompositeComponent';
for (var i = 0; i < parentKeys.length; i++) {
var key = parentKeys[i];
("production" !== process.env.NODE_ENV ? warning(
ownerBasedContext[key] === parentBasedContext[key],
'owner-based and parent-based contexts differ ' +
'(values: `%s` vs `%s`) for key (%s) while mounting %s ' +
'(see: http://fb.me/react-context-by-parent)',
ownerBasedContext[key],
parentBasedContext[key],
key,
displayName
) : null);
}
},
/**
* 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 = inst.context;
var nextProps = inst.props;
// Distinguish between a props update versus a simple state update
if (prevParentElement !== nextParentElement) {
nextContext = this._processContext(nextParentElement._context);
nextProps = this._processProps(nextParentElement.props);
if ("production" !== process.env.NODE_ENV) {
if (nextUnmaskedContext != null) {
this._warnIfContextsDiffer(
nextParentElement._context,
nextUnmaskedContext
);
}
}
// 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 ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
typeof shouldUpdate !== 'undefined',
'%s.shouldComponentUpdate(): Returned undefined instead of a ' +
'boolean value. Make sure to return true or false.',
this.getName() || 'ReactCompositeComponent'
) : null);
}
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;
}
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 prevProps = inst.props;
var prevState = inst.state;
var 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 (inst.componentDidUpdate) {
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,
this._currentElement.type
);
var nextMarkup = ReactReconciler.mountComponent(
this._renderedComponent,
thisID,
transaction,
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 ("production" !== process.env.NODE_ENV) {
// 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;
var previousContext = ReactContext.current;
ReactContext.current = this._processChildContext(
this._currentElement._context
);
ReactCurrentOwner.current = this;
try {
renderedComponent =
this._renderValidatedComponentWithoutOwnerOrContext();
} finally {
ReactContext.current = previousContext;
ReactCurrentOwner.current = null;
}
("production" !== process.env.NODE_ENV ? invariant(
// TODO: An `isValidNode` function would probably be more appropriate
renderedComponent === null || renderedComponent === false ||
ReactElement.isValidElement(renderedComponent),
'%s.render(): A valid ReactComponent must be returned. You may have ' +
'returned undefined, an array or some other invalid object.',
this.getName() || 'ReactCompositeComponent'
) : invariant(// TODO: An `isValidNode` function would probably be more appropriate
renderedComponent === null || renderedComponent === false ||
ReactElement.isValidElement(renderedComponent)));
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();
var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
refs[ref] = component.getPublicInstance();
},
/**
* 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 React.render. Can be null for stateless
* components.
*
* @return {ReactComponent} the public component instance.
* @internal
*/
getPublicInstance: function() {
return this._instance;
},
// Stub
_instantiateReactComponent: null
};
ReactPerf.measureMethods(
ReactCompositeComponentMixin,
'ReactCompositeComponent',
{
mountComponent: 'mountComponent',
updateComponent: 'updateComponent',
_renderValidatedComponent: '_renderValidatedComponent'
}
);
var ReactCompositeComponent = {
Mixin: ReactCompositeComponentMixin
};
module.exports = ReactCompositeComponent;
}).call(this,require('_process'))
},{"./Object.assign":32,"./ReactComponentEnvironment":44,"./ReactContext":47,"./ReactCurrentOwner":48,"./ReactElement":66,"./ReactElementValidator":67,"./ReactInstanceMap":76,"./ReactLifeCycle":77,"./ReactNativeComponent":83,"./ReactPerf":85,"./ReactPropTypeLocationNames":87,"./ReactPropTypeLocations":88,"./ReactReconciler":92,"./ReactUpdates":103,"./emptyObject":134,"./invariant":154,"./shouldUpdateReactComponent":171,"./warning":175,"_process":2}],47:[function(require,module,exports){
(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 ReactContext
*/
'use strict';
var assign = require("./Object.assign");
var emptyObject = require("./emptyObject");
var warning = require("./warning");
var didWarn = false;
/**
* Keeps track of the current context.
*
* The context is automatically passed down the component ownership hierarchy
* and is accessible via `this.context` on ReactCompositeComponents.
*/
var ReactContext = {
/**
* @internal
* @type {object}
*/
current: emptyObject,
/**
* Temporarily extends the current context while executing scopedCallback.
*
* A typical use case might look like
*
* render: function() {
* var children = ReactContext.withContext({foo: 'foo'}, () => (
*
* ));
* return <div>{children}</div>;
* }
*
* @param {object} newContext New context to merge into the existing context
* @param {function} scopedCallback Callback to run with the new context
* @return {ReactComponent|array<ReactComponent>}
*/
withContext: function(newContext, scopedCallback) {
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
didWarn,
'withContext is deprecated and will be removed in a future version. ' +
'Use a wrapper component with getChildContext instead.'
) : null);
didWarn = true;
}
var result;
var previousContext = ReactContext.current;
ReactContext.current = assign({}, previousContext, newContext);
try {
result = scopedCallback();
} finally {
ReactContext.current = previousContext;
}
return result;
}
};
module.exports = ReactContext;
}).call(this,require('_process'))
},{"./Object.assign":32,"./emptyObject":134,"./warning":175,"_process":2}],48:[function(require,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.
*
* The depth indicate how many composite components are above this render level.
*/
var ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/
current: null
};
module.exports = ReactCurrentOwner;
},{}],49:[function(require,module,exports){
(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
* @typechecks static-only
*/
'use strict';
var ReactElement = require("./ReactElement");
var ReactElementValidator = require("./ReactElementValidator");
var mapObject = require("./mapObject");
/**
* Create a factory that creates HTML tag elements.
*
* @param {string} tag Tag name (e.g. `div`).
* @private
*/
function createDOMFactory(tag) {
if ("production" !== process.env.NODE_ENV) {
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 ReactDOM = 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',
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',
defs: 'defs',
ellipse: 'ellipse',
g: 'g',
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 = ReactDOM;
}).call(this,require('_process'))
},{"./ReactElement":66,"./ReactElementValidator":67,"./mapObject":162,"_process":2}],50:[function(require,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 AutoFocusMixin = require("./AutoFocusMixin");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var keyMirror = require("./keyMirror");
var button = ReactElement.createFactory('button');
var mouseListenerNames = keyMirror({
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 = ReactClass.createClass({
displayName: 'ReactDOMButton',
tagName: 'BUTTON',
mixins: [AutoFocusMixin, ReactBrowserComponentMixin],
render: function() {
var props = {};
// Copy the props; except the mouse listeners if we're disabled
for (var key in this.props) {
if (this.props.hasOwnProperty(key) &&
(!this.props.disabled || !mouseListenerNames[key])) {
props[key] = this.props[key];
}
}
return button(props, this.props.children);
}
});
module.exports = ReactDOMButton;
},{"./AutoFocusMixin":5,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66,"./keyMirror":160}],51:[function(require,module,exports){
(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 CSSPropertyOperations = require("./CSSPropertyOperations");
var DOMProperty = require("./DOMProperty");
var DOMPropertyOperations = require("./DOMPropertyOperations");
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var ReactComponentBrowserEnvironment =
require("./ReactComponentBrowserEnvironment");
var ReactMount = require("./ReactMount");
var ReactMultiChild = require("./ReactMultiChild");
var ReactPerf = require("./ReactPerf");
var assign = require("./Object.assign");
var escapeTextContentForBrowser = require("./escapeTextContentForBrowser");
var invariant = require("./invariant");
var isEventSupported = require("./isEventSupported");
var keyOf = require("./keyOf");
var warning = require("./warning");
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 STYLE = keyOf({style: null});
var ELEMENT_NODE_TYPE = 1;
/**
* Optionally injectable operations for mutating the DOM
*/
var BackendIDOperations = null;
/**
* @param {?object} props
*/
function assertValidProps(props) {
if (!props) {
return;
}
// Note the use of `==` which checks for null or undefined.
if (props.dangerouslySetInnerHTML != null) {
("production" !== process.env.NODE_ENV ? invariant(
props.children == null,
'Can only set one of `children` or `props.dangerouslySetInnerHTML`.'
) : invariant(props.children == null));
("production" !== process.env.NODE_ENV ? invariant(
props.dangerouslySetInnerHTML.__html != null,
'`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' +
'Please visit http://fb.me/react-invariant-dangerously-set-inner-html ' +
'for more information.'
) : invariant(props.dangerouslySetInnerHTML.__html != null));
}
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
props.innerHTML == null,
'Directly setting property `innerHTML` is not permitted. ' +
'For more information, lookup documentation on `dangerouslySetInnerHTML`.'
) : null);
("production" !== process.env.NODE_ENV ? 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.'
) : null);
}
("production" !== process.env.NODE_ENV ? invariant(
props.style == null || typeof props.style === 'object',
'The `style` prop expects a mapping from style properties to values, ' +
'not a string. For example, style={{marginRight: spacing + \'em\'}} when ' +
'using JSX.'
) : invariant(props.style == null || typeof props.style === 'object'));
}
function putListener(id, registrationName, listener, transaction) {
if ("production" !== process.env.NODE_ENV) {
// IE8 has no API for event capturing and the `onScroll` event doesn't
// bubble.
("production" !== process.env.NODE_ENV ? warning(
registrationName !== 'onScroll' || isEventSupported('scroll', true),
'This browser doesn\'t support the `onScroll` event'
) : null);
}
var container = ReactMount.findReactContainerForID(id);
if (container) {
var doc = container.nodeType === ELEMENT_NODE_TYPE ?
container.ownerDocument :
container;
listenTo(registrationName, doc);
}
transaction.getPutListenerQueue().enqueuePutListener(
id,
registrationName,
listener
);
}
// 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.
};
// We accept any tag to be rendered but since this gets injected into abitrary
// 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)) {
("production" !== process.env.NODE_ENV ? invariant(VALID_TAG_REGEX.test(tag), 'Invalid tag: %s', tag) : invariant(VALID_TAG_REGEX.test(tag)));
validatedTagCache[tag] = true;
}
}
/**
* 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;
this._renderedChildren = null;
this._previousStyleCopy = null;
this._rootNodeID = 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
* @return {string} The computed markup.
*/
mountComponent: function(rootID, transaction, context) {
this._rootNodeID = rootID;
assertValidProps(this._currentElement.props);
var closeTag = omittedCloseTags[this._tag] ? '' : '</' + this._tag + '>';
return (
this._createOpenTagMarkupAndPutListeners(transaction) +
this._createContentMarkup(transaction, context) +
closeTag
);
},
/**
* 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
* @return {string} Markup of opening tag.
*/
_createOpenTagMarkupAndPutListeners: function(transaction) {
var props = this._currentElement.props;
var ret = '<' + this._tag;
for (var propKey in props) {
if (!props.hasOwnProperty(propKey)) {
continue;
}
var propValue = props[propKey];
if (propValue == null) {
continue;
}
if (registrationNameModules.hasOwnProperty(propKey)) {
putListener(this._rootNodeID, propKey, propValue, transaction);
} else {
if (propKey === STYLE) {
if (propValue) {
propValue = this._previousStyleCopy = assign({}, props.style);
}
propValue = CSSPropertyOperations.createMarkupForStyles(propValue);
}
var 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} context
* @return {string} Content markup.
*/
_createContentMarkup: function(transaction, context) {
var prefix = '';
if (this._tag === 'listing' ||
this._tag === 'pre' ||
this._tag === 'textarea') {
// Add an initial newline because browsers ignore the first newline in
// a <listing>, <pre>, or <textarea> as an "authoring convenience" -- see
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody.
prefix = '\n';
}
var props = this._currentElement.props;
// Intentional use of != to avoid catching zero/false.
var innerHTML = props.dangerouslySetInnerHTML;
if (innerHTML != null) {
if (innerHTML.__html != null) {
return prefix + innerHTML.__html;
}
} else {
var contentToUse =
CONTENT_TYPES[typeof props.children] ? props.children : null;
var childrenToUse = contentToUse != null ? null : props.children;
if (contentToUse != null) {
return prefix + escapeTextContentForBrowser(contentToUse);
} else if (childrenToUse != null) {
var mountImages = this.mountChildren(
childrenToUse,
transaction,
context
);
return prefix + mountImages.join('');
}
}
return prefix;
},
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) {
assertValidProps(this._currentElement.props);
this._updateDOMProperties(prevElement.props, transaction);
this._updateDOMChildren(prevElement.props, transaction, context);
},
/**
* 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 {ReactReconcileTransaction} transaction
*/
_updateDOMProperties: function(lastProps, transaction) {
var nextProps = this._currentElement.props;
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)) {
deleteListener(this._rootNodeID, propKey);
} else if (
DOMProperty.isStandardName[propKey] ||
DOMProperty.isCustomAttribute(propKey)) {
BackendIDOperations.deletePropertyByID(
this._rootNodeID,
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) {
nextProp = this._previousStyleCopy = assign({}, nextProp);
}
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)) {
putListener(this._rootNodeID, propKey, nextProp, transaction);
} else if (
DOMProperty.isStandardName[propKey] ||
DOMProperty.isCustomAttribute(propKey)) {
BackendIDOperations.updatePropertyByID(
this._rootNodeID,
propKey,
nextProp
);
}
}
if (styleUpdates) {
BackendIDOperations.updateStylesByID(
this._rootNodeID,
styleUpdates
);
}
},
/**
* Reconciles the children with the various properties that affect the
* children content.
*
* @param {object} lastProps
* @param {ReactReconcileTransaction} transaction
*/
_updateDOMChildren: function(lastProps, transaction, context) {
var nextProps = this._currentElement.props;
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) {
BackendIDOperations.updateInnerHTMLByID(
this._rootNodeID,
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() {
this.unmountChildren();
ReactBrowserEventEmitter.deleteAllListeners(this._rootNodeID);
ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);
this._rootNodeID = null;
}
};
ReactPerf.measureMethods(ReactDOMComponent, 'ReactDOMComponent', {
mountComponent: 'mountComponent',
updateComponent: 'updateComponent'
});
assign(
ReactDOMComponent.prototype,
ReactDOMComponent.Mixin,
ReactMultiChild.Mixin
);
ReactDOMComponent.injection = {
injectIDOperations: function(IDOperations) {
ReactDOMComponent.BackendIDOperations = BackendIDOperations = IDOperations;
}
};
module.exports = ReactDOMComponent;
}).call(this,require('_process'))
},{"./CSSPropertyOperations":9,"./DOMProperty":14,"./DOMPropertyOperations":15,"./Object.assign":32,"./ReactBrowserEventEmitter":36,"./ReactComponentBrowserEnvironment":43,"./ReactMount":80,"./ReactMultiChild":81,"./ReactPerf":85,"./escapeTextContentForBrowser":135,"./invariant":154,"./isEventSupported":155,"./keyOf":161,"./warning":175,"_process":2}],52:[function(require,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 ReactDOMForm
*/
'use strict';
var EventConstants = require("./EventConstants");
var LocalEventTrapMixin = require("./LocalEventTrapMixin");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var form = ReactElement.createFactory('form');
/**
* Since onSubmit doesn't bubble OR capture on the top level in IE8, we need
* to capture it on the <form> element itself. There are lots of hacks we could
* do to accomplish this, but the most reliable is to make <form> a
* composite component and use `componentDidMount` to attach the event handlers.
*/
var ReactDOMForm = ReactClass.createClass({
displayName: 'ReactDOMForm',
tagName: 'FORM',
mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],
render: function() {
// TODO: Instead of using `ReactDOM` directly, we should use JSX. However,
// `jshint` fails to parse JSX so in order for linting to work in the open
// source repo, we need to just use `ReactDOM.form`.
return form(this.props);
},
componentDidMount: function() {
this.trapBubbledEvent(EventConstants.topLevelTypes.topReset, 'reset');
this.trapBubbledEvent(EventConstants.topLevelTypes.topSubmit, 'submit');
}
});
module.exports = ReactDOMForm;
},{"./EventConstants":19,"./LocalEventTrapMixin":30,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66}],53:[function(require,module,exports){
(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
*/
/*jslint evil: true */
'use strict';
var CSSPropertyOperations = require("./CSSPropertyOperations");
var DOMChildrenOperations = require("./DOMChildrenOperations");
var DOMPropertyOperations = require("./DOMPropertyOperations");
var ReactMount = require("./ReactMount");
var ReactPerf = require("./ReactPerf");
var invariant = require("./invariant");
var setInnerHTML = require("./setInnerHTML");
/**
* 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. This is made injectable via
* `ReactDOMComponent.BackendIDOperations`.
*/
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);
("production" !== process.env.NODE_ENV ? invariant(
!INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
'updatePropertyByID(...): %s',
INVALID_PROPERTY_ERRORS[name]
) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));
// 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);
}
},
/**
* Updates a DOM node to remove a property. This should only be used to remove
* DOM properties in `DOMProperty`.
*
* @param {string} id ID of the node to update.
* @param {string} name A property name to remove, see `DOMProperty`.
* @internal
*/
deletePropertyByID: function(id, name, value) {
var node = ReactMount.getNode(id);
("production" !== process.env.NODE_ENV ? invariant(
!INVALID_PROPERTY_ERRORS.hasOwnProperty(name),
'updatePropertyByID(...): %s',
INVALID_PROPERTY_ERRORS[name]
) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));
DOMPropertyOperations.deleteValueForProperty(node, name, value);
},
/**
* Updates a DOM node with new style values. If a value is specified as '',
* the corresponding style property will be unset.
*
* @param {string} id ID of the node to update.
* @param {object} styles Mapping from styles to values.
* @internal
*/
updateStylesByID: function(id, styles) {
var node = ReactMount.getNode(id);
CSSPropertyOperations.setValueForStyles(node, styles);
},
/**
* Updates a DOM node's innerHTML.
*
* @param {string} id ID of the node to update.
* @param {string} html An HTML string.
* @internal
*/
updateInnerHTMLByID: function(id, html) {
var node = ReactMount.getNode(id);
setInnerHTML(node, html);
},
/**
* Updates a DOM node's text content set by `props.content`.
*
* @param {string} id ID of the node to update.
* @param {string} content Text content.
* @internal
*/
updateTextContentByID: function(id, content) {
var node = ReactMount.getNode(id);
DOMChildrenOperations.updateTextContent(node, content);
},
/**
* 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', {
updatePropertyByID: 'updatePropertyByID',
deletePropertyByID: 'deletePropertyByID',
updateStylesByID: 'updateStylesByID',
updateInnerHTMLByID: 'updateInnerHTMLByID',
updateTextContentByID: 'updateTextContentByID',
dangerouslyReplaceNodeWithMarkupByID: 'dangerouslyReplaceNodeWithMarkupByID',
dangerouslyProcessChildrenUpdates: 'dangerouslyProcessChildrenUpdates'
});
module.exports = ReactDOMIDOperations;
}).call(this,require('_process'))
},{"./CSSPropertyOperations":9,"./DOMChildrenOperations":13,"./DOMPropertyOperations":15,"./ReactMount":80,"./ReactPerf":85,"./invariant":154,"./setInnerHTML":168,"_process":2}],54:[function(require,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 ReactDOMIframe
*/
'use strict';
var EventConstants = require("./EventConstants");
var LocalEventTrapMixin = require("./LocalEventTrapMixin");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var iframe = ReactElement.createFactory('iframe');
/**
* Since onLoad doesn't bubble OR capture on the top level in IE8, we need to
* capture it on the <iframe> element itself. There are lots of hacks we could
* do to accomplish this, but the most reliable is to make <iframe> a composite
* component and use `componentDidMount` to attach the event handlers.
*/
var ReactDOMIframe = ReactClass.createClass({
displayName: 'ReactDOMIframe',
tagName: 'IFRAME',
mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],
render: function() {
return iframe(this.props);
},
componentDidMount: function() {
this.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load');
}
});
module.exports = ReactDOMIframe;
},{"./EventConstants":19,"./LocalEventTrapMixin":30,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66}],55:[function(require,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 ReactDOMImg
*/
'use strict';
var EventConstants = require("./EventConstants");
var LocalEventTrapMixin = require("./LocalEventTrapMixin");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var img = ReactElement.createFactory('img');
/**
* Since onLoad doesn't bubble OR capture on the top level in IE8, we need to
* capture it on the <img> element itself. There are lots of hacks we could do
* to accomplish this, but the most reliable is to make <img> a composite
* component and use `componentDidMount` to attach the event handlers.
*/
var ReactDOMImg = ReactClass.createClass({
displayName: 'ReactDOMImg',
tagName: 'IMG',
mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],
render: function() {
return img(this.props);
},
componentDidMount: function() {
this.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load');
this.trapBubbledEvent(EventConstants.topLevelTypes.topError, 'error');
}
});
module.exports = ReactDOMImg;
},{"./EventConstants":19,"./LocalEventTrapMixin":30,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66}],56:[function(require,module,exports){
(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 AutoFocusMixin = require("./AutoFocusMixin");
var DOMPropertyOperations = require("./DOMPropertyOperations");
var LinkedValueUtils = require("./LinkedValueUtils");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var ReactMount = require("./ReactMount");
var ReactUpdates = require("./ReactUpdates");
var assign = require("./Object.assign");
var invariant = require("./invariant");
var input = ReactElement.createFactory('input');
var instancesByReactID = {};
function forceUpdateIfMounted() {
/*jshint validthis:true */
if (this.isMounted()) {
this.forceUpdate();
}
}
/**
* 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 = ReactClass.createClass({
displayName: 'ReactDOMInput',
tagName: 'INPUT',
mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],
getInitialState: function() {
var defaultValue = this.props.defaultValue;
return {
initialChecked: this.props.defaultChecked || false,
initialValue: defaultValue != null ? defaultValue : null
};
},
render: function() {
// Clone `this.props` so we don't mutate the input.
var props = assign({}, this.props);
props.defaultChecked = null;
props.defaultValue = null;
var value = LinkedValueUtils.getValue(this);
props.value = value != null ? value : this.state.initialValue;
var checked = LinkedValueUtils.getChecked(this);
props.checked = checked != null ? checked : this.state.initialChecked;
props.onChange = this._handleChange;
return input(props, this.props.children);
},
componentDidMount: function() {
var id = ReactMount.getID(this.getDOMNode());
instancesByReactID[id] = this;
},
componentWillUnmount: function() {
var rootNode = this.getDOMNode();
var id = ReactMount.getID(rootNode);
delete instancesByReactID[id];
},
componentDidUpdate: function(prevProps, prevState, prevContext) {
var rootNode = this.getDOMNode();
if (this.props.checked != null) {
DOMPropertyOperations.setValueForProperty(
rootNode,
'checked',
this.props.checked || false
);
}
var value = LinkedValueUtils.getValue(this);
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.
DOMPropertyOperations.setValueForProperty(rootNode, 'value', '' + value);
}
},
_handleChange: function(event) {
var returnValue;
var onChange = LinkedValueUtils.getOnChange(this);
if (onChange) {
returnValue = onChange.call(this, 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 = this.props.name;
if (this.props.type === 'radio' && name != null) {
var rootNode = this.getDOMNode();
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, groupLen = group.length; i < groupLen; i++) {
var otherNode = group[i];
if (otherNode === rootNode ||
otherNode.form !== rootNode.form) {
continue;
}
var otherID = ReactMount.getID(otherNode);
("production" !== process.env.NODE_ENV ? invariant(
otherID,
'ReactDOMInput: Mixing React and non-React radio inputs with the ' +
'same `name` is not supported.'
) : invariant(otherID));
var otherInstance = instancesByReactID[otherID];
("production" !== process.env.NODE_ENV ? invariant(
otherInstance,
'ReactDOMInput: Unknown radio button ID %s.',
otherID
) : invariant(otherInstance));
// 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;
}).call(this,require('_process'))
},{"./AutoFocusMixin":5,"./DOMPropertyOperations":15,"./LinkedValueUtils":29,"./Object.assign":32,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66,"./ReactMount":80,"./ReactUpdates":103,"./invariant":154,"_process":2}],57:[function(require,module,exports){
(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 ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var warning = require("./warning");
var option = ReactElement.createFactory('option');
/**
* Implements an <option> native component that warns when `selected` is set.
*/
var ReactDOMOption = ReactClass.createClass({
displayName: 'ReactDOMOption',
tagName: 'OPTION',
mixins: [ReactBrowserComponentMixin],
componentWillMount: function() {
// TODO (yungsters): Remove support for `selected` in <option>.
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
this.props.selected == null,
'Use the `defaultValue` or `value` props on <select> instead of ' +
'setting `selected` on <option>.'
) : null);
}
},
render: function() {
return option(this.props, this.props.children);
}
});
module.exports = ReactDOMOption;
}).call(this,require('_process'))
},{"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66,"./warning":175,"_process":2}],58:[function(require,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 ReactDOMSelect
*/
'use strict';
var AutoFocusMixin = require("./AutoFocusMixin");
var LinkedValueUtils = require("./LinkedValueUtils");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var ReactUpdates = require("./ReactUpdates");
var assign = require("./Object.assign");
var select = ReactElement.createFactory('select');
function updateOptionsIfPendingUpdateAndMounted() {
/*jshint validthis:true */
if (this._pendingUpdate) {
this._pendingUpdate = false;
var value = LinkedValueUtils.getValue(this);
if (value != null && this.isMounted()) {
updateOptions(this, value);
}
}
}
/**
* Validation function for `value` and `defaultValue`.
* @private
*/
function selectValueType(props, propName, componentName) {
if (props[propName] == null) {
return null;
}
if (props.multiple) {
if (!Array.isArray(props[propName])) {
return new Error(
("The `" + propName + "` prop supplied to <select> must be an array if ") +
("`multiple` is true.")
);
}
} else {
if (Array.isArray(props[propName])) {
return new Error(
("The `" + propName + "` prop supplied to <select> must be a scalar ") +
("value if `multiple` is false.")
);
}
}
}
/**
* @param {ReactComponent} component Instance of ReactDOMSelect
* @param {*} propValue A stringable (with `multiple`, a list of stringables).
* @private
*/
function updateOptions(component, propValue) {
var selectedValue, i, l;
var options = component.getDOMNode().options;
if (component.props.multiple) {
selectedValue = {};
for (i = 0, l = propValue.length; i < l; i++) {
selectedValue['' + propValue[i]] = true;
}
for (i = 0, l = options.length; i < l; 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, l = options.length; i < l; 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 = ReactClass.createClass({
displayName: 'ReactDOMSelect',
tagName: 'SELECT',
mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],
propTypes: {
defaultValue: selectValueType,
value: selectValueType
},
render: function() {
// Clone `this.props` so we don't mutate the input.
var props = assign({}, this.props);
props.onChange = this._handleChange;
props.value = null;
return select(props, this.props.children);
},
componentWillMount: function() {
this._pendingUpdate = false;
},
componentDidMount: function() {
var value = LinkedValueUtils.getValue(this);
if (value != null) {
updateOptions(this, value);
} else if (this.props.defaultValue != null) {
updateOptions(this, this.props.defaultValue);
}
},
componentDidUpdate: function(prevProps) {
var value = LinkedValueUtils.getValue(this);
if (value != null) {
this._pendingUpdate = false;
updateOptions(this, value);
} else if (!prevProps.multiple !== !this.props.multiple) {
// For simplicity, reapply `defaultValue` if `multiple` is toggled.
if (this.props.defaultValue != null) {
updateOptions(this, this.props.defaultValue);
} else {
// Revert the select back to its default unselected state.
updateOptions(this, this.props.multiple ? [] : '');
}
}
},
_handleChange: function(event) {
var returnValue;
var onChange = LinkedValueUtils.getOnChange(this);
if (onChange) {
returnValue = onChange.call(this, event);
}
this._pendingUpdate = true;
ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);
return returnValue;
}
});
module.exports = ReactDOMSelect;
},{"./AutoFocusMixin":5,"./LinkedValueUtils":29,"./Object.assign":32,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66,"./ReactUpdates":103}],59:[function(require,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 ReactDOMSelection
*/
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
var getNodeForCharacterOffset = require("./getNodeForCharacterOffset");
var getTextContentAccessor = require("./getTextContentAccessor");
/**
* 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);
// 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;
},{"./ExecutionEnvironment":25,"./getNodeForCharacterOffset":147,"./getTextContentAccessor":149}],60:[function(require,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 ReactDOMTextComponent
* @typechecks static-only
*/
'use strict';
var DOMPropertyOperations = require("./DOMPropertyOperations");
var ReactComponentBrowserEnvironment =
require("./ReactComponentBrowserEnvironment");
var ReactDOMComponent = require("./ReactDOMComponent");
var assign = require("./Object.assign");
var escapeTextContentForBrowser = require("./escapeTextContentForBrowser");
/**
* 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) {
this._rootNodeID = rootID;
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;
ReactDOMComponent.BackendIDOperations.updateTextContentByID(
this._rootNodeID,
nextStringText
);
}
}
},
unmountComponent: function() {
ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);
}
});
module.exports = ReactDOMTextComponent;
},{"./DOMPropertyOperations":15,"./Object.assign":32,"./ReactComponentBrowserEnvironment":43,"./ReactDOMComponent":51,"./escapeTextContentForBrowser":135}],61:[function(require,module,exports){
(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 AutoFocusMixin = require("./AutoFocusMixin");
var DOMPropertyOperations = require("./DOMPropertyOperations");
var LinkedValueUtils = require("./LinkedValueUtils");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var ReactUpdates = require("./ReactUpdates");
var assign = require("./Object.assign");
var invariant = require("./invariant");
var warning = require("./warning");
var textarea = ReactElement.createFactory('textarea');
function forceUpdateIfMounted() {
/*jshint validthis:true */
if (this.isMounted()) {
this.forceUpdate();
}
}
/**
* 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 = ReactClass.createClass({
displayName: 'ReactDOMTextarea',
tagName: 'TEXTAREA',
mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],
getInitialState: function() {
var defaultValue = this.props.defaultValue;
// TODO (yungsters): Remove support for children content in <textarea>.
var children = this.props.children;
if (children != null) {
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
false,
'Use the `defaultValue` or `value` props instead of setting ' +
'children on <textarea>.'
) : null);
}
("production" !== process.env.NODE_ENV ? invariant(
defaultValue == null,
'If you supply `defaultValue` on a <textarea>, do not pass children.'
) : invariant(defaultValue == null));
if (Array.isArray(children)) {
("production" !== process.env.NODE_ENV ? invariant(
children.length <= 1,
'<textarea> can only have at most one child.'
) : invariant(children.length <= 1));
children = children[0];
}
defaultValue = '' + children;
}
if (defaultValue == null) {
defaultValue = '';
}
var value = LinkedValueUtils.getValue(this);
return {
// 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)
};
},
render: function() {
// Clone `this.props` so we don't mutate the input.
var props = assign({}, this.props);
("production" !== process.env.NODE_ENV ? invariant(
props.dangerouslySetInnerHTML == null,
'`dangerouslySetInnerHTML` does not make sense on <textarea>.'
) : invariant(props.dangerouslySetInnerHTML == null));
props.defaultValue = null;
props.value = null;
props.onChange = this._handleChange;
// Always set children to the same thing. In IE9, the selection range will
// get reset if `textContent` is mutated.
return textarea(props, this.state.initialValue);
},
componentDidUpdate: function(prevProps, prevState, prevContext) {
var value = LinkedValueUtils.getValue(this);
if (value != null) {
var rootNode = this.getDOMNode();
// Cast `value` to a string to ensure the value is set correctly. While
// browsers typically do this as necessary, jsdom doesn't.
DOMPropertyOperations.setValueForProperty(rootNode, 'value', '' + value);
}
},
_handleChange: function(event) {
var returnValue;
var onChange = LinkedValueUtils.getOnChange(this);
if (onChange) {
returnValue = onChange.call(this, event);
}
ReactUpdates.asap(forceUpdateIfMounted, this);
return returnValue;
}
});
module.exports = ReactDOMTextarea;
}).call(this,require('_process'))
},{"./AutoFocusMixin":5,"./DOMPropertyOperations":15,"./LinkedValueUtils":29,"./Object.assign":32,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactElement":66,"./ReactUpdates":103,"./invariant":154,"./warning":175,"_process":2}],62:[function(require,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 ReactDefaultBatchingStrategy
*/
'use strict';
var ReactUpdates = require("./ReactUpdates");
var Transaction = require("./Transaction");
var assign = require("./Object.assign");
var emptyFunction = require("./emptyFunction");
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) {
var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
ReactDefaultBatchingStrategy.isBatchingUpdates = true;
// The code is written this way to avoid extra allocations
if (alreadyBatchingUpdates) {
callback(a, b, c, d);
} else {
transaction.perform(callback, null, a, b, c, d);
}
}
};
module.exports = ReactDefaultBatchingStrategy;
},{"./Object.assign":32,"./ReactUpdates":103,"./Transaction":120,"./emptyFunction":133}],63:[function(require,module,exports){
(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 = require("./BeforeInputEventPlugin");
var ChangeEventPlugin = require("./ChangeEventPlugin");
var ClientReactRootIndex = require("./ClientReactRootIndex");
var DefaultEventPluginOrder = require("./DefaultEventPluginOrder");
var EnterLeaveEventPlugin = require("./EnterLeaveEventPlugin");
var ExecutionEnvironment = require("./ExecutionEnvironment");
var HTMLDOMPropertyConfig = require("./HTMLDOMPropertyConfig");
var MobileSafariClickEventPlugin = require("./MobileSafariClickEventPlugin");
var ReactBrowserComponentMixin = require("./ReactBrowserComponentMixin");
var ReactClass = require("./ReactClass");
var ReactComponentBrowserEnvironment =
require("./ReactComponentBrowserEnvironment");
var ReactDefaultBatchingStrategy = require("./ReactDefaultBatchingStrategy");
var ReactDOMComponent = require("./ReactDOMComponent");
var ReactDOMButton = require("./ReactDOMButton");
var ReactDOMForm = require("./ReactDOMForm");
var ReactDOMImg = require("./ReactDOMImg");
var ReactDOMIDOperations = require("./ReactDOMIDOperations");
var ReactDOMIframe = require("./ReactDOMIframe");
var ReactDOMInput = require("./ReactDOMInput");
var ReactDOMOption = require("./ReactDOMOption");
var ReactDOMSelect = require("./ReactDOMSelect");
var ReactDOMTextarea = require("./ReactDOMTextarea");
var ReactDOMTextComponent = require("./ReactDOMTextComponent");
var ReactElement = require("./ReactElement");
var ReactEventListener = require("./ReactEventListener");
var ReactInjection = require("./ReactInjection");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var ReactMount = require("./ReactMount");
var ReactReconcileTransaction = require("./ReactReconcileTransaction");
var SelectEventPlugin = require("./SelectEventPlugin");
var ServerReactRootIndex = require("./ServerReactRootIndex");
var SimpleEventPlugin = require("./SimpleEventPlugin");
var SVGDOMPropertyConfig = require("./SVGDOMPropertyConfig");
var createFullPageComponent = require("./createFullPageComponent");
function autoGenerateWrapperClass(type) {
return ReactClass.createClass({
tagName: type.toUpperCase(),
render: function() {
return new ReactElement(
type,
null,
null,
null,
null,
this.props
);
}
});
}
function inject() {
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,
MobileSafariClickEventPlugin: MobileSafariClickEventPlugin,
SelectEventPlugin: SelectEventPlugin,
BeforeInputEventPlugin: BeforeInputEventPlugin
});
ReactInjection.NativeComponent.injectGenericComponentClass(
ReactDOMComponent
);
ReactInjection.NativeComponent.injectTextComponentClass(
ReactDOMTextComponent
);
ReactInjection.NativeComponent.injectAutoWrapper(
autoGenerateWrapperClass
);
// This needs to happen before createFullPageComponent() otherwise the mixin
// won't be included.
ReactInjection.Class.injectMixin(ReactBrowserComponentMixin);
ReactInjection.NativeComponent.injectComponentClasses({
'button': ReactDOMButton,
'form': ReactDOMForm,
'iframe': ReactDOMIframe,
'img': ReactDOMImg,
'input': ReactDOMInput,
'option': ReactDOMOption,
'select': ReactDOMSelect,
'textarea': ReactDOMTextarea,
'html': createFullPageComponent('html'),
'head': createFullPageComponent('head'),
'body': createFullPageComponent('body')
});
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);
ReactInjection.DOMComponent.injectIDOperations(ReactDOMIDOperations);
if ("production" !== process.env.NODE_ENV) {
var url = (ExecutionEnvironment.canUseDOM && window.location.href) || '';
if ((/[?&]react_perf\b/).test(url)) {
var ReactDefaultPerf = require("./ReactDefaultPerf");
ReactDefaultPerf.start();
}
}
}
module.exports = {
inject: inject
};
}).call(this,require('_process'))
},{"./BeforeInputEventPlugin":6,"./ChangeEventPlugin":11,"./ClientReactRootIndex":12,"./DefaultEventPluginOrder":17,"./EnterLeaveEventPlugin":18,"./ExecutionEnvironment":25,"./HTMLDOMPropertyConfig":27,"./MobileSafariClickEventPlugin":31,"./ReactBrowserComponentMixin":35,"./ReactClass":41,"./ReactComponentBrowserEnvironment":43,"./ReactDOMButton":50,"./ReactDOMComponent":51,"./ReactDOMForm":52,"./ReactDOMIDOperations":53,"./ReactDOMIframe":54,"./ReactDOMImg":55,"./ReactDOMInput":56,"./ReactDOMOption":57,"./ReactDOMSelect":58,"./ReactDOMTextComponent":60,"./ReactDOMTextarea":61,"./ReactDefaultBatchingStrategy":62,"./ReactDefaultPerf":64,"./ReactElement":66,"./ReactEventListener":71,"./ReactInjection":73,"./ReactInstanceHandles":75,"./ReactMount":80,"./ReactReconcileTransaction":91,"./SVGDOMPropertyConfig":105,"./SelectEventPlugin":106,"./ServerReactRootIndex":107,"./SimpleEventPlugin":108,"./createFullPageComponent":129,"_process":2}],64:[function(require,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 ReactDefaultPerf
* @typechecks static-only
*/
'use strict';
var DOMProperty = require("./DOMProperty");
var ReactDefaultPerfAnalysis = require("./ReactDefaultPerfAnalysis");
var ReactMount = require("./ReactMount");
var ReactPerf = require("./ReactPerf");
var performanceNow = require("./performanceNow");
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 args=[],$__0=0,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);
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
});
start = performanceNow();
rv = func.apply(this, args);
ReactDefaultPerf._allMeasurements[
ReactDefaultPerf._allMeasurements.length - 1
].totalTime = performanceNow() - start;
return rv;
} else if (fnName === '_mountImageIntoNode' ||
moduleName === 'ReactDOMIDOperations') {
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
ReactDefaultPerf._recordWrite(
args[0],
fnName,
totalTime,
Array.prototype.slice.call(args, 1)
);
}
return rv;
} else if (moduleName === 'ReactCompositeComponent' && (
(// TODO: receiveComponent()?
(fnName === 'mountComponent' ||
fnName === 'updateComponent' || fnName === '_renderValidatedComponent')))) {
if (typeof this._currentElement.type === 'string') {
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) {
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;
},{"./DOMProperty":14,"./ReactDefaultPerfAnalysis":65,"./ReactMount":80,"./ReactPerf":85,"./performanceNow":166}],65:[function(require,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 ReactDefaultPerfAnalysis
*/
var assign = require("./Object.assign");
// 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',
TEXT_CONTENT: 'set textContent',
'updatePropertyByID': 'update attribute',
'deletePropertyByID': 'delete attribute',
'updateStylesByID': 'update styles',
'updateInnerHTMLByID': 'set innerHTML',
'dangerouslyReplaceNodeWithMarkupByID': 'replace'
};
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 = [];
for (var i = 0; i < measurements.length; i++) {
var measurement = measurements[i];
var id;
for (id in measurement.writes) {
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;
}
}
if (!isDirty && measurement.counts[id] > 0) {
cleanComponents[id] = true;
}
}
return cleanComponents;
}
var ReactDefaultPerfAnalysis = {
getExclusiveSummary: getExclusiveSummary,
getInclusiveSummary: getInclusiveSummary,
getDOMSummary: getDOMSummary,
getTotalTime: getTotalTime
};
module.exports = ReactDefaultPerfAnalysis;
},{"./Object.assign":32}],66:[function(require,module,exports){
(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 ReactContext = require("./ReactContext");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var assign = require("./Object.assign");
var warning = require("./warning");
var RESERVED_PROPS = {
key: true,
ref: true
};
/**
* Warn for mutations.
*
* @internal
* @param {object} object
* @param {string} key
*/
function defineWarningProperty(object, key) {
Object.defineProperty(object, key, {
configurable: false,
enumerable: true,
get: function() {
if (!this._store) {
return null;
}
return this._store[key];
},
set: function(value) {
("production" !== process.env.NODE_ENV ? warning(
false,
'Don\'t set the %s property of the React element. Instead, ' +
'specify the correct value when initially creating the element.',
key
) : null);
this._store[key] = value;
}
});
}
/**
* This is updated to true if the membrane is successfully created.
*/
var useMutationMembrane = false;
/**
* Warn for mutations.
*
* @internal
* @param {object} element
*/
function defineMutationMembrane(prototype) {
try {
var pseudoFrozenProperties = {
props: true
};
for (var key in pseudoFrozenProperties) {
defineWarningProperty(prototype, key);
}
useMutationMembrane = true;
} catch (x) {
// IE will fail on defineProperty
}
}
/**
* 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 {string|object} ref
* @param {*} key
* @param {*} props
* @internal
*/
var ReactElement = function(type, key, ref, owner, context, props) {
// Built-in properties that belong on the element
this.type = type;
this.key = key;
this.ref = ref;
// Record the component responsible for creating this element.
this._owner = owner;
// TODO: Deprecate withContext, and then the context becomes accessible
// through the owner.
this._context = context;
if ("production" !== process.env.NODE_ENV) {
// The validation flag and props are currently mutative. We put them 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.
this._store = {props: props, originalProps: assign({}, props)};
// 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.
try {
Object.defineProperty(this._store, 'validated', {
configurable: false,
enumerable: false,
writable: true
});
} catch (x) {
}
this._store.validated = false;
// We're not allowed to set props directly on the object so we early
// return and rely on the prototype membrane to forward to the backing
// store.
if (useMutationMembrane) {
Object.freeze(this);
return;
}
}
this.props = props;
};
// We intentionally don't expose the function on the constructor property.
// ReactElement should be indistinguishable from a plain object.
ReactElement.prototype = {
_isReactElement: true
};
if ("production" !== process.env.NODE_ENV) {
defineMutationMembrane(ReactElement.prototype);
}
ReactElement.createElement = function(type, config, children) {
var propName;
// Reserved names are extracted
var props = {};
var key = null;
var ref = null;
if (config != null) {
ref = config.ref === undefined ? null : config.ref;
key = config.key === undefined ? null : '' + config.key;
// 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 new ReactElement(
type,
key,
ref,
ReactCurrentOwner.current,
ReactContext.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.type.
// 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.cloneAndReplaceProps = function(oldElement, newProps) {
var newElement = new ReactElement(
oldElement.type,
oldElement.key,
oldElement.ref,
oldElement._owner,
oldElement._context,
newProps
);
if ("production" !== process.env.NODE_ENV) {
// 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;
// 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 new ReactElement(
element.type,
key,
ref,
owner,
element._context,
props
);
};
/**
* @param {?object} object
* @return {boolean} True if `object` is a valid component.
* @final
*/
ReactElement.isValidElement = function(object) {
// ReactTestUtils is often used outside of beforeEach where as React is
// within it. This leads to two different instances of React on the same
// page. To identify a element from a different React instance we use
// a flag instead of an instanceof check.
var isElement = !!(object && object._isReactElement);
// if (isElement && !(object instanceof ReactElement)) {
// This is an indicator that you're using multiple versions of React at the
// same time. This will screw with ownership and stuff. Fix it, please.
// TODO: We could possibly warn here.
// }
return isElement;
};
module.exports = ReactElement;
}).call(this,require('_process'))
},{"./Object.assign":32,"./ReactContext":47,"./ReactCurrentOwner":48,"./warning":175,"_process":2}],67:[function(require,module,exports){
(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 = require("./ReactElement");
var ReactFragment = require("./ReactFragment");
var ReactPropTypeLocations = require("./ReactPropTypeLocations");
var ReactPropTypeLocationNames = require("./ReactPropTypeLocationNames");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactNativeComponent = require("./ReactNativeComponent");
var getIteratorFn = require("./getIteratorFn");
var invariant = require("./invariant");
var warning = require("./warning");
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 = {};
var NUMERIC_PROPERTY_REGEX = /^\d+$/;
/**
* Gets the instance's name for use in warnings.
*
* @internal
* @return {?string} Display name or undefined
*/
function getName(instance) {
var publicInstance = instance && instance.getPublicInstance();
if (!publicInstance) {
return undefined;
}
var constructor = publicInstance.constructor;
if (!constructor) {
return undefined;
}
return constructor.displayName || constructor.name || undefined;
}
/**
* Gets the current owner's displayName for use in warnings.
*
* @internal
* @return {?string} Display name or undefined
*/
function getCurrentOwnerDisplayName() {
var current = ReactCurrentOwner.current;
return (
current && getName(current) || undefined
);
}
/**
* 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.validated || element.key != null) {
return;
}
element._store.validated = true;
warnAndMonitorForKeyUse(
'Each child in an array or iterator should have a unique "key" prop.',
element,
parentType
);
}
/**
* Warn if the key is being defined as an object property but has an incorrect
* value.
*
* @internal
* @param {string} name Property name of the key.
* @param {ReactElement} element Component that requires a key.
* @param {*} parentType element's parent's type.
*/
function validatePropertyKey(name, element, parentType) {
if (!NUMERIC_PROPERTY_REGEX.test(name)) {
return;
}
warnAndMonitorForKeyUse(
'Child objects should have non-numeric keys so ordering is preserved.',
element,
parentType
);
}
/**
* Shared warning and monitoring code for the key warnings.
*
* @internal
* @param {string} message The base warning that gets output.
* @param {ReactElement} element Component that requires a key.
* @param {*} parentType element's parent's type.
*/
function warnAndMonitorForKeyUse(message, element, parentType) {
var ownerName = getCurrentOwnerDisplayName();
var parentName = typeof parentType === 'string' ?
parentType : parentType.displayName || parentType.name;
var useName = ownerName || parentName;
var memoizer = ownerHasKeyUseWarning[message] || (
(ownerHasKeyUseWarning[message] = {})
);
if (memoizer.hasOwnProperty(useName)) {
return;
}
memoizer[useName] = true;
var parentOrOwnerAddendum =
ownerName ? (" Check the render method of " + ownerName + ".") :
parentName ? (" Check the React.render call using <" + parentName + ">.") :
'';
// 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.
var childOwnerAddendum = '';
if (element &&
element._owner &&
element._owner !== ReactCurrentOwner.current) {
// Name of the component that originally created this child.
var childOwnerName = getName(element._owner);
childOwnerAddendum = (" It was passed a child from " + childOwnerName + ".");
}
("production" !== process.env.NODE_ENV ? warning(
false,
message + '%s%s See http://fb.me/react-warning-keys for more information.',
parentOrOwnerAddendum,
childOwnerAddendum
) : null);
}
/**
* 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 (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.
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);
}
}
}
} else if (typeof node === 'object') {
var fragment = ReactFragment.extractIfFragment(node);
for (var key in fragment) {
if (fragment.hasOwnProperty(key)) {
validatePropertyKey(key, fragment[key], 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.
("production" !== process.env.NODE_ENV ? invariant(
typeof propTypes[propName] === 'function',
'%s: %s type `%s` is invalid; it must be a function, usually from ' +
'React.PropTypes.',
componentName || 'React class',
ReactPropTypeLocationNames[location],
propName
) : invariant(typeof propTypes[propName] === 'function'));
error = propTypes[propName](props, propName, componentName, location);
} catch (ex) {
error = ex;
}
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(this);
("production" !== process.env.NODE_ENV ? warning(false, 'Failed propType: %s%s', error.message, addendum) : null);
}
}
}
}
var warnedPropsMutations = {};
/**
* Warn about mutating props when setting `propName` on `element`.
*
* @param {string} propName The string key within props that was set
* @param {ReactElement} element
*/
function warnForPropsMutation(propName, element) {
var type = element.type;
var elementName = typeof type === 'string' ? type : type.displayName;
var ownerName = element._owner ?
element._owner.getPublicInstance().constructor.displayName : null;
var warningKey = propName + '|' + elementName + '|' + ownerName;
if (warnedPropsMutations.hasOwnProperty(warningKey)) {
return;
}
warnedPropsMutations[warningKey] = true;
var elementInfo = '';
if (elementName) {
elementInfo = ' <' + elementName + ' />';
}
var ownerInfo = '';
if (ownerName) {
ownerInfo = ' The element was created by ' + ownerName + '.';
}
("production" !== process.env.NODE_ENV ? warning(
false,
'Don\'t set .props.%s of the React component%s. ' +
'Instead, specify the correct value when ' +
'initially creating the element.%s',
propName,
elementInfo,
ownerInfo
) : null);
}
// Inline Object.is polyfill
function is(a, b) {
if (a !== a) {
// NaN
return b !== b;
}
if (a === 0 && b === 0) {
// +-0
return 1 / a === 1 / b;
}
return a === b;
}
/**
* Given an element, check if its props have been mutated since element
* creation (or the last call to this function). In particular, check if any
* new props have been added, which we can't directly catch by defining warning
* properties on the props object.
*
* @param {ReactElement} element
*/
function checkAndWarnForMutatedProps(element) {
if (!element._store) {
// Element was created using `new ReactElement` directly or with
// `ReactElement.createElement`; skip mutation checking
return;
}
var originalProps = element._store.originalProps;
var props = element.props;
for (var propName in props) {
if (props.hasOwnProperty(propName)) {
if (!originalProps.hasOwnProperty(propName) ||
!is(originalProps[propName], props[propName])) {
warnForPropsMutation(propName, element);
// Copy over the new value so that the two props objects match again
originalProps[propName] = props[propName];
}
}
}
}
/**
* Given an element, validate that its props follow the propTypes definition,
* provided by the type.
*
* @param {ReactElement} element
*/
function validatePropTypes(element) {
if (element.type == null) {
// This has already warned. Don't throw.
return;
}
// Extract the component class from the element. Converts string types
// to a composite class which may have propTypes.
// TODO: Validating a string's propTypes is not decoupled from the
// rendering target which is problematic.
var componentClass = ReactNativeComponent.getComponentClassForElement(
element
);
var name = componentClass.displayName || componentClass.name;
if (componentClass.propTypes) {
checkPropTypes(
name,
componentClass.propTypes,
element.props,
ReactPropTypeLocations.prop
);
}
if (typeof componentClass.getDefaultProps === 'function') {
("production" !== process.env.NODE_ENV ? warning(
componentClass.getDefaultProps.isReactClassApproved,
'getDefaultProps is only used on classic React.createClass ' +
'definitions. Use a static property named `defaultProps` instead.'
) : null);
}
}
var ReactElementValidator = {
checkAndWarnForMutatedProps: checkAndWarnForMutatedProps,
createElement: function(type, props, children) {
// We warn in this case but don't throw. We expect the element creation to
// succeed and there will likely be errors in render.
("production" !== process.env.NODE_ENV ? warning(
type != null,
'React.createElement: type should not be null or undefined. It should ' +
'be a string (for DOM elements) or a ReactClass (for composite ' +
'components).'
) : null);
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;
}
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 ("production" !== process.env.NODE_ENV) {
try {
Object.defineProperty(
validatedFactory,
'type',
{
enumerable: false,
get: function() {
("production" !== process.env.NODE_ENV ? warning(
false,
'Factory.type is deprecated. Access the class directly ' +
'before passing it to createFactory.'
) : null);
Object.defineProperty(this, 'type', {
value: type
});
return type;
}
}
);
} catch (x) {
// IE will fail on defineProperty (es5-shim/sham too)
}
}
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;
}).call(this,require('_process'))
},{"./ReactCurrentOwner":48,"./ReactElement":66,"./ReactFragment":72,"./ReactNativeComponent":83,"./ReactPropTypeLocationNames":87,"./ReactPropTypeLocations":88,"./getIteratorFn":145,"./invariant":154,"./warning":175,"_process":2}],68:[function(require,module,exports){
(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 ReactEmptyComponent
*/
'use strict';
var ReactElement = require("./ReactElement");
var ReactInstanceMap = require("./ReactInstanceMap");
var invariant = require("./invariant");
var component;
// This registry keeps track of the React IDs of the components that rendered to
// `null` (in reality a placeholder such as `noscript`)
var nullComponentIDsRegistry = {};
var ReactEmptyComponentInjection = {
injectEmptyComponent: function(emptyComponent) {
component = ReactElement.createFactory(emptyComponent);
}
};
var ReactEmptyComponentType = function() {};
ReactEmptyComponentType.prototype.componentDidMount = function() {
var internalInstance = ReactInstanceMap.get(this);
// TODO: Make sure we run these methods in the correct order, we shouldn't
// need this check. We're going to assume if we're here it means we ran
// componentWillUnmount already so there is no internal instance (it gets
// removed as part of the unmounting process).
if (!internalInstance) {
return;
}
registerNullComponentID(internalInstance._rootNodeID);
};
ReactEmptyComponentType.prototype.componentWillUnmount = function() {
var internalInstance = ReactInstanceMap.get(this);
// TODO: Get rid of this check. See TODO in componentDidMount.
if (!internalInstance) {
return;
}
deregisterNullComponentID(internalInstance._rootNodeID);
};
ReactEmptyComponentType.prototype.render = function() {
("production" !== process.env.NODE_ENV ? invariant(
component,
'Trying to return null from a render, but no null placeholder component ' +
'was injected.'
) : invariant(component));
return component();
};
var emptyElement = ReactElement.createElement(ReactEmptyComponentType);
/**
* 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];
}
/**
* @param {string} id Component's `_rootNodeID`.
* @return {boolean} True if the component is rendered to null.
*/
function isNullComponentID(id) {
return !!nullComponentIDsRegistry[id];
}
var ReactEmptyComponent = {
emptyElement: emptyElement,
injection: ReactEmptyComponentInjection,
isNullComponentID: isNullComponentID
};
module.exports = ReactEmptyComponent;
}).call(this,require('_process'))
},{"./ReactElement":66,"./ReactInstanceMap":76,"./invariant":154,"_process":2}],69:[function(require,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 ReactErrorUtils
* @typechecks
*/
"use strict";
var ReactErrorUtils = {
/**
* Creates a guarded version of a function. This is supposed to make debugging
* of event handlers easier. To aid debugging with the browser's debugger,
* this currently simply returns the original function.
*
* @param {function} func Function to be executed
* @param {string} name The name of the guard
* @return {function}
*/
guard: function(func, name) {
return func;
}
};
module.exports = ReactErrorUtils;
},{}],70:[function(require,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 ReactEventEmitterMixin
*/
'use strict';
var EventPluginHub = require("./EventPluginHub");
function runEventQueueInBatch(events) {
EventPluginHub.enqueueEvents(events);
EventPluginHub.processEventQueue();
}
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) {
var events = EventPluginHub.extractEvents(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent
);
runEventQueueInBatch(events);
}
};
module.exports = ReactEventEmitterMixin;
},{"./EventPluginHub":21}],71:[function(require,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 ReactEventListener
* @typechecks static-only
*/
'use strict';
var EventListener = require("./EventListener");
var ExecutionEnvironment = require("./ExecutionEnvironment");
var PooledClass = require("./PooledClass");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var ReactMount = require("./ReactMount");
var ReactUpdates = require("./ReactUpdates");
var assign = require("./Object.assign");
var getEventTarget = require("./getEventTarget");
var getUnboundedScrollPosition = require("./getUnboundedScrollPosition");
/**
* 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) {
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, l = bookKeeping.ancestors.length; i < l; i++) {
topLevelTarget = bookKeeping.ancestors[i];
var topLevelTargetID = ReactMount.getID(topLevelTarget) || '';
ReactEventListener._handleTopLevel(
bookKeeping.topLevelType,
topLevelTarget,
topLevelTargetID,
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;
},{"./EventListener":20,"./ExecutionEnvironment":25,"./Object.assign":32,"./PooledClass":33,"./ReactInstanceHandles":75,"./ReactMount":80,"./ReactUpdates":103,"./getEventTarget":144,"./getUnboundedScrollPosition":150}],72:[function(require,module,exports){
(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 ReactFragment
*/
'use strict';
var ReactElement = require("./ReactElement");
var warning = require("./warning");
/**
* We used to allow keyed objects to serve as a collection of ReactElements,
* or nested sets. This allowed us a way to explicitly key a set a fragment of
* components. This is now being replaced with an opaque data structure.
* The upgrade path is to call React.addons.createFragment({ key: value }) to
* create a keyed fragment. The resulting data structure is opaque, for now.
*/
if ("production" !== process.env.NODE_ENV) {
var fragmentKey = '_reactFragment';
var didWarnKey = '_reactDidWarn';
var canWarnForReactFragment = false;
try {
// Feature test. Don't even try to issue this warning if we can't use
// enumerable: false.
var dummy = function() {
return 1;
};
Object.defineProperty(
{},
fragmentKey,
{enumerable: false, value: true}
);
Object.defineProperty(
{},
'key',
{enumerable: true, get: dummy}
);
canWarnForReactFragment = true;
} catch (x) { }
var proxyPropertyAccessWithWarning = function(obj, key) {
Object.defineProperty(obj, key, {
enumerable: true,
get: function() {
("production" !== process.env.NODE_ENV ? warning(
this[didWarnKey],
'A ReactFragment is an opaque type. Accessing any of its ' +
'properties is deprecated. Pass it to one of the React.Children ' +
'helpers.'
) : null);
this[didWarnKey] = true;
return this[fragmentKey][key];
},
set: function(value) {
("production" !== process.env.NODE_ENV ? warning(
this[didWarnKey],
'A ReactFragment is an immutable opaque type. Mutating its ' +
'properties is deprecated.'
) : null);
this[didWarnKey] = true;
this[fragmentKey][key] = value;
}
});
};
var issuedWarnings = {};
var didWarnForFragment = function(fragment) {
// We use the keys and the type of the value as a heuristic to dedupe the
// warning to avoid spamming too much.
var fragmentCacheKey = '';
for (var key in fragment) {
fragmentCacheKey += key + ':' + (typeof fragment[key]) + ',';
}
var alreadyWarnedOnce = !!issuedWarnings[fragmentCacheKey];
issuedWarnings[fragmentCacheKey] = true;
return alreadyWarnedOnce;
};
}
var ReactFragment = {
// Wrap a keyed object in an opaque proxy that warns you if you access any
// of its properties.
create: function(object) {
if ("production" !== process.env.NODE_ENV) {
if (typeof object !== 'object' || !object || Array.isArray(object)) {
("production" !== process.env.NODE_ENV ? warning(
false,
'React.addons.createFragment only accepts a single object.',
object
) : null);
return object;
}
if (ReactElement.isValidElement(object)) {
("production" !== process.env.NODE_ENV ? warning(
false,
'React.addons.createFragment does not accept a ReactElement ' +
'without a wrapper object.'
) : null);
return object;
}
if (canWarnForReactFragment) {
var proxy = {};
Object.defineProperty(proxy, fragmentKey, {
enumerable: false,
value: object
});
Object.defineProperty(proxy, didWarnKey, {
writable: true,
enumerable: false,
value: false
});
for (var key in object) {
proxyPropertyAccessWithWarning(proxy, key);
}
Object.preventExtensions(proxy);
return proxy;
}
}
return object;
},
// Extract the original keyed object from the fragment opaque type. Warn if
// a plain object is passed here.
extract: function(fragment) {
if ("production" !== process.env.NODE_ENV) {
if (canWarnForReactFragment) {
if (!fragment[fragmentKey]) {
("production" !== process.env.NODE_ENV ? warning(
didWarnForFragment(fragment),
'Any use of a keyed object should be wrapped in ' +
'React.addons.createFragment(object) before being passed as a ' +
'child.'
) : null);
return fragment;
}
return fragment[fragmentKey];
}
}
return fragment;
},
// Check if this is a fragment and if so, extract the keyed object. If it
// is a fragment-like object, warn that it should be wrapped. Ignore if we
// can't determine what kind of object this is.
extractIfFragment: function(fragment) {
if ("production" !== process.env.NODE_ENV) {
if (canWarnForReactFragment) {
// If it is the opaque type, return the keyed object.
if (fragment[fragmentKey]) {
return fragment[fragmentKey];
}
// Otherwise, check each property if it has an element, if it does
// it is probably meant as a fragment, so we can warn early. Defer,
// the warning to extract.
for (var key in fragment) {
if (fragment.hasOwnProperty(key) &&
ReactElement.isValidElement(fragment[key])) {
// This looks like a fragment object, we should provide an
// early warning.
return ReactFragment.extract(fragment);
}
}
}
}
return fragment;
}
};
module.exports = ReactFragment;
}).call(this,require('_process'))
},{"./ReactElement":66,"./warning":175,"_process":2}],73:[function(require,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 ReactInjection
*/
'use strict';
var DOMProperty = require("./DOMProperty");
var EventPluginHub = require("./EventPluginHub");
var ReactComponentEnvironment = require("./ReactComponentEnvironment");
var ReactClass = require("./ReactClass");
var ReactEmptyComponent = require("./ReactEmptyComponent");
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var ReactNativeComponent = require("./ReactNativeComponent");
var ReactDOMComponent = require("./ReactDOMComponent");
var ReactPerf = require("./ReactPerf");
var ReactRootIndex = require("./ReactRootIndex");
var ReactUpdates = require("./ReactUpdates");
var ReactInjection = {
Component: ReactComponentEnvironment.injection,
Class: ReactClass.injection,
DOMComponent: ReactDOMComponent.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;
},{"./DOMProperty":14,"./EventPluginHub":21,"./ReactBrowserEventEmitter":36,"./ReactClass":41,"./ReactComponentEnvironment":44,"./ReactDOMComponent":51,"./ReactEmptyComponent":68,"./ReactNativeComponent":83,"./ReactPerf":85,"./ReactRootIndex":94,"./ReactUpdates":103}],74:[function(require,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 ReactInputSelection
*/
'use strict';
var ReactDOMSelection = require("./ReactDOMSelection");
var containsNode = require("./containsNode");
var focusNode = require("./focusNode");
var getActiveElement = require("./getActiveElement");
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) {
return elem && (
((elem.nodeName === 'INPUT' && elem.type === 'text') ||
elem.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') {
// 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') {
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;
},{"./ReactDOMSelection":59,"./containsNode":127,"./focusNode":138,"./getActiveElement":140}],75:[function(require,module,exports){
(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 = require("./ReactRootIndex");
var invariant = require("./invariant");
var SEPARATOR = '.';
var SEPARATOR_LENGTH = SEPARATOR.length;
/**
* Maximum depth of traversals before we consider the possibility of a bad ID.
*/
var MAX_TREE_DEPTH = 100;
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
isValidID(ancestorID) && isValidID(destinationID),
'getNextDescendantID(%s, %s): Received an invalid React DOM ID.',
ancestorID,
destinationID
) : invariant(isValidID(ancestorID) && isValidID(destinationID)));
("production" !== process.env.NODE_ENV ? invariant(
isAncestorIDOf(ancestorID, destinationID),
'getNextDescendantID(...): React has made an invalid assumption about ' +
'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.',
ancestorID,
destinationID
) : invariant(isAncestorIDOf(ancestorID, destinationID)));
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);
("production" !== process.env.NODE_ENV ? invariant(
isValidID(longestCommonID),
'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s',
oneID,
twoID,
longestCommonID
) : invariant(isValidID(longestCommonID)));
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 {?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 || '';
("production" !== process.env.NODE_ENV ? invariant(
start !== stop,
'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.',
start
) : invariant(start !== stop));
var traverseUp = isAncestorIDOf(stop, start);
("production" !== process.env.NODE_ENV ? invariant(
traverseUp || isAncestorIDOf(start, stop),
'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' +
'not have a parent path.',
start,
stop
) : invariant(traverseUp || isAncestorIDOf(start, stop)));
// 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;
}
("production" !== process.env.NODE_ENV ? invariant(
depth++ < MAX_TREE_DEPTH,
'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' +
'traversing the React DOM ID tree. This may be due to malformed IDs: %s',
start, stop
) : invariant(depth++ < MAX_TREE_DEPTH));
}
}
/**
* 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);
}
},
/**
* 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);
},
/**
* Exposed for unit testing.
* @private
*/
_getFirstCommonAncestorID: getFirstCommonAncestorID,
/**
* Exposed for unit testing.
* @private
*/
_getNextDescendantID: getNextDescendantID,
isAncestorIDOf: isAncestorIDOf,
SEPARATOR: SEPARATOR
};
module.exports = ReactInstanceHandles;
}).call(this,require('_process'))
},{"./ReactRootIndex":94,"./invariant":154,"_process":2}],76:[function(require,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;
},{}],77:[function(require,module,exports){
/**
* 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 ReactLifeCycle
*/
'use strict';
/**
* This module manages the bookkeeping when a component is in the process
* of being mounted or being unmounted. This is used as a way to enforce
* invariants (or warnings) when it is not recommended to call
* setState/forceUpdate.
*
* currentlyMountingInstance: During the construction phase, it is not possible
* to trigger an update since the instance is not fully mounted yet. However, we
* currently allow this as a convenience for mutating the initial state.
*
* currentlyUnmountingInstance: During the unmounting phase, the instance is
* still mounted and can therefore schedule an update. However, this is not
* recommended and probably an error since it's about to be unmounted.
* Therefore we still want to trigger in an error for that case.
*/
var ReactLifeCycle = {
currentlyMountingInstance: null,
currentlyUnmountingInstance: null
};
module.exports = ReactLifeCycle;
},{}],78:[function(require,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 ReactLink
* @typechecks static-only
*/
'use strict';
/**
* ReactLink encapsulates a common pattern in which a component wants to modify
* a prop received from its parent. ReactLink allows the parent to pass down a
* value coupled with a callback that, when invoked, expresses an intent to
* modify that value. For example:
*
* React.createClass({
* getInitialState: function() {
* return {value: ''};
* },
* render: function() {
* var valueLink = new ReactLink(this.state.value, this._handleValueChange);
* return <input valueLink={valueLink} />;
* },
* this._handleValueChange: function(newValue) {
* this.setState({value: newValue});
* }
* });
*
* We have provided some sugary mixins to make the creation and
* consumption of ReactLink easier; see LinkedValueUtils and LinkedStateMixin.
*/
var React = require("./React");
/**
* @param {*} value current value of the link
* @param {function} requestChange callback to request a change
*/
function ReactLink(value, requestChange) {
this.value = value;
this.requestChange = requestChange;
}
/**
* Creates a PropType that enforces the ReactLink API and optionally checks the
* type of the value being passed inside the link. Example:
*
* MyComponent.propTypes = {
* tabIndexLink: ReactLink.PropTypes.link(React.PropTypes.number)
* }
*/
function createLinkTypeChecker(linkType) {
var shapes = {
value: typeof linkType === 'undefined' ?
React.PropTypes.any.isRequired :
linkType.isRequired,
requestChange: React.PropTypes.func.isRequired
};
return React.PropTypes.shape(shapes);
}
ReactLink.PropTypes = {
link: createLinkTypeChecker
};
module.exports = ReactLink;
},{"./React":34}],79:[function(require,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 ReactMarkupChecksum
*/
'use strict';
var adler32 = require("./adler32");
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);
return markup.replace(
'>',
' ' + 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;
},{"./adler32":123}],80:[function(require,module,exports){
(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 = require("./DOMProperty");
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactElement = require("./ReactElement");
var ReactElementValidator = require("./ReactElementValidator");
var ReactEmptyComponent = require("./ReactEmptyComponent");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var ReactInstanceMap = require("./ReactInstanceMap");
var ReactMarkupChecksum = require("./ReactMarkupChecksum");
var ReactPerf = require("./ReactPerf");
var ReactReconciler = require("./ReactReconciler");
var ReactUpdateQueue = require("./ReactUpdateQueue");
var ReactUpdates = require("./ReactUpdates");
var emptyObject = require("./emptyObject");
var containsNode = require("./containsNode");
var getReactRootElementInContainer = require("./getReactRootElementInContainer");
var instantiateReactComponent = require("./instantiateReactComponent");
var invariant = require("./invariant");
var setInnerHTML = require("./setInnerHTML");
var shouldUpdateReactComponent = require("./shouldUpdateReactComponent");
var warning = require("./warning");
var SEPARATOR = ReactInstanceHandles.SEPARATOR;
var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
var nodeCache = {};
var ELEMENT_NODE_TYPE = 1;
var DOC_NODE_TYPE = 9;
/** Mapping from reactRootID to React component instance. */
var instancesByReactRootID = {};
/** Mapping from reactRootID to `container` nodes. */
var containersByReactRootID = {};
if ("production" !== process.env.NODE_ENV) {
/** __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} 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) {
("production" !== process.env.NODE_ENV ? invariant(
!isValid(cached, id),
'ReactMount: Two valid but unequal nodes with the same `%s`: %s',
ATTR_NAME, id
) : invariant(!isValid(cached, id)));
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 (ReactEmptyComponent.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) {
("production" !== process.env.NODE_ENV ? invariant(
internalGetID(node) === id,
'ReactMount: Unexpected modification of `%s`',
ATTR_NAME
) : invariant(internalGetID(node) === id));
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) {
var markup = ReactReconciler.mountComponent(
componentInstance, rootID, transaction, emptyObject
);
componentInstance._isTopLevel = true;
ReactMount._mountImageIntoNode(markup, container, shouldReuseMarkup);
}
/**
* 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) {
var transaction = ReactUpdates.ReactReconcileTransaction.getPooled();
transaction.perform(
mountComponentIntoNode,
null,
componentInstance,
rootID,
container,
transaction,
shouldReuseMarkup
);
ReactUpdates.ReactReconcileTransaction.release(transaction);
}
/**
* 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 = {
/** 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) {
if ("production" !== process.env.NODE_ENV) {
ReactElementValidator.checkAndWarnForMutatedProps(nextElement);
}
ReactMount.scrollMonitor(container, function() {
ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement);
if (callback) {
ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);
}
});
if ("production" !== process.env.NODE_ENV) {
// 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) {
("production" !== process.env.NODE_ENV ? invariant(
container && (
(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
),
'_registerComponent(...): Target container is not a DOM element.'
) : invariant(container && (
(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
)));
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
) {
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case.
("production" !== process.env.NODE_ENV ? 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.'
) : null);
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
);
if ("production" !== process.env.NODE_ENV) {
// 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 {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) {
("production" !== process.env.NODE_ENV ? invariant(
ReactElement.isValidElement(nextElement),
'React.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(ReactElement.isValidElement(nextElement)));
var prevComponent = instancesByReactRootID[getReactRootID(container)];
if (prevComponent) {
var prevElement = prevComponent._currentElement;
if (shouldUpdateReactComponent(prevElement, nextElement)) {
return ReactMount._updateRootComponent(
prevComponent,
nextElement,
container,
callback
).getPublicInstance();
} else {
ReactMount.unmountComponentAtNode(container);
}
}
var reactRootElement = getReactRootElementInContainer(container);
var containerHasReactMarkup =
reactRootElement && ReactMount.isRenderedByReact(reactRootElement);
if ("production" !== process.env.NODE_ENV) {
if (!containerHasReactMarkup || reactRootElement.nextSibling) {
var rootElementSibling = reactRootElement;
while (rootElementSibling) {
if (ReactMount.isRenderedByReact(rootElementSibling)) {
("production" !== process.env.NODE_ENV ? 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.'
) : null);
break;
}
rootElementSibling = rootElementSibling.nextSibling;
}
}
}
var shouldReuseMarkup = containerHasReactMarkup && !prevComponent;
var component = ReactMount._renderNewRootComponent(
nextElement,
container,
shouldReuseMarkup
).getPublicInstance();
if (callback) {
callback.call(component);
}
return component;
},
/**
* Constructs a component instance of `constructor` with `initialProps` and
* renders it into the supplied `container`.
*
* @param {function} constructor React component constructor.
* @param {?object} props Initial props of the component instance.
* @param {DOMElement} container DOM element to render into.
* @return {ReactComponent} Component instance rendered in `container`.
*/
constructAndRenderComponent: function(constructor, props, container) {
var element = ReactElement.createElement(constructor, props);
return ReactMount.render(element, container);
},
/**
* Constructs a component instance of `constructor` with `initialProps` and
* renders it into a container node identified by supplied `id`.
*
* @param {function} componentConstructor React component constructor
* @param {?object} props Initial props of the component instance.
* @param {string} id ID of the DOM element to render into.
* @return {ReactComponent} Component instance rendered in the container node.
*/
constructAndRenderComponentByID: function(constructor, props, id) {
var domNode = document.getElementById(id);
("production" !== process.env.NODE_ENV ? invariant(
domNode,
'Tried to get element with id of "%s" but it is not present on the page.',
id
) : invariant(domNode));
return ReactMount.constructAndRenderComponent(constructor, props, domNode);
},
/**
* 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.)
("production" !== process.env.NODE_ENV ? 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.'
) : null);
("production" !== process.env.NODE_ENV ? invariant(
container && (
(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
),
'unmountComponentAtNode(...): Target container is not a DOM element.'
) : invariant(container && (
(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
)));
var reactRootID = getReactRootID(container);
var component = instancesByReactRootID[reactRootID];
if (!component) {
return false;
}
ReactMount.unmountComponentFromNode(component, container);
delete instancesByReactRootID[reactRootID];
delete containersByReactRootID[reactRootID];
if ("production" !== process.env.NODE_ENV) {
delete rootElementsByReactRootID[reactRootID];
}
return true;
},
/**
* 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}
*/
unmountComponentFromNode: function(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);
}
},
/**
* 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 ("production" !== process.env.NODE_ENV) {
var rootElement = rootElementsByReactRootID[reactRootID];
if (rootElement && rootElement.parentNode !== container) {
("production" !== process.env.NODE_ENV ? invariant(
// Call internalGetID here because getID calls isValid which calls
// findReactContainerForID (this function).
internalGetID(rootElement) === reactRootID,
'ReactMount: Root element ID differed from reactRootID.'
) : invariant(// Call internalGetID here because getID calls isValid which calls
// findReactContainerForID (this function).
internalGetID(rootElement) === reactRootID));
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 {
("production" !== process.env.NODE_ENV ? warning(
false,
'ReactMount: Root element has been removed from its original ' +
'container. New container:', rootElement.parentNode
) : null);
}
}
}
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);
},
/**
* True if the supplied `node` is rendered by React.
*
* @param {*} node DOM Element to check.
* @return {boolean} True if the DOM Element appears to be rendered by React.
* @internal
*/
isRenderedByReact: function(node) {
if (node.nodeType !== 1) {
// Not a DOMElement, therefore not a React component
return false;
}
var id = ReactMount.getID(node);
return id ? id.charAt(0) === SEPARATOR : false;
},
/**
* Traverses up the ancestors of the supplied node to find a node that is a
* DOM representation of a React component.
*
* @param {*} node
* @return {?DOMEventTarget}
* @internal
*/
getFirstReactDOM: function(node) {
var current = node;
while (current && current.parentNode !== current) {
if (ReactMount.isRenderedByReact(current)) {
return current;
}
current = current.parentNode;
}
return null;
},
/**
* 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;
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;
("production" !== process.env.NODE_ENV ? 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));
},
_mountImageIntoNode: function(markup, container, shouldReuseMarkup) {
("production" !== process.env.NODE_ENV ? invariant(
container && (
(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
),
'mountComponentIntoNode(...): Target container is not valid.'
) : invariant(container && (
(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
)));
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 diffIndex = firstDifferenceIndex(markup, rootMarkup);
var difference = ' (client) ' +
markup.substring(diffIndex - 20, diffIndex + 20) +
'\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);
("production" !== process.env.NODE_ENV ? invariant(
container.nodeType !== DOC_NODE_TYPE,
'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(container.nodeType !== DOC_NODE_TYPE));
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? 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
) : null);
}
}
}
("production" !== process.env.NODE_ENV ? invariant(
container.nodeType !== DOC_NODE_TYPE,
'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 React.renderToString() for server rendering.'
) : invariant(container.nodeType !== DOC_NODE_TYPE));
setInnerHTML(container, markup);
},
/**
* React ID utilities.
*/
getReactRootID: getReactRootID,
getID: getID,
setID: setID,
getNode: getNode,
getNodeFromInstance: getNodeFromInstance,
purgeID: purgeID
};
ReactPerf.measureMethods(ReactMount, 'ReactMount', {
_renderNewRootComponent: '_renderNewRootComponent',
_mountImageIntoNode: '_mountImageIntoNode'
});
module.exports = ReactMount;
}).call(this,require('_process'))
},{"./DOMProperty":14,"./ReactBrowserEventEmitter":36,"./ReactCurrentOwner":48,"./ReactElement":66,"./ReactElementValidator":67,"./ReactEmptyComponent":68,"./ReactInstanceHandles":75,"./ReactInstanceMap":76,"./ReactMarkupChecksum":79,"./ReactPerf":85,"./ReactReconciler":92,"./ReactUpdateQueue":102,"./ReactUpdates":103,"./containsNode":127,"./emptyObject":134,"./getReactRootElementInContainer":148,"./instantiateReactComponent":153,"./invariant":154,"./setInnerHTML":168,"./shouldUpdateReactComponent":171,"./warning":175,"_process":2}],81:[function(require,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 ReactMultiChild
* @typechecks static-only
*/
'use strict';
var ReactComponentEnvironment = require("./ReactComponentEnvironment");
var ReactMultiChildUpdateTypes = require("./ReactMultiChildUpdateTypes");
var ReactReconciler = require("./ReactReconciler");
var ReactChildReconciler = require("./ReactChildReconciler");
/**
* 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 enqueueMarkup(parentID, markup, toIndex) {
// NOTE: Null values reduce hidden classes.
updateQueue.push({
parentID: parentID,
parentNode: null,
type: ReactMultiChildUpdateTypes.INSERT_MARKUP,
markupIndex: markupQueue.push(markup) - 1,
textContent: 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,
textContent: 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,
textContent: null,
fromIndex: fromIndex,
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,
textContent: 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: {
/**
* 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 = ReactChildReconciler.instantiateChildren(
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);
index++;
}
}
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._unmountChildByName(prevChildren[name], name);
}
}
// Set new text content.
this.setTextContent(nextContent);
errorThrown = false;
} finally {
updateDepth--;
if (!updateDepth) {
if (errorThrown) {
clearQueue();
} else {
processQueue();
}
}
}
},
/**
* Updates the rendered children with new children.
*
* @param {?object} nextNestedChildren Nested child maps.
* @param {ReactReconcileTransaction} transaction
* @internal
*/
updateChildren: function(nextNestedChildren, transaction, context) {
updateDepth++;
var errorThrown = true;
try {
this._updateChildren(nextNestedChildren, 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} nextNestedChildren Nested child maps.
* @param {ReactReconcileTransaction} transaction
* @final
* @protected
*/
_updateChildren: function(nextNestedChildren, transaction, context) {
var prevChildren = this._renderedChildren;
var nextChildren = ReactChildReconciler.updateChildren(
prevChildren, nextNestedChildren, 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._unmountChildByName(prevChild, name);
}
// 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._unmountChildByName(prevChildren[name], 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) {
enqueueMarkup(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);
},
/**
* 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 by name.
*
* NOTE: This is part of `updateChildren` and is here for readability.
*
* @param {ReactComponent} child Component to unmount.
* @param {string} name Name of the child in `this._renderedChildren`.
* @private
*/
_unmountChildByName: function(child, name) {
this.removeChild(child);
child._mountIndex = null;
}
}
};
module.exports = ReactMultiChild;
},{"./ReactChildReconciler":39,"./ReactComponentEnvironment":44,"./ReactMultiChildUpdateTypes":82,"./ReactReconciler":92}],82:[function(require,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 ReactMultiChildUpdateTypes
*/
'use strict';
var keyMirror = require("./keyMirror");
/**
* 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,
TEXT_CONTENT: null
});
module.exports = ReactMultiChildUpdateTypes;
},{"./keyMirror":160}],83:[function(require,module,exports){
(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 = require("./Object.assign");
var invariant = require("./invariant");
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);
},
// Temporary hack since we expect DOM refs to behave like composites,
// for this release.
injectAutoWrapper: function(wrapperFactory) {
autoGenerateWrapperClass = wrapperFactory;
}
};
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
genericComponentClass,
'There is no registered component for the tag %s',
element.type
) : invariant(genericComponentClass));
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;
}).call(this,require('_process'))
},{"./Object.assign":32,"./invariant":154,"_process":2}],84:[function(require,module,exports){
(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 = require("./invariant");
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
ReactOwner.isValidOwner(owner),
'addComponentAsRefTo(...): Only a ReactOwner can have refs. This ' +
'usually means that you\'re trying to add a ref to a component that ' +
'doesn\'t have an owner (that is, was not created inside of another ' +
'component\'s `render` method). Try rendering this component inside of ' +
'a new top-level component which will hold the ref.'
) : invariant(ReactOwner.isValidOwner(owner)));
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) {
("production" !== process.env.NODE_ENV ? invariant(
ReactOwner.isValidOwner(owner),
'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. This ' +
'usually means that you\'re trying to remove a ref to a component that ' +
'doesn\'t have an owner (that is, was not created inside of another ' +
'component\'s `render` method). Try rendering this component inside of ' +
'a new top-level component which will hold the ref.'
) : invariant(ReactOwner.isValidOwner(owner)));
// 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;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],85:[function(require,module,exports){
(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 ("production" !== process.env.NODE_ENV) {
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 ("production" !== process.env.NODE_ENV) {
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;
}).call(this,require('_process'))
},{"_process":2}],86:[function(require,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 ReactPropTransferer
*/
'use strict';
var assign = require("./Object.assign");
var emptyFunction = require("./emptyFunction");
var joinClasses = require("./joinClasses");
/**
* Creates a transfer strategy that will merge prop values using the supplied
* `mergeStrategy`. If a prop was previously unset, this just sets it.
*
* @param {function} mergeStrategy
* @return {function}
*/
function createTransferStrategy(mergeStrategy) {
return function(props, key, value) {
if (!props.hasOwnProperty(key)) {
props[key] = value;
} else {
props[key] = mergeStrategy(props[key], value);
}
};
}
var transferStrategyMerge = createTransferStrategy(function(a, b) {
// `merge` overrides the first object's (`props[key]` above) keys using the
// second object's (`value`) keys. An object's style's existing `propA` would
// get overridden. Flip the order here.
return assign({}, b, a);
});
/**
* Transfer strategies dictate how props are transferred by `transferPropsTo`.
* NOTE: if you add any more exceptions to this list you should be sure to
* update `cloneWithProps()` accordingly.
*/
var TransferStrategies = {
/**
* Never transfer `children`.
*/
children: emptyFunction,
/**
* Transfer the `className` prop by merging them.
*/
className: createTransferStrategy(joinClasses),
/**
* Transfer the `style` prop (which is an object) by merging them.
*/
style: transferStrategyMerge
};
/**
* Mutates the first argument by transferring the properties from the second
* argument.
*
* @param {object} props
* @param {object} newProps
* @return {object}
*/
function transferInto(props, newProps) {
for (var thisKey in newProps) {
if (!newProps.hasOwnProperty(thisKey)) {
continue;
}
var transferStrategy = TransferStrategies[thisKey];
if (transferStrategy && TransferStrategies.hasOwnProperty(thisKey)) {
transferStrategy(props, thisKey, newProps[thisKey]);
} else if (!props.hasOwnProperty(thisKey)) {
props[thisKey] = newProps[thisKey];
}
}
return props;
}
/**
* ReactPropTransferer are capable of transferring props to another component
* using a `transferPropsTo` method.
*
* @class ReactPropTransferer
*/
var ReactPropTransferer = {
/**
* Merge two props objects using TransferStrategies.
*
* @param {object} oldProps original props (they take precedence)
* @param {object} newProps new props to merge in
* @return {object} a new object containing both sets of props merged.
*/
mergeProps: function(oldProps, newProps) {
return transferInto(assign({}, oldProps), newProps);
}
};
module.exports = ReactPropTransferer;
},{"./Object.assign":32,"./emptyFunction":133,"./joinClasses":159}],87:[function(require,module,exports){
(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 ("production" !== process.env.NODE_ENV) {
ReactPropTypeLocationNames = {
prop: 'prop',
context: 'context',
childContext: 'child context'
};
}
module.exports = ReactPropTypeLocationNames;
}).call(this,require('_process'))
},{"_process":2}],88:[function(require,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 ReactPropTypeLocations
*/
'use strict';
var keyMirror = require("./keyMirror");
var ReactPropTypeLocations = keyMirror({
prop: null,
context: null,
childContext: null
});
module.exports = ReactPropTypeLocations;
},{"./keyMirror":160}],89:[function(require,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 ReactPropTypes
*/
'use strict';
var ReactElement = require("./ReactElement");
var ReactFragment = require("./ReactFragment");
var ReactPropTypeLocationNames = require("./ReactPropTypeLocationNames");
var emptyFunction = require("./emptyFunction");
/**
* 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 elementTypeChecker = createElementTypeChecker();
var nodeTypeChecker = createNodeChecker();
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: elementTypeChecker,
instanceOf: createInstanceTypeChecker,
node: nodeTypeChecker,
objectOf: createObjectOfTypeChecker,
oneOf: createEnumTypeChecker,
oneOfType: createUnionTypeChecker,
shape: createShapeTypeChecker
};
function createChainableTypeChecker(validate) {
function checkType(isRequired, props, propName, componentName, location) {
componentName = componentName || ANONYMOUS;
if (props[propName] == null) {
var locationName = ReactPropTypeLocationNames[location];
if (isRequired) {
return new Error(
("Required " + locationName + " `" + propName + "` was not specified in ") +
("`" + componentName + "`.")
);
}
return null;
} else {
return validate(props, propName, componentName, location);
}
}
var chainedCheckType = checkType.bind(null, false);
chainedCheckType.isRequired = checkType.bind(null, true);
return chainedCheckType;
}
function createPrimitiveTypeChecker(expectedType) {
function validate(props, propName, componentName, location) {
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 + " `" + propName + "` 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) {
var propValue = props[propName];
if (!Array.isArray(propValue)) {
var locationName = ReactPropTypeLocationNames[location];
var propType = getPropType(propValue);
return new Error(
("Invalid " + locationName + " `" + propName + "` of type ") +
("`" + propType + "` supplied to `" + componentName + "`, expected an array.")
);
}
for (var i = 0; i < propValue.length; i++) {
var error = typeChecker(propValue, i, componentName, location);
if (error instanceof Error) {
return error;
}
}
return null;
}
return createChainableTypeChecker(validate);
}
function createElementTypeChecker() {
function validate(props, propName, componentName, location) {
if (!ReactElement.isValidElement(props[propName])) {
var locationName = ReactPropTypeLocationNames[location];
return new Error(
("Invalid " + locationName + " `" + propName + "` supplied to ") +
("`" + componentName + "`, expected a ReactElement.")
);
}
return null;
}
return createChainableTypeChecker(validate);
}
function createInstanceTypeChecker(expectedClass) {
function validate(props, propName, componentName, location) {
if (!(props[propName] instanceof expectedClass)) {
var locationName = ReactPropTypeLocationNames[location];
var expectedClassName = expectedClass.name || ANONYMOUS;
return new Error(
("Invalid " + locationName + " `" + propName + "` supplied to ") +
("`" + componentName + "`, expected instance of `" + expectedClassName + "`.")
);
}
return null;
}
return createChainableTypeChecker(validate);
}
function createEnumTypeChecker(expectedValues) {
function validate(props, propName, componentName, location) {
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 + " `" + propName + "` of value `" + propValue + "` ") +
("supplied to `" + componentName + "`, expected one of " + valuesString + ".")
);
}
return createChainableTypeChecker(validate);
}
function createObjectOfTypeChecker(typeChecker) {
function validate(props, propName, componentName, location) {
var propValue = props[propName];
var propType = getPropType(propValue);
if (propType !== 'object') {
var locationName = ReactPropTypeLocationNames[location];
return new Error(
("Invalid " + locationName + " `" + propName + "` 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);
if (error instanceof Error) {
return error;
}
}
}
return null;
}
return createChainableTypeChecker(validate);
}
function createUnionTypeChecker(arrayOfTypeCheckers) {
function validate(props, propName, componentName, location) {
for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
var checker = arrayOfTypeCheckers[i];
if (checker(props, propName, componentName, location) == null) {
return null;
}
}
var locationName = ReactPropTypeLocationNames[location];
return new Error(
("Invalid " + locationName + " `" + propName + "` supplied to ") +
("`" + componentName + "`.")
);
}
return createChainableTypeChecker(validate);
}
function createNodeChecker() {
function validate(props, propName, componentName, location) {
if (!isNode(props[propName])) {
var locationName = ReactPropTypeLocationNames[location];
return new Error(
("Invalid " + locationName + " `" + propName + "` supplied to ") +
("`" + componentName + "`, expected a ReactNode.")
);
}
return null;
}
return createChainableTypeChecker(validate);
}
function createShapeTypeChecker(shapeTypes) {
function validate(props, propName, componentName, location) {
var propValue = props[propName];
var propType = getPropType(propValue);
if (propType !== 'object') {
var locationName = ReactPropTypeLocationNames[location];
return new Error(
("Invalid " + locationName + " `" + propName + "` 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);
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;
}
propValue = ReactFragment.extractIfFragment(propValue);
for (var k in propValue) {
if (!isNode(propValue[k])) {
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;
}
module.exports = ReactPropTypes;
},{"./ReactElement":66,"./ReactFragment":72,"./ReactPropTypeLocationNames":87,"./emptyFunction":133}],90:[function(require,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 ReactPutListenerQueue
*/
'use strict';
var PooledClass = require("./PooledClass");
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var assign = require("./Object.assign");
function ReactPutListenerQueue() {
this.listenersToPut = [];
}
assign(ReactPutListenerQueue.prototype, {
enqueuePutListener: function(rootNodeID, propKey, propValue) {
this.listenersToPut.push({
rootNodeID: rootNodeID,
propKey: propKey,
propValue: propValue
});
},
putListeners: function() {
for (var i = 0; i < this.listenersToPut.length; i++) {
var listenerToPut = this.listenersToPut[i];
ReactBrowserEventEmitter.putListener(
listenerToPut.rootNodeID,
listenerToPut.propKey,
listenerToPut.propValue
);
}
},
reset: function() {
this.listenersToPut.length = 0;
},
destructor: function() {
this.reset();
}
});
PooledClass.addPoolingTo(ReactPutListenerQueue);
module.exports = ReactPutListenerQueue;
},{"./Object.assign":32,"./PooledClass":33,"./ReactBrowserEventEmitter":36}],91:[function(require,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 ReactReconcileTransaction
* @typechecks static-only
*/
'use strict';
var CallbackQueue = require("./CallbackQueue");
var PooledClass = require("./PooledClass");
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var ReactInputSelection = require("./ReactInputSelection");
var ReactPutListenerQueue = require("./ReactPutListenerQueue");
var Transaction = require("./Transaction");
var assign = require("./Object.assign");
/**
* 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 occured. `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();
}
};
var PUT_LISTENER_QUEUEING = {
initialize: function() {
this.putListenerQueue.reset();
},
close: function() {
this.putListenerQueue.putListeners();
}
};
/**
* 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 = [
PUT_LISTENER_QUEUEING,
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() {
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.putListenerQueue = ReactPutListenerQueue.getPooled();
}
var Mixin = {
/**
* @see Transaction
* @abstract
* @final
* @return {array<object>} List of operation wrap proceedures.
* TODO: convert to array<TransactionWrapper>
*/
getTransactionWrappers: function() {
return TRANSACTION_WRAPPERS;
},
/**
* @return {object} The queue to collect `onDOMReady` callbacks with.
*/
getReactMountReady: function() {
return this.reactMountReady;
},
getPutListenerQueue: function() {
return this.putListenerQueue;
},
/**
* `PooledClass` looks for this, and will invoke this before allowing this
* instance to be resused.
*/
destructor: function() {
CallbackQueue.release(this.reactMountReady);
this.reactMountReady = null;
ReactPutListenerQueue.release(this.putListenerQueue);
this.putListenerQueue = null;
}
};
assign(ReactReconcileTransaction.prototype, Transaction.Mixin, Mixin);
PooledClass.addPoolingTo(ReactReconcileTransaction);
module.exports = ReactReconcileTransaction;
},{"./CallbackQueue":10,"./Object.assign":32,"./PooledClass":33,"./ReactBrowserEventEmitter":36,"./ReactInputSelection":74,"./ReactPutListenerQueue":90,"./Transaction":120}],92:[function(require,module,exports){
(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 ReactReconciler
*/
'use strict';
var ReactRef = require("./ReactRef");
var ReactElementValidator = require("./ReactElementValidator");
/**
* 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 ("production" !== process.env.NODE_ENV) {
ReactElementValidator.checkAndWarnForMutatedProps(
internalInstance._currentElement
);
}
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 && nextElement._owner != null) {
// 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.
return;
}
if ("production" !== process.env.NODE_ENV) {
ReactElementValidator.checkAndWarnForMutatedProps(nextElement);
}
var refsChanged = ReactRef.shouldUpdateRefs(
prevElement,
nextElement
);
if (refsChanged) {
ReactRef.detachRefs(internalInstance, prevElement);
}
internalInstance.receiveComponent(nextElement, transaction, context);
if (refsChanged) {
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;
}).call(this,require('_process'))
},{"./ReactElementValidator":67,"./ReactRef":93,"_process":2}],93:[function(require,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 ReactRef
*/
'use strict';
var ReactOwner = require("./ReactOwner");
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) {
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.
return (
nextElement._owner !== prevElement._owner ||
nextElement.ref !== prevElement.ref
);
};
ReactRef.detachRefs = function(instance, element) {
var ref = element.ref;
if (ref != null) {
detachRef(ref, instance, element._owner);
}
};
module.exports = ReactRef;
},{"./ReactOwner":84}],94:[function(require,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;
},{}],95:[function(require,module,exports){
(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 ReactElement = require("./ReactElement");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var ReactMarkupChecksum = require("./ReactMarkupChecksum");
var ReactServerRenderingTransaction =
require("./ReactServerRenderingTransaction");
var emptyObject = require("./emptyObject");
var instantiateReactComponent = require("./instantiateReactComponent");
var invariant = require("./invariant");
/**
* @param {ReactElement} element
* @return {string} the HTML markup
*/
function renderToString(element) {
("production" !== process.env.NODE_ENV ? invariant(
ReactElement.isValidElement(element),
'renderToString(): You must pass a valid ReactElement.'
) : invariant(ReactElement.isValidElement(element)));
var transaction;
try {
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);
}
}
/**
* @param {ReactElement} element
* @return {string} the HTML markup, without the extra React ID and checksum
* (for generating static pages)
*/
function renderToStaticMarkup(element) {
("production" !== process.env.NODE_ENV ? invariant(
ReactElement.isValidElement(element),
'renderToStaticMarkup(): You must pass a valid ReactElement.'
) : invariant(ReactElement.isValidElement(element)));
var transaction;
try {
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);
}
}
module.exports = {
renderToString: renderToString,
renderToStaticMarkup: renderToStaticMarkup
};
}).call(this,require('_process'))
},{"./ReactElement":66,"./ReactInstanceHandles":75,"./ReactMarkupChecksum":79,"./ReactServerRenderingTransaction":96,"./emptyObject":134,"./instantiateReactComponent":153,"./invariant":154,"_process":2}],96:[function(require,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 ReactServerRenderingTransaction
* @typechecks
*/
'use strict';
var PooledClass = require("./PooledClass");
var CallbackQueue = require("./CallbackQueue");
var ReactPutListenerQueue = require("./ReactPutListenerQueue");
var Transaction = require("./Transaction");
var assign = require("./Object.assign");
var emptyFunction = require("./emptyFunction");
/**
* 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
};
var PUT_LISTENER_QUEUEING = {
initialize: function() {
this.putListenerQueue.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 = [
PUT_LISTENER_QUEUEING,
ON_DOM_READY_QUEUEING
];
/**
* @class ReactServerRenderingTransaction
* @param {boolean} renderToStaticMarkup
*/
function ReactServerRenderingTransaction(renderToStaticMarkup) {
this.reinitializeTransaction();
this.renderToStaticMarkup = renderToStaticMarkup;
this.reactMountReady = CallbackQueue.getPooled(null);
this.putListenerQueue = ReactPutListenerQueue.getPooled();
}
var Mixin = {
/**
* @see Transaction
* @abstract
* @final
* @return {array} Empty list of operation wrap proceedures.
*/
getTransactionWrappers: function() {
return TRANSACTION_WRAPPERS;
},
/**
* @return {object} The queue to collect `onDOMReady` callbacks with.
*/
getReactMountReady: function() {
return this.reactMountReady;
},
getPutListenerQueue: function() {
return this.putListenerQueue;
},
/**
* `PooledClass` looks for this, and will invoke this before allowing this
* instance to be resused.
*/
destructor: function() {
CallbackQueue.release(this.reactMountReady);
this.reactMountReady = null;
ReactPutListenerQueue.release(this.putListenerQueue);
this.putListenerQueue = null;
}
};
assign(
ReactServerRenderingTransaction.prototype,
Transaction.Mixin,
Mixin
);
PooledClass.addPoolingTo(ReactServerRenderingTransaction);
module.exports = ReactServerRenderingTransaction;
},{"./CallbackQueue":10,"./Object.assign":32,"./PooledClass":33,"./ReactPutListenerQueue":90,"./Transaction":120,"./emptyFunction":133}],97:[function(require,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 ReactStateSetters
*/
'use strict';
var ReactStateSetters = {
/**
* Returns a function that calls the provided function, and uses the result
* of that to set the component's state.
*
* @param {ReactCompositeComponent} component
* @param {function} funcReturningState Returned callback uses this to
* determine how to update state.
* @return {function} callback that when invoked uses funcReturningState to
* determined the object literal to setState.
*/
createStateSetter: function(component, funcReturningState) {
return function(a, b, c, d, e, f) {
var partialState = funcReturningState.call(component, a, b, c, d, e, f);
if (partialState) {
component.setState(partialState);
}
};
},
/**
* Returns a single-argument callback that can be used to update a single
* key in the component's state.
*
* Note: this is memoized function, which makes it inexpensive to call.
*
* @param {ReactCompositeComponent} component
* @param {string} key The key in the state that you should update.
* @return {function} callback of 1 argument which calls setState() with
* the provided keyName and callback argument.
*/
createStateKeySetter: function(component, key) {
// Memoize the setters.
var cache = component.__keySetters || (component.__keySetters = {});
return cache[key] || (cache[key] = createStateKeySetter(component, key));
}
};
function createStateKeySetter(component, key) {
// Partial state is allocated outside of the function closure so it can be
// reused with every call, avoiding memory allocation when this function
// is called.
var partialState = {};
return function stateKeySetter(value) {
partialState[key] = value;
component.setState(partialState);
};
}
ReactStateSetters.Mixin = {
/**
* Returns a function that calls the provided function, and uses the result
* of that to set the component's state.
*
* For example, these statements are equivalent:
*
* this.setState({x: 1});
* this.createStateSetter(function(xValue) {
* return {x: xValue};
* })(1);
*
* @param {function} funcReturningState Returned callback uses this to
* determine how to update state.
* @return {function} callback that when invoked uses funcReturningState to
* determined the object literal to setState.
*/
createStateSetter: function(funcReturningState) {
return ReactStateSetters.createStateSetter(this, funcReturningState);
},
/**
* Returns a single-argument callback that can be used to update a single
* key in the component's state.
*
* For example, these statements are equivalent:
*
* this.setState({x: 1});
* this.createStateKeySetter('x')(1);
*
* Note: this is memoized function, which makes it inexpensive to call.
*
* @param {string} key The key in the state that you should update.
* @return {function} callback of 1 argument which calls setState() with
* the provided keyName and callback argument.
*/
createStateKeySetter: function(key) {
return ReactStateSetters.createStateKeySetter(this, key);
}
};
module.exports = ReactStateSetters;
},{}],98:[function(require,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 ReactTestUtils
*/
'use strict';
var EventConstants = require("./EventConstants");
var EventPluginHub = require("./EventPluginHub");
var EventPropagators = require("./EventPropagators");
var React = require("./React");
var ReactElement = require("./ReactElement");
var ReactEmptyComponent = require("./ReactEmptyComponent");
var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
var ReactCompositeComponent = require("./ReactCompositeComponent");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var ReactInstanceMap = require("./ReactInstanceMap");
var ReactMount = require("./ReactMount");
var ReactUpdates = require("./ReactUpdates");
var SyntheticEvent = require("./SyntheticEvent");
var assign = require("./Object.assign");
var topLevelTypes = EventConstants.topLevelTypes;
function Event(suffix) {}
/**
* @class ReactTestUtils
*/
/**
* Todo: Support the entire DOM.scry query syntax. For now, these simple
* utilities will suffice for testing purposes.
* @lends ReactTestUtils
*/
var ReactTestUtils = {
renderIntoDocument: function(instance) {
var div = document.createElement('div');
// None of our tests actually require attaching the container to the
// DOM, and doing so creates a mess that we rely on test isolation to
// clean up, so we're going to stop honoring the name of this method
// (and probably rename it eventually) if no problems arise.
// document.documentElement.appendChild(div);
return React.render(instance, div);
},
isElement: function(element) {
return ReactElement.isValidElement(element);
},
isElementOfType: function(inst, convenienceConstructor) {
return (
ReactElement.isValidElement(inst) &&
inst.type === convenienceConstructor
);
},
isDOMComponent: function(inst) {
// TODO: Fix this heuristic. It's just here because composites can currently
// pretend to be DOM components.
return !!(inst && inst.tagName && inst.getDOMNode);
},
isDOMComponentElement: function(inst) {
return !!(inst &&
ReactElement.isValidElement(inst) &&
!!inst.tagName);
},
isCompositeComponent: function(inst) {
return typeof inst.render === 'function' &&
typeof inst.setState === 'function';
},
isCompositeComponentWithType: function(inst, type) {
return !!(ReactTestUtils.isCompositeComponent(inst) &&
(inst.constructor === type));
},
isCompositeComponentElement: function(inst) {
if (!ReactElement.isValidElement(inst)) {
return false;
}
// We check the prototype of the type that will get mounted, not the
// instance itself. This is a future proof way of duck typing.
var prototype = inst.type.prototype;
return (
typeof prototype.render === 'function' &&
typeof prototype.setState === 'function'
);
},
isCompositeComponentElementWithType: function(inst, type) {
return !!(ReactTestUtils.isCompositeComponentElement(inst) &&
(inst.constructor === type));
},
getRenderedChildOfCompositeComponent: function(inst) {
if (!ReactTestUtils.isCompositeComponent(inst)) {
return null;
}
var internalInstance = ReactInstanceMap.get(inst);
return internalInstance._renderedComponent.getPublicInstance();
},
findAllInRenderedTree: function(inst, test) {
if (!inst) {
return [];
}
var ret = test(inst) ? [inst] : [];
if (ReactTestUtils.isDOMComponent(inst)) {
var internalInstance = ReactInstanceMap.get(inst);
var renderedChildren = internalInstance
._renderedComponent
._renderedChildren;
var key;
for (key in renderedChildren) {
if (!renderedChildren.hasOwnProperty(key)) {
continue;
}
if (!renderedChildren[key].getPublicInstance) {
continue;
}
ret = ret.concat(
ReactTestUtils.findAllInRenderedTree(
renderedChildren[key].getPublicInstance(),
test
)
);
}
} else if (ReactTestUtils.isCompositeComponent(inst)) {
ret = ret.concat(
ReactTestUtils.findAllInRenderedTree(
ReactTestUtils.getRenderedChildOfCompositeComponent(inst),
test
)
);
}
return ret;
},
/**
* Finds all instance of components in the rendered tree that are DOM
* components with the class name matching `className`.
* @return an array of all the matches.
*/
scryRenderedDOMComponentsWithClass: function(root, className) {
return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
var instClassName = inst.props.className;
return ReactTestUtils.isDOMComponent(inst) && (
(instClassName && (' ' + instClassName + ' ').indexOf(' ' + className + ' ') !== -1)
);
});
},
/**
* Like scryRenderedDOMComponentsWithClass but expects there to be one result,
* and returns that one result, or throws exception if there is any other
* number of matches besides one.
* @return {!ReactDOMComponent} The one match.
*/
findRenderedDOMComponentWithClass: function(root, className) {
var all =
ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
if (all.length !== 1) {
throw new Error('Did not find exactly one match ' +
'(found: ' + all.length + ') for class:' + className
);
}
return all[0];
},
/**
* Finds all instance of components in the rendered tree that are DOM
* components with the tag name matching `tagName`.
* @return an array of all the matches.
*/
scryRenderedDOMComponentsWithTag: function(root, tagName) {
return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
return ReactTestUtils.isDOMComponent(inst) &&
inst.tagName === tagName.toUpperCase();
});
},
/**
* Like scryRenderedDOMComponentsWithTag but expects there to be one result,
* and returns that one result, or throws exception if there is any other
* number of matches besides one.
* @return {!ReactDOMComponent} The one match.
*/
findRenderedDOMComponentWithTag: function(root, tagName) {
var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
if (all.length !== 1) {
throw new Error('Did not find exactly one match for tag:' + tagName);
}
return all[0];
},
/**
* Finds all instances of components with type equal to `componentType`.
* @return an array of all the matches.
*/
scryRenderedComponentsWithType: function(root, componentType) {
return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
return ReactTestUtils.isCompositeComponentWithType(
inst,
componentType
);
});
},
/**
* Same as `scryRenderedComponentsWithType` but expects there to be one result
* and returns that one result, or throws exception if there is any other
* number of matches besides one.
* @return {!ReactComponent} The one match.
*/
findRenderedComponentWithType: function(root, componentType) {
var all = ReactTestUtils.scryRenderedComponentsWithType(
root,
componentType
);
if (all.length !== 1) {
throw new Error(
'Did not find exactly one match for componentType:' + componentType
);
}
return all[0];
},
/**
* Pass a mocked component module to this method to augment it with
* useful methods that allow it to be used as a dummy React component.
* Instead of rendering as usual, the component will become a simple
* <div> containing any provided children.
*
* @param {object} module the mock function object exported from a
* module that defines the component to be mocked
* @param {?string} mockTagName optional dummy root tag name to return
* from render method (overrides
* module.mockTagName if provided)
* @return {object} the ReactTestUtils object (for chaining)
*/
mockComponent: function(module, mockTagName) {
mockTagName = mockTagName || module.mockTagName || "div";
module.prototype.render.mockImplementation(function() {
return React.createElement(
mockTagName,
null,
this.props.children
);
});
return this;
},
/**
* Simulates a top level event being dispatched from a raw event that occured
* on an `Element` node.
* @param topLevelType {Object} A type from `EventConstants.topLevelTypes`
* @param {!Element} node The dom to simulate an event occurring on.
* @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
*/
simulateNativeEventOnNode: function(topLevelType, node, fakeNativeEvent) {
fakeNativeEvent.target = node;
ReactBrowserEventEmitter.ReactEventListener.dispatchEvent(
topLevelType,
fakeNativeEvent
);
},
/**
* Simulates a top level event being dispatched from a raw event that occured
* on the `ReactDOMComponent` `comp`.
* @param topLevelType {Object} A type from `EventConstants.topLevelTypes`.
* @param comp {!ReactDOMComponent}
* @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
*/
simulateNativeEventOnDOMComponent: function(
topLevelType,
comp,
fakeNativeEvent) {
ReactTestUtils.simulateNativeEventOnNode(
topLevelType,
comp.getDOMNode(),
fakeNativeEvent
);
},
nativeTouchData: function(x, y) {
return {
touches: [
{pageX: x, pageY: y}
]
};
},
createRenderer: function() {
return new ReactShallowRenderer();
},
Simulate: null,
SimulateNative: {}
};
/**
* @class ReactShallowRenderer
*/
var ReactShallowRenderer = function() {
this._instance = null;
};
ReactShallowRenderer.prototype.getRenderOutput = function() {
return (
(this._instance && this._instance._renderedComponent &&
this._instance._renderedComponent._renderedOutput)
|| null
);
};
var NoopInternalComponent = function(element) {
this._renderedOutput = element;
this._currentElement = element === null || element === false ?
ReactEmptyComponent.emptyElement :
element;
};
NoopInternalComponent.prototype = {
mountComponent: function() {
},
receiveComponent: function(element) {
this._renderedOutput = element;
this._currentElement = element === null || element === false ?
ReactEmptyComponent.emptyElement :
element;
},
unmountComponent: function() {
}
};
var ShallowComponentWrapper = function() { };
assign(
ShallowComponentWrapper.prototype,
ReactCompositeComponent.Mixin, {
_instantiateReactComponent: function(element) {
return new NoopInternalComponent(element);
},
_replaceNodeWithMarkupByID: function() {},
_renderValidatedComponent:
ReactCompositeComponent.Mixin.
_renderValidatedComponentWithoutOwnerOrContext
}
);
ReactShallowRenderer.prototype.render = function(element, context) {
var transaction = ReactUpdates.ReactReconcileTransaction.getPooled();
this._render(element, transaction, context);
ReactUpdates.ReactReconcileTransaction.release(transaction);
};
ReactShallowRenderer.prototype.unmount = function() {
if (this._instance) {
this._instance.unmountComponent();
}
};
ReactShallowRenderer.prototype._render = function(element, transaction, context) {
if (!this._instance) {
var rootID = ReactInstanceHandles.createReactRootID();
var instance = new ShallowComponentWrapper(element.type);
instance.construct(element);
instance.mountComponent(rootID, transaction, context);
this._instance = instance;
} else {
this._instance.receiveComponent(element, transaction, context);
}
};
/**
* Exports:
*
* - `ReactTestUtils.Simulate.click(Element/ReactDOMComponent)`
* - `ReactTestUtils.Simulate.mouseMove(Element/ReactDOMComponent)`
* - `ReactTestUtils.Simulate.change(Element/ReactDOMComponent)`
* - ... (All keys from event plugin `eventTypes` objects)
*/
function makeSimulator(eventType) {
return function(domComponentOrNode, eventData) {
var node;
if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
node = domComponentOrNode.getDOMNode();
} else if (domComponentOrNode.tagName) {
node = domComponentOrNode;
}
var fakeNativeEvent = new Event();
fakeNativeEvent.target = node;
// We don't use SyntheticEvent.getPooled in order to not have to worry about
// properly destroying any properties assigned from `eventData` upon release
var event = new SyntheticEvent(
ReactBrowserEventEmitter.eventNameDispatchConfigs[eventType],
ReactMount.getID(node),
fakeNativeEvent
);
assign(event, eventData);
EventPropagators.accumulateTwoPhaseDispatches(event);
ReactUpdates.batchedUpdates(function() {
EventPluginHub.enqueueEvents(event);
EventPluginHub.processEventQueue();
});
};
}
function buildSimulators() {
ReactTestUtils.Simulate = {};
var eventType;
for (eventType in ReactBrowserEventEmitter.eventNameDispatchConfigs) {
/**
* @param {!Element || ReactDOMComponent} domComponentOrNode
* @param {?object} eventData Fake event data to use in SyntheticEvent.
*/
ReactTestUtils.Simulate[eventType] = makeSimulator(eventType);
}
}
// Rebuild ReactTestUtils.Simulate whenever event plugins are injected
var oldInjectEventPluginOrder = EventPluginHub.injection.injectEventPluginOrder;
EventPluginHub.injection.injectEventPluginOrder = function() {
oldInjectEventPluginOrder.apply(this, arguments);
buildSimulators();
};
var oldInjectEventPlugins = EventPluginHub.injection.injectEventPluginsByName;
EventPluginHub.injection.injectEventPluginsByName = function() {
oldInjectEventPlugins.apply(this, arguments);
buildSimulators();
};
buildSimulators();
/**
* Exports:
*
* - `ReactTestUtils.SimulateNative.click(Element/ReactDOMComponent)`
* - `ReactTestUtils.SimulateNative.mouseMove(Element/ReactDOMComponent)`
* - `ReactTestUtils.SimulateNative.mouseIn/ReactDOMComponent)`
* - `ReactTestUtils.SimulateNative.mouseOut(Element/ReactDOMComponent)`
* - ... (All keys from `EventConstants.topLevelTypes`)
*
* Note: Top level event types are a subset of the entire set of handler types
* (which include a broader set of "synthetic" events). For example, onDragDone
* is a synthetic event. Except when testing an event plugin or React's event
* handling code specifically, you probably want to use ReactTestUtils.Simulate
* to dispatch synthetic events.
*/
function makeNativeSimulator(eventType) {
return function(domComponentOrNode, nativeEventData) {
var fakeNativeEvent = new Event(eventType);
assign(fakeNativeEvent, nativeEventData);
if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
ReactTestUtils.simulateNativeEventOnDOMComponent(
eventType,
domComponentOrNode,
fakeNativeEvent
);
} else if (!!domComponentOrNode.tagName) {
// Will allow on actual dom nodes.
ReactTestUtils.simulateNativeEventOnNode(
eventType,
domComponentOrNode,
fakeNativeEvent
);
}
};
}
var eventType;
for (eventType in topLevelTypes) {
// Event type is stored as 'topClick' - we transform that to 'click'
var convenienceName = eventType.indexOf('top') === 0 ?
eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType;
/**
* @param {!Element || ReactDOMComponent} domComponentOrNode
* @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
*/
ReactTestUtils.SimulateNative[convenienceName] =
makeNativeSimulator(eventType);
}
module.exports = ReactTestUtils;
},{"./EventConstants":19,"./EventPluginHub":21,"./EventPropagators":24,"./Object.assign":32,"./React":34,"./ReactBrowserEventEmitter":36,"./ReactCompositeComponent":46,"./ReactElement":66,"./ReactEmptyComponent":68,"./ReactInstanceHandles":75,"./ReactInstanceMap":76,"./ReactMount":80,"./ReactUpdates":103,"./SyntheticEvent":112}],99:[function(require,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.
*
* @typechecks static-only
* @providesModule ReactTransitionChildMapping
*/
'use strict';
var ReactChildren = require("./ReactChildren");
var ReactFragment = require("./ReactFragment");
var ReactTransitionChildMapping = {
/**
* Given `this.props.children`, return an object mapping key to child. Just
* simple syntactic sugar around ReactChildren.map().
*
* @param {*} children `this.props.children`
* @return {object} Mapping of key to child
*/
getChildMapping: function(children) {
if (!children) {
return children;
}
return ReactFragment.extract(ReactChildren.map(children, function(child) {
return child;
}));
},
/**
* When you're adding or removing children some may be added or removed in the
* same render pass. We want to show *both* since we want to simultaneously
* animate elements in and out. This function takes a previous set of keys
* and a new set of keys and merges them with its best guess of the correct
* ordering. In the future we may expose some of the utilities in
* ReactMultiChild to make this easy, but for now React itself does not
* directly have this concept of the union of prevChildren and nextChildren
* so we implement it here.
*
* @param {object} prev prev children as returned from
* `ReactTransitionChildMapping.getChildMapping()`.
* @param {object} next next children as returned from
* `ReactTransitionChildMapping.getChildMapping()`.
* @return {object} a key set that contains all keys in `prev` and all keys
* in `next` in a reasonable order.
*/
mergeChildMappings: function(prev, next) {
prev = prev || {};
next = next || {};
function getValueForKey(key) {
if (next.hasOwnProperty(key)) {
return next[key];
} else {
return prev[key];
}
}
// For each key of `next`, the list of keys to insert before that key in
// the combined list
var nextKeysPending = {};
var pendingKeys = [];
for (var prevKey in prev) {
if (next.hasOwnProperty(prevKey)) {
if (pendingKeys.length) {
nextKeysPending[prevKey] = pendingKeys;
pendingKeys = [];
}
} else {
pendingKeys.push(prevKey);
}
}
var i;
var childMapping = {};
for (var nextKey in next) {
if (nextKeysPending.hasOwnProperty(nextKey)) {
for (i = 0; i < nextKeysPending[nextKey].length; i++) {
var pendingNextKey = nextKeysPending[nextKey][i];
childMapping[nextKeysPending[nextKey][i]] = getValueForKey(
pendingNextKey
);
}
}
childMapping[nextKey] = getValueForKey(nextKey);
}
// Finally, add the keys which didn't appear before any key in `next`
for (i = 0; i < pendingKeys.length; i++) {
childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
}
return childMapping;
}
};
module.exports = ReactTransitionChildMapping;
},{"./ReactChildren":40,"./ReactFragment":72}],100:[function(require,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 ReactTransitionEvents
*/
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
/**
* EVENT_NAME_MAP is used to determine which event fired when a
* transition/animation ends, based on the style property used to
* define that event.
*/
var EVENT_NAME_MAP = {
transitionend: {
'transition': 'transitionend',
'WebkitTransition': 'webkitTransitionEnd',
'MozTransition': 'mozTransitionEnd',
'OTransition': 'oTransitionEnd',
'msTransition': 'MSTransitionEnd'
},
animationend: {
'animation': 'animationend',
'WebkitAnimation': 'webkitAnimationEnd',
'MozAnimation': 'mozAnimationEnd',
'OAnimation': 'oAnimationEnd',
'msAnimation': 'MSAnimationEnd'
}
};
var endEvents = [];
function detectEvents() {
var testEl = document.createElement('div');
var style = testEl.style;
// On some platforms, in particular some releases of Android 4.x,
// the un-prefixed "animation" and "transition" properties are defined on the
// style object but the events that fire will still be prefixed, so we need
// to check if the un-prefixed events are useable, and if not remove them
// from the map
if (!('AnimationEvent' in window)) {
delete EVENT_NAME_MAP.animationend.animation;
}
if (!('TransitionEvent' in window)) {
delete EVENT_NAME_MAP.transitionend.transition;
}
for (var baseEventName in EVENT_NAME_MAP) {
var baseEvents = EVENT_NAME_MAP[baseEventName];
for (var styleName in baseEvents) {
if (styleName in style) {
endEvents.push(baseEvents[styleName]);
break;
}
}
}
}
if (ExecutionEnvironment.canUseDOM) {
detectEvents();
}
// We use the raw {add|remove}EventListener() call because EventListener
// does not know how to remove event listeners and we really should
// clean up. Also, these events are not triggered in older browsers
// so we should be A-OK here.
function addEventListener(node, eventName, eventListener) {
node.addEventListener(eventName, eventListener, false);
}
function removeEventListener(node, eventName, eventListener) {
node.removeEventListener(eventName, eventListener, false);
}
var ReactTransitionEvents = {
addEndEventListener: function(node, eventListener) {
if (endEvents.length === 0) {
// If CSS transitions are not supported, trigger an "end animation"
// event immediately.
window.setTimeout(eventListener, 0);
return;
}
endEvents.forEach(function(endEvent) {
addEventListener(node, endEvent, eventListener);
});
},
removeEndEventListener: function(node, eventListener) {
if (endEvents.length === 0) {
return;
}
endEvents.forEach(function(endEvent) {
removeEventListener(node, endEvent, eventListener);
});
}
};
module.exports = ReactTransitionEvents;
},{"./ExecutionEnvironment":25}],101:[function(require,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 ReactTransitionGroup
*/
'use strict';
var React = require("./React");
var ReactTransitionChildMapping = require("./ReactTransitionChildMapping");
var assign = require("./Object.assign");
var cloneWithProps = require("./cloneWithProps");
var emptyFunction = require("./emptyFunction");
var ReactTransitionGroup = React.createClass({
displayName: 'ReactTransitionGroup',
propTypes: {
component: React.PropTypes.any,
childFactory: React.PropTypes.func
},
getDefaultProps: function() {
return {
component: 'span',
childFactory: emptyFunction.thatReturnsArgument
};
},
getInitialState: function() {
return {
children: ReactTransitionChildMapping.getChildMapping(this.props.children)
};
},
componentWillMount: function() {
this.currentlyTransitioningKeys = {};
this.keysToEnter = [];
this.keysToLeave = [];
},
componentDidMount: function() {
var initialChildMapping = this.state.children;
for (var key in initialChildMapping) {
if (initialChildMapping[key]) {
this.performAppear(key);
}
}
},
componentWillReceiveProps: function(nextProps) {
var nextChildMapping = ReactTransitionChildMapping.getChildMapping(
nextProps.children
);
var prevChildMapping = this.state.children;
this.setState({
children: ReactTransitionChildMapping.mergeChildMappings(
prevChildMapping,
nextChildMapping
)
});
var key;
for (key in nextChildMapping) {
var hasPrev = prevChildMapping && prevChildMapping.hasOwnProperty(key);
if (nextChildMapping[key] && !hasPrev &&
!this.currentlyTransitioningKeys[key]) {
this.keysToEnter.push(key);
}
}
for (key in prevChildMapping) {
var hasNext = nextChildMapping && nextChildMapping.hasOwnProperty(key);
if (prevChildMapping[key] && !hasNext &&
!this.currentlyTransitioningKeys[key]) {
this.keysToLeave.push(key);
}
}
// If we want to someday check for reordering, we could do it here.
},
componentDidUpdate: function() {
var keysToEnter = this.keysToEnter;
this.keysToEnter = [];
keysToEnter.forEach(this.performEnter);
var keysToLeave = this.keysToLeave;
this.keysToLeave = [];
keysToLeave.forEach(this.performLeave);
},
performAppear: function(key) {
this.currentlyTransitioningKeys[key] = true;
var component = this.refs[key];
if (component.componentWillAppear) {
component.componentWillAppear(
this._handleDoneAppearing.bind(this, key)
);
} else {
this._handleDoneAppearing(key);
}
},
_handleDoneAppearing: function(key) {
var component = this.refs[key];
if (component.componentDidAppear) {
component.componentDidAppear();
}
delete this.currentlyTransitioningKeys[key];
var currentChildMapping = ReactTransitionChildMapping.getChildMapping(
this.props.children
);
if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
// This was removed before it had fully appeared. Remove it.
this.performLeave(key);
}
},
performEnter: function(key) {
this.currentlyTransitioningKeys[key] = true;
var component = this.refs[key];
if (component.componentWillEnter) {
component.componentWillEnter(
this._handleDoneEntering.bind(this, key)
);
} else {
this._handleDoneEntering(key);
}
},
_handleDoneEntering: function(key) {
var component = this.refs[key];
if (component.componentDidEnter) {
component.componentDidEnter();
}
delete this.currentlyTransitioningKeys[key];
var currentChildMapping = ReactTransitionChildMapping.getChildMapping(
this.props.children
);
if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
// This was removed before it had fully entered. Remove it.
this.performLeave(key);
}
},
performLeave: function(key) {
this.currentlyTransitioningKeys[key] = true;
var component = this.refs[key];
if (component.componentWillLeave) {
component.componentWillLeave(this._handleDoneLeaving.bind(this, key));
} else {
// Note that this is somewhat dangerous b/c it calls setState()
// again, effectively mutating the component before all the work
// is done.
this._handleDoneLeaving(key);
}
},
_handleDoneLeaving: function(key) {
var component = this.refs[key];
if (component.componentDidLeave) {
component.componentDidLeave();
}
delete this.currentlyTransitioningKeys[key];
var currentChildMapping = ReactTransitionChildMapping.getChildMapping(
this.props.children
);
if (currentChildMapping && currentChildMapping.hasOwnProperty(key)) {
// This entered again before it fully left. Add it again.
this.performEnter(key);
} else {
var newChildren = assign({}, this.state.children);
delete newChildren[key];
this.setState({children: newChildren});
}
},
render: function() {
// TODO: we could get rid of the need for the wrapper node
// by cloning a single child
var childrenToRender = [];
for (var key in this.state.children) {
var child = this.state.children[key];
if (child) {
// You may need to apply reactive updates to a child as it is leaving.
// The normal React way to do it won't work since the child will have
// already been removed. In case you need this behavior you can provide
// a childFactory function to wrap every child, even the ones that are
// leaving.
childrenToRender.push(cloneWithProps(
this.props.childFactory(child),
{ref: key, key: key}
));
}
}
return React.createElement(
this.props.component,
this.props,
childrenToRender
);
}
});
module.exports = ReactTransitionGroup;
},{"./Object.assign":32,"./React":34,"./ReactTransitionChildMapping":99,"./cloneWithProps":126,"./emptyFunction":133}],102:[function(require,module,exports){
(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 ReactLifeCycle = require("./ReactLifeCycle");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactElement = require("./ReactElement");
var ReactInstanceMap = require("./ReactInstanceMap");
var ReactUpdates = require("./ReactUpdates");
var assign = require("./Object.assign");
var invariant = require("./invariant");
var warning = require("./warning");
function enqueueUpdate(internalInstance) {
if (internalInstance !== ReactLifeCycle.currentlyMountingInstance) {
// If we're in a componentWillMount handler, don't enqueue a rerender
// because ReactUpdates assumes we're in a browser context (which is
// wrong for server rendering) and we're about to do a render anyway.
// See bug in #1740.
ReactUpdates.enqueueUpdate(internalInstance);
}
}
function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
("production" !== process.env.NODE_ENV ? invariant(
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
) : invariant(ReactCurrentOwner.current == null));
var internalInstance = ReactInstanceMap.get(publicInstance);
if (!internalInstance) {
if ("production" !== process.env.NODE_ENV) {
// 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.
("production" !== process.env.NODE_ENV ? 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.',
callerName,
callerName
) : null);
}
return null;
}
if (internalInstance === ReactLifeCycle.currentlyUnmountingInstance) {
return null;
}
return internalInstance;
}
/**
* ReactUpdateQueue allows for state updates to be scheduled into a later
* reconciliation step.
*/
var ReactUpdateQueue = {
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
typeof callback === 'function',
'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +
'`setState`, `replaceState`, or `forceUpdate` with a callback that ' +
'isn\'t callable.'
) : invariant(typeof callback === 'function'));
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 ||
internalInstance === ReactLifeCycle.currentlyMountingInstance) {
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) {
("production" !== process.env.NODE_ENV ? invariant(
typeof callback === 'function',
'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +
'`setState`, `replaceState`, or `forceUpdate` with a callback that ' +
'isn\'t callable.'
) : invariant(typeof callback === 'function'));
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 `shouldUpdateComponent`, 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;
}
("production" !== process.env.NODE_ENV ? invariant(
internalInstance._isTopLevel,
'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(internalInstance._isTopLevel));
// Merge with the pending element if it exists, otherwise with existing
// element props.
var element = internalInstance._pendingElement ||
internalInstance._currentElement;
var props = assign({}, element.props, partialProps);
internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(
element,
props
);
enqueueUpdate(internalInstance);
},
/**
* 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;
}
("production" !== process.env.NODE_ENV ? invariant(
internalInstance._isTopLevel,
'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(internalInstance._isTopLevel));
// Merge with the pending element if it exists, otherwise with existing
// element props.
var element = internalInstance._pendingElement ||
internalInstance._currentElement;
internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(
element,
props
);
enqueueUpdate(internalInstance);
},
enqueueElementInternal: function(internalInstance, newElement) {
internalInstance._pendingElement = newElement;
enqueueUpdate(internalInstance);
}
};
module.exports = ReactUpdateQueue;
}).call(this,require('_process'))
},{"./Object.assign":32,"./ReactCurrentOwner":48,"./ReactElement":66,"./ReactInstanceMap":76,"./ReactLifeCycle":77,"./ReactUpdates":103,"./invariant":154,"./warning":175,"_process":2}],103:[function(require,module,exports){
(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 = require("./CallbackQueue");
var PooledClass = require("./PooledClass");
var ReactCurrentOwner = require("./ReactCurrentOwner");
var ReactPerf = require("./ReactPerf");
var ReactReconciler = require("./ReactReconciler");
var Transaction = require("./Transaction");
var assign = require("./Object.assign");
var invariant = require("./invariant");
var warning = require("./warning");
var dirtyComponents = [];
var asapCallbackQueue = CallbackQueue.getPooled();
var asapEnqueued = false;
var batchingStrategy = null;
function ensureInjected() {
("production" !== process.env.NODE_ENV ? invariant(
ReactUpdates.ReactReconcileTransaction && batchingStrategy,
'ReactUpdates: must inject a reconcile transaction class and batching ' +
'strategy'
) : invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy));
}
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();
}
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) {
ensureInjected();
batchingStrategy.batchedUpdates(callback, a, b, c, d);
}
/**
* 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;
("production" !== process.env.NODE_ENV ? invariant(
len === dirtyComponents.length,
'Expected flush transaction\'s stored dirty-components length (%s) to ' +
'match dirty-components array length (%s).',
len,
dirtyComponents.length
) : invariant(len === dirtyComponents.length));
// 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.)
("production" !== process.env.NODE_ENV ? warning(
ReactCurrentOwner.current == null,
'enqueueUpdate(): 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.'
) : null);
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) {
("production" !== process.env.NODE_ENV ? invariant(
batchingStrategy.isBatchingUpdates,
'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' +
'updates are not being batched.'
) : invariant(batchingStrategy.isBatchingUpdates));
asapCallbackQueue.enqueue(callback, context);
asapEnqueued = true;
}
var ReactUpdatesInjection = {
injectReconcileTransaction: function(ReconcileTransaction) {
("production" !== process.env.NODE_ENV ? invariant(
ReconcileTransaction,
'ReactUpdates: must provide a reconcile transaction class'
) : invariant(ReconcileTransaction));
ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
},
injectBatchingStrategy: function(_batchingStrategy) {
("production" !== process.env.NODE_ENV ? invariant(
_batchingStrategy,
'ReactUpdates: must provide a batching strategy'
) : invariant(_batchingStrategy));
("production" !== process.env.NODE_ENV ? invariant(
typeof _batchingStrategy.batchedUpdates === 'function',
'ReactUpdates: must provide a batchedUpdates() function'
) : invariant(typeof _batchingStrategy.batchedUpdates === 'function'));
("production" !== process.env.NODE_ENV ? invariant(
typeof _batchingStrategy.isBatchingUpdates === 'boolean',
'ReactUpdates: must provide an isBatchingUpdates boolean attribute'
) : invariant(typeof _batchingStrategy.isBatchingUpdates === 'boolean'));
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;
}).call(this,require('_process'))
},{"./CallbackQueue":10,"./Object.assign":32,"./PooledClass":33,"./ReactCurrentOwner":48,"./ReactPerf":85,"./ReactReconciler":92,"./Transaction":120,"./invariant":154,"./warning":175,"_process":2}],104:[function(require,module,exports){
(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 ReactWithAddons
*/
/**
* This module exists purely in the open source project, and is meant as a way
* to create a separate standalone build of React. This build has "addons", or
* functionality we've built and think might be useful but doesn't have a good
* place to live inside React core.
*/
'use strict';
var LinkedStateMixin = require("./LinkedStateMixin");
var React = require("./React");
var ReactComponentWithPureRenderMixin =
require("./ReactComponentWithPureRenderMixin");
var ReactCSSTransitionGroup = require("./ReactCSSTransitionGroup");
var ReactFragment = require("./ReactFragment");
var ReactTransitionGroup = require("./ReactTransitionGroup");
var ReactUpdates = require("./ReactUpdates");
var cx = require("./cx");
var cloneWithProps = require("./cloneWithProps");
var update = require("./update");
React.addons = {
CSSTransitionGroup: ReactCSSTransitionGroup,
LinkedStateMixin: LinkedStateMixin,
PureRenderMixin: ReactComponentWithPureRenderMixin,
TransitionGroup: ReactTransitionGroup,
batchedUpdates: ReactUpdates.batchedUpdates,
classSet: cx,
cloneWithProps: cloneWithProps,
createFragment: ReactFragment.create,
update: update
};
if ("production" !== process.env.NODE_ENV) {
React.addons.Perf = require("./ReactDefaultPerf");
React.addons.TestUtils = require("./ReactTestUtils");
}
module.exports = React;
}).call(this,require('_process'))
},{"./LinkedStateMixin":28,"./React":34,"./ReactCSSTransitionGroup":37,"./ReactComponentWithPureRenderMixin":45,"./ReactDefaultPerf":64,"./ReactFragment":72,"./ReactTestUtils":98,"./ReactTransitionGroup":101,"./ReactUpdates":103,"./cloneWithProps":126,"./cx":131,"./update":174,"_process":2}],105:[function(require,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 SVGDOMPropertyConfig
*/
/*jslint bitwise: true*/
'use strict';
var DOMProperty = require("./DOMProperty");
var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
var SVGDOMPropertyConfig = {
Properties: {
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,
y1: MUST_USE_ATTRIBUTE,
y2: MUST_USE_ATTRIBUTE,
y: MUST_USE_ATTRIBUTE
},
DOMAttributeNames: {
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'
}
};
module.exports = SVGDOMPropertyConfig;
},{"./DOMProperty":14}],106:[function(require,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 SelectEventPlugin
*/
'use strict';
var EventConstants = require("./EventConstants");
var EventPropagators = require("./EventPropagators");
var ReactInputSelection = require("./ReactInputSelection");
var SyntheticEvent = require("./SyntheticEvent");
var getActiveElement = require("./getActiveElement");
var isTextInputElement = require("./isTextInputElement");
var keyOf = require("./keyOf");
var shallowEqual = require("./shallowEqual");
var topLevelTypes = EventConstants.topLevelTypes;
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;
/**
* 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
* @param {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) {
// 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
);
syntheticEvent.type = 'select';
syntheticEvent.target = activeElement;
EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);
return syntheticEvent;
}
}
/**
* 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) {
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);
// Chrome and IE fire non-standard event when selection is changed (and
// sometimes when it hasn't).
// 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.
case topLevelTypes.topSelectionChange:
case topLevelTypes.topKeyDown:
case topLevelTypes.topKeyUp:
return constructSelectEvent(nativeEvent);
}
}
};
module.exports = SelectEventPlugin;
},{"./EventConstants":19,"./EventPropagators":24,"./ReactInputSelection":74,"./SyntheticEvent":112,"./getActiveElement":140,"./isTextInputElement":157,"./keyOf":161,"./shallowEqual":170}],107:[function(require,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;
},{}],108:[function(require,module,exports){
(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 = require("./EventConstants");
var EventPluginUtils = require("./EventPluginUtils");
var EventPropagators = require("./EventPropagators");
var SyntheticClipboardEvent = require("./SyntheticClipboardEvent");
var SyntheticEvent = require("./SyntheticEvent");
var SyntheticFocusEvent = require("./SyntheticFocusEvent");
var SyntheticKeyboardEvent = require("./SyntheticKeyboardEvent");
var SyntheticMouseEvent = require("./SyntheticMouseEvent");
var SyntheticDragEvent = require("./SyntheticDragEvent");
var SyntheticTouchEvent = require("./SyntheticTouchEvent");
var SyntheticUIEvent = require("./SyntheticUIEvent");
var SyntheticWheelEvent = require("./SyntheticWheelEvent");
var getEventCharCode = require("./getEventCharCode");
var invariant = require("./invariant");
var keyOf = require("./keyOf");
var warning = require("./warning");
var topLevelTypes = EventConstants.topLevelTypes;
var eventTypes = {
blur: {
phasedRegistrationNames: {
bubbled: keyOf({onBlur: true}),
captured: keyOf({onBlurCapture: 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})
}
},
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})
}
},
error: {
phasedRegistrationNames: {
bubbled: keyOf({onError: true}),
captured: keyOf({onErrorCapture: 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})
}
},
reset: {
phasedRegistrationNames: {
bubbled: keyOf({onReset: true}),
captured: keyOf({onResetCapture: true})
}
},
scroll: {
phasedRegistrationNames: {
bubbled: keyOf({onScroll: true}),
captured: keyOf({onScrollCapture: true})
}
},
submit: {
phasedRegistrationNames: {
bubbled: keyOf({onSubmit: true}),
captured: keyOf({onSubmitCapture: 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})
}
},
wheel: {
phasedRegistrationNames: {
bubbled: keyOf({onWheel: true}),
captured: keyOf({onWheelCapture: true})
}
}
};
var topLevelEventsToDispatchConfig = {
topBlur: eventTypes.blur,
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,
topError: eventTypes.error,
topFocus: eventTypes.focus,
topInput: eventTypes.input,
topKeyDown: eventTypes.keyDown,
topKeyPress: eventTypes.keyPress,
topKeyUp: eventTypes.keyUp,
topLoad: eventTypes.load,
topMouseDown: eventTypes.mouseDown,
topMouseMove: eventTypes.mouseMove,
topMouseOut: eventTypes.mouseOut,
topMouseOver: eventTypes.mouseOver,
topMouseUp: eventTypes.mouseUp,
topPaste: eventTypes.paste,
topReset: eventTypes.reset,
topScroll: eventTypes.scroll,
topSubmit: eventTypes.submit,
topTouchCancel: eventTypes.touchCancel,
topTouchEnd: eventTypes.touchEnd,
topTouchMove: eventTypes.touchMove,
topTouchStart: eventTypes.touchStart,
topWheel: eventTypes.wheel
};
for (var type in topLevelEventsToDispatchConfig) {
topLevelEventsToDispatchConfig[type].dependencies = [type];
}
var SimpleEventPlugin = {
eventTypes: eventTypes,
/**
* Same as the default implementation, except cancels the event when return
* value is false. This behavior will be disabled in a future release.
*
* @param {object} Event to be dispatched.
* @param {function} Application-level callback.
* @param {string} domID DOM ID to pass to the callback.
*/
executeDispatch: function(event, listener, domID) {
var returnValue = EventPluginUtils.executeDispatch(event, listener, domID);
("production" !== process.env.NODE_ENV ? warning(
typeof returnValue !== 'boolean',
'Returning `false` from an event handler is deprecated and will be ' +
'ignored in a future release. Instead, manually call ' +
'e.stopPropagation() or e.preventDefault(), as appropriate.'
) : null);
if (returnValue === false) {
event.stopPropagation();
event.preventDefault();
}
},
/**
* @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) {
var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];
if (!dispatchConfig) {
return null;
}
var EventConstructor;
switch (topLevelType) {
case topLevelTypes.topInput:
case topLevelTypes.topLoad:
case topLevelTypes.topError:
case topLevelTypes.topReset:
case topLevelTypes.topSubmit:
// 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;
}
("production" !== process.env.NODE_ENV ? invariant(
EventConstructor,
'SimpleEventPlugin: Unhandled event type, `%s`.',
topLevelType
) : invariant(EventConstructor));
var event = EventConstructor.getPooled(
dispatchConfig,
topLevelTargetID,
nativeEvent
);
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
}
};
module.exports = SimpleEventPlugin;
}).call(this,require('_process'))
},{"./EventConstants":19,"./EventPluginUtils":23,"./EventPropagators":24,"./SyntheticClipboardEvent":109,"./SyntheticDragEvent":111,"./SyntheticEvent":112,"./SyntheticFocusEvent":113,"./SyntheticKeyboardEvent":115,"./SyntheticMouseEvent":116,"./SyntheticTouchEvent":117,"./SyntheticUIEvent":118,"./SyntheticWheelEvent":119,"./getEventCharCode":141,"./invariant":154,"./keyOf":161,"./warning":175,"_process":2}],109:[function(require,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 SyntheticClipboardEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = require("./SyntheticEvent");
/**
* @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) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);
module.exports = SyntheticClipboardEvent;
},{"./SyntheticEvent":112}],110:[function(require,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 SyntheticCompositionEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = require("./SyntheticEvent");
/**
* @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) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticEvent.augmentClass(
SyntheticCompositionEvent,
CompositionEventInterface
);
module.exports = SyntheticCompositionEvent;
},{"./SyntheticEvent":112}],111:[function(require,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 SyntheticDragEvent
* @typechecks static-only
*/
'use strict';
var SyntheticMouseEvent = require("./SyntheticMouseEvent");
/**
* @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) {
SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);
module.exports = SyntheticDragEvent;
},{"./SyntheticMouseEvent":116}],112:[function(require,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 SyntheticEvent
* @typechecks static-only
*/
'use strict';
var PooledClass = require("./PooledClass");
var assign = require("./Object.assign");
var emptyFunction = require("./emptyFunction");
var getEventTarget = require("./getEventTarget");
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var EventInterface = {
type: null,
target: getEventTarget,
// 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) {
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 {
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 (event.preventDefault) {
event.preventDefault();
} else {
event.returnValue = false;
}
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
},
stopPropagation: function() {
var event = this.nativeEvent;
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.threeArgumentPooler);
};
PooledClass.addPoolingTo(SyntheticEvent, PooledClass.threeArgumentPooler);
module.exports = SyntheticEvent;
},{"./Object.assign":32,"./PooledClass":33,"./emptyFunction":133,"./getEventTarget":144}],113:[function(require,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 SyntheticFocusEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = require("./SyntheticUIEvent");
/**
* @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) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);
module.exports = SyntheticFocusEvent;
},{"./SyntheticUIEvent":118}],114:[function(require,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 SyntheticInputEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = require("./SyntheticEvent");
/**
* @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) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticEvent.augmentClass(
SyntheticInputEvent,
InputEventInterface
);
module.exports = SyntheticInputEvent;
},{"./SyntheticEvent":112}],115:[function(require,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 SyntheticKeyboardEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = require("./SyntheticUIEvent");
var getEventCharCode = require("./getEventCharCode");
var getEventKey = require("./getEventKey");
var getEventModifierState = require("./getEventModifierState");
/**
* @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) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);
module.exports = SyntheticKeyboardEvent;
},{"./SyntheticUIEvent":118,"./getEventCharCode":141,"./getEventKey":142,"./getEventModifierState":143}],116:[function(require,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 SyntheticMouseEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = require("./SyntheticUIEvent");
var ViewportMetrics = require("./ViewportMetrics");
var getEventModifierState = require("./getEventModifierState");
/**
* @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) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);
module.exports = SyntheticMouseEvent;
},{"./SyntheticUIEvent":118,"./ViewportMetrics":121,"./getEventModifierState":143}],117:[function(require,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 SyntheticTouchEvent
* @typechecks static-only
*/
'use strict';
var SyntheticUIEvent = require("./SyntheticUIEvent");
var getEventModifierState = require("./getEventModifierState");
/**
* @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) {
SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);
module.exports = SyntheticTouchEvent;
},{"./SyntheticUIEvent":118,"./getEventModifierState":143}],118:[function(require,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 SyntheticUIEvent
* @typechecks static-only
*/
'use strict';
var SyntheticEvent = require("./SyntheticEvent");
var getEventTarget = require("./getEventTarget");
/**
* @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) {
SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);
module.exports = SyntheticUIEvent;
},{"./SyntheticEvent":112,"./getEventTarget":144}],119:[function(require,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 SyntheticWheelEvent
* @typechecks static-only
*/
'use strict';
var SyntheticMouseEvent = require("./SyntheticMouseEvent");
/**
* @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) {
SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);
}
SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);
module.exports = SyntheticWheelEvent;
},{"./SyntheticMouseEvent":116}],120:[function(require,module,exports){
(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 = require("./invariant");
/**
* `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 = [];
} else {
this.wrapperInitData.length = 0;
}
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.
*
* @param {function} method Member of scope to call.
* @param {Object} scope Scope to invoke from.
* @param {Object?=} args... Arguments to pass to the method (optional).
* Helps prevent need to bind in many cases.
* @return Return value from `method`.
*/
perform: function(method, scope, a, b, c, d, e, f) {
("production" !== process.env.NODE_ENV ? invariant(
!this.isInTransaction(),
'Transaction.perform(...): Cannot initialize a transaction when there ' +
'is already an outstanding transaction.'
) : invariant(!this.isInTransaction()));
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) {
("production" !== process.env.NODE_ENV ? invariant(
this.isInTransaction(),
'Transaction.closeAll(): Cannot close transaction when none are open.'
) : invariant(this.isInTransaction()));
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 occured.
*/
OBSERVED_ERROR: {}
};
module.exports = Transaction;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],121:[function(require,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;
},{}],122:[function(require,module,exports){
(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 = require("./invariant");
/**
*
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
next != null,
'accumulateInto(...): Accumulated items must not be null or undefined.'
) : invariant(next != null));
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;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],123:[function(require,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
*/
/* jslint bitwise:true */
'use strict';
var MOD = 65521;
// This is a clean-room implementation of adler32 designed for detecting
// if markup is not what we expect it to be. It does not need to be
// cryptographically strong, only reasonably good at detecting if markup
// generated on the server is different than that on the client.
function adler32(data) {
var a = 1;
var b = 0;
for (var i = 0; i < data.length; i++) {
a = (a + data.charCodeAt(i)) % MOD;
b = (b + a) % MOD;
}
return a | (b << 16);
}
module.exports = adler32;
},{}],124:[function(require,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
*/
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;
},{}],125:[function(require,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 camelizeStyleName
* @typechecks
*/
"use strict";
var camelize = require("./camelize");
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;
},{"./camelize":124}],126:[function(require,module,exports){
(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 cloneWithProps
*/
'use strict';
var ReactElement = require("./ReactElement");
var ReactPropTransferer = require("./ReactPropTransferer");
var keyOf = require("./keyOf");
var warning = require("./warning");
var CHILDREN_PROP = keyOf({children: null});
/**
* Sometimes you want to change the props of a child passed to you. Usually
* this is to add a CSS class.
*
* @param {ReactElement} child child element you'd like to clone
* @param {object} props props you'd like to modify. className and style will be
* merged automatically.
* @return {ReactElement} a clone of child with props merged in.
*/
function cloneWithProps(child, props) {
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
!child.ref,
'You are calling cloneWithProps() on a child with a ref. This is ' +
'dangerous because you\'re creating a new child which will not be ' +
'added as a ref to its parent.'
) : null);
}
var newProps = ReactPropTransferer.mergeProps(props, child.props);
// Use `child.props.children` if it is provided.
if (!newProps.hasOwnProperty(CHILDREN_PROP) &&
child.props.hasOwnProperty(CHILDREN_PROP)) {
newProps.children = child.props.children;
}
// The current API doesn't retain _owner and _context, which is why this
// doesn't use ReactElement.cloneAndReplaceProps.
return ReactElement.createElement(child.type, newProps);
}
module.exports = cloneWithProps;
}).call(this,require('_process'))
},{"./ReactElement":66,"./ReactPropTransferer":86,"./keyOf":161,"./warning":175,"_process":2}],127:[function(require,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 containsNode
* @typechecks
*/
var isTextNode = require("./isTextNode");
/*jslint bitwise:true */
/**
* 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(outerNode, innerNode) {
if (!outerNode || !innerNode) {
return false;
} else if (outerNode === innerNode) {
return true;
} else if (isTextNode(outerNode)) {
return false;
} else if (isTextNode(innerNode)) {
return containsNode(outerNode, innerNode.parentNode);
} else if (outerNode.contains) {
return outerNode.contains(innerNode);
} else if (outerNode.compareDocumentPosition) {
return !!(outerNode.compareDocumentPosition(innerNode) & 16);
} else {
return false;
}
}
module.exports = containsNode;
},{"./isTextNode":158}],128:[function(require,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 createArrayFromMixed
* @typechecks
*/
var toArray = require("./toArray");
/**
* 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
(// HTMLCollection/NodeList
(Array.isArray(obj) ||
// arguments
('callee' in obj) || '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;
},{"./toArray":172}],129:[function(require,module,exports){
(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 createFullPageComponent
* @typechecks
*/
'use strict';
// Defeat circular references by requiring this directly.
var ReactClass = require("./ReactClass");
var ReactElement = require("./ReactElement");
var invariant = require("./invariant");
/**
* Create a component that will throw an exception when unmounted.
*
* 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.
*
* @param {string} tag The tag to wrap
* @return {function} convenience constructor of new component
*/
function createFullPageComponent(tag) {
var elementFactory = ReactElement.createFactory(tag);
var FullPageComponent = ReactClass.createClass({
tagName: tag.toUpperCase(),
displayName: 'ReactFullPageComponent' + tag,
componentWillUnmount: function() {
("production" !== process.env.NODE_ENV ? 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.constructor.displayName
) : invariant(false));
},
render: function() {
return elementFactory(this.props);
}
});
return FullPageComponent;
}
module.exports = createFullPageComponent;
}).call(this,require('_process'))
},{"./ReactClass":41,"./ReactElement":66,"./invariant":154,"_process":2}],130:[function(require,module,exports){
(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
*/
/*jslint evil: true, sub: true */
var ExecutionEnvironment = require("./ExecutionEnvironment");
var createArrayFromMixed = require("./createArrayFromMixed");
var getMarkupWrap = require("./getMarkupWrap");
var invariant = require("./invariant");
/**
* 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;
("production" !== process.env.NODE_ENV ? invariant(!!dummyNode, 'createNodesFromMarkup dummy not initialized') : invariant(!!dummyNode));
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) {
("production" !== process.env.NODE_ENV ? invariant(
handleScript,
'createNodesFromMarkup(...): Unexpected <script> element rendered.'
) : invariant(handleScript));
createArrayFromMixed(scripts).forEach(handleScript);
}
var nodes = createArrayFromMixed(node.childNodes);
while (node.lastChild) {
node.removeChild(node.lastChild);
}
return nodes;
}
module.exports = createNodesFromMarkup;
}).call(this,require('_process'))
},{"./ExecutionEnvironment":25,"./createArrayFromMixed":128,"./getMarkupWrap":146,"./invariant":154,"_process":2}],131:[function(require,module,exports){
(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 cx
*/
/**
* This function is used to mark string literals representing CSS class names
* so that they can be transformed statically. This allows for modularization
* and minification of CSS class names.
*
* In static_upstream, this function is actually implemented, but it should
* eventually be replaced with something more descriptive, and the transform
* that is used in the main stack should be ported for use elsewhere.
*
* @param string|object className to modularize, or an object of key/values.
* In the object case, the values are conditions that
* determine if the className keys should be included.
* @param [string ...] Variable list of classNames in the string case.
* @return string Renderable space-separated CSS className.
*/
'use strict';
var warning = require("./warning");
var warned = false;
function cx(classNames) {
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
warned,
'React.addons.classSet will be deprecated in a future version. See ' +
'http://fb.me/react-addons-classset'
) : null);
warned = true;
}
if (typeof classNames == 'object') {
return Object.keys(classNames).filter(function(className) {
return classNames[className];
}).join(' ');
} else {
return Array.prototype.join.call(arguments, ' ');
}
}
module.exports = cx;
}).call(this,require('_process'))
},{"./warning":175,"_process":2}],132:[function(require,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 dangerousStyleValue
* @typechecks static-only
*/
'use strict';
var CSSProperty = require("./CSSProperty");
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;
},{"./CSSProperty":8}],133:[function(require,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
*/
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;
},{}],134:[function(require,module,exports){
(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 ("production" !== process.env.NODE_ENV) {
Object.freeze(emptyObject);
}
module.exports = emptyObject;
}).call(this,require('_process'))
},{"_process":2}],135:[function(require,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;
},{}],136:[function(require,module,exports){
(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 = require("./ReactCurrentOwner");
var ReactInstanceMap = require("./ReactInstanceMap");
var ReactMount = require("./ReactMount");
var invariant = require("./invariant");
var isNode = require("./isNode");
var warning = require("./warning");
/**
* Returns the DOM node rendered by this element.
*
* @param {ReactComponent|DOMElement} componentOrElement
* @return {DOMElement} The root node of this element.
*/
function findDOMNode(componentOrElement) {
if ("production" !== process.env.NODE_ENV) {
var owner = ReactCurrentOwner.current;
if (owner !== null) {
("production" !== process.env.NODE_ENV ? 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'
) : null);
owner._warnedAboutRefsInRender = true;
}
}
if (componentOrElement == null) {
return null;
}
if (isNode(componentOrElement)) {
return componentOrElement;
}
if (ReactInstanceMap.has(componentOrElement)) {
return ReactMount.getNodeFromInstance(componentOrElement);
}
("production" !== process.env.NODE_ENV ? invariant(
componentOrElement.render == null ||
typeof componentOrElement.render !== 'function',
'Component (with keys: %s) contains `render` method ' +
'but is not mounted in the DOM',
Object.keys(componentOrElement)
) : invariant(componentOrElement.render == null ||
typeof componentOrElement.render !== 'function'));
("production" !== process.env.NODE_ENV ? invariant(
false,
'Element appears to be neither ReactComponent nor DOMNode (keys: %s)',
Object.keys(componentOrElement)
) : invariant(false));
}
module.exports = findDOMNode;
}).call(this,require('_process'))
},{"./ReactCurrentOwner":48,"./ReactInstanceMap":76,"./ReactMount":80,"./invariant":154,"./isNode":156,"./warning":175,"_process":2}],137:[function(require,module,exports){
(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 = require("./traverseAllChildren");
var warning = require("./warning");
/**
* @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.hasOwnProperty(name);
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? 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
) : null);
}
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;
}).call(this,require('_process'))
},{"./traverseAllChildren":173,"./warning":175,"_process":2}],138:[function(require,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 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;
},{}],139:[function(require,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} 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;
},{}],140:[function(require,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
*/
/**
* 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 body is not yet defined.
*/
function getActiveElement() /*?DOMElement*/ {
try {
return document.activeElement || document.body;
} catch (e) {
return document.body;
}
}
module.exports = getActiveElement;
},{}],141:[function(require,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 {string} 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;
},{}],142:[function(require,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 getEventKey
* @typechecks static-only
*/
'use strict';
var getEventCharCode = require("./getEventCharCode");
/**
* 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;
},{"./getEventCharCode":141}],143:[function(require,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) {
/*jshint validthis:true */
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;
},{}],144:[function(require,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;
},{}],145:[function(require,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;
},{}],146:[function(require,module,exports){
(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
*/
var ExecutionEnvironment = require("./ExecutionEnvironment");
var invariant = require("./invariant");
/**
* 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 = {
// Force wrapping for SVG elements because if they get created inside a <div>,
// they will be initialized in the wrong namespace (and will not display).
'circle': true,
'defs': true,
'ellipse': true,
'g': true,
'line': true,
'linearGradient': true,
'path': true,
'polygon': true,
'polyline': true,
'radialGradient': true,
'rect': true,
'stop': true,
'text': true
};
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>', '</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,
'circle': svgWrap,
'defs': svgWrap,
'ellipse': svgWrap,
'g': svgWrap,
'line': svgWrap,
'linearGradient': svgWrap,
'path': svgWrap,
'polygon': svgWrap,
'polyline': svgWrap,
'radialGradient': svgWrap,
'rect': svgWrap,
'stop': svgWrap,
'text': svgWrap
};
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(!!dummyNode, 'Markup wrapping node not initialized') : invariant(!!dummyNode));
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;
}).call(this,require('_process'))
},{"./ExecutionEnvironment":25,"./invariant":154,"_process":2}],147:[function(require,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;
},{}],148:[function(require,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 getReactRootElementInContainer
*/
'use strict';
var DOC_NODE_TYPE = 9;
/**
* @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;
}
}
module.exports = getReactRootElementInContainer;
},{}],149:[function(require,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 getTextContentAccessor
*/
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
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;
},{"./ExecutionEnvironment":25}],150:[function(require,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;
},{}],151:[function(require,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
*/
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;
},{}],152:[function(require,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 hyphenateStyleName
* @typechecks
*/
"use strict";
var hyphenate = require("./hyphenate");
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;
},{"./hyphenate":151}],153:[function(require,module,exports){
(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 = require("./ReactCompositeComponent");
var ReactEmptyComponent = require("./ReactEmptyComponent");
var ReactNativeComponent = require("./ReactNativeComponent");
var assign = require("./Object.assign");
var invariant = require("./invariant");
var warning = require("./warning");
// To avoid a cyclic dependency, we create the final class in this module
var ReactCompositeComponentWrapper = function() { };
assign(
ReactCompositeComponentWrapper.prototype,
ReactCompositeComponent.Mixin,
{
_instantiateReactComponent: instantiateReactComponent
}
);
/**
* 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.mountComponent === 'function' &&
typeof type.prototype.receiveComponent === 'function'
);
}
/**
* Given a ReactNode, create an instance that will actually be mounted.
*
* @param {ReactNode} node
* @param {*} parentCompositeType The composite type that resolved this.
* @return {object} A new instance of the element's constructor.
* @protected
*/
function instantiateReactComponent(node, parentCompositeType) {
var instance;
if (node === null || node === false) {
node = ReactEmptyComponent.emptyElement;
}
if (typeof node === 'object') {
var element = node;
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
element && (typeof element.type === 'function' ||
typeof element.type === 'string'),
'Only functions or strings can be mounted as React components.'
) : null);
}
// Special case string values
if (parentCompositeType === element.type &&
typeof element.type === 'string') {
// Avoid recursion if the wrapper renders itself.
instance = ReactNativeComponent.createInternalComponent(element);
// All native components are currently wrapped in a composite so we're
// safe to assume that this is what we should instantiate.
} else if (isInternalComponentType(element.type)) {
// This is temporarily available for custom components that are not string
// represenations. 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 {
("production" !== process.env.NODE_ENV ? invariant(
false,
'Encountered invalid React node of type %s',
typeof node
) : invariant(false));
}
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? warning(
typeof instance.construct === 'function' &&
typeof instance.mountComponent === 'function' &&
typeof instance.receiveComponent === 'function' &&
typeof instance.unmountComponent === 'function',
'Only React Components can be mounted.'
) : null);
}
// 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 ("production" !== process.env.NODE_ENV) {
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 ("production" !== process.env.NODE_ENV) {
if (Object.preventExtensions) {
Object.preventExtensions(instance);
}
}
return instance;
}
module.exports = instantiateReactComponent;
}).call(this,require('_process'))
},{"./Object.assign":32,"./ReactCompositeComponent":46,"./ReactEmptyComponent":68,"./ReactNativeComponent":83,"./invariant":154,"./warning":175,"_process":2}],154:[function(require,module,exports){
(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.
*/
var invariant = function(condition, format, a, b, c, d, e, f) {
if ("production" !== process.env.NODE_ENV) {
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(
'Invariant Violation: ' +
format.replace(/%s/g, function() { return args[argIndex++]; })
);
}
error.framesToPop = 1; // we don't care about invariant's own frame
throw error;
}
};
module.exports = invariant;
}).call(this,require('_process'))
},{"_process":2}],155:[function(require,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 isEventSupported
*/
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
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;
},{"./ExecutionEnvironment":25}],156:[function(require,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.
*/
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;
},{}],157:[function(require,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) {
return elem && (
(elem.nodeName === 'INPUT' && supportedInputTypes[elem.type] || elem.nodeName === 'TEXTAREA')
);
}
module.exports = isTextInputElement;
},{}],158:[function(require,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 isTextNode
* @typechecks
*/
var isNode = require("./isNode");
/**
* @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;
},{"./isNode":156}],159:[function(require,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 joinClasses
* @typechecks static-only
*/
'use strict';
/**
* Combines multiple className strings into one.
* http://jsperf.com/joinclasses-args-vs-array
*
* @param {...?string} classes
* @return {string}
*/
function joinClasses(className/*, ... */) {
if (!className) {
className = '';
}
var nextClass;
var argLength = arguments.length;
if (argLength > 1) {
for (var ii = 1; ii < argLength; ii++) {
nextClass = arguments[ii];
if (nextClass) {
className = (className ? className + ' ' : '') + nextClass;
}
}
}
return className;
}
module.exports = joinClasses;
},{}],160:[function(require,module,exports){
(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 = require("./invariant");
/**
* 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;
("production" !== process.env.NODE_ENV ? invariant(
obj instanceof Object && !Array.isArray(obj),
'keyMirror(...): Argument must be an object.'
) : invariant(obj instanceof Object && !Array.isArray(obj)));
for (key in obj) {
if (!obj.hasOwnProperty(key)) {
continue;
}
ret[key] = key;
}
return ret;
};
module.exports = keyMirror;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],161:[function(require,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 loosing 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.
*/
var keyOf = function(oneKeyObj) {
var key;
for (key in oneKeyObj) {
if (!oneKeyObj.hasOwnProperty(key)) {
continue;
}
return key;
}
return null;
};
module.exports = keyOf;
},{}],162:[function(require,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;
},{}],163:[function(require,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;
},{}],164:[function(require,module,exports){
(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 = require("./ReactElement");
var invariant = require("./invariant");
/**
* 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) {
("production" !== process.env.NODE_ENV ? invariant(
ReactElement.isValidElement(children),
'onlyChild must be passed a children with exactly one child.'
) : invariant(ReactElement.isValidElement(children)));
return children;
}
module.exports = onlyChild;
}).call(this,require('_process'))
},{"./ReactElement":66,"./invariant":154,"_process":2}],165:[function(require,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 performance
* @typechecks
*/
"use strict";
var ExecutionEnvironment = require("./ExecutionEnvironment");
var performance;
if (ExecutionEnvironment.canUseDOM) {
performance =
window.performance ||
window.msPerformance ||
window.webkitPerformance;
}
module.exports = performance || {};
},{"./ExecutionEnvironment":25}],166:[function(require,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 performanceNow
* @typechecks
*/
var performance = require("./performance");
/**
* 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 || !performance.now) {
performance = Date;
}
var performanceNow = performance.now.bind(performance);
module.exports = performanceNow;
},{"./performance":165}],167:[function(require,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 quoteAttributeValueForBrowser
*/
'use strict';
var escapeTextContentForBrowser = require("./escapeTextContentForBrowser");
/**
* 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;
},{"./escapeTextContentForBrowser":135}],168:[function(require,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 setInnerHTML
*/
/* globals MSApp */
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
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.
node.innerHTML = '\uFEFF' + 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;
},{"./ExecutionEnvironment":25}],169:[function(require,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 setTextContent
*/
'use strict';
var ExecutionEnvironment = require("./ExecutionEnvironment");
var escapeTextContentForBrowser = require("./escapeTextContentForBrowser");
var setInnerHTML = require("./setInnerHTML");
/**
* 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;
},{"./ExecutionEnvironment":25,"./escapeTextContentForBrowser":135,"./setInnerHTML":168}],170:[function(require,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
*/
'use strict';
/**
* Performs equality by iterating through keys on an object and returning
* false when any key has values which are not strictly equal between
* objA and objB. Returns true when the values of all keys are strictly equal.
*
* @return {boolean}
*/
function shallowEqual(objA, objB) {
if (objA === objB) {
return true;
}
var key;
// Test for A's keys different from B.
for (key in objA) {
if (objA.hasOwnProperty(key) &&
(!objB.hasOwnProperty(key) || objA[key] !== objB[key])) {
return false;
}
}
// Test for B's keys missing from A.
for (key in objB) {
if (objB.hasOwnProperty(key) && !objA.hasOwnProperty(key)) {
return false;
}
}
return true;
}
module.exports = shallowEqual;
},{}],171:[function(require,module,exports){
(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 shouldUpdateReactComponent
* @typechecks static-only
*/
'use strict';
var warning = require("./warning");
/**
* 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) {
if (prevElement != null && nextElement != null) {
var prevType = typeof prevElement;
var nextType = typeof nextElement;
if (prevType === 'string' || prevType === 'number') {
return (nextType === 'string' || nextType === 'number');
} else {
if (nextType === 'object' &&
prevElement.type === nextElement.type &&
prevElement.key === nextElement.key) {
var ownersMatch = prevElement._owner === nextElement._owner;
var prevName = null;
var nextName = null;
var nextDisplayName = null;
if ("production" !== process.env.NODE_ENV) {
if (!ownersMatch) {
if (prevElement._owner != null &&
prevElement._owner.getPublicInstance() != null &&
prevElement._owner.getPublicInstance().constructor != null) {
prevName =
prevElement._owner.getPublicInstance().constructor.displayName;
}
if (nextElement._owner != null &&
nextElement._owner.getPublicInstance() != null &&
nextElement._owner.getPublicInstance().constructor != null) {
nextName =
nextElement._owner.getPublicInstance().constructor.displayName;
}
if (nextElement.type != null &&
nextElement.type.displayName != null) {
nextDisplayName = nextElement.type.displayName;
}
if (nextElement.type != null && typeof nextElement.type === 'string') {
nextDisplayName = nextElement.type;
}
if (typeof nextElement.type !== 'string' ||
nextElement.type === 'input' ||
nextElement.type === 'textarea') {
if ((prevElement._owner != null &&
prevElement._owner._isOwnerNecessary === false) ||
(nextElement._owner != null &&
nextElement._owner._isOwnerNecessary === false)) {
if (prevElement._owner != null) {
prevElement._owner._isOwnerNecessary = true;
}
if (nextElement._owner != null) {
nextElement._owner._isOwnerNecessary = true;
}
("production" !== process.env.NODE_ENV ? warning(
false,
'<%s /> is being rendered by both %s and %s using the same ' +
'key (%s) in the same place. Currently, this means that ' +
'they don\'t preserve state. This behavior should be very ' +
'rare so we\'re considering deprecating it. Please contact ' +
'the React team and explain your use case so that we can ' +
'take that into consideration.',
nextDisplayName || 'Unknown Component',
prevName || '[Unknown]',
nextName || '[Unknown]',
prevElement.key
) : null);
}
}
}
}
return ownersMatch;
}
}
}
return false;
}
module.exports = shouldUpdateReactComponent;
}).call(this,require('_process'))
},{"./warning":175,"_process":2}],172:[function(require,module,exports){
(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 toArray
* @typechecks
*/
var invariant = require("./invariant");
/**
* 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).
("production" !== process.env.NODE_ENV ? invariant(
!Array.isArray(obj) &&
(typeof obj === 'object' || typeof obj === 'function'),
'toArray: Array-like object expected'
) : invariant(!Array.isArray(obj) &&
(typeof obj === 'object' || typeof obj === 'function')));
("production" !== process.env.NODE_ENV ? invariant(
typeof length === 'number',
'toArray: Object needs a length property'
) : invariant(typeof length === 'number'));
("production" !== process.env.NODE_ENV ? invariant(
length === 0 ||
(length - 1) in obj,
'toArray: Object should have keys for indices'
) : invariant(length === 0 ||
(length - 1) in obj));
// 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;
}).call(this,require('_process'))
},{"./invariant":154,"_process":2}],173:[function(require,module,exports){
(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 ReactElement = require("./ReactElement");
var ReactFragment = require("./ReactFragment");
var ReactInstanceHandles = require("./ReactInstanceHandles");
var getIteratorFn = require("./getIteratorFn");
var invariant = require("./invariant");
var warning = require("./warning");
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 {*} key 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 {!number} indexSoFar Number of children encountered until this point.
* @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,
indexSoFar,
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,
indexSoFar
);
return 1;
}
var child, nextName, nextIndex;
var subtreeCount = 0; // Count of children found in the current subtree.
if (Array.isArray(children)) {
for (var i = 0; i < children.length; i++) {
child = children[i];
nextName = (
(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +
getComponentKey(child, i)
);
nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
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 = (
(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +
getComponentKey(child, ii++)
);
nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext
);
}
} else {
if ("production" !== process.env.NODE_ENV) {
("production" !== process.env.NODE_ENV ? 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.'
) : null);
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 = (
(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +
wrapUserProvidedKey(entry[0]) + SUBSEPARATOR +
getComponentKey(child, 0)
);
nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext
);
}
}
}
} else if (type === 'object') {
("production" !== process.env.NODE_ENV ? invariant(
children.nodeType !== 1,
'traverseAllChildren(...): Encountered an invalid child; DOM ' +
'elements are not valid children of React components.'
) : invariant(children.nodeType !== 1));
var fragment = ReactFragment.extract(children);
for (var key in fragment) {
if (fragment.hasOwnProperty(key)) {
child = fragment[key];
nextName = (
(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +
wrapUserProvidedKey(key) + SUBSEPARATOR +
getComponentKey(child, 0)
);
nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext
);
}
}
}
}
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, '', 0, callback, traverseContext);
}
module.exports = traverseAllChildren;
}).call(this,require('_process'))
},{"./ReactElement":66,"./ReactFragment":72,"./ReactInstanceHandles":75,"./getIteratorFn":145,"./invariant":154,"./warning":175,"_process":2}],174:[function(require,module,exports){
(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 update
*/
'use strict';
var assign = require("./Object.assign");
var keyOf = require("./keyOf");
var invariant = require("./invariant");
function shallowCopy(x) {
if (Array.isArray(x)) {
return x.concat();
} else if (x && typeof x === 'object') {
return assign(new x.constructor(), x);
} else {
return x;
}
}
var COMMAND_PUSH = keyOf({$push: null});
var COMMAND_UNSHIFT = keyOf({$unshift: null});
var COMMAND_SPLICE = keyOf({$splice: null});
var COMMAND_SET = keyOf({$set: null});
var COMMAND_MERGE = keyOf({$merge: null});
var COMMAND_APPLY = keyOf({$apply: null});
var ALL_COMMANDS_LIST = [
COMMAND_PUSH,
COMMAND_UNSHIFT,
COMMAND_SPLICE,
COMMAND_SET,
COMMAND_MERGE,
COMMAND_APPLY
];
var ALL_COMMANDS_SET = {};
ALL_COMMANDS_LIST.forEach(function(command) {
ALL_COMMANDS_SET[command] = true;
});
function invariantArrayCase(value, spec, command) {
("production" !== process.env.NODE_ENV ? invariant(
Array.isArray(value),
'update(): expected target of %s to be an array; got %s.',
command,
value
) : invariant(Array.isArray(value)));
var specValue = spec[command];
("production" !== process.env.NODE_ENV ? invariant(
Array.isArray(specValue),
'update(): expected spec of %s to be an array; got %s. ' +
'Did you forget to wrap your parameter in an array?',
command,
specValue
) : invariant(Array.isArray(specValue)));
}
function update(value, spec) {
("production" !== process.env.NODE_ENV ? invariant(
typeof spec === 'object',
'update(): You provided a key path to update() that did not contain one ' +
'of %s. Did you forget to include {%s: ...}?',
ALL_COMMANDS_LIST.join(', '),
COMMAND_SET
) : invariant(typeof spec === 'object'));
if (spec.hasOwnProperty(COMMAND_SET)) {
("production" !== process.env.NODE_ENV ? invariant(
Object.keys(spec).length === 1,
'Cannot have more than one key in an object with %s',
COMMAND_SET
) : invariant(Object.keys(spec).length === 1));
return spec[COMMAND_SET];
}
var nextValue = shallowCopy(value);
if (spec.hasOwnProperty(COMMAND_MERGE)) {
var mergeObj = spec[COMMAND_MERGE];
("production" !== process.env.NODE_ENV ? invariant(
mergeObj && typeof mergeObj === 'object',
'update(): %s expects a spec of type \'object\'; got %s',
COMMAND_MERGE,
mergeObj
) : invariant(mergeObj && typeof mergeObj === 'object'));
("production" !== process.env.NODE_ENV ? invariant(
nextValue && typeof nextValue === 'object',
'update(): %s expects a target of type \'object\'; got %s',
COMMAND_MERGE,
nextValue
) : invariant(nextValue && typeof nextValue === 'object'));
assign(nextValue, spec[COMMAND_MERGE]);
}
if (spec.hasOwnProperty(COMMAND_PUSH)) {
invariantArrayCase(value, spec, COMMAND_PUSH);
spec[COMMAND_PUSH].forEach(function(item) {
nextValue.push(item);
});
}
if (spec.hasOwnProperty(COMMAND_UNSHIFT)) {
invariantArrayCase(value, spec, COMMAND_UNSHIFT);
spec[COMMAND_UNSHIFT].forEach(function(item) {
nextValue.unshift(item);
});
}
if (spec.hasOwnProperty(COMMAND_SPLICE)) {
("production" !== process.env.NODE_ENV ? invariant(
Array.isArray(value),
'Expected %s target to be an array; got %s',
COMMAND_SPLICE,
value
) : invariant(Array.isArray(value)));
("production" !== process.env.NODE_ENV ? invariant(
Array.isArray(spec[COMMAND_SPLICE]),
'update(): expected spec of %s to be an array of arrays; got %s. ' +
'Did you forget to wrap your parameters in an array?',
COMMAND_SPLICE,
spec[COMMAND_SPLICE]
) : invariant(Array.isArray(spec[COMMAND_SPLICE])));
spec[COMMAND_SPLICE].forEach(function(args) {
("production" !== process.env.NODE_ENV ? invariant(
Array.isArray(args),
'update(): expected spec of %s to be an array of arrays; got %s. ' +
'Did you forget to wrap your parameters in an array?',
COMMAND_SPLICE,
spec[COMMAND_SPLICE]
) : invariant(Array.isArray(args)));
nextValue.splice.apply(nextValue, args);
});
}
if (spec.hasOwnProperty(COMMAND_APPLY)) {
("production" !== process.env.NODE_ENV ? invariant(
typeof spec[COMMAND_APPLY] === 'function',
'update(): expected spec of %s to be a function; got %s.',
COMMAND_APPLY,
spec[COMMAND_APPLY]
) : invariant(typeof spec[COMMAND_APPLY] === 'function'));
nextValue = spec[COMMAND_APPLY](nextValue);
}
for (var k in spec) {
if (!(ALL_COMMANDS_SET.hasOwnProperty(k) && ALL_COMMANDS_SET[k])) {
nextValue[k] = update(value[k], spec[k]);
}
}
return nextValue;
}
module.exports = update;
}).call(this,require('_process'))
},{"./Object.assign":32,"./invariant":154,"./keyOf":161,"_process":2}],175:[function(require,module,exports){
(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 = require("./emptyFunction");
/**
* 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 ("production" !== process.env.NODE_ENV) {
warning = function(condition, format ) {for (var args=[],$__0=2,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);
if (format === undefined) {
throw new Error(
'`warning(condition, format, ...args)` requires a warning ' +
'message argument'
);
}
if (format.length < 10 || /^[s\W]*$/.test(format)) {
throw new Error(
'The warning format should be able to uniquely identify this ' +
'warning. Please, use a more descriptive format than: ' + format
);
}
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++];});
console.warn(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;
}).call(this,require('_process'))
},{"./emptyFunction":133,"_process":2}],176:[function(require,module,exports){
module.exports = require('./lib/React');
},{"./lib/React":34}]},{},[1]);
|
(function() {
'use strict';
angular
.module('catalogue.home', [
'ionic',
'ngCordova',
'catalogue.common'
])
.config(function($stateProvider) {
$stateProvider
.state('app.home', {
url: '/home',
views: {
'menuContent': {
templateUrl: 'scripts/home/home.html',
controller: 'HomeController as vm'
}
}
});
});
})();
|
/**
* Created by zaiseoul on 16/1/18.
*/
$(function(){
var viewConfig = {
reference : $('#title_parent .control-label'),//排版参照物
height : (AutoLayout.CONST.height.default * 6) //强制设置高度
};
//设置 销售价(RMB)、销售价(KR)约束
var AutoLayout1 = new AutoLayoutObject("form", viewConfig, [
'H:|-39-[hotel_id_parent(create_date_parent)]-130-[create_date_parent]-|',
'H:|-40-[info_lastname_parent(create_date_parent-50)]-115-[info_firstname_parent]-|',
'H:|-39-[score_facility_parent(create_date_parent)]-[score_location_parent]-|',
'H:|-39-[score_clean_parent(create_date_parent)]-50-[score_friendly_parent]-|',
'H:|-39-[score_recommend_parent(create_date_parent)]',
//'V:|[hotel_id_parent(=='+AutoLayout.CONST.height.default+'),create_date_parent(==hotel_id_parent)]|',
'V:|-[hotel_id_parent(info_lastname_parent,score_facility_parent,score_clean_parent,score_recommend_parent)]-[info_lastname_parent]-[score_facility_parent]-[score_clean_parent]-[score_recommend_parent]-|',
'V:|-[create_date_parent(info_firstname_parent,score_location_parent,score_friendly_parent,score_recommend_parent)]-[info_firstname_parent]-[score_location_parent]-[score_friendly_parent]-[score_recommend_parent]-|',
//'V:|[info_lastname_parent(=='+AutoLayout.CONST.height.default+'),info_firstname_parent(==info_lastname_parent)]|',
] );
}) |
import React from 'react';
import PropTypes from 'prop-types';
export default function CarouselControl({ children, style, direction, onClick, onKeyDown }) {
return (
<a className={`carousel__control carousel__control--${ direction }`}
role="button"
style={style}
onClick={onClick}
onKeyDown={onKeyDown}
tabIndex={0}
aria-label={`${ direction } button`}
>
{children}
</a>
);
}
if (process.env.NODE_ENV !== 'production') {
CarouselControl.propTypes = {
children: PropTypes.node,
style: PropTypes.shape({
display: PropTypes.string,
}),
onClick: PropTypes.func.isRequired,
onKeyDown: PropTypes.func,
direction: PropTypes.oneOf([ 'previous', 'next' ]),
};
}
|
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Controller = require('./Controller');
var RestController = (function (_super) {
__extends(RestController, _super);
function RestController() {
_super.apply(this, arguments);
}
RestController.prototype.index = function (req, res) {
};
RestController.prototype.new = function (req, res) {
};
RestController.prototype.create = function (req, res) {
};
RestController.prototype.show = function (req, res) {
};
RestController.prototype.edit = function (req, res) {
};
RestController.prototype.update = function (req, res) {
};
RestController.prototype.destroy = function (req, res) {
};
RestController.prototype.get_index = function (req, res) {
return this.index(req, res);
};
RestController.prototype.get_new = function (req, res) {
return this.new(req, res);
};
RestController.prototype.post_index = function (req, res) {
return this.create(req, res);
};
RestController.prototype.attach = function (app, path) {
if (typeof path === "undefined") { path = "/"; }
_super.prototype.attach.call(this, app, path);
path = this.attachedPath;
app.get(path + ':id', this.createRoutingHandler('show'));
app.get(path + ':id/edit', this.createRoutingHandler('edit'));
app.put(path + ':id', this.createRoutingHandler('update'));
app.del(path + ':id', this.createRoutingHandler('destroy'));
};
return RestController;
})(Controller);
module.exports = RestController;
//# sourceMappingURL=RestController.js.map
|
import jQuery from 'jquery';
import angular from 'angular';
import _datePicker from 'jquery-ui/datepicker'; // sets up jQuery with the datepicker plugin
export default angular.module('ui.date', [])
.constant('uiDateConfig', {})
.constant('uiDateFormatConfig', '')
.factory('uiDateConverter', ['uiDateFormatConfig', function(uiDateFormatConfig) {
return {
stringToDate: stringToDate,
dateToString: dateToString,
};
function dateToString(uiDateFormat, value) {
var dateFormat = uiDateFormat || uiDateFormatConfig;
if (value) {
if (dateFormat) {
try {
return jQuery.datepicker.formatDate(dateFormat, value);
} catch (formatException) {
return undefined;
}
}
if (value.toISOString) {
return value.toISOString();
}
}
return null;
}
function stringToDate(dateFormat, valueToParse) {
dateFormat = dateFormat || uiDateFormatConfig;
if (angular.isDate(valueToParse) && !isNaN(valueToParse)) {
return valueToParse;
}
if (angular.isString(valueToParse)) {
if (dateFormat) {
return jQuery.datepicker.parseDate(dateFormat, valueToParse);
}
var isoDate = new Date(valueToParse);
return isNaN(isoDate.getTime()) ? null : isoDate;
}
if (angular.isNumber(valueToParse)) {
// presumably timestamp to date object
return new Date(valueToParse);
}
return null;
}
}])
.directive('uiDate', ['uiDateConfig', 'uiDateConverter', function uiDateDirective(uiDateConfig, uiDateConverter) {
return {
require: '?ngModel',
link: function link(scope, element, attrs, controller) {
var $element = jQuery(element);
var getOptions = function() {
return angular.extend({}, uiDateConfig, scope.$eval(attrs.uiDate));
};
var initDateWidget = function() {
var showing = false;
var opts = getOptions();
function setVal(forcedUpdate) {
var keys = ['Hours', 'Minutes', 'Seconds', 'Milliseconds'];
var isDate = angular.isDate(controller.$modelValue);
var preserve = {};
if (!forcedUpdate && isDate && controller.$modelValue.toDateString() === $element.datepicker('getDate').toDateString()) {
return;
}
if (isDate) {
angular.forEach(keys, function(key) {
preserve[key] = controller.$modelValue['get' + key]();
});
}
var newViewValue = $element.datepicker('getDate');
if (isDate) {
angular.forEach(keys, (key) => {
newViewValue['set' + key](preserve[key]);
});
}
controller.$setViewValue(newViewValue);
}
// If we have a controller (i.e. ngModelController) then wire it up
if (controller) {
// Set the view value in a $apply block when users selects
// (calling directive user's function too if provided)
var _onSelect = opts.onSelect || angular.noop;
opts.onSelect = function(value, picker) {
scope.$apply(function() {
showing = true;
setVal();
_onSelect(value, picker);
$element.blur();
});
};
var _beforeShow = opts.beforeShow || angular.noop;
opts.beforeShow = function(input, picker) {
showing = true;
_beforeShow(input, picker);
};
var _onClose = opts.onClose || angular.noop;
opts.onClose = function(value, picker) {
showing = false;
_onClose(value, picker);
};
element.on('focus', function(focusEvent) {
if (attrs.readonly) {
focusEvent.stopImmediatePropagation();
}
});
$element.off('blur.datepicker').on('blur.datepicker', function() {
if (!showing) {
scope.$apply(function() {
$element.datepicker('setDate', $element.datepicker('getDate'));
setVal();
});
}
});
controller.$validators.uiDateValidator = function uiDateValidator(modelValue, viewValue) {
return viewValue === null
|| viewValue === ''
|| angular.isDate(uiDateConverter.stringToDate(attrs.uiDateFormat, viewValue));
};
controller.$parsers.push(function uiDateParser(valueToParse) {
return uiDateConverter.stringToDate(attrs.uiDateFormat, valueToParse);
});
// Update the date picker when the model changes
controller.$render = function() {
// Force a render to override whatever is in the input text box
if (angular.isDate(controller.$modelValue) === false && angular.isString(controller.$modelValue)) {
controller.$modelValue = uiDateConverter.stringToDate(attrs.uiDateFormat, controller.$modelValue);
}
$element.datepicker('setDate', controller.$modelValue);
};
}
// Check if the $element already has a datepicker.
//
if ($element.data('datepicker')) {
// Updates the datepicker options
$element.datepicker('option', opts);
$element.datepicker('refresh');
} else {
// Creates the new datepicker widget
$element.datepicker(opts);
// Cleanup on destroy, prevent memory leaking
$element.on('$destroy', function() {
$element.datepicker('hide');
$element.datepicker('destroy');
});
}
if (controller) {
controller.$render();
// Update the model with the value from the datepicker after parsed
setVal(true);
}
};
// Watch for changes to the directives options
scope.$watch(getOptions, initDateWidget, true);
},
};
}])
.directive('uiDateFormat', ['uiDateConverter', function(uiDateConverter) {
return {
require: 'ngModel',
link: function(scope, element, attrs, modelCtrl) {
var dateFormat = attrs.uiDateFormat;
// Use the datepicker with the attribute value as the dateFormat string to convert to and from a string
modelCtrl.$formatters.unshift(function(value) {
return uiDateConverter.stringToDate(dateFormat, value);
});
modelCtrl.$parsers.push(function(value) {
return uiDateConverter.dateToString(dateFormat, value);
});
},
};
}]);
|
// write out all texas gauges as a geojson feature collection
var JSONStream = require('JSONStream');
var featurecollection = require('turf-featurecollection')
var es = require('event-stream');
var nwsGauges = require('../index.js');
nwsGauges.stream('tx')
.pipe(nwsGauges.geojsonify({style: true}))
.pipe(es.writeArray(function(err, features) {
var fc = featurecollection(features);
es.readArray([fc])
.pipe(JSONStream.stringify(false))
.pipe(process.stdout);
}));
|
version https://git-lfs.github.com/spec/v1
oid sha256:3ab2df98cb7f74f1b766a0b3270d39d96bbb88b622d33a4a94ea0686bf48af60
size 6096
|
var express = require('express');
var path = require('path');
var PORT = 8080;
var app = express();
app.use('/dist', express.static(path.join(__dirname, '/dist')));
app.use(express.static(__dirname));
app.listen( PORT, function(err, res){
console.log('Server listens to port ' + PORT + '...');
});
|
/* global describe beforeEach it */
var proxyquire = require('proxyquire')
var sinon = require('sinon')
var supertest = require('supertest')
var expect = require('chai').expect
var express = require('express')
var bodyParser = require('body-parser')
var rest = require('../../lib/rest')
describe('index', function () {
var request
beforeEach(function () {
// Setting up the app this way means all dependencies from app.js are explicitly defined per route file
var app = express()
app.set('views', './views')
app.set('view engine', 'pug')
app.use(bodyParser.urlencoded({ extended: false }))
var route = proxyquire('../../routes/index', {
'../../lib/rest': rest
})
// Inversion of control on route file
// http://evanshortiss.com/development/javascript/2016/04/15/express-testing-using-ioc.html
route(app)
request = supertest(app)
})
describe('GET /', function () {
it('should respond with a 500 on rest client error', function (done) {
if (rest.getItems.restore) rest.getItems.restore()
sinon.stub(rest, 'getItems', function (callback) {
callback({ message: 'error' }, null)
})
request
.get('/')
.expect(500)
.end(done())
})
it('should respond with a 200 and render items', function (done) {
if (rest.getItems.restore) rest.getItems.restore()
var getItemsStub = sinon.stub(rest, 'getItems', function (callback) {
callback(null, [{id: 1, name: 'Milk'}])
})
request
.get('/')
.expect(200, function (error, response) {
expect(getItemsStub.calledOnce).to.be.true
expect(error).to.be.null
expect(response.text).to.contain('Milk')
done()
})
})
})
describe('POST /add', function () {
it('should respond with a 200 and redirect', function (done) {
var addItemStub = sinon.stub(rest, 'addItem', function (item, callback) {
callback(null, {name: 'Cheese'})
})
request
.post('/add')
.send({name: 'Cheese'})
.expect(302, function (error, response) {
expect(addItemStub.calledOnce).to.be.true
expect(error).to.be.null
done()
})
})
})
describe('GET /delete/1234', function () {
it('should respond with a 200 and redirect', function (done) {
var deleteItemStub = sinon.stub(rest, 'deleteItem', function (id, callback) {
callback(null)
})
request
.get('/delete/1234')
.expect(302, function (error, response) {
expect(deleteItemStub.calledOnce).to.be.true
expect(error).to.be.null
done()
})
})
})
})
|
'use strict';
var path = require('path');
const app = require('express')();
const bodyParser = require('body-parser');
const mongoose = require('mongoose');
const PORT = process.env.PORT || 3000; //have to have process.env.PORT for heroku to work - uses random port;
const MONGODB_HOST = process.env.MONGODB_HOST || 'localhost';
const MONGODB_USER = process.env.MONGODB_USER || '';
const MONGODB_PASS = process.env.MONGODB_PASS || '';
const MONGODB_PORT = process.env.MONGODB_PORT || 27017;
const MONGODB_DB_NAME = process.env.MONGODB_DB_NAME || 'node-webserver';
const MONGODB_AUTH = MONGODB_USER
? `${MONGODB_USER}:${MONGODB_PASS}@`
: '';
const MONGODB_URL = `mongodb://${MONGODB_AUTH}${MONGODB_HOST}:${MONGODB_PORT}/${MONGODB_DB_NAME}`
//kteikslkdjfdsl
const routes = require('./routes/');
app.set('view engine', 'jade'); //configures node to read jade
app.use(require('node-sass-middleware')({
src: path.join(__dirname, 'public'),
dest: path.join(__dirname, 'public'),
indentedSyntax: true,
sourceMap: true
}));
app.locals.title = 'THE Super Cool App';
//bodyParser is middleware that looks at request, sees if it's a form. If it is, it adds the req.body
//so we can receive form. Need this to receive form.
app.use(bodyParser.urlencoded({extended: false}));
app.use(bodyParser.json());
app.use(routes);
mongoose.connect(MONGODB_URL);
mongoose.connection.on('open', () => {
console.log('MONGO OPEN');
app.listen(PORT, () => {
console.log(`Node.js server started. Listening on port ${PORT}`);
});
})
|
/**
* @constructor
* @description 可以通过 window.getComputedStyle 获取
- 计算样式的属性是只读
- 计算样式的值是绝对值【会将百分比和点之类相对的单位全部转换成绝对值】,所有指定尺寸的属性都会有一个以像素为度量单位的值,颜色的属性将会以 rgb 或 rgba 的格式返回
- 不会计算符合属性，只基于最基础的属性[chrome43已经可以获取组合属性]
- 计算样式的 cssText 属性未定义
- 计算样式与 style{@link HTMLElement.style} 获取不同，[实例](../../example/javascript/CSSModule/CSSStyleDeclaration/getComputedStyle_style.html)
*/
function CSSStyleDeclaration(){}
/**
* 属性的数量
* @type {Number}
*/
CSSStyleDeclaration.length = 0
CSSStyleDeclaration.prototype = {
/**
* 返回可选的优先级，"Important"或空字符串
* @return {string} ['important'| '']
* @example
* styleObj.getPropertyPriority('color')
*/
getPropertyPriority: function(){},
/**
* 返回属性值
* @param {string} prop 需要获取的键 **不能输入驼峰字符串，只能输入css属性**
* @return {string}
* @example
* styleObj.getPropertyvalue()
*/
getPropertyValue: function(prop){},
/**
* 返回属性名或空字符串
* @param {number} idx 返回指定位置的属性名
* @return {string}
*/
item: function(idx){},
/**
* 删除属性，未删除成功，抛出异常，属性为readonly
* @param {string} prop 被删除的属性
* @return {string} 返回被删除的属性
*/
removeProperty: function(prop){},
/**
* 设置属性,未设置成功，抛出异常，属性为readonly
* @param {string} prop 属性
* @param {string} val 值
* @param {string} priority 优先级
*/
setProperty: function(prop,val,priority){}
}
|
/*
Problem 5. Selection sort
Sorting an array means to arrange its elements in increasing order.
Write a script to sort an array.
Use the selection sort algorithm: Find the smallest element, move it at the first position, find the smallest from the rest, move it at the second position, etc.
Hint: Use a second array
*/
// An array of example values
var example = [3, 5, 8, 4, 7, 2, 1];
// The actual solution to the task
function solution(example){
var currentMin,
helper,
indexOne,
indexTwo;
for (indexOne = 0; indexOne < example.length; indexOne += 1) {
currentMin = indexOne;
for (indexTwo = indexOne + 1; indexTwo < example.length; indexTwo += 1) {
if (example[currentMin] > example [indexTwo]) {
currentMin = indexTwo;
}
}
helper = example[indexOne];
example[indexOne] = example[currentMin];
example[currentMin] = helper;
}
// One array algorithm, who's the boss? :P
return example.join(', ');
}
// Print result
console.log(example.join(', ') + " sorted to: " + solution(example)); |
game.PlayScreen = me.ScreenObject.extend({
onResetEvent: function() {
var levelname = "level0"+game.data.level;
me.levelDirector.loadLevel(levelname);
game.data.scrollVel = game.data.scrollVelStart-(game.data.level/10);
this.HUD = new game.HUD.Container();
me.game.world.addChild(this.HUD);
if(game.debug.playBGM){
me.audio.playTrack("battleThemeA",0.5);
}
},
onDestroyEvent: function() {
me.game.world.removeChild(this.HUD);
me.audio.stopTrack();
},
}); |
let lastErr = null
let lastPromise = null
export function lintJson (CodeMirror) {
CodeMirror.registerHelper('lint', 'json', lint)
}
export function setError (err) {
lastErr = err ? [
{
from: window.CodeMirror.Pos(err.line, 0),
to: window.CodeMirror.Pos(err.line, 0),
message: err.message
}] : []
if (lastPromise) {
lastPromise(lastErr)
lastPromise = null
lastErr = null
}
}
function lint () {
return new Promise(resolve => {
lastPromise = resolve
if (lastErr) {
lastPromise(lastErr)
lastPromise = null
lastErr = null
}
})
}
|
(function (factory) {
/* global define */
if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module.
define(['jquery'], factory);
} else if (typeof module === 'object' && module.exports) {
// Node/CommonJS
module.exports = factory(require('jquery'));
} else {
// Browser globals
factory(window.jQuery);
}
}(function($) {
// Extends plugins for adding well.
// - plugin is external module for customizing.
$.extend($.summernote.plugins, {
/**
* @param {Object} context - context object has status of editor.
*/
'well': function(context) {
var self = this;
// ui has renders to build ui elements.
// - you can create a button with `ui.button`
var ui = $.summernote.ui;
var $editor = context.layoutInfo.editor;
var options = context.options;
var lang = options.langInfo;
// add well button
context.memo('button.well', function() {
// create button
var button = ui.button({
contents: '<i class="glyphicon glyphicon-unchecked"/>',
tooltip: 'Text box',
hide: true,
click: function() {
// invoke insertText method with 'well' on editor module.
context.invoke('editor.insertText', 'well');
},
});
// create jQuery object from button instance.
var $well = button.render();
return $well;
});
// This events will be attached when editor is initialized.
this.events = {
// This will be called after modules are initialized.
'summernote.init': function (we, e) {
//console.log('summernote initialized', we, e);
},
// This will be called when user releases a key on editable.
'summernote.keyup': function (we, e) {
//console.log('summernote keyup', we, e);
}
};
}
});
}));
//
//
// (function(factory) {
// /* global define */
// if (typeof define === 'function' && define.amd) {
// // AMD. Register as an anonymous module.
// define(['jquery'], factory);
// } else {
// // Browser globals: jQuery
// factory(window.jQuery);
// }
// }(function($) {
//
// // template, editor
// var tmpl = $.summernote.renderer.getTemplate();
//
// // core functions: range, dom
// var range = $.summernote.core.range;
//
// //var dom = $.summernote.core.dom;
//
// var getTextOnRange = function($editable) {
// $editable.focus();
//
// var rng = range.create();
//
// // if range on anchor, expand range with anchor
// if (rng.isOnAnchor()) {
// var anchor = dom.ancestor(rng.sc, dom.isAnchor);
// rng = range.createFromNode(anchor);
// }
//
// return rng.toString();
// };
// /**
// * @class plugin.textbox
// *
// * Text box Plugin
// */
// $.summernote.addPlugin({
// /** @property {String} name name of plugin */
// name: 'textboxwell',
// /**
// * @property {Object} buttons
// * @property {Function} buttons.well function to make button
// */
// buttons: { // buttons
// textboxwell: function(lang) {
//
// return tmpl.iconButton('fa fa-square-o', {
// event: 'well',
// title: lang.textboxwell.welltext,
// hide: true,
// });
// },
// },
//
// /**
// * @property {Object} events
// * @property {Function} events.well run function when button that has a 'well' event name fires click
// */
// events: { // events
// well: function(event, editor, layoutInfo) {
// var $editable = layoutInfo.editable();
// text = getTextOnRange($editable);
//
// var div = $('<div class="well">' + text + '</div>');
// editor.insertNode($editable, div[0], true);
// },
// },
//
//
// });
// }));
|
/**
* Created by wangyefeng on 02/03/2017.
*/
// navigator height 48px
import React from 'react'
import { hashHistory } from 'react-router'
import { connect } from 'react-redux'
import Header from '../container/navigator/header'
import './navigator/header.css'
class Navigator extends React.Component {
static protoTypes = {
children: React.PropTypes.Object,
}
static defaultProps = {
children: {},
}
state = {
current: 'mail',
}
handleClick = (e) => {
switch (e.key) {
case 'smile':
hashHistory.push('about')
break
case 'home':
hashHistory.push('home')
break
case 'article':
hashHistory.push('list')
break
case 'tag':
hashHistory.push('tag')
break
default:
break
}
this.setState({
current: e.key,
})
}
render() {
return (
<div>
<Header />
<div className="header-placeholder" />
{this.props.children}
</div>
)
}
}
// function mapStateToProps(state) {
// return {
// value: state.count
// }
// }
// Map Redux actions to component props
// function mapDispatchToProps(dispatch) {
// return {
// onIncreaseClick: () => dispatch(increaseAction)
// }
// }
export default connect()(Navigator)
|
// All symbols in the Combining Diacritical Marks Supplement block as per Unicode v5.2.0:
[
'\u1DC0',
'\u1DC1',
'\u1DC2',
'\u1DC3',
'\u1DC4',
'\u1DC5',
'\u1DC6',
'\u1DC7',
'\u1DC8',
'\u1DC9',
'\u1DCA',
'\u1DCB',
'\u1DCC',
'\u1DCD',
'\u1DCE',
'\u1DCF',
'\u1DD0',
'\u1DD1',
'\u1DD2',
'\u1DD3',
'\u1DD4',
'\u1DD5',
'\u1DD6',
'\u1DD7',
'\u1DD8',
'\u1DD9',
'\u1DDA',
'\u1DDB',
'\u1DDC',
'\u1DDD',
'\u1DDE',
'\u1DDF',
'\u1DE0',
'\u1DE1',
'\u1DE2',
'\u1DE3',
'\u1DE4',
'\u1DE5',
'\u1DE6',
'\u1DE7',
'\u1DE8',
'\u1DE9',
'\u1DEA',
'\u1DEB',
'\u1DEC',
'\u1DED',
'\u1DEE',
'\u1DEF',
'\u1DF0',
'\u1DF1',
'\u1DF2',
'\u1DF3',
'\u1DF4',
'\u1DF5',
'\u1DF6',
'\u1DF7',
'\u1DF8',
'\u1DF9',
'\u1DFA',
'\u1DFB',
'\u1DFC',
'\u1DFD',
'\u1DFE',
'\u1DFF'
]; |
import Value from '../models/value'
/**
* Changes.
*
* @type {Object}
*/
const Changes = {}
/**
* Set `properties` on the value.
*
* @param {Change} change
* @param {Object|Value} properties
* @param {Object} options
*/
Changes.setValue = (change, properties, options = {}) => {
properties = Value.createProperties(properties)
const { value } = change
change.applyOperation(
{
type: 'set_value',
properties,
value,
},
options
)
}
/**
* Export.
*
* @type {Object}
*/
export default Changes
|
(function () {
'use strict';
function data($http, $q, notifier, baseServiceUrl) {
function get(url, queryParams) {
var defered = $q.defer();
$http.get(baseServiceUrl + '/' + url, { params: queryParams })
.then(function (response) {
defered.resolve(response.data);
}, function (error) {
notifier.error(getErrorMessage(error));
defered.reject(error);
});
return defered.promise;
}
function post(url, postData) {
var defered = $q.defer();
$http.post(baseServiceUrl + '/' + url, postData)
.then(function (response) {
defered.resolve(response.data);
}, function (error) {
notifier.error(getErrorMessage(error));
defered.reject(error);
});
return defered.promise;
}
function put(url, putData) {
var defered = $q.defer();
$http.put(baseServiceUrl + '/' + url, putData)
.then(function (response) {
defered.resolve(response.data);
}, function (error) {
notifier.error(getErrorMessage(error));
defered.reject(error);
});
return defered.promise;
}
function getErrorMessage(error) {
return error.data && error.data.message || error;
}
return {
get: get,
post: post,
put: put
};
}
angular.module('librarySystem.services')
.factory('data', ['$http', '$q', 'notifier', 'baseServiceUrl', data]);
}()); |
import MagicString from 'magic-string';
import parse from './utils/parse';
import patchCommas from './patchers/patchCommas';
import patchComments from './patchers/patchComments';
import patchDeclarations from './patchers/patchDeclarations';
import patchEmbeddedJavaScript from './patchers/patchEmbeddedJavaScript';
import patchEquality from './patchers/patchEquality';
import patchKeywords from './patchers/patchKeywords';
import patchPrototypeAccess from './patchers/patchPrototypeAccess';
import patchRegularExpressions from './patchers/patchRegularExpressions';
import patchReturns from './patchers/patchReturns';
import patchSemicolons from './patchers/patchSemicolons';
import patchSequences from './patchers/patchSequences';
import patchStringInterpolation from './patchers/patchStringInterpolation';
import patchThis from './patchers/patchThis';
import preprocessBinaryExistentialOperator from './preprocessors/preprocessBinaryExistentialOperator';
import preprocessCompoundAssignment from './preprocessors/preprocessCompoundAssignment';
import preprocessConditional from './preprocessors/preprocessConditional';
import preprocessSoakedMemberAccessOp from './preprocessors/preprocessSoakedMemberAccessOp';
import preprocessTry from './preprocessors/preprocessTry';
import traverse from './utils/traverse';
import { patchCallOpening, patchCallClosing } from './patchers/patchCalls';
import { patchClassStart, patchClassEnd } from './patchers/patchClass';
import { patchConditionalStart, patchConditionalEnd } from './patchers/patchConditional';
import { patchExistentialOperatorStart, patchExistentialOperatorEnd } from './patchers/patchExistentialOperator';
import { patchFunctionStart, patchFunctionEnd } from './patchers/patchFunctions';
import { patchObjectBraceOpening, patchObjectBraceClosing } from './patchers/patchObjectBraces';
import { patchSpreadStart, patchSpreadEnd } from './patchers/patchSpread';
import { patchRestStart, patchRestEnd } from './patchers/patchRest';
import { patchThrowStart, patchThrowEnd } from './patchers/patchThrow';
import { patchTryStart, patchTryEnd } from './patchers/patchTry';
/**
* Decaffeinate CoffeeScript source code by adding optional punctuation.
*
* @param source
* @returns {string}
*/
export function convert(source) {
const ast = parse(source);
const patcher = new MagicString(source);
let wasRewritten = false;
traverse(ast, (node) => {
if (wasRewritten) {
return false;
}
wasRewritten = preprocessCompoundAssignment(node, patcher) ||
preprocessConditional(node, patcher) ||
preprocessBinaryExistentialOperator(node, patcher) ||
preprocessSoakedMemberAccessOp(node, patcher) ||
preprocessTry(node, patcher);
});
if (wasRewritten) {
return convert(patcher.toString());
}
traverse(ast, (node, descend) => {
patchConditionalStart(node, patcher);
patchRegularExpressions(node, patcher);
patchReturns(node, patcher);
patchKeywords(node, patcher);
patchThis(node, patcher);
patchPrototypeAccess(node, patcher);
patchStringInterpolation(node, patcher);
patchCallOpening(node, patcher);
patchObjectBraceOpening(node, patcher);
patchDeclarations(node, patcher);
patchFunctionStart(node, patcher);
patchClassStart(node, patcher);
patchEquality(node, patcher);
patchThrowStart(node, patcher);
patchSpreadStart(node, patcher);
patchRestStart(node, patcher);
patchTryStart(node, patcher);
patchEmbeddedJavaScript(node, patcher);
patchExistentialOperatorStart(node, patcher);
descend(node);
patchTryEnd(node, patcher);
patchConditionalEnd(node, patcher);
patchThrowEnd(node, patcher);
patchExistentialOperatorEnd(node, patcher);
patchFunctionEnd(node, patcher);
patchClassEnd(node, patcher);
patchObjectBraceClosing(node, patcher);
patchCallClosing(node, patcher);
patchSemicolons(node, patcher);
patchSequences(node, patcher);
patchCommas(node, patcher);
patchSpreadEnd(node, patcher);
patchRestEnd(node, patcher);
});
patchComments(patcher);
return patcher.toString();
}
|
/* eslint strict: 0 */
'use strict';
process.env.NODE_ENV = process.env.NODE_ENV || 'production';
const path = require('path');
var _ = require('lodash');
var Job = require('./jobs/jobs');
var RepositoryProcess = require('./process/RepositoryProcess');
const electron = require('electron');
const app = electron.app;
const ipc = electron.ipcMain;
const BrowserWindow = electron.BrowserWindow;
const Menu = electron.Menu;
const crashReporter = electron.crashReporter;
const Tray = electron.Tray;
const shell = electron.shell;
const dialog = electron.dialog;
var Positioner = require('electron-positioner');
var storage = require('electron-json-storage');
var appIcon;
var positioner; //holds cornerWindow position
var open = require('mac-open');
let menu;
let template;
var mainWindow = null;
var cornerWindow = null;
var isDarwin = (process.platform === 'darwin');
var isLinux = (process.platform === 'linux');
var isWindows = (process.platform === 'win32');
crashReporter.start();
const ITEM_HEIGHT = 60;
const ITEM_HEIGHT_EXTRAS = 45;
const hasSetup = false;
var job = new Job();
var repoProcess = new RepositoryProcess();
//killswitch the app
const doKill = false;
if (process.env.NODE_ENV === 'development') {
require('electron-debug')();
}
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit();
});
app.on('ready', () => {
//killswitch
if(doKill){
storage.remove('updateInterval');
storage.remove('repositories');
return;
}
var value = new Promise(function(resolve, reject){
return storage.get('repositories', function(err, data){
if(err) reject(err);
resolve(data);
});
})
.then(function(data){
if(data.length){
start();
}else{
loadSetup();
}
return data;
});
});
var loadSetup = function(event){
console.log('loadSetup');
if(cornerWindow){
cornerWindow.close();
}
mainWindow = new BrowserWindow({
width: 800,
height: 850,
frame: false,
title: 'Gitty'
});
mainWindow.loadURL(`file://${__dirname}/app/app.html`);
mainWindow.on('closed', () => {
mainWindow = null;
});
ipc.on('app-quit', function() {
app.quit();
});
if (process.env.NODE_ENV === 'development') {
//mainWindow.openDevTools();
}
}
var start = function(event){
console.log('start');
if(mainWindow){
mainWindow.close();
}
appIcon = new Tray( path.join( __dirname, '/images/gitty-icon-20.png' ));
var template = [
{
label: 'Show Repositories',
type: 'normal',
click: function(item, focusedWindow){
cornerWindow.show();
}
},
{
label: 'Hide Repositories',
type: 'normal',
click: function(){
cornerWindow.hide();
}
},
{
type: 'separator'
},
{
label: 'Sync Now',
type: 'normal',
click: function(item, focusedWindow){
refreshRepositories();
}
},
{
type: 'separator'
},
{
label: 'Update Repositories',
submenu: [
{
label: 'Every 10 Seconds',
type: 'radio',
click: function(event, index){
var interval = 10000;
storage.set('updateInterval', interval, function(){
restartJob(interval);
});
},
value: 10000
},
{
label: 'Every 1 minute',
type: 'radio',
click: function(event, index){
var interval = 60000;
storage.set('updateInterval', interval, function(){
restartJob(interval);
});
},
value: 60000
},
{
label: 'Every 5 Minutes',
type: 'radio',
click: function(event, index){
var interval = 300000;
storage.set('updateInterval', interval, function(){
restartJob(interval);
});
},
value: 300000
},
{
label: 'Every 10 Minutes',
type: 'radio',
click: function(event, index){
var interval = 600000;
storage.set('updateInterval', interval, function(){
restartJob(interval);
});
},
value: 600000
},
{
label: 'Every 30 Minutes',
type: 'radio',
click: function(event, index){
var interval = 1800000;
storage.set('updateInterval', interval, function(){
restartJob(interval);
});
},
value: 1800000
}
]
},
{
type: 'separator'
},
{
label: 'Add Repositories',
type: 'normal',
click: onAddRepository
},
{
type: 'separator'
},
{
label: 'Move Window',
submenu: [
{
label: 'Top Left',
click: function(event, index){
if(cornerWindow && positioner){
positioner.move('topLeft');
}
}
},
{
label: 'Top Right',
click: function(event, index){
if(cornerWindow && positioner){
positioner.move('topRight');
}
}
},
{
label: 'Bottom Left',
click: function(event, index){
if(cornerWindow && positioner){
positioner.move('bottomLeft');
}
}
},
{
label: 'Bottom Right',
click: function(event, index){
if(cornerWindow && positioner){
positioner.move('bottomRight');
}
}
}
]
},
{
label: 'Set External Opener',
submenu: [
{
label: 'Terminal',
click: function(){
storage.set('terminal', 'terminal');
}
},
{
label: 'iTerm',
click: function(){
storage.set('terminal', 'iterm');
}
},
{
label: 'Sublime Text',
click: function(){
storage.set('terminal', 'Sublime Text');
}
},
{
label: 'Sublime Text 2',
click: function(){
storage.set('terminal', 'Sublime Text 2');
}
}
]
},
{
type: 'separator'
},
{
label: 'Quit',
type: 'normal',
click: function(){
app.quit();
}
},
];
//create the corner window
cornerWindow = new BrowserWindow({
width: 650,
height: 200,
show: false,
resizable: true,
skipTaskbar: true,
title: 'Gitty',
frame: false });
cornerWindow.on('closed', function(){
cornerWindow = null;
appIcon.destroy();
});
if (process.env.NODE_ENV === 'development') {
//cornerWindow.openDevTools();
}
cornerWindow.loadURL(`file://${__dirname}/app/app.html#repositories`);
cornerWindow.setMenuBarVisibility(false);
cornerWindow.show();
positioner = new Positioner(cornerWindow);
positioner.move('topRight');
cornerWindow.on('closed', () => {
job.stop();
})
cornerWindow.on('blur', function(){
//cornerWindow.hide();
})
storage.get('updateInterval', function(err,data){
var updateIndex;
var checkValue;
if(err) throw err;
if(data && _.isInteger(data)){
checkValue = data;
}else{
checkValue = 600000;
}
updateIndex = _.findIndex(template[5].submenu, {value: checkValue})
template[5].submenu[updateIndex].checked = true;
var contextMenu = Menu.buildFromTemplate(template);
appIcon.setContextMenu(contextMenu);
});
storage.get('repositories', function(err,data){
console.log('-- repositories');
var paths = data;
cornerWindow.setSize(650, calculateHeight(paths.length) );
storage.get('updateInterval', function(err, data){
if(err) throw err;
repoProcess.set(cornerWindow);
console.log('running ----');
job.set( function(){
repoProcess.run();
});
startJob(data);
})
});
}
/**
Starts a Job
**/
const startJob = function(data){
console.log('----');
console.log('startJob', data);
var interval = _.isNumber(data) ? 600000 : data;
console.log('starting job interval: ', interval);
job.start(data);
}
/**
Retarts a Job
**/
const restartJob = function(data){
console.log('----------');
console.log('restartJob!', data);
job.stop();
job.start(data);
}
const refreshRepositories = function(evt, index){
console.log('refreshRepositories');
if(repoProcess){
storage.get('repositories', function(err, data){
if(cornerWindow){
repoProcess.set(cornerWindow);
if(Array.isArray(data) && data.length){
console.log('YES');
cornerWindow.setSize(650, calculateHeight(data.length))
}else{
console.log("NO");
}
}
//repoProcess.run(data || []);
job.runImmediate();
})
}
}
const onAddRepository = function(event, index){
console.log('onAddRepository')
dialog.showOpenDialog({
properties: [ 'openFile', 'openDirectory', 'multiSelections' ]
}, function(pathArray){
if(pathArray){
cornerWindow.webContents.send('addRepositories', pathArray);
}
});
}
const calculateHeight = function(numItems){
return numItems * ITEM_HEIGHT;
}
/**
* Called when we want to refresh repositories
*/
ipc.on('refreshRepositories', refreshRepositories);
ipc.on('setup', loadSetup);
ipc.on('start', start);
/**
* Resizes corner window
*/
ipc.on('resizeCornerWindow', function(event){
storage.get('repositories', function(err,data){
var paths = data;
if(cornerWindow){
cornerWindow.setSize(650, calculateHeight(paths.length) );
}
});
})
/**
* Message called in React App Initialization
*/
ipc.on('react-app-started', function(event, index){
});
/**
* Git Pull a repo on a specific index
*/
ipc.on('git-pull', function(event, index){
//var gitProcess = new RepositoryProcess();
repoProcess.set(cornerWindow);
repoProcess.pullStorageIndex(index);
})
/**
* Opens a Terminal
*/
ipc.on('openTerminal', function(event,path){
storage.has('terminal', function(err,hasData){
if(hasData){
storage.get('terminal', function(err,data){
open(path, { a: data });
})
}else{
open(path, { a: "Terminal" });
}
})
storage.get('terminal', function(err,data){
if(err) throw err;
});
})
|
'use strict';
angular.module('mean.system').service('Places', ['$log', '$resource', '$http', '$location', '$q', function($log, $resource, $http, $location, $q) {
var savedResults = {};
var savedQuery = {};
var fetching = false;
return {
getData: function() {
return savedResults;
},
setData: function(results) {
$log.info('Data set:', results);
savedResults = results;
},
clearData: function() {
savedResults = {};
},
getQuery: function() {
return savedQuery;
},
setQuery: function(query) {
$log.info('Query set:', query);
_.forOwn(query, function(v, k) {
$location.search(k, v);
});
savedQuery = query;
},
clearQuery: function() {
savedQuery = {};
},
fetching: function(val) {
$log.info('Fetching:', val);
fetching = val;
return this.fetched();
},
fetched: function() {
return fetching;
},
get: function(query) {
this.setQuery(query);
this.fetching(true);
var deferred = $q.defer();
if (query.location === 'Current Location') {
query = _.omit(query, ['location']);
} else {
query = _.omit(query, ['latlng']);
}
var promise = $http({
url: '/api/1/places',
method: 'POST',
data: query
});
promise.then(function(data) {
$log.debug(data);
this.setData(data.data);
this.fetching(false);
if (_.has(data.data, 'places') && data.data.places.length === 0) {
return deferred.reject(new Error('No more results'));
}
return deferred.resolve(data);
}.bind(this), function(err) {
this.fetching(false);
return deferred.reject(err);
}.bind(this));
return deferred.promise;
}
};
}]);
|
ET.Cities = Backbone.Collection.extend({
/*
* List of cities.
*/
model : ET.City,
url : 'res/stats/cities.json',
//TODO do the headquarters fns make more sense as part of career?
/**
* Returns the City object representing the player's headquarters
*/
getHeadquarters : function() {
return this.findWhere({
headquarters : true
});
},
/**
* Changes the player's headquarters. The old headquarters will be removed.
* @param {City} city the new headquarters.
*/
setHeadquarters : function(city) {
if (ET.career.spendMoney(city.getHeadquarterCost())) {
this.findWhere({
headquarters : true
}).set('headquarters', false);
city.set('headquarters', true);
}
}
}); |
/*
---
name: omniGrid
description: Advanced DataGrid for Mootools
version: 1.2.6
copyright: Marko Šantić (http://www.omnisdata.com/omnigrid)
license: MIT License
authors:
- Marko Šantić (marko@omnisdata.com)
requires:
Core/1.2.4: '*'
More/1.2.4.4: [Fx.Scroll, Drag]
provides: [omniGrid]
...
*/
var omniGrid = new Class({
Implements: [Events,Options],
getOptions: function(){
return {
alternaterows: true,
showHeader:true,
sortHeader:false,
resizeColumns:true,
selectable:true,
serverSort:true,
sortOn: null,
sortBy: 'ASC',
filterHide: true,
filterHideCls: 'hide',
filterSelectedCls: 'filter',
multipleSelection:true,
editable:false,
editondblclick:false,
// accordion
accordion:false,
accordionRenderer:null,
autoSectionToggle:true, // if true just one section can be open/visible
showtoggleicon:true,
openAccordionOnDblClick:false,
// pagination
url:null,
pagination:false,
page:1,
perPageOptions: [10, 20, 50, 100, 200],
perPage:10,
filterInput:false,
// dataProvider
dataProvider:null
};
},
initialize: function(container, options){
this.setOptions(this.getOptions(), options);
this.container = $(container);
if (!this.container)
return;
this.draw();
this.reset();
this.loadData();
},
// API
reset: function(){
this.renderData();
this.refreshDelayID = null;
this.dragging = false;
this.selected = new Array();
if (this.options.accordion)
this.elements = this.ulBody.getElements('li:nth-child(2n+1)') // all li el. except accordian sections
else
this.elements = this.ulBody.getElements('li');
this.filtered = false;
this.lastsection = null;
if (this.options.alternaterows) this.altRow();
this.elements.each(function(el,i){
el.addEvent('click', this.onRowClick.bind(this));
el.addEvent('dblclick', this.onRowDblClick.bind(this));
el.addEvent('mouseover', this.onRowMouseOver.bind(this) );
el.addEvent('mouseout', this.onRowMouseOut.bind(this) );
}, this);
// ******************************************************************
// **************************** Setup header ************************
// ******************************************************************
this.container.getElements('.th').each(function(el,i){
//alert(el.dataType);
var dataType = el.retrieve('dataType');
if(dataType){
el.getdate = function(str){
// inner util function to convert 2-digit years to 4
function fixYear(yr) {
yr = +yr;
if (yr<50) { yr += 2000; }
else if (yr<100) { yr += 1900; }
return yr;
};
var ret;
//
if (str.length>12){
strtime = str.substring(str.lastIndexOf(' ')+1);
strtime = strtime.substring(0,2)+strtime.substr(-2)
}else{
strtime = '0000';
}
//
// YYYY-MM-DD
if (ret=str.match(/(\d{2,4})-(\d{1,2})-(\d{1,2})/)) {
return (fixYear(ret[1])*10000) + (ret[2]*100) + (+ret[3]) + strtime;
}
// DD/MM/YY[YY] or DD-MM-YY[YY]
if (ret=str.match(/(\d{1,2})[\/-](\d{1,2})[\/-](\d{2,4})/)) {
return (fixYear(ret[3])*10000) + (ret[2]*100) + (+ret[1]) + strtime;
}
return 999999990000; // So non-parsed dates will be last, not first
};
//
el.findData = function(elem){
var child = elem.getFirst();
if(child){
return el.findData(child);
}else{
return elem.innerHTML.trim();
}
};
//
el.compare = function(a, b){
// a i b su LI elementi
var var1 = a.getChildren()[i].innerHTML.trim();
var var2 = b.getChildren()[i].innerHTML.trim();
//console.log(el.sortBy);
//var1 = a.getChildren()[i].firstChild.data;
//var2 = b.getChildren()[i].firstChild.data;
if(dataType == 'number'){
var1 = parseFloat(var1);
var2 = parseFloat(var2);
if(el.sortBy == 'ASC'){
return var1-var2;
}else{
return var2-var1;
}
}else if(dataType == 'string'){
var1 = var1.toUpperCase();
var2 = var2.toUpperCase();
if(var1==var2){return 0};
if(el.sortBy == 'ASC'){
if(var1<var2){return -1};
}else{
if(var1>var2){return -1};
}
return 1;
}else if(dataType == 'date'){
var1 = parseFloat(el.getdate(var1));
var2 = parseFloat(el.getdate(var2));
if(el.sortBy == 'ASC'){
return var1-var2;
}else{
return var2-var1;
}
}else if(dataType == 'currency'){
var1 = parseFloat(var1.substr(1).replace(',',''));
var2 = parseFloat(var2.substr(1).replace(',',''));
if(el.sortBy == 'ASC'){
return var1-var2;
}else{
return var2-var1;
}
}
}
}
}, this);
},
// API
// pretvara zadanu columnu u inline edit mode
// options = {
// dataIndex:Number - column name || columnIndex:Number - column index
//}
edit: function(options){
var sels = this.getSelectedIndices();
if ( !sels || sels.length==0 || !this.options.editable ) return;
this.finishEditing(); // ako je negde otvoren
var li = this.elements[ sels[0] ];
// nadi index u columnModel
var c = options.columnIndex ? options.columnIndex : 0; // ako ne nade ili nije definiran pretpostavi 1.
var colmod;
if (options.dataIndex)
{
for (; c < this.options.columnModel.length; c++)
{
colmod = this.options.columnModel[c];
if (colmod.hidden) continue;
//console.log(colmod.dataIndex+" "+options.dataIndex);
if ( colmod.dataIndex == options.dataIndex ) break;
}
}
if (c == this.options.columnModel.length) return; // znaci da nije nasao columnu
colmod = this.options.columnModel[c];
if (!colmod.editable) return;
var td = li.getElements('div.td')[c];
var data = this.options.data[ sels[0] ];
var width = td.getStyle('width').toInt()-5;
var height = 15;
var html = data[colmod.dataIndex];
td.innerHTML = "";
var input = new Element('input', {style:"width: "+width+"px; height: "+height+"px;", maxlength:254, value: html} );
input.addClass('inline');
input.addEvent("keyup", this.finishEditing.bind(this) );
input.addEvent("blur", this.finishEditing.bind(this) );
input.inject(td);
input.focus();
//td.innerHTML = " onkeypress=\"return fieldEnter(this,event,' actual.id ')\" onfocus=\"highLight(this);\" onblur=\"noLight(this); return fieldBlur(this,' actual.id ');\" />";
//td.innerHTML = '';
this.inlineEditSafe = {row:sels[0], columnModel: colmod, td:td, input:input, oldvalue: html};
this.inlineeditmode = true; // radi chromea jer poziva keyup i blur event skoro paralelno !?
return this.inlineEditSafe;
// global click za finish editing --> ne treba jer ima onblur event
//(Browser.Engine.trident ? document : window).addEvent("click", this.finishEditing.bind(this) );
},
finishEditing: function(evt)
{
if (!this.inlineeditmode) return;
if ( evt && evt.type == "keyup" && evt.key != 'enter' && evt.key != 'esc' ) return;
//if (evt) console.log(evt.type+" "+this.inlineEditSafe.oldvalue+" "+this.editmode);
this.inlineeditmode = false; // radi chromea
var row = this.inlineEditSafe.row;
var data = this.options.data[ row ];
var colmod = this.inlineEditSafe.columnModel;
var td = this.inlineEditSafe.td;
//alert(this.inlineEditSafe);
// ako nije potvrdio sa ENTER vrati na staro
data[colmod.dataIndex] = ( evt && evt.type == "keyup" && evt.key == 'enter') ? this.inlineEditSafe.input.value : this.inlineEditSafe.oldvalue;
td.innerHTML = colmod.labelFunction ? colmod.labelFunction(data, row, colmod) : data[colmod.dataIndex];
if (td.innerHTML.length == 0) td.innerHTML = " "; // bitno jer inace ne bi drugi put reagirao na dbl click
// opali event samo za key=ENTER i ako je je napravljena promjena
if ( evt && evt.type == "keyup" && evt.key == 'enter' && this.inlineEditSafe.oldvalue != td.innerHTML )
{
// opali event za van
this.inlineEditSafe.target = this; // ovo je mozda lose jer poslije brisem varijablu this.inlineEditSafe
this.fireEvent("editcomplete", this.inlineEditSafe);
}
this.inlineEditSafe = null;
},
toggle: function(el){
if ( el.getStyle('display') == 'block' )
{
el.setStyle('display', 'none');
}else{
el.setStyle('display', 'block');
}
},
// API
getSection: function(row){
return this.ulBody.getElement('.section-'+row);
},
getLiParent: function (target){
// ! ako se koristi labelFunction onda neki html elem. moze hvatati event, detektiraj pravi li
target = $(target);
while ( target && !target.hasClass('td') ){
target = target.getParent();
}
if (target)
return target.getParent();
},
onRowMouseOver: function (evt){
var li = this.getLiParent(evt.target);
if (!li) return;
if (!this.dragging)
li.addClass('over');
this.fireEvent("mouseover", {target:this, row:li.retrieve('row'), element:li });
},
onRowMouseOut: function (evt){
var li = this.getLiParent(evt.target);
if (!li) return;
if (!this.dragging)
li.removeClass('over');
this.fireEvent("mouseout", {target:this, row:li.retrieve('row'), element:li });
},
onRowClick: function (evt){
var li = this.getLiParent(evt.target);
if (!li) return;
if (this.options.selectable)
{
var currentindex = li.retrieve('row');
var selectedNum = this.selected.length;
var dontselect = false;
if ( (!evt.control && !evt.shift) || !this.options.multipleSelection )
{
// ocisti stari selection
this.elements.each(function(el, i){ el.removeClass('selected') }, this);
//for (var i=0; i<this.selected.length; i++) this.elements[ this.selected[i] ].removeClass('selected');
this.selected = new Array();
}
if ( evt.control )
{
for (var i=0; i<selectedNum; i++)
{
if ( currentindex == this.selected[i] ) // ako je vec selektiran unselectaj ga
{
this.elements[ currentindex ].removeClass('selected');
this.selected.splice(i, 1 );
dontselect = true;
}
}
}
if ( evt.shift && this.options.multipleSelection )
{
var si = 0;
if (this.selected.length>0)
si = this.selected[selectedNum-1]; // uzmi zadnjeg
var endindex = currentindex;
startindex = Math.min(si, endindex);
endindex = Math.max(si, endindex);
//if ( !evt.control ) this.unselectAll(); // ako ne drzi shift+ctrl ocisti select
for (var i=startindex; i<=endindex; i++)
{
this.elements[i].addClass('selected');
this.selected.push( Number(i) );
}
}
if (!dontselect)
{
li.addClass('selected');
this.selected.push( Number(li.retrieve('row')) );
}
this.unique(this.selected, true); // izbaci sve duplikate iz selection arr.
}
//console.log(this.selected);
if (this.options.accordion && !this.options.openAccordionOnDblClick)
{
this.accordianOpen(li);
}
this.fireEvent("click", {indices:this.selected, target:this, row:li.retrieve('row'), element:li });
},
toggleIconClick: function(evt)
{
var li = this.getLiParent(evt.target);
this.accordianOpen(li);
},
accordianOpen: function(li)
{
var section = this.getSection(li.retrieve('row'));
if (this.options.autoSectionToggle)
{
if (this.lastsection)
if (this.lastsection != section)
{
this.lastsection.setStyle('display', 'none');
this.lastsection.getPrevious().getElement('.toggleicon').setStyle('background-position', '0 0');
}
if (!this.options.accordionRenderer)
{
section.setStyle('display', 'block');
}
}
if (this.options.accordionRenderer)
{
this.toggle( section );
}
if (this.options.showtoggleicon)
{
li.getElement('.toggleicon').setStyle('background-position', section.getStyle('display') == 'block' ? '-16px 0' : '0 0');
}
this.lastsection = section;
},
onRowDblClick: function (evt){
var li = this.getLiParent(evt.target);
if (!li) return;
var t = evt.target;
if ( this.options.editable && this.options.editondblclick && t.hasClass('td') )
{
var childs = li.getChildren();
for(var i=0; i<childs.length; i++)
{
if (childs[i] == t) break;
}
var obj = this.edit({columnIndex:i});
if (obj) obj.input.selectRange(0, obj.input.value.length);
}
if (this.options.accordion && this.options.openAccordionOnDblClick)
{
this.accordianOpen(li);
}
this.fireEvent("dblclick", {row:li.retrieve('row'), target:this, element:li});
},
onLoadData: function (data)
{
//this.hideLoader(); //u setData() jer mu nekad dosta treba da nacrta
this.setData(data);
// API
this.fireEvent("loaddata", {target:this, pkey:data.pkey}); // jedino pkey salje van jer se on nigdje ne sprema trenutno unutar OMG
},
unique: function(a, asNumber)
{
function om_sort_number(a, b)
{
return a - b;
}
var sf = asNumber ? om_sort_number : function(){};
a.sort( sf );
for (var i = 1; i < a.length; i++)
{
if (a[i-1] == a[i])
{
a.splice(i, 1);
i--;
}
}
return a;
},
// API
loadData: function (url)
{
if (!this.options.url && !this.options.dataProvider)
return;
var param = {};
// ************* pagination *************************
if (this.options.pagination)
param = {page:this.options.page, perpage:this.options.perPage};
// ************* server sorting *********************
if (this.options.serverSort){
param.sorton = this.options.sortOn;
param.sortby = this.options.sortBy;
}
if (this.options.filterInput)
{
var cfilter = this.container.getElement('input.cfilter');
if (cfilter) param.filter = cfilter.value;
}
this.showLoader();
if (this.options.dataProvider)
{
// load data throw external class
this.options.dataProvider.loadData(param);
}else
{
var url = (url != null) ? url : this.options.url;
var request = new Request.JSON({url:url, data:param});
request.addEvent("complete", this.onLoadData.bind(this) ) ;
request.get();
}
},
// API
refresh: function(){
this.loadData();
},
// API
setData: function(data, cm)
{
if (!data) return;
this.options.data = data.data;
// ako nije zadana columnModel napravi ga sam
if (!this.options.columnModel) this.setAutoColumnModel();
if (this.options.pagination)
{
this.options.page = data.page*1;
this.options.total = data.total;
this.options.maxpage = Math.ceil(this.options.total/this.options.perPage);
this.container.getElement('div.pDiv input').value = data.page;
var to = (data.page*this.options.perPage) > data.total ? data.total : (data.page*this.options.perPage);
this.container.getElement('div.pDiv .pPageStat').set('html', ((data.page-1)*this.options.perPage+1)+'..'+to+' / '+data.total);
this.container.getElement('div.pDiv .pcontrol span').set('html', this.options.maxpage);
}
if (cm)
{
// first check is new columnModel different from active one
if (this.options.columnModel != cm)
{
this.options.columnModel = cm;
// if we change columnModel then we must redraw entire component
this.draw();
}
}
this.reset();
this.hideLoader(); // kad je zavrsio sa loadanjem i crtanjem tek onda makni loader
},
// API
getData: function(){
return this.options.data;
},
// API
getDataByRow: function(row){
if (row >=0 && row<this.options.data.length)
return this.options.data[row];
},
// API
setDataByRow: function(row, data){
if (row >=0 && row<this.options.data.length)
{
this.options.data[row] = data;
this.reset();
}
},
// API
setScroll: function(x, y)
{
var bDiv = this.container.getElement('.bDiv');
new Fx.Scroll(bDiv).set(x, y);
},
// API
addRow: function(data, row){
if (row >=0)
{
// ako podataci nisu inic. napravi novi array
if (!this.options.data)
this.options.data = [];
this.options.data.splice(row, 0, data);
this.reset();
}
},
// API
deleteRow: function(row){
if (row >=0 && row<this.options.data.length)
{
this.options.data.splice(row, 1);
this.reset();
}
},
isHidden: function(i){
return this.elements[i].hasClass( this.options.filterHideCls );
},
hideWhiteOverflow: function(i){
if ( this.container.getElement('.gBlock') )
this.container.getElement('.gBlock').dispose();
var pReload = this.container.getElement('div.pDiv .pReload');
if (pReload)
pReload.removeClass('loading');
},
showWhiteOverflow: function(i){
// ************* white overflow & loader ************
if ( this.container.getElement('.gBlock') )
this.container.getElement('.gBlock').dispose();
var gBlock = new Element('div', {style:'top: 0px; left: 0px; background: white none repeat scroll 0% 0%; -moz-background-clip: -moz-initial; -moz-background-origin: -moz-initial; -moz-background-inline-policy: -moz-initial; position: absolute; z-index: 999; opacity: 0.5; filter: alpha(opacity=50'} ) ;
var bDiv = this.container.getElement('.bDiv');
var top = 1;
top += this.container.getElement('.tDiv') ? this.container.getElement('.tDiv').getSize().y : 0;
top += this.container.getElement('.hDiv') ? this.container.getElement('.hDiv').getSize().y : 0;
// height: (bDiv && bDiv.getSize().y ? bDiv.getSize().y:this.options.height)
gBlock.setStyles({width:this.options.width, height: this.options.height-1, top:0});
gBlock.addClass('gBlock');
this.container.appendChild(gBlock);
var pReload = this.container.getElement('div.pDiv .pReload');
if (pReload)
pReload.addClass('loading');
},
showLoader: function(){
if (this.loader)
return;
this.showWhiteOverflow(); // ovako bi cak mogao maknuti u sve staviti unutar showLoadera
this.loader = new Element('div');
this.loader.addClass('elementloader');
this.loader.inject(this.container);
// pozicioniranje loadera
/*var gBlock = this.container.getElement('.gBlock');
var sizeGBlock = gBlock.getSize();
var top = 0;
top += this.container.getElement('.tDiv') ? this.container.getElement('.tDiv').getSize().y : 0;
top += this.container.getElement('.hDiv') ? this.container.getElement('.hDiv').getSize().y : 0;
this.loader.setStyles({top:top+sizeGBlock.y/2-16, left: sizeGBlock.x/2});
*/
this.loader.setStyles({top:this.options.height/2-16, left: this.options.width/2});
},
hideLoader: function(){
if (!this.loader)
return;
this.hideWhiteOverflow();
this.loader.dispose();
this.loader = null;
},
// API
selectAll: function(){
this.elements.each(function(el, i){
this.selected.push(el.retrieve('row'));
el.addClass('selected');
}, this);
},
// API
unselectAll: function(){
this.elements.each(function(el, i){
el.removeClass('selected');
}, this);
this.selected = [];
},
// API
getSelectedIndices: function(){
return this.selected;
},
// API
setSelectedIndices: function(arr){
this.selected = arr;
for (var i = 0; i < arr.length; i++)
{
var li = this.elements[arr[i]];
//el.addClass('selected');
// simulate user click
this.onRowClick({target:li.getFirst(), control:false});
}
},
// mislim da je visak
onMouseOver: function(obj){
//alert(3);
obj.columnModel.onMouseOver(obj.element, obj.data);
},
// API
removeHeader: function(){
var obj = this.container.getElement('.hDiv');
if (obj) obj.empty(); //obj.set('html', ' ');
this.options.columnModel = null;
},
// API
removeAll: function(){
if (this.ulBody)
this.ulBody.empty();
this.selected = new Array();
//this.options.data = null;
},
// API
setColumnModel: function(cmu){
if ( !cmu )
return;
this.options.columnModel = cmu;
this.draw();
},
// API
setColumnProperty: function(columnName, property, value){
var cmu = this.options.columnModel;
if ( !cmu || !columnName || !property ) return;
columnName = columnName.toLowerCase();
for (var i=0; i<cmu.length; i++)
{
if ( cmu[i].dataIndex.toLowerCase() == columnName )
{
cmu[i][property] = value;
return;
}
}
},
// Automatsko odredivanje column modela ako nije zadan
setAutoColumnModel: function(){
if ( !this.options.data ) return;
var rowCount = this.options.data.length;
if ( !(rowCount>0) )
return;
this.options.columnModel = [];
// uzmi schemu od prvog podatka
for ( var cn in this.options.data[0] )
{
var dataType = typeof(this.options.data[0][cn]) == "number" ? "number" : "string";
this.options.columnModel.push({header:cn, dataIndex:cn, dataType: dataType, editable:true});
}
this.fireEvent("autocolummodel", {target:this, columnModel:this.options.columnModel});
this.draw();
},
// API
setSize: function(w, h){
// Width
this.options.width = w ? w : this.options.width;
this.container.setStyle('width', this.options.width);
var width = this.options.width-2;
if (this.options.buttons) this.container.getElement('.tDiv').setStyle('width', width);
var hDiv = this.container.getElement('.hDiv');
if (this.options.showHeader && hDiv) hDiv.setStyle('width', width);
var bodyEl = this.container.getElement('.bDiv');
bodyEl.setStyle('width', width);
this.container.getElement('.pDiv').setStyle('width', width);
// Height
this.options.height = h ? h : this.options.height;
bodyEl.setStyle('height', this.getBodyHeight() );
this.container.setStyle('height', this.options.height);
// ako je kojim slucajem whiteOverflow namjesti
var gBlock = this.container.getElement('.gBlock');
if (gBlock)
gBlock.setStyles({width:this.options.width, height: bodyEl.getSize().y });
},
onBodyScroll: function(){
var hbox = this.container.getElement('.hDivBox');
var bbox = this.container.getElement('.bDiv');
var xs = bbox.getScroll().x;
//hbox.setStyle('position', 'relative');
hbox.setStyle('left', -xs);
this.rePosDrag();
//console.debug(xs);
},
onBodyClick: function(){
},
onBodyMouseOver: function(){
//console.debug(this.onBodyScrollID);
},
onBodyMouseOut: function(){
},
// ************************************************************************
// ************************* Drag columns events **************************
// ************************************************************************
rePosDrag: function(){
if (!this.options.resizeColumns)
return;
var dragTempWidth = 0;
var cDrags = this.container.getElements('.cDrag div');
var scrollX = this.container.getElement('div.bDiv').getScroll().x;
for (var c = 0; c < this.options.columnModel.length; c++) {
var columnModel = this.options.columnModel[c];
//if (columnModel.hidden) continue;
// hidden-1
var dragSt = cDrags[c];
dragSt.setStyle('left', dragTempWidth+columnModel.width+(Browser.Engine.trident ? 1 : 1 )-scrollX);
//console.log(dragTempWidth+columnModel.width+2);
if (!columnModel.hidden)
dragTempWidth += columnModel.width;
}
},
onColumnDragComplete: function(target){
this.dragging = false;
var colindex = target.retrieve('column');
// nadi poziciju prvo
var cDrag = this.container.getElement('div.cDrag');
var dragSt = cDrag.getElements('div')[colindex];
var scrollX = this.container.getElement('div.bDiv').getScroll().x;
// izracunaj nove ukupne duljine
this.sumWidth = 0;
for (var c = 0; c < this.options.columnModel.length; c++) {
var columnModel = this.options.columnModel[c];
//if (columnModel.hidden) continue;
if (c == colindex)
{
// nova vrijednost pomaknute kolone
var pos = dragSt.getStyle('left').toInt()+scrollX-this.sumWidth-(Browser.Engine.trident ? -1 : 1 ); // zato sto je u dragSt.left +2
}else if (!columnModel.hidden)
this.sumWidth += columnModel.width;
}
//console.log(pos);
if (pos<30) // minimalna velicina kolone
pos = 30
this.options.columnModel[colindex].width = pos;
this.sumWidth += pos;
//console.log(this.sumWidth);
this.ulBody.setStyle('width', this.sumWidth+this.visibleColumns*(Browser.Engine.trident ? 1 : 1 ));
var hDivBox = this.container.getElement('div.hDivBox');
hDivBox.setStyle('width', this.sumWidth+this.visibleColumns*2);
// header
var columns = hDivBox.getElements('div.th');
var columnObj = columns[colindex];
columnObj.setStyle('width', pos-(Browser.Engine.trident ? 6 : 6 ));
var visibleColumns = this.visibleColumns; // radi this. u each-u
// radi accordiana
var elements = this.ulBody.getElements('li.tr');
// sve kolone u body
elements.each(function(el, i){
el.setStyle('width', this.sumWidth+2*visibleColumns); // inace se Div-ovi wrapaju
if (!el.hasClass('section'))
{
var columns = el.getElements('div.td');
var columnObj = columns[colindex];
columnObj.setStyle('width', pos-(Browser.Engine.trident ? 6 : 6 ));
}
});
this.rePosDrag();
},
onColumnDragStart: function(target){
this.dragging = true;
},
onColumnDragging: function(target){
target.setStyle('top', 1);
},
overDragColumn: function(evt){
evt.target.addClass('dragging');
},
outDragColumn: function(evt){
evt.target.removeClass('dragging');
},
// ************************************************************************
// ************************* Header events ********************************
// ************************************************************************
clickHeaderColumn: function(evt){
if (this.dragging) return;
var colindex = evt.target.retrieve('column');
var columnModel = this.options.columnModel[colindex];
evt.target.removeClass(columnModel.sort);
columnModel.sort = (columnModel.sort == 'ASC') ? 'DESC' : 'ASC';
evt.target.addClass(columnModel.sort);
//hidden-1
this.sort(colindex);
},
overHeaderColumn: function(evt){
if (this.dragging) return;
var colindex = evt.target.retrieve('column');
var columnModel = this.options.columnModel[colindex];
evt.target.addClass(columnModel.sort);
},
outHeaderColumn: function(evt){
if (this.dragging) return;
var colindex = evt.target.retrieve('column');
var columnModel = this.options.columnModel[colindex];
evt.target.removeClass(columnModel.sort);
},
getBodyHeight: function(){
// da ukupna visina cijelog grida bude this.options.height za body moramo oduzeti header
// header
var headerHeight = this.options.showHeader ? 24+2 : 0; //+2 radi bordera
// toolbar
var toolbarHeight = this.options.buttons ? this.container.getElement('.tDiv').getStyle('height').toInt() : 0;
// pagination toolbar height 25px + 1px bottom border
var paginationToolbar = this.options.pagination ? 26 : 0;
return this.options.height-headerHeight-toolbarHeight-paginationToolbar-2; //+2 radi bordera
},
renderData: function(){
this.ulBody.empty();
this.inlineEditSafe = null;
if (this.options.data && this.options.data.length)
{
var columnCount = this.options.columnModel.length;
var rowCount = this.options.data.length;
for (var r=0; r<rowCount; r++)
{
var rowdata = this.options.data[r];
var li = new Element('li');
li.setStyle('width', this.sumWidth+2*this.visibleColumns); // inace se Div-ovi wrapaju, a u IE nastaje cudan 1px border ispod LI el.
li.store('row', r);
li.addClass('tr');
this.ulBody.appendChild(li);
if (this.options.tooltip)
{
this.options.tooltip.attach( tr );
}
var firstvisible = -1;
for (var c=0; c<columnCount; c++)
{
var columnModel = this.options.columnModel[c];
//if (columnModel.hidden)
// continue;
var div = new Element('div');
div.addClass('td');
div.setStyle('width', columnModel.width-6); // zbog paddinga u ff
//div.setStyle('overflow-x', 'hidden');
li.appendChild(div);
firstvisible = (!columnModel.hidden && firstvisible == -1) ? c : firstvisible;
var toggleicon = "";
if (firstvisible==c && this.options.accordion && this.options.showtoggleicon)
{
toggleicon = "<div class='toggleicon'></div>";
}
if (columnModel.hidden) div.setStyle('display', 'none');
if (columnModel.onMouseOver)
{
div.onmouseover = this.onMouseOver.bind(this, {element:div, columnModel:columnModel, data:rowdata });
}
// title
if (columnModel.title) div.title = rowdata[columnModel.title];
if (columnModel.dataType == "checkbox")
{
var input = new Element('input', {type:"checkbox"});
if (columnModel.onChange)
{
input.onclick = this.onSelect.bind(this, {columnModel:columnModel, row:r, input:input});
}
div.appendChild(input);
var val = rowdata[columnModel.dataIndex];
if ( val == 1 || val=='t') {
input.set('checked', true);
}
}else if (columnModel.type == "image") {
/* var img = new Element('img');
img.src = this.options.data[r][columnModel.dataIndex];
td.appendChild(img);*/
}else if (columnModel.type == 'custom') {
//columnModel.labelFunction(td, this.options.data[r], r);
}else if (columnModel.labelFunction != null) {
div.innerHTML = columnModel.labelFunction(rowdata, r, columnModel);
}else {
var str = new String(rowdata[columnModel.dataIndex]); // mora biti string, jer ako dode 0 kao broj error
if (str == null || str == 'null' || str == 'undefined' || str == "" ) str = ' ';
var trimmed = str.replace(/^\s+|\s+$/g, ''); // ako je prazan string
if(trimmed.length==0) str = ' ';
// Column text align propert.
// moram prije srediti racunanje width radi padding:0 kad se aling
//if (columnModel.align) div.setStyles({'text-align': columnModel.align, 'padding-left':0});
div.innerHTML = toggleicon+str;
// *** reg. event to toggleicon ***
if (firstvisible==c && this.options.accordion && this.options.showtoggleicon)
{
div.getElement('.toggleicon').addEvent('click', this.toggleIconClick.bind(this));
}
}
} // for column
// ***********************
if (this.options.accordion)
{
/* var div = new Element('div');
div.addClass('section');
li.appendChild(div);
*/
var li2 = new Element('li');
li2.addClass('section');
li2.addClass('section-'+r);
li2.setStyle('width', this.sumWidth+2*this.visibleColumns); // inace se Div-ovi wrapaju, a u IE nastaje cudan 1px border ispod LI el.
this.ulBody.appendChild(li2);
if (this.options.accordionRenderer)
this.options.accordionRenderer({parent:li2, row:r, grid:this, rowdata: rowdata});
}
}
}
},
// ************************************************************************
// ************************* Main draw function ***************************
// ************************************************************************
draw: function(){
this.removeAll(); // reset variables and only empty ulBody
this.container.empty(); // empty all
// ************************************************************************
// ************************* Common ***************************************
// ************************************************************************
var width = this.options.width - (Browser.Engine.trident ? 2 : 2 ); //-2 radi bordera
var columnCount = this.options.columnModel ? this.options.columnModel.length : 0;
// ************************************************************************
// ************************* Container ************************************
// ************************************************************************
if (this.options.width) this.container.setStyle('width', this.options.width);
this.container.addClass('omnigrid');
// ************************************************************************
// ************************* Toolbar **************************************
// ************************************************************************
if (this.options.buttons)
{
var tDiv = new Element('div');
tDiv.addClass('tDiv');
tDiv.setStyle('width', width);
tDiv.setStyle('height', 25+(Browser.Engine.trident ? 2 : 0 ));// borderi u FF
this.container.appendChild(tDiv);
var bt = this.options.buttons;
for (var i = 0; i < bt.length; i++) {
var fBt = new Element('div');
tDiv.appendChild(fBt);
if (bt[i].separator)
{
fBt.addClass('btnseparator');
continue;
}
fBt.addClass('fbutton');
var cBt = new Element('div');
cBt.addEvent('click', bt[i].onclick.bind(this, [bt[i].bclass, this]));
cBt.addEvent('mouseover', function(){this.addClass('fbOver'); });
cBt.addEvent('mouseout', function(){this.removeClass('fbOver'); });
fBt.appendChild(cBt);
var spanBt = new Element('span');
spanBt.addClass(bt[i].bclass);
spanBt.setStyle('padding-left', 20 );
spanBt.set('html', bt[i].name);
cBt.appendChild(spanBt);
}
}
// ************************************************************************
// ************************* Header ***************************************
// ************************************************************************
var hDiv = new Element('div');
hDiv.addClass('hDiv');
hDiv.setStyle('width', width ); // borderi u FF
this.container.appendChild(hDiv);
var hDivBox = new Element('div');
hDivBox.addClass('hDivBox');
hDiv.appendChild(hDivBox);
this.sumWidth = 0;
this.visibleColumns = 0; // razlikuje se od columnCount jer podaci za neke kolone su ocitani ali se ne prikazuju, npr. bitno kod li width
for (var c = 0; c < columnCount; c++) {
var columnModel = this.options.columnModel[c];
var div = new Element('div');
// ******************************************
// ****** default postavke columnModela *****
if (columnModel.width == null) this.options.columnModel[c].width = 100;
columnModel.sort = 'ASC';
// ******************************************
// ********************** Header events **************************
if (this.options.sortHeader)
{
div.addEvent('click', this.clickHeaderColumn.bind(this));
div.addEvent('mouseout', this.outHeaderColumn.bind(this));
div.addEvent('mouseover', this.overHeaderColumn.bind(this));
}
div.store('column', c);
div.store('dataType', columnModel.dataType);
div.addClass('th');
div.setStyle('width', columnModel.width-(Browser.Engine.trident ? 6 : 6 ));
hDivBox.appendChild(div);
if (columnModel.hidden)
div.setStyle('display', 'none');
else{
this.sumWidth += columnModel.width;
this.visibleColumns++;
}
var header = columnModel.header;
if (header)
div.innerHTML = header;
}
hDivBox.setStyle('width', this.sumWidth+this.visibleColumns*2);
if (!this.options.showHeader)
hDiv.setStyle('display', 'none');
// ************************************************************************
// ************************* Column size drag *****************************
// ************************************************************************
// odredivanje visine body dijela
if (this.options.height)
{
var bodyHeight = this.getBodyHeight();
this.container.setStyle('height', this.options.height);
}
if (this.options.resizeColumns)
{
var cDrag = new Element('div');
cDrag.addClass('cDrag');
var toolbarHeight = this.options.buttons ? tDiv.getStyle('height').toInt() : 0; // toolbar
cDrag.setStyle('top', toolbarHeight);
this.container.appendChild(cDrag);
var dragTempWidth = 0;
for (var c = 0; c < columnCount; c++) {
var columnModel = this.options.columnModel[c];
//if (columnModel.hidden) continue;
var dragSt = new Element('div');
//alert(dragTempWidth+' '+columnModel.width);
// -(Browser.Engine.trident ? 10 : 0 )
var headerHeight = this.options.showHeader ? 24+2 : 0; // +2 border
dragSt.setStyles({top:1,left: dragTempWidth+columnModel.width, height: headerHeight, display:'block'}); // bodyHeight+
dragSt.store('column', c);
cDrag.appendChild(dragSt);
// Events
dragSt.addEvent('mouseout', this.outDragColumn.bind(this));
dragSt.addEvent('mouseover', this.overDragColumn.bind(this));
var dragMove = new Drag(dragSt, {snap:0}); // , {container: this.container.getElement('.cDrag') }
dragMove.addEvent('drag', this.onColumnDragging.bind(this) );
dragMove.addEvent('start', this.onColumnDragStart.bind(this) );
dragMove.addEvent('complete', this.onColumnDragComplete.bind(this) );
if (columnModel.hidden)
dragSt.setStyle('display', 'none');
else
dragTempWidth += columnModel.width;
}
}
// ************************************************************************
// ************************* Body *****************************************
// ************************************************************************
var bDiv = new Element('div');
bDiv.addClass('bDiv');
if (this.options.width)
bDiv.setStyle('width', width);
bDiv.setStyle('height', bodyHeight);
this.container.appendChild(bDiv);
// scroll event
this.onBodyScrollBind = this.onBodyScroll.bind(this);
bDiv.addEvent('scroll', this.onBodyScrollBind);
//alert(this.visibleColumns);
this.ulBody = new Element('ul');
this.ulBody.setStyle('width', this.sumWidth+this.visibleColumns*(Browser.Engine.trident ? 1 : 1 )); // da se ne vidi visak, ul je overflow hidden
bDiv.appendChild(this.ulBody);
if (this.options.pagination && !this.container.getElement('div.pDiv') )
{
var pDiv = new Element('div');
pDiv.addClass('pDiv');
pDiv.setStyle('width', width);
pDiv.setStyle('height', 25);
this.container.appendChild(pDiv);
var pDiv2 = new Element('div');
pDiv2.addClass('pDiv2');
pDiv.appendChild(pDiv2);
var h = '<div class="pGroup"><select class="rp" name="rp">';
// *****
var optIdx;
var setDefaultPerPage = false;
for (optIdx=0; optIdx<this.options.perPageOptions.length; optIdx++)
{
if (this.options.perPageOptions[optIdx] != this.options.perPage)
h += '<option value="' + this.options.perPageOptions[optIdx] + '">' + this.options.perPageOptions[optIdx] +'</option>';
else{
setDefaultPerPage = true;
h += '<option selected="selected" value="' + this.options.perPageOptions[optIdx] + '">' + this.options.perPageOptions[optIdx] +'</option>' ;
}
}
// *****
h += '</select></div>';
h += '<div class="btnseparator"></div><div class="pGroup"><div class="pFirst pButton"></div><div class="pPrev pButton"></div></div>';
h += '<div class="btnseparator"></div><div class="pGroup"><span class="pcontrol"><input class="cpage" type="text" value="1" size="4" style="text-align:center"/> / <span></span></span></div>';
h += '<div class="btnseparator"></div><div class="pGroup"><div class="pNext pButton"></div><div class="pLast pButton"></div></div>';
h += '<div class="btnseparator"></div><div class="pGroup"><div class="pReload pButton"></div></div>';
h += '<div class="btnseparator"></div><div class="pGroup"><span class="pPageStat"></div>';
if (this.options.filterInput) h += '<div class="btnseparator"></div><div class="pGroup"><span class="pcontrol"><input class="cfilter" type="text" value="" style="" /><span></div>';
pDiv2.innerHTML = h;
// set this.options.perPage value from this.options.perPageOptions array
var rpObj = pDiv2.getElement('.rp');
if (!setDefaultPerPage && rpObj.options.length>0)
{
this.options.perPage = rpObj.options[0].value;
rpObj.options[0].selected = true;
}
// ********
pDiv2.getElement('.pFirst').addEvent('click', this.firstPage.bind(this) );
pDiv2.getElement('.pPrev').addEvent('click', this.prevPage.bind(this) );
pDiv2.getElement('.pNext').addEvent('click', this.nextPage.bind(this) );
pDiv2.getElement('.pLast').addEvent('click', this.lastPage.bind(this) );
pDiv2.getElement('.pReload').addEvent('click', this.refresh.bind(this) );
pDiv2.getElement('.rp').addEvent('change', this.perPageChange.bind(this));
pDiv2.getElement('input.cpage').addEvent('keyup', this.pageChange.bind(this) );
if (this.options.filterInput) pDiv2.getElement('input.cfilter').addEvent('change', this.firstPage.bind(this) ); // goto 1 & refresh
}
},
firstPage: function(){
this.options.page = 1;
this.refresh();
},
prevPage: function(){
if (this.options.page>1){
this.options.page--;
this.refresh();
}
},
nextPage: function(){
if( (this.options.page+1) > this.options.maxpage)
return;
this.options.page++;
this.refresh();
},
lastPage: function(){
this.options.page = this.options.maxpage;
this.refresh();
},
perPageChange: function(){
this.options.page = 1;
this.options.perPage = this.container.getElement('.rp').value;
this.refresh();
},
pageChange: function(){
var np = this.container.getElement('div.pDiv2 input').value;
if (np>0 && np<=this.options.maxpage)
{
if (this.refreshDelayID)
$clear(this.refreshDelayID)
this.options.page = np;
this.refreshDelayID = this.refresh.delay(1000, this);
}
},
// API
gotoPage: function(p){
if (p>0 && p<=this.options.maxpage)
{
this.options.page = p;
this.refresh();
}
},
setPerPage: function(p){
if (p>0)
{
this.options.perPage = p;
this.refresh();
}
},
// API, not doc
sort: function(index, by){
if ( index<0 || index>=this.options.columnModel.length )
return;
if(this.options.onStart){
this.fireEvent('onStart');
}
//
var header = this.container.getElements('.th');
var el = header[index];
if (by != null)
el.addClass(by.toLowerCase());
if(el.hasClass('ASC')){
el.sortBy = 'ASC';
}else if(el.hasClass('DESC')){
el.sortBy = 'DESC';
}
if (this.options.serverSort){
this.options.sortOn = this.options.columnModel[index].dataIndex;
this.options.sortBy = el.sortBy;
this.refresh();
}else{
// Sorting...
this.elements.sort(el.compare);
this.elements.injectInside(this.ulBody);
// Update selection array because indices has been changed
this.selected = new Array();
this.elements.each(function(el ,i){
if(el.hasClass('selected')){
this.selected.push(el.retrieve('row'));
}
}, this);
// Filter
if(this.filtered){
this.filteredAltRow();
}else{
this.altRow();
}
}
},
altRow: function(){
this.elements.each(function(el,i){
if(i % 2){
el.removeClass('erow');
}else{
el.addClass('erow');
}
});
},
filteredAltRow: function(){
this.ulBody.getElements('.'+this.options.filterSelectedCls).each(function(el,i){
if(i % 2){
el.removeClass('erow');
}else{
el.addClass('erow');
}
});
},
// API
filter: function(form){
//var form = $(form);
var col = 0;
var key = '';
if ( !(form.length>0) )
this.clearFilter();
key = form;
if(key)
{
for (var i=0; i<this.options.data.length; i++)
{
var dat = this.options.data[i];
for (var c=0; c<this.options.columnModel.length; c++)
{
var columnModel = this.options.columnModel[c];
if ( columnModel.type == "checkbox")
continue;
var el = this.elements[i];
if(this.options.filterHide){
el.removeClass('erow');
}
if(dat[columnModel.dataIndex] != null && dat[columnModel.dataIndex].toLowerCase().indexOf(key) > -1)
{
el.addClass(this.options.filterSelectedCls);
if(this.options.filterHide){
el.removeClass(this.options.filterHideCls);
}
break;
}else{
el.removeClass(this.options.filterSelectedCls);
if(this.options.filterHide){
el.addClass(this.options.filterHideCls);
}
}
}
}
if(this.options.filterHide){
this.filteredAltRow();
this.filtered = true;
}
}
},
// API
clearFilter: function(){
this.elements.each(function(el,i){
el.removeClass(this.options.filterSelectedCls);
if(this.options.filterHide){
el.removeClass(this.options.filterHideCls);
}
}, this);
if(this.options.filterHide){
this.altRow();
this.filtered = false;
}
}
});
/*************************************************************/
|
/* jshint node:true */
/*global describe:true, it:true, before:true, beforeEach:true */
"use strict";
// # Tests for mongo-concept-network-state module
// ## Required libraries
var assert = require('assert');
// Module to test
var ConceptNetwork = require('../lib/mongo-concept-network').ConceptNetwork;
var ConceptNetworkState = require('../lib/mongo-concept-network-state')
.ConceptNetworkState;
// ## ConceptNetwork
describe('ConceptNetworkState', function () {
// ### Constructor
describe('#Constructor', function () {
it('should throw an exception if no ConceptNetwork is given', function () {
assert.throws(function () {
var cns = new ConceptNetworkState();
},
Error);
});
it('should not throw an exception', function () {
assert.doesNotThrow(function () {
var cn = new ConceptNetwork("test");
var cns = new ConceptNetworkState(cn);
}, null, "unexpected error");
});
});
describe('#activate', function () {
var cn, cns, node1;
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.addNode("Node 1", function (node) {
node1 = node;
done();
});
});
it('should put the node activation to 100', function (done) {
cns.activate(node1._id, function (nodeState) {
assert.equal(nodeState.activationValue, 100);
done();
});
});
});
describe('#getters', function () {
var cn, cns, node1, node2, node3;
describe('##getActivationValue', function () {
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.addNode("Node 1", function (node) {
node1 = node;
cn.addNode("Node 2", function (node) {
node2 = node;
cns.activate(node1._id, function (nodeState) {
done();
});
});
});
});
it('should get a zero activation value', function (done) {
cns.getActivationValue(node2._id, function (activationValue) {
assert.equal(activationValue, 0);
done();
});
});
it('should get a 100 activation value', function (done) {
cns.getActivationValue(node1._id, function (activationValue) {
assert.equal(activationValue, 100);
done();
});
});
});
describe('##getOldActivationValue', function () {
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.addNode("Node 1", function (node) {
node1 = node;
cn.addNode("Node 2", function (node) {
node2 = node;
cns.activate(node1._id, function (nodeState) {
cns.propagate(function () { done(); });
});
});
});
});
it('should get a zero activation value', function (done) {
cns.getOldActivationValue(node2._id, function (activationValue) {
assert.equal(activationValue, 0);
done();
});
});
it('should get a 100 activation value', function (done) {
cns.getActivationValue(node1._id, function (activationValue) {
assert.equal(activationValue, 100);
done();
});
//assert.deepEqual(cns.getOldActivationValue(node1.id), 100);
});
});
describe('##getMaximumActivationValue', function () {
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.db.conceptnetwork.remove()
.then(function () {
cn.addNode("Node 1", function (node) {
node1 = node;
cn.addNode("sNode 2", function (node) {
node2 = node;
cn.addNode("tNode 3", function (node) {
node3 = node;
done();
});
});
});
});
});
it('should return 0 when no node is activated', function (done) {
cns.getMaximumActivationValue(function (maximumActivationValue) {
assert.equal(maximumActivationValue, 0);
done();
});
});
it('should get the maximum activation value for any token', function (done) {
cns.setActivationValue(node1._id, 75, function () {
cns.setActivationValue(node2._id, 70, function () {
cns.setActivationValue(node3._id, 50, function () {
cns.getMaximumActivationValue(function (maximumActivationValue) {
assert.equal(maximumActivationValue, 75);
done();
});
});
});
});
});
it('should get the maximum activation value for s tokens', function (done) {
cns.setActivationValue(node1._id, 75, function () {
cns.setActivationValue(node2._id, 70, function () {
cns.setActivationValue(node3._id, 50, function () {
cns.getMaximumActivationValue('s', function (maximumActivationValue) {
assert.equal(maximumActivationValue, 70);
done();
});
});
});
});
});
});
describe('##getActivatedTypedNodes', function () {
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.db.conceptnetwork.remove()
.then(function () {
cn.addNode("Node 1", function (node) {
node1 = node;
cn.addNode("sNode 2", function (node) {
node2 = node;
cn.addNode("tNode 3", function (node) {
node3 = node;
done();
});
});
});
});
});
it('should return an empty array', function () {
cns.getActivatedTypedNodes(function (activatedNodes) {
assert.deepEqual(activatedNodes, []);
});
});
it('should return one-node-array', function () {
cns.setActivationValue(node1._id, 100, function () {
cns.getActivatedTypedNodes(function (result) {
assert.deepEqual(result,
[{"node": {"id": node1._id, "label": "Node 1", "occ": 1},
"activationValue": 100}]);
});
});
});
it('should return two-nodes-array', function () {
cns.setActivationValue(node2._id, 95, function () {
cns.getActivatedTypedNodes(function (result) {
assert.deepEqual(result,
[
{"node": {"id": node1._id, "label": "Node 1", "occ": 1},
"activationValue": 100},
{"node": {"id": node2._id, "label": "sNode 2", "occ": 1},
"activationValue": 95}
]);
});
});
});
it('should return one-node-array of type s', function () {
cns.getActivatedTypedNodes("s", function (result) {
assert.deepEqual(result,
[
{"node": {"id": node2._id, "label": "sNode 2", "occ": 1},
"activationValue": 95}
]);
});
});
it('should return one-node-array where threshold = 96', function () {
cns.getActivatedTypedNodes('', 96, function (result) {
assert.deepEqual(result,
[{"node": {"id": node1._id, "label": "Node 1", "occ": 1},
"activationValue": 100}]);
});
});
});
});
describe('#setters', function () {
var cn, cns, node1, node2;
describe('##setActivationValue', function () {
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.db.conceptnetwork.remove()
.then(function () {
cn.addNode("Node 1", function (node) {
node1 = node;
cn.addNode("Node 2", function (node) {
node2 = node;
done();
});
});
});
});
it('should set a zero activation value', function (done) {
cns.setActivationValue(node2._id, 0, function () {
cns.getActivationValue(node2._id, function (activationValue) {
assert.deepEqual(activationValue, 0);
done();
});
});
});
it('should set a 75 activation value', function (done) {
cns.setActivationValue(node1._id, 75, function () {
cns.getActivationValue(node1._id, function (activationValue) {
assert.deepEqual(activationValue, 75);
done();
});
});
});
});
});
describe('#propagate', function () {
var cn, cns, node1, node2, link12;
before(function (done) {
cn = new ConceptNetwork("test");
cns = new ConceptNetworkState(cn);
cn.db.conceptnetwork.remove()
.then(function () {
cn.addNode("Node 1", function (node) {
node1 = node;
cn.addNode("Node 2", function (node) {
node2 = node;
cn.addLink(node1._id, node2._id, function (link) {
link12 = link;
done();
});
});
});
});
});
it('should deactivate node without afferent links', function (done) {
cns.activate(node1._id, function (node) {
cns.getActivationValue(node1._id, function (activationValue) {
assert.equal(activationValue, 100);
cns.propagate(function () {
cns.getActivationValue(node1._id, function (activationValue) {
assert(activationValue < 100,
"activationValue should be less than 100");
done();
});
});
});
});
});
it('should activate node 2', function (done) {
cns.getActivationValue(node2._id, function (activationValue) {
assert.ok(activationValue > 0,
"activationValue should be strictly positive");
done();
});
});
});
});
|
process.env.NODE_ENV = (process.env.NODE_ENV || 'development').trim();
import path from 'path';
import { argv } from 'yargs';
const config = new Map();
// ------------------------------------
// Environment
// ------------------------------------
config.set('env', process.env.NODE_ENV);
config.set('globals', {
'process.env' : {
'NODE_ENV' : JSON.stringify(config.get('env'))
},
'NODE_ENV' : config.get('env'),
'__DEV__' : config.get('env') === 'development',
'__PROD__' : config.get('env') === 'production',
'__DEBUG__' : !!argv.debug,
'__DEBUG_NW__' : !!argv.nw
});
// ------------------------------------
// Server
// ------------------------------------
config.set('server_host', 'localhost');
config.set('server_port', process.env.PORT || 4000);
// ------------------------------------
// Webpack
// ------------------------------------
config.set('webpack_port', 3000);
config.set('webpack_public_path',
`http://${config.get('server_host')}:${config.get('webpack_port')}/`
);
// build options
config.set('webpack_lint_in_dev', true);
// ------------------------------------
// Project
// ------------------------------------
config.set('path_project', path.resolve(__dirname, '../'));
config.set('dir_src', 'client');
config.set('dir_dist', 'dist');
config.set('vendor_dependencies', [
'history',
'immutable',
'react',
'react-redux',
'react-router',
'redux',
'redux-devtools',
'redux-devtools/lib/react'
]);
// ------------------------------------
// Utilities
// ------------------------------------
const paths = (() => {
const base = [config.get('path_project')],
resolve = path.resolve;
const project = (...args) => resolve.apply(resolve, [...base, ...args]);
return {
project : project,
src : project.bind(null, config.get('dir_src')),
dist : project.bind(null, config.get('dir_dist'))
};
})();
config.set('utils_paths', paths);
config.set('utils_aliases', [
'actions',
'components',
'constants',
'containers',
'dispatchers',
'layouts',
'models',
'reducers',
'routes',
'services',
'stores',
'styles',
'utils',
'views'
].reduce((acc, x) => ((acc[x] = paths.src(x)) && acc), {}));
export default config;
|
module.exports = function() {
return {
module: {
rules: [
/**
* ```
* npm i file-loader --save-dev
* ```
*
* Instructs webpack to emit the required object as file and to return its public URL
* [github]{@link https://github.com/webpack-contrib/file-loader}
* [npm]{@link https://www.npmjs.com/package/file-loader}
* [Documentation]{@link https://webpack.js.org/concepts/loaders/}
*
*/
{
test: /\.(eot|svg|cur|png|jpg|gif)$/,
loader: 'file-loader',
options: {
// name: '[name].[hash:20].[ext]',
},
},
],
},
};
};
|
/**
* @license Copyright (c) 2003-2016, CKSource - Frederico Knabben. All rights reserved.
* For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'language', 'it', {
button: 'Imposta lingua',
remove: 'Rimuovi lingua'
} );
|
"use strict";
app.config(['$stateProvider', '$locationProvider', function ($stateProvider, $locationProvider) {
// 设定路由
$stateProvider
.state('otherAProduct', { //app首页
url: "/others/A",
templateUrl: "pages/others/A/a.html",
controller: "otherAProductController"
})
}]).controller('otherAProductController', ['$scope', '$rootScope', '$stateParams', '$location', '$http', function ($scope, $rootScope, $stateParams, $location, $http) {
$scope.activeTag = "csrtc";
$scope.pageType = 'A';
$scope.category = systemName + "_csrtc_" + $scope.pageType;
writebdLog($scope.category, "_Load", "渠道号", $scope.gh);
$scope.products = [
{
id: 424,
name: '健维宝1罐 + 神酒1瓶 + 干果1盒 送鲜果蜜1盒',
price: 398,
select: true
},
{
id: 425,
name: '春砂仁干果2盒 送鲜果蜜1盒',
price: 298,
select: false
},
{
id: 426,
name: '春砂仁健维宝2罐',
price: 298,
select: false
},
{
id: 427,
name: '春之神酒2瓶',
price: 298,
select: false
},
{
id: 428,
name: '春砂仁鲜果蜜2盒',
price: 198,
select: false
}
];
$scope.$root.share = {
homeLink: 'http://' + window.location.host + '/others/A' + window.location.search,
shareTitle: '春砂仁，您的养胃专家，广东阳春源产地生产，良心品质！',
shareDisc: '养胃首选春砂仁，多种吃法，老少咸宜，套餐限时特价398元，再送鲜果密一盒！货到付款，先到先得！',
picUrl: 'http://' + window.location.host + '/images/others/A/nativeShare.jpg'
};
$scope.mainProduct = $scope.products[0];
$scope.selectProduct = function (product) {
$scope.mainProduct = product;
writebdLog($scope.category, "_SelectPackage", "渠道号", $scope.gh);
};
var objGetters = new Array();
for (var i = 0; i <= 10; i++) {
objGetters.push(
{
txt: getRandomReceiverPhone() + " 购买了春砂仁鲜果蜜2盒 <span>" + getRanDomTime() + "分钟前</span>"
}
);
}
$scope.getters = objGetters;
$scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
//下面是在数据 render完成后执行的js
$(".getters").slide({
mainCell: "ul",
autoPage: true,
effect: "topMarquee",
autoPlay: true,
interTime: 50,
vis: 5
});
});
$container = $(".content-scrollable");
$scope.goToSelect = function () {
var $scrollTo = $('.select-area');
$container.animate({
scrollTop: $scrollTo.offset().top - $container.offset().top + $container.scrollTop()
});
writebdLog($scope.category, "_ToSelect", "渠道号", $scope.gh); //立即订购
};
$scope.goTo = function (target) {
var $scrollTo = $(target);
$container.animate({
scrollTop: $scrollTo.offset().top - $container.offset().top + $container.scrollTop()
});
};
$scope.getContact = function () {
writebdLog($scope.category, "_CustConsult", "渠道号", $scope.gh); //客服咨询
};
$scope.checkBuyHistory = function () {
};
$scope.submitForm = function (e, value) {
var $form = $("#checkoutForm");
if (!$scope.checkAddress()) {
$scope.goTo('#receiverAddress');
return false;
}
if (!$scope.$root.checkActiveCode()) {
$scope.goTo('#receiverAddress');
return false;
}
$scope.$root.toast.open();
$http.jsonp(cfApi.apiHost + '/product/checkOrderCount.html?receiverMobile=' + $scope.checkoutForm.receiverMobile.$modelValue + '&productId=' + $scope.mainProduct.id + '&s=wap&time=' + new Date().getTime() + '&callback=JSON_CALLBACK').success(function (data, status, headers, config) {//查看是否下过单
if (data.result) {
$form.submit();
$scope.$root.toast.close();
writebdLog($scope.category, "_" + value, "渠道号", $scope.gh);//立即支付
} else {
$scope.$root.toast.close();
$scope.$root.appDialog.open('', '您已购买过该商品，确认要再买一单吗？');
}
});
};
$scope.$watch('btnType', function (n, o, $scope) {
if (n !== o && n !== undefined) {
if(n){
var $form = $("#checkoutForm");
$form.submit();
}
}
});
}]); |
test('.lg()', 8, function () {
equal(MathLib.lg(1), 0, 'MathLib.lg(1) should be 0');
equal(MathLib.lg(10), 1, 'MathLib.lg(10) should be 1');
equal(MathLib.lg(+Infinity), +Infinity, 'MathLib.lg(+Infinity) should be +Infinity');
equal(MathLib.lg(+0), -Infinity, 'MathLib.lg(+0) should be -Infinity');
equal(MathLib.lg(-0), -Infinity, 'MathLib.lg(-0) should be -Infinity');
equal(MathLib.isNaN(MathLib.lg(-4)), true, 'MathLib.lg(-4) should be NaN');
equal(MathLib.isNaN(MathLib.lg(-Infinity)), true, 'MathLib.lg(-Infinity) should be NaN');
equal(MathLib.isNaN(MathLib.lg(NaN)), true, 'MathLib.lg(NaN) should be NaN');
}); |
module.exports = function (value, settings) {
let text = `Volume: ${value}`
return [{
'fallback': text,
'color': settings.color,
'title': text
}]
}
|
var $M = require("@effectful/debugger"),
$x = $M.context,
$ret = $M.ret,
$unhandled = $M.unhandled,
$brk = $M.brk,
$mcall = $M.mcall,
$m = $M.module("file.js", null, typeof module === "undefined" ? null : module, null, "$", {
__webpack_require__: typeof __webpack_require__ !== "undefined" && __webpack_require__
}, null),
$s$1 = [{
a: [1, "1:9-1:10"]
}, null, 0],
$s$2 = [{}, $s$1, 1],
$m$0 = $M.fun("m$0", "file.js", null, null, [], 0, 2, "1:0-7:0", 32, function ($, $l, $p) {
for (;;) switch ($.state = $.goto) {
case 0:
$l[1] = $m$1($);
$.goto = 2;
continue;
case 1:
$.goto = 2;
return $unhandled($.error);
case 2:
return $ret($.result);
default:
throw new Error("Invalid state");
}
}, null, null, 0, [[0, "1:0-6:1", $s$1], [16, "7:0-7:0", $s$1], [16, "7:0-7:0", $s$1]]),
$m$1 = $M.fun("m$1", "a", null, $m$0, [], 0, 1, "1:0-6:1", 0, function ($, $l, $p) {
for (;;) switch ($.state = $.goto) {
case 0:
$.goto = 1;
$brk();
$.state = 1;
case 1:
$.goto = 2;
$p = ($x.call = eff)("1");
$.state = 2;
case 2:
$.goto = 3;
$mcall("log", console, $p, 3);
$.state = 3;
case 3:
$.goto = 4;
$brk();
$.state = 4;
case 4:
$.goto = 5;
$mcall("log", console, "2");
$.state = 5;
case 5:
$.goto = 6;
$brk();
$.state = 6;
case 6:
$.goto = 7;
$mcall("log", console, "3");
$.state = 7;
case 7:
$.goto = 8;
$brk();
$.state = 8;
case 8:
$.goto = 9;
$p = ($x.call = eff)(2);
$.state = 9;
case 9:
$.result = $p;
$.goto = 11;
continue;
case 10:
$.goto = 11;
return $unhandled($.error);
case 11:
return $ret($.result);
default:
throw new Error("Invalid state");
}
}, null, null, 1, [[4, "2:2-2:27", $s$2], [2, "2:14-2:22", $s$2], [2, "2:2-2:26", $s$2], [4, "3:2-3:19", $s$2], [2, "3:2-3:18", $s$2], [4, "4:2-4:19", $s$2], [2, "4:2-4:18", $s$2], [4, "5:2-5:16", $s$2], [2, "5:9-5:15", $s$2], [0, null, $s$2], [16, "6:1-6:1", $s$2], [16, "6:1-6:1", $s$2]]);
$M.moduleExports(); |
//>>built
define("epi/clientResourcesLoader",["epi","dojo"],function(_1,_2){var _3={},_4={};_1.clientResourcesLoader={_loadStyles:function(_5){if(!_2.isArray(_5)){return;}_2.forEach(_5,function(_6){var _7=_6.toLowerCase();if(!(_7 in _3)){var _8=_2.query("head")[0];_2.create("link",{rel:"stylesheet",type:"text/css",href:_6},_8);_3[_7]=1;}else{_3[_7]+=1;}});},_loadScripts:function(_9){var _a=new _2.Deferred();var _b=[];if(_2.isArray(_9)){_2.forEach(_9,function(_c){if(!(_c in _4)){_b.push(_c);}});}var _d=function(_e){if(_e.length==0){_a.resolve();return;}var _f=_e.shift();require([_f],function(){_4[_f]=true;_d(_e);});};_d(_b);return _a;},loadResources:function(_10,_11){this._loadStyles(_10);return this._loadScripts(_11);}};return _1.clientResourcesLoader;}); |
module.exports = {
'url': 'mongodb://localhost:27017/authentication'
}
|
'use strict';
require('should');
var path = require('path'),
influxService = require(path.resolve('./modules/core/server/services/influx.server.service')),
config = require(path.resolve('./config/config'));
describe('Service: influx', function() {
context('InfluxDB disabled', function () {
var originalInfluxSettings;
before(function () {
originalInfluxSettings = config.influxdb.enabled;
config.influxdb.enabled = false;
});
after(function () {
config.influxdb.enabled = originalInfluxSettings;
});
it('Getting client returns error if no InfluxDB configured', function(done) {
influxService.getClient(function(err) {
try {
err.message.should.equal('No InfluxDB configured.');
return done();
} catch (e) {
return done(e);
}
});
});
});
it('Writing point returns error with no measurementName', function(done) {
influxService.writePoint(null, { value: 1 }, { tag: 'tag' }, function(err) {
try {
err.message.should.equal('InfluxDB Service: no `measurementName` defined.');
return done();
} catch (e) {
return done(e);
}
});
});
it('Writing point returns error with no value', function(done) {
influxService.writePoint('test', null, { tag: 'tag' }, function(err) {
try {
err.message.should.equal('InfluxDB Service: no `fields` defined.');
return done();
} catch (e) {
return done(e);
}
});
});
it('Writing point returns error with no tag', function(done) {
influxService.writePoint('test', { value: 1 }, null, function(err) {
try {
err.message.should.equal('InfluxDB Service: no `tags` defined.');
return done();
} catch (e) {
return done(e);
}
});
});
});
|
import WaveSurfer from '../wavesurfer/wavesurfer.js';
import TimelinePlugin from '../wavesurfer/plugin/timeline.js';
import RegionPlugin from '../wavesurfer/plugin/regions.js';
import FileDownloader from './fileDownloader.js';
export default class WaveList {
constructor(params) {
this.waveformId = 0;
this.wavesurfers = [];
this.maxTrackLength = 0;
this.container =params["container"];
/* If there is a region in waveformId 1, currentRegionInfo becomes {id: 1, region: regionObject}
* regionObject.start gives start position, regionObject.end gives end position.
*/
this.currentRegionInfo = null;
this.timeline = null;
this.copyBuffer = null;
};
static create(params) {
const waveList = new WaveList(params);
return waveList.init();
};
init() {
// this.removeRegionOnOutsideClick(this);
this.bindAddRowButton(this);
return this;
};
clear() {
this.waveformId = 0;
this.wavesurfers = [];
$(this.container).html("");
this.currentRegionInfo = null;
if (this.timeline != null) {
this.timeline.destroy();
this.timeline = null;
$("#waveform-timeline").html("");
}
this.copyBuffer = null;
}
add(container) {
const waveformNum = this.waveformId++;
this.addEmptyRow(container, waveformNum);
let wavesurfer = this.addWaveForm(waveformNum);
return wavesurfer;
}
addEmptyRow(container, waveformNum) {
var newRowtag = `
<div class="row">
<div class="col-md-2">
<div class="row vertical-align-center">
<div class="col-md-4">
<span class="track-name"> Track${waveformNum} </span>
</div>
<div class="col-md-4">
<input id="mute${waveformNum}" type="checkbox" checked data-toggle="toggle"
data-on="ON" data-off="OFF" data-size="small">
</div>
</div>
<div class="row vertical-align-center">
<div class="col-md-2">
<span class="glyphicon glyphicon-volume-up"></span>
</div>
<div class="col-md-10">
<input type="range" id="volume${waveformNum}" min="0" max="100" value="50"/>
</div>
</div>
<div class="row">
<div class="col-md-6 padding-local-button">
<button class="btn btn-sm btn-default btn-block" onclick="document.getElementById('upload${waveformNum}').click();">
<span class="glyphicon glyphicon-open"></span>
Upload
</button>
<input type="file" style="display:none;" id="upload${waveformNum}" accept = "audio/*"/>
</div>
<div class="col-md-6 padding-local-button right">
<button id="download${waveformNum}" class="btn btn-sm btn-default btn-block">
<span class="glyphicon glyphicon-download-alt"></span>
Download
</button>
</div>
</div>
<div class="row">
<div class="col-md-6 padding-local-button">
<button id="library${waveformNum}" type="button" class="btn btn-sm btn-default btn-block" data-index="${waveformNum}" data-toggle="modal" data-target="#libraryModal">
<span class="glyphicon glyphicon-folder-open"></span>
Library
</button>
</div>
<div class="col-md-6 padding-local-button right">
<button id="save${waveformNum}" class="btn btn-sm btn-default btn-block">
<span class="glyphicon glyphicon-floppy-save"></span>
Save
</button>
</div>
</div>
</div>
<div class="col-md-10">
<div id="waveRow${waveformNum}">
</div>
</div>
</div>
`
$(container).append(newRowtag);
$("#mute" + waveformNum).bootstrapToggle();
}
addWaveForm(waveformNum) {
const wsInstance = WaveSurfer.create({
id: waveformNum,
container: '#waveRow' + waveformNum,
waveColor: 'violet',
progressColor: 'purple',
cursorWidth: 1,
plugins: [
/*
TimelinePlugin.create({
container: '#waveform-timeline'
}),
*/
RegionPlugin.create({
dragSelection: true,
addFunction: this.addNewRegion.bind(this),
color: "rgba(0, 0, 0, 0.5)",
})
],
getMaxTrackLengthFunction: this.getMaxTrackLength.bind(this),
setMaxTrackLengthFunction: this.setMaxTrackLength.bind(this),
synchronizeProgressFunction: this.synchronizeProgress.bind(this)
});
this.wavesurfers.push(wsInstance);
wsInstance.on('ready', function () {
let length = wsInstance.backend.getDuration();
if (this.timeline == null) {
this.timeline = TimelinePlugin.create({
container: "#waveform-timeline",
timelineClickFunction: this.moveAndPlayAllByTimeline.bind(this)
}, wsInstance);
}
if (length + 20 > this.maxTrackLength) {
this.maxTrackLength = length + 20;
this.timeline.render();
for (var i = 0; i < this.wavesurfers.length; i++) {
if (this.wavesurfers[i].backend.buffer !== null) {
this.wavesurfers[i].drawer.fireEvent("redraw");
}
}
}
wsInstance.setVolume(0.5);
}.bind(this));
this.bindLocalButtons(waveformNum, wsInstance);
/* Load empty buffer */
let audioContext = wsInstance.backend.ac;
let emptyBuffer = audioContext.createBuffer(2, 44100 * 30, 44100);
wsInstance.loadDecodedBuffer(emptyBuffer);
return wsInstance;
}
bindLocalButtons(waveformNum, wsInstance) {
$("#download" + waveformNum).click(function() {
FileDownloader.saveToWav(wsInstance.backend.buffer, 0);
});
$("#upload" + waveformNum).change(function() {
wsInstance.loadBlob(this.files[0]);
});
$("#save" + waveformNum).click(function() {
FileDownloader.saveToWav(wsInstance.backend.buffer, 1);
}.bind(this));
$("#volume" + waveformNum).on("input", (function() {
wsInstance.setVolume(this.value / 100.0);
}));
$("#mute" + waveformNum).change(function() {
wsInstance.toggleMute();
});
}
addNewRegion(waveformNum, region) {
if (this.currentRegionInfo != null) {
this.currentRegionInfo["region"].remove();
}
this.currentRegionInfo = {};
this.currentRegionInfo["id"] = waveformNum;
this.currentRegionInfo["region"] = region;
}
setMaxTrackLength(length) {
this.maxTrackLength = length;
}
getMaxTrackLength() {
return this.maxTrackLength;
}
moveAndPlayAllByTimeline(position) {
for (var i = 0; i < this.wavesurfers.length; i++) {
var progress = this.wavesurfers[i].adjustProgress(position);
//var progress = time / wavesurferList[i].backend.getDuration();
this.wavesurfers[i].seekTo(progress);
if (progress < 1) {
this.wavesurfers[i].play();
} else {
this.wavesurfers[i].pause();
}
}
}
synchronizeProgress(wsInstance) {
// Synchronize the movement of wave cursors.
for (var i = 0; i < this.wavesurfers.length; i++) {
if (wsInstance == this.wavesurfers[i]) {
wsInstance.drawer.progress(wsInstance.backend.getPlayedPercents());
//var progress = time / wavesurferList[i].backend.getDuration();
//wavesurferList[i].drawer.progress(progress);
} else {
this.wavesurfers[i].drawer.updateProgress(wsInstance.drawer.progressWave.offsetWidth);
}
}
}
removeRegion() {
if (this.currentRegionInfo != null) {
this.currentRegionInfo["region"].remove();
this.currentRegionInfo = null;
}
}
removeRegionOnOutsideClick(waveList) {
$(document).click(function(event) {
console.log("Click doc");
if(!$(event.target).closest('wave').length) {
console.log("delete region");
console.log(this.currentRegionInfo);
this.removeRegion();
}
}.bind(this));
}
bindAddRowButton(waveList) {
$("#addRow").on("click", function() {
this.add(this.container);
}.bind(this));
}
static alertWithSnackbar(message) {
// Get the snackbar DIV
let snackbar = $("#snackbar");
// Add the "show" class to DIV
snackbar.text(message);
snackbar.attr("class", "show");
// After 3 seconds, remove the show class from DIV
setTimeout(function(){
snackbar.text("");
snackbar.attr("class", "");
}, 3000);
}
} |
/*
Copyright (c) 2003-2013, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'image2', 'nb', {
alt: 'Alternativ tekst',
btnUpload: 'Send det til serveren',
captioned: 'Bilde med bildetekst',
infoTab: 'Bildeinformasjon',
lockRatio: 'Lås forhold',
menu: 'Bildeegenskaper',
pathName: 'bilde',
pathNameCaption: 'bildetekst',
resetSize: 'Tilbakestill størrelse',
resizer: 'Klikk og dra for å endre størrelse',
title: 'Bildeegenskaper',
uploadTab: 'Last opp',
urlMissing: 'Bildets adresse mangler.'
} );
|
import {expect} from 'chai';
import {packColorLE, packColorBE, unpackColorLE, unpackColorBE} from '../../src/video/colors';
describe('video/colors', () => {
it('packs color', () => {
expect(packColorLE(0x12, 0x34, 0x56, 0x78)).to.equal(0x78563412);
expect(packColorBE(0x12, 0x34, 0x56, 0x78)).to.equal(0x12345678);
expect(packColorLE(0x12, 0x34, 0x56)).to.equal(0xFF563412);
expect(packColorBE(0x12, 0x34, 0x56)).to.equal(0x123456FF);
});
it('unpacks color', () => {
expect(unpackColorLE(0x78563412)).to.deep.equal([0x12, 0x34, 0x56, 0x78]);
expect(unpackColorBE(0x12345678)).to.deep.equal([0x12, 0x34, 0x56, 0x78]);
});
});
|
import { moduleForModel, test } from 'ember-qunit';
moduleForModel('gpa', 'Unit | Model | gpa', {
// Specify the other units that are required for this test.
needs: []
});
test('it exists', function(assert) {
let model = this.subject();
// let store = this.store();
assert.ok(!!model);
});
|
Map = {};
// Store the sizes
Map.width = 0;
Map.height = 0;
// Store the map data
Map.data = [];
Map.sprites = [];
// Expose map access through an API.
Map.setSize = function(w, h) {
this.width = Math.max(w, 0);
this.height = Math.max(h, 0);
this.data = [];
for (var y = 0; y < h; y++)
for (var x = 0; x < w; x++)
Map.set(x, y, null);
};
Map.set = function(x, y, obj) {
if (x < 0 || x >= this.width || y < 0 || y >= this.height)
return;
this.data[y * this.width + x] = obj;
};
Map.get = function(x, y) {
if (x < 0 || x >= this.width || y < 0 || y >= this.height)
return null;
return this.data[y * this.width + x];
};
Map.addSprite = function(sprite) {
this.sprites.push(sprite);
};
Map.getSprites = function() {
return this.sprites;
};
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.