react-flex-layout
Version:
Simple layouts for full screen React applications
1,612 lines (1,335 loc) • 752 kB
JavaScript
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(1);
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _get = __webpack_require__(2)['default'];
var _inherits = __webpack_require__(18)['default'];
var _createClass = __webpack_require__(27)['default'];
var _classCallCheck = __webpack_require__(30)['default'];
var _interopRequireDefault = __webpack_require__(31)['default'];
var _react = __webpack_require__(32);
var _react2 = _interopRequireDefault(_react);
var _reactDom = __webpack_require__(189);
var _reactDom2 = _interopRequireDefault(_reactDom);
var _libIndexJs = __webpack_require__(190);
var _domready = __webpack_require__(199);
var _domready2 = _interopRequireDefault(_domready);
var _locationBar = __webpack_require__(200);
var _locationBar2 = _interopRequireDefault(_locationBar);
var locationBar = new _locationBar2['default']();
var Horizontal = (function (_React$Component) {
_inherits(Horizontal, _React$Component);
function Horizontal(props) {
_classCallCheck(this, Horizontal);
_get(Object.getPrototypeOf(Horizontal.prototype), 'constructor', this).call(this, props);
}
_createClass(Horizontal, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column1'
),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 'flex' },
'Column2'
)
);
}
}]);
return Horizontal;
})(_react2['default'].Component);
var FixedRightPane = (function (_React$Component2) {
_inherits(FixedRightPane, _React$Component2);
function FixedRightPane(props) {
_classCallCheck(this, FixedRightPane);
_get(Object.getPrototypeOf(FixedRightPane.prototype), 'constructor', this).call(this, props);
}
_createClass(FixedRightPane, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 'flex' },
'Column1'
),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column2'
)
);
}
}]);
return FixedRightPane;
})(_react2['default'].Component);
var ThreeColumn = (function (_React$Component3) {
_inherits(ThreeColumn, _React$Component3);
function ThreeColumn(props) {
_classCallCheck(this, ThreeColumn);
_get(Object.getPrototypeOf(ThreeColumn.prototype), 'constructor', this).call(this, props);
}
_createClass(ThreeColumn, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column1'
),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 'flex' },
'Column2'
),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column3'
)
);
}
}]);
return ThreeColumn;
})(_react2['default'].Component);
var HorizontalResizer = (function (_React$Component4) {
_inherits(HorizontalResizer, _React$Component4);
function HorizontalResizer(props) {
_classCallCheck(this, HorizontalResizer);
_get(Object.getPrototypeOf(HorizontalResizer.prototype), 'constructor', this).call(this, props);
}
_createClass(HorizontalResizer, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column1'
),
_react2['default'].createElement(_libIndexJs.LayoutSplitter, null),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 'flex' },
'Column2'
)
);
}
}]);
return HorizontalResizer;
})(_react2['default'].Component);
var BothFixedHorizontalResizer = (function (_React$Component5) {
_inherits(BothFixedHorizontalResizer, _React$Component5);
function BothFixedHorizontalResizer(props) {
_classCallCheck(this, BothFixedHorizontalResizer);
_get(Object.getPrototypeOf(BothFixedHorizontalResizer.prototype), 'constructor', this).call(this, props);
}
_createClass(BothFixedHorizontalResizer, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
'div',
{ style: { border: '1px solid #000', height: 200, width: 313 } },
_react2['default'].createElement(
_libIndexJs.Layout,
{ fill: 'container' },
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column1'
),
_react2['default'].createElement(_libIndexJs.LayoutSplitter, null),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 200 },
'Column2'
)
)
);
}
}]);
return BothFixedHorizontalResizer;
})(_react2['default'].Component);
var VerticalResizer = (function (_React$Component6) {
_inherits(VerticalResizer, _React$Component6);
function VerticalResizer(props) {
_classCallCheck(this, VerticalResizer);
_get(Object.getPrototypeOf(VerticalResizer.prototype), 'constructor', this).call(this, props);
}
_createClass(VerticalResizer, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutHeight: 200 },
'Row1'
),
_react2['default'].createElement(_libIndexJs.LayoutSplitter, null),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutHeight: 'flex' },
'Row2'
)
);
}
}]);
return VerticalResizer;
})(_react2['default'].Component);
var TwoColoredRows = (function (_React$Component7) {
_inherits(TwoColoredRows, _React$Component7);
function TwoColoredRows(props) {
_classCallCheck(this, TwoColoredRows);
_get(Object.getPrototypeOf(TwoColoredRows.prototype), 'constructor', this).call(this, props);
}
_createClass(TwoColoredRows, [{
key: 'render',
value: function render() {
// Here we highlight the columns so it is easy to see if the outer layout
// is not being resized.
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutHeight: 200 },
_react2['default'].createElement(
'div',
{ style: { height: '100%', background: 'cyan' } },
'Row 2'
)
),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutHeight: 'flex' },
_react2['default'].createElement(
'div',
{ style: { height: '100%', background: 'pink' } },
'Row 2'
)
)
);
}
}]);
return TwoColoredRows;
})(_react2['default'].Component);
var Nested = (function (_React$Component8) {
_inherits(Nested, _React$Component8);
function Nested(props) {
_classCallCheck(this, Nested);
_get(Object.getPrototypeOf(Nested.prototype), 'constructor', this).call(this, props);
}
_createClass(Nested, [{
key: 'render',
value: function render() {
return _react2['default'].createElement(
_libIndexJs.Layout,
null,
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 100 },
'Column1'
),
_react2['default'].createElement(_libIndexJs.LayoutSplitter, null),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutWidth: 'flex' },
_react2['default'].createElement(TwoColoredRows, null)
)
);
}
}]);
return Nested;
})(_react2['default'].Component);
var Example = (function (_React$Component9) {
_inherits(Example, _React$Component9);
function Example(props) {
_classCallCheck(this, Example);
_get(Object.getPrototypeOf(Example.prototype), 'constructor', this).call(this, props);
this.state = {};
}
_createClass(Example, [{
key: 'componentDidMount',
value: function componentDidMount() {
var _this = this;
locationBar.route(/horizontal/, function () {
_this.setState({ page: _react2['default'].createElement(Horizontal, null) });
});
locationBar.route(/fixedright/, function () {
_this.setState({ page: _react2['default'].createElement(FixedRightPane, null) });
});
locationBar.route(/threecolumn/, function () {
_this.setState({ page: _react2['default'].createElement(ThreeColumn, null) });
});
locationBar.route(/oneflexhorizontalresize/, function () {
_this.setState({ page: _react2['default'].createElement(HorizontalResizer, null) });
});
locationBar.route(/bothfixedhorizontalresize/, function () {
_this.setState({ page: _react2['default'].createElement(BothFixedHorizontalResizer, null) });
});
locationBar.route(/verticalresize/, function () {
_this.setState({ page: _react2['default'].createElement(VerticalResizer, null) });
});
locationBar.route(/nested/, function () {
_this.setState({ page: _react2['default'].createElement(Nested, null) });
});
locationBar.start();
}
}, {
key: 'render',
value: function render() {
var example = this.state.page ? this.state.page : _react2['default'].createElement(
'div',
null,
'Select an example'
);
return _react2['default'].createElement(
_libIndexJs.Layout,
{ fill: 'window' },
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutHeight: 100 },
_react2['default'].createElement(
'a',
{ href: '#horizontal' },
'Horizontal'
),
' |',
_react2['default'].createElement(
'a',
{ href: '#fixedright' },
'Fixed right column'
),
' |',
_react2['default'].createElement(
'a',
{ href: '#threecolumn' },
'Three column'
),
' |',
_react2['default'].createElement(
'a',
{ href: '#oneflexhorizontalresize' },
'Horizontal Splitter'
),
' |',
_react2['default'].createElement(
'a',
{ href: '#bothfixedhorizontalresize' },
'Both fixed Horizontal Splitter'
),
' |',
_react2['default'].createElement(
'a',
{ href: '#verticalresize' },
'Vertical Splitter'
),
' |',
_react2['default'].createElement(
'a',
{ href: '#nested' },
'Nested'
)
),
_react2['default'].createElement(
_libIndexJs.Layout,
{ layoutHeight: 'flex' },
example
)
);
}
}]);
return Example;
})(_react2['default'].Component);
(0, _domready2['default'])(function () {
var container = document.createElement('div');
document.body.appendChild(container);
_reactDom2['default'].render(_react2['default'].createElement(Example, null), container);
});
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _Object$getOwnPropertyDescriptor = __webpack_require__(3)["default"];
exports["default"] = function get(_x, _x2, _x3) {
var _again = true;
_function: while (_again) {
var object = _x,
property = _x2,
receiver = _x3;
_again = false;
if (object === null) object = Function.prototype;
var desc = _Object$getOwnPropertyDescriptor(object, property);
if (desc === undefined) {
var parent = Object.getPrototypeOf(object);
if (parent === null) {
return undefined;
} else {
_x = parent;
_x2 = property;
_x3 = receiver;
_again = true;
desc = parent = undefined;
continue _function;
}
} else if ("value" in desc) {
return desc.value;
} else {
var getter = desc.get;
if (getter === undefined) {
return undefined;
}
return getter.call(receiver);
}
}
};
exports.__esModule = true;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(4), __esModule: true };
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(5);
__webpack_require__(6);
module.exports = function getOwnPropertyDescriptor(it, key){
return $.getDesc(it, key);
};
/***/ },
/* 5 */
/***/ function(module, exports) {
var $Object = Object;
module.exports = {
create: $Object.create,
getProto: $Object.getPrototypeOf,
isEnum: {}.propertyIsEnumerable,
getDesc: $Object.getOwnPropertyDescriptor,
setDesc: $Object.defineProperty,
setDescs: $Object.defineProperties,
getKeys: $Object.keys,
getNames: $Object.getOwnPropertyNames,
getSymbols: $Object.getOwnPropertySymbols,
each: [].forEach
};
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
var toIObject = __webpack_require__(7);
__webpack_require__(11)('getOwnPropertyDescriptor', function($getOwnPropertyDescriptor){
return function getOwnPropertyDescriptor(it, key){
return $getOwnPropertyDescriptor(toIObject(it), key);
};
});
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(8)
, defined = __webpack_require__(10);
module.exports = function(it){
return IObject(defined(it));
};
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(9);
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
return cof(it) == 'String' ? it.split('') : Object(it);
};
/***/ },
/* 9 */
/***/ function(module, exports) {
var toString = {}.toString;
module.exports = function(it){
return toString.call(it).slice(8, -1);
};
/***/ },
/* 10 */
/***/ function(module, exports) {
// 7.2.1 RequireObjectCoercible(argument)
module.exports = function(it){
if(it == undefined)throw TypeError("Can't call method on " + it);
return it;
};
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
// most Object methods by ES6 should accept primitives
var $export = __webpack_require__(12)
, core = __webpack_require__(14)
, fails = __webpack_require__(17);
module.exports = function(KEY, exec){
var fn = (core.Object || {})[KEY] || Object[KEY]
, exp = {};
exp[KEY] = exec(fn);
$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
};
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(13)
, core = __webpack_require__(14)
, ctx = __webpack_require__(15)
, PROTOTYPE = 'prototype';
var $export = function(type, name, source){
var IS_FORCED = type & $export.F
, IS_GLOBAL = type & $export.G
, IS_STATIC = type & $export.S
, IS_PROTO = type & $export.P
, IS_BIND = type & $export.B
, IS_WRAP = type & $export.W
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
, key, own, out;
if(IS_GLOBAL)source = name;
for(key in source){
// contains in native
own = !IS_FORCED && target && key in target;
if(own && key in exports)continue;
// export native or passed
out = own ? target[key] : source[key];
// prevent global pollution for namespaces
exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
// bind timers to global for call from export context
: IS_BIND && own ? ctx(out, global)
// wrap global constructors for prevent change them in library
: IS_WRAP && target[key] == out ? (function(C){
var F = function(param){
return this instanceof C ? new C(param) : C(param);
};
F[PROTOTYPE] = C[PROTOTYPE];
return F;
// make static versions for prototype methods
})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
}
};
// type bitmap
$export.F = 1; // forced
$export.G = 2; // global
$export.S = 4; // static
$export.P = 8; // proto
$export.B = 16; // bind
$export.W = 32; // wrap
module.exports = $export;
/***/ },
/* 13 */
/***/ function(module, exports) {
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
/***/ },
/* 14 */
/***/ function(module, exports) {
var core = module.exports = {version: '1.2.6'};
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {
// optional / simple context binding
var aFunction = __webpack_require__(16);
module.exports = function(fn, that, length){
aFunction(fn);
if(that === undefined)return fn;
switch(length){
case 1: return function(a){
return fn.call(that, a);
};
case 2: return function(a, b){
return fn.call(that, a, b);
};
case 3: return function(a, b, c){
return fn.call(that, a, b, c);
};
}
return function(/* ...args */){
return fn.apply(that, arguments);
};
};
/***/ },
/* 16 */
/***/ function(module, exports) {
module.exports = function(it){
if(typeof it != 'function')throw TypeError(it + ' is not a function!');
return it;
};
/***/ },
/* 17 */
/***/ function(module, exports) {
module.exports = function(exec){
try {
return !!exec();
} catch(e){
return true;
}
};
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _Object$create = __webpack_require__(19)["default"];
var _Object$setPrototypeOf = __webpack_require__(21)["default"];
exports["default"] = function (subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}
subClass.prototype = _Object$create(superClass && superClass.prototype, {
constructor: {
value: subClass,
enumerable: false,
writable: true,
configurable: true
}
});
if (superClass) _Object$setPrototypeOf ? _Object$setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};
exports.__esModule = true;
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(20), __esModule: true };
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(5);
module.exports = function create(P, D){
return $.create(P, D);
};
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(22), __esModule: true };
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(23);
module.exports = __webpack_require__(14).Object.setPrototypeOf;
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.3.19 Object.setPrototypeOf(O, proto)
var $export = __webpack_require__(12);
$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(24).set});
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */
var getDesc = __webpack_require__(5).getDesc
, isObject = __webpack_require__(25)
, anObject = __webpack_require__(26);
var check = function(O, proto){
anObject(O);
if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
};
module.exports = {
set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
function(test, buggy, set){
try {
set = __webpack_require__(15)(Function.call, getDesc(Object.prototype, '__proto__').set, 2);
set(test, []);
buggy = !(test instanceof Array);
} catch(e){ buggy = true; }
return function setPrototypeOf(O, proto){
check(O, proto);
if(buggy)O.__proto__ = proto;
else set(O, proto);
return O;
};
}({}, false) : undefined),
check: check
};
/***/ },
/* 25 */
/***/ function(module, exports) {
module.exports = function(it){
return typeof it === 'object' ? it !== null : typeof it === 'function';
};
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(25);
module.exports = function(it){
if(!isObject(it))throw TypeError(it + ' is not an object!');
return it;
};
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _Object$defineProperty = __webpack_require__(28)["default"];
exports["default"] = (function () {
function defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
_Object$defineProperty(target, descriptor.key, descriptor);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
})();
exports.__esModule = true;
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(29), __esModule: true };
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(5);
module.exports = function defineProperty(it, key, desc){
return $.setDesc(it, key, desc);
};
/***/ },
/* 30 */
/***/ function(module, exports) {
"use strict";
exports["default"] = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
exports.__esModule = true;
/***/ },
/* 31 */
/***/ function(module, exports) {
"use strict";
exports["default"] = function (obj) {
return obj && obj.__esModule ? obj : {
"default": obj
};
};
exports.__esModule = true;
/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
module.exports = __webpack_require__(33);
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule React
*/
'use strict';
var ReactDOM = __webpack_require__(34);
var ReactDOMServer = __webpack_require__(179);
var ReactIsomorphic = __webpack_require__(183);
var assign = __webpack_require__(70);
var deprecated = __webpack_require__(188);
// `version` will be added here by ReactIsomorphic.
var React = {};
assign(React, ReactIsomorphic);
assign(React, {
// ReactDOM
findDOMNode: deprecated('findDOMNode', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.findDOMNode),
render: deprecated('render', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.render),
unmountComponentAtNode: deprecated('unmountComponentAtNode', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.unmountComponentAtNode),
// ReactDOMServer
renderToString: deprecated('renderToString', 'ReactDOMServer', 'react-dom/server', ReactDOMServer, ReactDOMServer.renderToString),
renderToStaticMarkup: deprecated('renderToStaticMarkup', 'ReactDOMServer', 'react-dom/server', ReactDOMServer, ReactDOMServer.renderToStaticMarkup)
});
React.__SECRET_DOM_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactDOM;
React.__SECRET_DOM_SERVER_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactDOMServer;
module.exports = React;
/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOM
*/
/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/
'use strict';
var ReactCurrentOwner = __webpack_require__(36);
var ReactDOMTextComponent = __webpack_require__(37);
var ReactDefaultInjection = __webpack_require__(102);
var ReactInstanceHandles = __webpack_require__(76);
var ReactMount = __webpack_require__(59);
var ReactPerf = __webpack_require__(49);
var ReactReconciler = __webpack_require__(81);
var ReactUpdates = __webpack_require__(85);
var ReactVersion = __webpack_require__(177);
var findDOMNode = __webpack_require__(122);
var renderSubtreeIntoContainer = __webpack_require__(178);
var warning = __webpack_require__(56);
ReactDefaultInjection.inject();
var render = ReactPerf.measure('React', 'render', ReactMount.render);
var React = {
findDOMNode: findDOMNode,
render: render,
unmountComponentAtNode: ReactMount.unmountComponentAtNode,
version: ReactVersion,
/* eslint-disable camelcase */
unstable_batchedUpdates: ReactUpdates.batchedUpdates,
unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer
};
// Inject the runtime into a devtools global hook regardless of browser.
// Allows for debugging when the hook is injected on the page.
/* eslint-enable camelcase */
if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {
__REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
CurrentOwner: ReactCurrentOwner,
InstanceHandles: ReactInstanceHandles,
Mount: ReactMount,
Reconciler: ReactReconciler,
TextComponent: ReactDOMTextComponent
});
}
if (process.env.NODE_ENV !== 'production') {
var ExecutionEnvironment = __webpack_require__(40);
if (ExecutionEnvironment.canUseDOM && window.top === window.self) {
// First check if devtools is not installed
if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
// If we're in Chrome or Firefox, provide a download link if not installed.
if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) {
console.debug('Download the React DevTools for a better development experience: ' + 'https://fb.me/react-devtools');
}
}
// If we're in IE8, check to see if we are in compatibility mode and provide
// information on preventing compatibility mode
var ieCompatibilityMode = document.documentMode && document.documentMode < 8;
process.env.NODE_ENV !== 'production' ? warning(!ieCompatibilityMode, 'Internet Explorer is running in compatibility mode; please add the ' + 'following tag to your HTML to prevent this from happening: ' + '<meta http-equiv="X-UA-Compatible" content="IE=edge" />') : undefined;
var expectedFeatures = [
// shims
Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.split, String.prototype.trim,
// shams
Object.create, Object.freeze];
for (var i = 0; i < expectedFeatures.length; i++) {
if (!expectedFeatures[i]) {
console.error('One or more ES5 shim/shams expected by React are not available: ' + 'https://fb.me/react-warning-polyfills');
break;
}
}
}
}
module.exports = React;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
/***/ },
/* 35 */
/***/ function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = setTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
clearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
setTimeout(drainQueue, 0);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ },
/* 36 */
/***/ function(module, exports) {
/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactCurrentOwner
*/
'use strict';
/**
* Keeps track of the current owner.
*
* The current owner is the component who should own any components that are
* currently being constructed.
*/
var ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/
current: null
};
module.exports = ReactCurrentOwner;
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule ReactDOMTextComponent
* @typechecks static-only
*/
'use strict';
var DOMChildrenOperations = __webpack_require__(38);
var DOMPropertyOperations = __webpack_require__(53);
var ReactComponentBrowserEnvironment = __webpack_require__(57);
var ReactMount = __webpack_require__(59);
var assign = __webpack_require__(70);
var escapeTextContentForBrowser = __webpack_require__(52);
var setTextContent = __webpack_require__(51);
var validateDOMNesting = __webpack_require__(101);
/**
* Text nodes violate a couple assumptions that React makes about components:
*
* - When mounting text into the DOM, adjacent text nodes are merged.
* - Text nodes cannot be assigned a React root ID.
*
* This component is used to wrap strings in elements so that they can undergo
* the same reconciliation that is applied to elements.
*
* TODO: Investigate representing React components in the DOM with text nodes.
*
* @class ReactDOMTextComponent
* @extends ReactComponent
* @internal
*/
var ReactDOMTextComponent = function (props) {
// This constructor and its argument is currently used by mocks.
};
assign(ReactDOMTextComponent.prototype, {
/**
* @param {ReactText} text
* @internal
*/
construct: function (text) {
// TODO: This is really a ReactText (ReactNode), not a ReactElement
this._currentElement = text;
this._stringText = '' + text;
// Properties
this._rootNodeID = null;
this._mountIndex = 0;
},
/**
* Creates the markup for this text node. This node is not intended to have
* any features besides containing text content.
*
* @param {string} rootID DOM ID of the root node.
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @return {string} Markup for this text node.
* @internal
*/
mountComponent: function (rootID, transaction, context) {
if (process.env.NODE_ENV !== 'production') {
if (context[validateDOMNesting.ancestorInfoContextKey]) {
validateDOMNesting('span', null, context[validateDOMNesting.ancestorInfoContextKey]);
}
}
this._rootNodeID = rootID;
if (transaction.useCreateElement) {
var ownerDocument = context[ReactMount.ownerDocumentContextKey];
var el = ownerDocument.createElement('span');
DOMPropertyOperations.setAttributeForID(el, rootID);
// Populate node cache
ReactMount.getID(el);
setTextContent(el, this._stringText);
return el;
} else {
var escapedText = escapeTextContentForBrowser(this._stringText);
if (transaction.renderToStaticMarkup) {
// Normally we'd wrap this in a `span` for the reasons stated above, but
// since this is a situation where React won't take over (static pages),
// we can simply return the text as it is.
return escapedText;
}
return '<span ' + DOMPropertyOperations.createMarkupForID(rootID) + '>' + escapedText + '</span>';
}
},
/**
* Updates this component by updating the text content.
*
* @param {ReactText} nextText The next text content
* @param {ReactReconcileTransaction} transaction
* @internal
*/
receiveComponent: function (nextText, transaction) {
if (nextText !== this._currentElement) {
this._currentElement = nextText;
var nextStringText = '' + nextText;
if (nextStringText !== this._stringText) {
// TODO: Save this as pending props and use performUpdateIfNecessary
// and/or updateComponent to do the actual update for consistency with
// other component types?
this._stringText = nextStringText;
var node = ReactMount.getNode(this._rootNodeID);
DOMChildrenOperations.updateTextContent(node, nextStringText);
}
}
},
unmountComponent: function () {
ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);
}
});
module.exports = ReactDOMTextComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule DOMChildrenOperations
* @typechecks static-only
*/
'use strict';
var Danger = __webpack_require__(39);
var ReactMultiChildUpdateTypes = __webpack_require__(47);
var ReactPerf = __webpack_require__(49);
var setInnerHTML = __webpack_require__(50);
var setTextContent = __webpack_require__(51);
var invariant = __webpack_require__(44);
/**
* Inserts `childNode` as a child of `parentNode` at the `index`.
*
* @param {DOMElement} parentNode Parent node in which to insert.
* @param {DOMElement} childNode Child node to insert.
* @param {number} index Index at which to insert the child.
* @internal
*/
function insertChildAt(parentNode, childNode, index) {
// By exploiting arrays returning `undefined` for an undefined index, we can
// rely exclusively on `insertBefore(node, null)` instead of also using
// `appendChild(node)`. However, using `undefined` is not allowed by all
// browsers so we must replace it with `null`.
// fix render order error in safari
// IE8 will throw error when index out of list size.
var beforeChild = index >= parentNode.childNodes.length ? null : parentNode.childNodes.item(index);
parentNode.insertBefore(childNode, beforeChild);
}
/**
* Operations for updating with DOM children.
*/
var DOMChildrenOperations = {
dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup,
updateTextContent: setTextContent,
/**
* Updates a component's children by processing a series of updates. The
* update configurations are each expected to have a `parentNode` property.
*
* @param {array<object>} updates List of update configurations.
* @param {array<string>} markupList List of markup strings.
* @internal
*/
processUpdates: function (updates, markupList) {
var update;
// Mapping from parent IDs to initial child orderings.
var initialChildren = null;
// List of children that will be moved or removed.
var updatedChildren = null;
for (var i = 0; i < updates.length; i++) {
update = updates[i];
if (update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING || update.type === ReactMultiChildUpdateTypes.REMOVE_NODE) {
var updatedIndex = update.fromIndex;
var updatedChild = update.parentNode.childNodes[updatedIndex];
var parentID = update.parentID;
!updatedChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processUpdates(): Unable to find child %s of element. This ' + 'probably means the DOM was unexpectedly mutated (e.g., by the ' + 'browser), usually due to forgetting a <tbody> when using tables, ' + 'nesting tags like <form>, <p>, or <a>, or using non-SVG elements ' + 'in an <svg> parent. Try inspecting the child nodes of the element ' + 'with React ID `%s`.', updatedIndex, parentID) : invariant(false) : undefined;
initialChildren = initialChildren || {};
initialChildren[parentID] = initialChildren[parentID] || [];
initialChildren[parentID][updatedIndex] = updatedChild;
updatedChildren = updatedChildren || [];
updatedChildren.push(updatedChild);
}
}
var renderedMarkup;
// markupList is either a list of markup or just a list of elements
if (markupList.length && typeof markupList[0] === 'string') {
renderedMarkup = Danger.dangerouslyRenderMarkup(markupList);
} else {
renderedMarkup = markupList;
}
// Remove updated children first so that `toIndex` is consistent.
if (updatedChildren) {
for (var j = 0; j < updatedChildren.length; j++) {
updatedChildren[j].parentNode.removeChild(updatedChildren[j]);
}
}
for (var k = 0; k < updates.length; k++) {
update = updates[k];
switch (update.type) {
case ReactMultiChildUpdateTypes.INSERT_MARKUP:
insertChildAt(update.parentNode, renderedMarkup[update.markupIndex], update.toIndex);
break;
case ReactMultiChildUpdateTypes.MOVE_EXISTING:
insertChildAt(update.parentNode, initialChildren[update.parentID][update.fromIndex], update.toIndex);
break;
case ReactMultiChildUpdateTypes.SET_MARKUP:
setInnerHTML(update.parentNode, update.content);
break;
case ReactMultiChildUpdateTypes.TEXT_CONTENT:
setTextContent(update.parentNode, update.content);
break;
case ReactMultiChildUpdateTypes.REMOVE_NODE:
// Already removed by the for-loop above.
break;
}
}
}
};
ReactPerf.measureMethods(DOMChildrenOperations, 'DOMChildrenOperations', {
updateTextContent: 'updateTextContent'
});
module.exports = DOMChildrenOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(35)))
/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright 2013-2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule Danger
* @typechecks static-only
*/
'use strict';
var ExecutionEnvironment = __webpack_require__(40);
var createNodesFromMarkup = __webpack_require__(41);
var emptyFunction = __webpack_require__(46);
var getMarkupWrap = __webpack_require__(45);
var invariant = __webpack_require__(44);
var OPEN_TAG_NAME_EXP = /^(<[^ \/>]+)/;
var RESULT_INDEX_ATTR = 'data-danger-index';
/**
* Extracts the `nodeName` from a string of markup.
*
* NOTE: Extracting the `nodeName` does not require a regular expression match
* because we make assumptions about React-generated markup (i.e. there are no
* spaces surrounding the opening tag and there is at least one attribute).
*
* @param {string} markup String of markup.
* @return {string} Node name of the supplied markup.
* @see http://jsperf.com/extract-nodename
*/
function getNodeName(markup) {
return markup.substring(1, markup.indexOf(' '));
}
var Danger = {
/**
* Renders markup into an array of nodes. The markup is expected to render
* into a list of root nodes. Also, the length of `resultList` and
* `markupList` should be the same.
*
* @param {array<string>} markupList List of markup strings to render.
* @return {array<DOMElement>} List of rendered nodes.
* @internal
*/
dangerouslyRenderMarkup: function (markupList) {
!ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' + 'thread. Make sure `window` and `document` are available globally ' + 'before requiring React when unit testing or use ' + 'ReactDOMServer.renderToString for server rendering.') : invariant(false) : undefined;
var nodeName;
var markupByNodeName = {};
// Group markup by `nodeName` if a wrap is necessary, else by '*'.
for (var i = 0; i < markupList.length; i++) {
!markupList[i] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyRenderMarkup(...): Missing markup.') : invariant(false) : undefined;
nodeName = getNodeName(markupList[i]);
nodeName = getMarkupWrap(nodeName) ? nodeName : '*';
markupByNodeName[nodeName] = markupByNodeName[nodeName] || [];
markupByNodeName[nodeName][i] = markupList[i];
}
var resultList = [];
var resultListAssignmentCount = 0;
for (nodeName in markupByNodeName) {
if (!markupByNodeName.hasOwnProperty(nodeName)) {
continue;
}
var markupListByNodeName = markupByNodeName[nodeName];
// This for-in loop skips the holes of the sparse array. The order of
// iteration should follow the order of assignment, which happens to match
// numerical index order, but we don't rely on that.
var resultIndex;
for (resultIndex in markupListByNodeName) {
if (markupListByNodeName.hasOwnProperty(resultIndex)) {
var markup = markupListByNodeName[resultIndex];
// Push the requested markup with an additional RESULT_INDEX_ATTR
// attribute. If the markup does not start with a < character, it
// will be discarded below (with an appropriate console.error).
markupListByNodeName[resultIndex] = markup.replace(OPEN_TAG_NAME_EXP,
// This index will be parsed back out below.
'$1 ' + RESULT_INDEX_ATTR + '="' + resultIndex + '" ');
}
}
// Render each group of markup with similar wrapping `nodeName`.
var renderNodes = createNodesFromMarkup(markupListByNodeName.join(''), emptyFunction // Do nothing special with <script> tags.
);
for (var j = 0; j < renderNodes.length; ++j) {
var renderNode = renderNodes[j];
if (renderNode.hasAttribute && renderNode.hasAttribute(RESULT_INDEX_ATTR)) {
resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR);
renderNode.removeAttribute(RESULT_INDEX_ATTR);
!!resultList.hasOwnProperty(resultIndex) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Danger: Assigning to an already-occupied result index.') : invariant(false) : undefined;
resultList[resultIndex] = renderNode;
// This should match resultList.length and markupList.length when
// we're done.
resultListAssignmentCount += 1;
} else if (process.env.NODE_ENV !== 'production') {
console.error('Danger: Discarding unexpected node:', renderNode);
}
}
}
// Although resultList was populated out of order, it should now be a dense
// array.
!(resultListAssignmentCount === resultList.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Danger: Did not assign to every index of resultList.') : invariant(false) : undefined;
!(resultList.length === markupList.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Danger: Expected markup to render %s nodes, but rendered %s.', markupList.length, resultList.length) : invariant(false) : undefined;
return resultList;
},
/**
* Replaces a node with a string of markup at its current position within its
* parent. The markup must render into a single root node.
*
* @param {DOMElement} oldChild Child node to replace.
* @param {string} markup Markup to render in place of the child node.
* @internal
*/
dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) {
!ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? i