Created
July 3, 2017 18:44
-
-
Save timdorr/f5ff0028e2d55eb38db568d7a5a97f87 to your computer and use it in GitHub Desktop.
React Router + Webpack 2 + BABEL_ENV=es (modules: false)
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(function webpackUniversalModuleDefinition(root, factory) { | |
if(typeof exports === 'object' && typeof module === 'object') | |
module.exports = factory(require("react")); | |
else if(typeof define === 'function' && define.amd) | |
define(["react"], factory); | |
else if(typeof exports === 'object') | |
exports["ReactRouter"] = factory(require("react")); | |
else | |
root["ReactRouter"] = factory(root["React"]); | |
})(this, function(__WEBPACK_EXTERNAL_MODULE_1__) { | |
return /******/ (function(modules) { // webpackBootstrap | |
/******/ // The module cache | |
/******/ var installedModules = {}; | |
/******/ | |
/******/ // The require function | |
/******/ function __webpack_require__(moduleId) { | |
/******/ | |
/******/ // Check if module is in cache | |
/******/ if(installedModules[moduleId]) { | |
/******/ return installedModules[moduleId].exports; | |
/******/ } | |
/******/ // Create a new module (and put it into the cache) | |
/******/ var module = installedModules[moduleId] = { | |
/******/ i: moduleId, | |
/******/ l: false, | |
/******/ exports: {} | |
/******/ }; | |
/******/ | |
/******/ // Execute the module function | |
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); | |
/******/ | |
/******/ // Flag the module as loaded | |
/******/ module.l = 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; | |
/******/ | |
/******/ // identity function for calling harmony imports with the correct context | |
/******/ __webpack_require__.i = function(value) { return value; }; | |
/******/ | |
/******/ // define getter function for harmony exports | |
/******/ __webpack_require__.d = function(exports, name, getter) { | |
/******/ if(!__webpack_require__.o(exports, name)) { | |
/******/ Object.defineProperty(exports, name, { | |
/******/ configurable: false, | |
/******/ enumerable: true, | |
/******/ get: getter | |
/******/ }); | |
/******/ } | |
/******/ }; | |
/******/ | |
/******/ // getDefaultExport function for compatibility with non-harmony modules | |
/******/ __webpack_require__.n = function(module) { | |
/******/ var getter = module && module.__esModule ? | |
/******/ function getDefault() { return module['default']; } : | |
/******/ function getModuleExports() { return module; }; | |
/******/ __webpack_require__.d(getter, 'a', getter); | |
/******/ return getter; | |
/******/ }; | |
/******/ | |
/******/ // Object.prototype.hasOwnProperty.call | |
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; | |
/******/ | |
/******/ // __webpack_public_path__ | |
/******/ __webpack_require__.p = ""; | |
/******/ | |
/******/ // Load entry module and return exports | |
/******/ return __webpack_require__(__webpack_require__.s = 14); | |
/******/ }) | |
/************************************************************************/ | |
/******/ ([ | |
/* 0 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
/** | |
* Copyright 2013-present, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
*/ | |
if (false) { | |
var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' && | |
Symbol.for && | |
Symbol.for('react.element')) || | |
0xeac7; | |
var isValidElement = function(object) { | |
return typeof object === 'object' && | |
object !== null && | |
object.$$typeof === REACT_ELEMENT_TYPE; | |
}; | |
// By explicitly using `prop-types` you are opting into new development behavior. | |
// http://fb.me/prop-types-in-prod | |
var throwOnDirectAccess = true; | |
module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess); | |
} else { | |
// By explicitly using `prop-types` you are opting into new production behavior. | |
// http://fb.me/prop-types-in-prod | |
module.exports = __webpack_require__(23)(); | |
} | |
/***/ }), | |
/* 1 */ | |
/***/ (function(module, exports) { | |
module.exports = __WEBPACK_EXTERNAL_MODULE_1__; | |
/***/ }), | |
/* 2 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* 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. | |
*/ | |
/** | |
* 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 = function() {}; | |
if (false) { | |
warning = function(condition, format, args) { | |
var len = arguments.length; | |
args = new Array(len > 2 ? len - 2 : 0); | |
for (var key = 2; key < len; key++) { | |
args[key - 2] = arguments[key]; | |
} | |
if (format === undefined) { | |
throw new Error( | |
'`warning(condition, format, ...args)` requires a warning ' + | |
'message argument' | |
); | |
} | |
if (format.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 (!condition) { | |
var argIndex = 0; | |
var message = 'Warning: ' + | |
format.replace(/%s/g, function() { | |
return args[argIndex++]; | |
}); | |
if (typeof console !== 'undefined') { | |
console.error(message); | |
} | |
try { | |
// 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; | |
/***/ }), | |
/* 3 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_warning__ = __webpack_require__(2); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_warning__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_invariant__ = __webpack_require__(7); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_invariant___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_invariant__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_prop_types__); | |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
/** | |
* The public API for putting history on context. | |
*/ | |
var Router = function (_React$Component) { | |
_inherits(Router, _React$Component); | |
function Router() { | |
var _temp, _this, _ret; | |
_classCallCheck(this, Router); | |
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
args[_key] = arguments[_key]; | |
} | |
return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = { | |
match: _this.computeMatch(_this.props.history.location.pathname) | |
}, _temp), _possibleConstructorReturn(_this, _ret); | |
} | |
Router.prototype.getChildContext = function getChildContext() { | |
return { | |
router: _extends({}, this.context.router, { | |
history: this.props.history, | |
route: { | |
location: this.props.history.location, | |
match: this.state.match | |
} | |
}) | |
}; | |
}; | |
Router.prototype.computeMatch = function computeMatch(pathname) { | |
return { | |
path: '/', | |
url: '/', | |
params: {}, | |
isExact: pathname === '/' | |
}; | |
}; | |
Router.prototype.componentWillMount = function componentWillMount() { | |
var _this2 = this; | |
var _props = this.props, | |
children = _props.children, | |
history = _props.history; | |
__WEBPACK_IMPORTED_MODULE_1_invariant___default()(children == null || __WEBPACK_IMPORTED_MODULE_2_react___default.a.Children.count(children) === 1, 'A <Router> may have only one child element'); | |
// Do this here so we can setState when a <Redirect> changes the | |
// location in componentWillMount. This happens e.g. when doing | |
// server rendering using a <StaticRouter>. | |
this.unlisten = history.listen(function () { | |
_this2.setState({ | |
match: _this2.computeMatch(history.location.pathname) | |
}); | |
}); | |
}; | |
Router.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { | |
__WEBPACK_IMPORTED_MODULE_0_warning___default()(this.props.history === nextProps.history, 'You cannot change <Router history>'); | |
}; | |
Router.prototype.componentWillUnmount = function componentWillUnmount() { | |
this.unlisten(); | |
}; | |
Router.prototype.render = function render() { | |
var children = this.props.children; | |
return children ? __WEBPACK_IMPORTED_MODULE_2_react___default.a.Children.only(children) : null; | |
}; | |
return Router; | |
}(__WEBPACK_IMPORTED_MODULE_2_react___default.a.Component); | |
Router.propTypes = { | |
history: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object.isRequired, | |
children: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.node | |
}; | |
Router.contextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object | |
}; | |
Router.childContextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object.isRequired | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (Router); | |
/***/ }), | |
/* 4 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_path_to_regexp__ = __webpack_require__(21); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_path_to_regexp___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_path_to_regexp__); | |
var patternCache = {}; | |
var cacheLimit = 10000; | |
var cacheCount = 0; | |
var compilePath = function compilePath(pattern, options) { | |
var cacheKey = '' + options.end + options.strict; | |
var cache = patternCache[cacheKey] || (patternCache[cacheKey] = {}); | |
if (cache[pattern]) return cache[pattern]; | |
var keys = []; | |
var re = __WEBPACK_IMPORTED_MODULE_0_path_to_regexp___default()(pattern, keys, options); | |
var compiledPattern = { re: re, keys: keys }; | |
if (cacheCount < cacheLimit) { | |
cache[pattern] = compiledPattern; | |
cacheCount++; | |
} | |
return compiledPattern; | |
}; | |
/** | |
* Public API for matching a URL pathname to a path pattern. | |
*/ | |
var matchPath = function matchPath(pathname) { | |
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; | |
if (typeof options === 'string') options = { path: options }; | |
var _options = options, | |
_options$path = _options.path, | |
path = _options$path === undefined ? '/' : _options$path, | |
_options$exact = _options.exact, | |
exact = _options$exact === undefined ? false : _options$exact, | |
_options$strict = _options.strict, | |
strict = _options$strict === undefined ? false : _options$strict; | |
var _compilePath = compilePath(path, { end: exact, strict: strict }), | |
re = _compilePath.re, | |
keys = _compilePath.keys; | |
var match = re.exec(pathname); | |
if (!match) return null; | |
var url = match[0], | |
values = match.slice(1); | |
var isExact = pathname === url; | |
if (exact && !isExact) return null; | |
return { | |
path: path, // the path pattern used to match | |
url: path === '/' && url === '' ? '/' : url, // the matched portion of the URL | |
isExact: isExact, // whether or not we matched exactly | |
params: keys.reduce(function (memo, key, index) { | |
memo[key.name] = values[index]; | |
return memo; | |
}, {}) | |
}; | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (matchPath); | |
/***/ }), | |
/* 5 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
exports.__esModule = true; | |
var addLeadingSlash = exports.addLeadingSlash = function addLeadingSlash(path) { | |
return path.charAt(0) === '/' ? path : '/' + path; | |
}; | |
var stripLeadingSlash = exports.stripLeadingSlash = function stripLeadingSlash(path) { | |
return path.charAt(0) === '/' ? path.substr(1) : path; | |
}; | |
var hasBasename = exports.hasBasename = function hasBasename(path, prefix) { | |
return new RegExp('^' + prefix + '(\\/|\\?|#|$)', 'i').test(path); | |
}; | |
var stripBasename = exports.stripBasename = function stripBasename(path, prefix) { | |
return hasBasename(path, prefix) ? path.substr(prefix.length) : path; | |
}; | |
var stripTrailingSlash = exports.stripTrailingSlash = function stripTrailingSlash(path) { | |
return path.charAt(path.length - 1) === '/' ? path.slice(0, -1) : path; | |
}; | |
var parsePath = exports.parsePath = function parsePath(path) { | |
var pathname = path || '/'; | |
var search = ''; | |
var hash = ''; | |
var hashIndex = pathname.indexOf('#'); | |
if (hashIndex !== -1) { | |
hash = pathname.substr(hashIndex); | |
pathname = pathname.substr(0, hashIndex); | |
} | |
var searchIndex = pathname.indexOf('?'); | |
if (searchIndex !== -1) { | |
search = pathname.substr(searchIndex); | |
pathname = pathname.substr(0, searchIndex); | |
} | |
return { | |
pathname: pathname, | |
search: search === '?' ? '' : search, | |
hash: hash === '#' ? '' : hash | |
}; | |
}; | |
var createPath = exports.createPath = function createPath(location) { | |
var pathname = location.pathname, | |
search = location.search, | |
hash = location.hash; | |
var path = pathname || '/'; | |
if (search && search !== '?') path += search.charAt(0) === '?' ? search : '?' + search; | |
if (hash && hash !== '#') path += hash.charAt(0) === '#' ? hash : '#' + hash; | |
return path; | |
}; | |
/***/ }), | |
/* 6 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_warning__ = __webpack_require__(2); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_warning__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_prop_types__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__matchPath__ = __webpack_require__(4); | |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
/** | |
* The public API for matching a single path and rendering. | |
*/ | |
var Route = function (_React$Component) { | |
_inherits(Route, _React$Component); | |
function Route() { | |
var _temp, _this, _ret; | |
_classCallCheck(this, Route); | |
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
args[_key] = arguments[_key]; | |
} | |
return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = { | |
match: _this.computeMatch(_this.props, _this.context.router) | |
}, _temp), _possibleConstructorReturn(_this, _ret); | |
} | |
Route.prototype.getChildContext = function getChildContext() { | |
return { | |
router: _extends({}, this.context.router, { | |
route: { | |
location: this.props.location || this.context.router.route.location, | |
match: this.state.match | |
} | |
}) | |
}; | |
}; | |
Route.prototype.computeMatch = function computeMatch(_ref, _ref2) { | |
var computedMatch = _ref.computedMatch, | |
location = _ref.location, | |
path = _ref.path, | |
strict = _ref.strict, | |
exact = _ref.exact; | |
var route = _ref2.route; | |
if (computedMatch) return computedMatch; // <Switch> already computed the match for us | |
var pathname = (location || route.location).pathname; | |
return path ? __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3__matchPath__["a" /* default */])(pathname, { path: path, strict: strict, exact: exact }) : route.match; | |
}; | |
Route.prototype.componentWillMount = function componentWillMount() { | |
var _props = this.props, | |
component = _props.component, | |
render = _props.render, | |
children = _props.children; | |
__WEBPACK_IMPORTED_MODULE_0_warning___default()(!(component && render), 'You should not use <Route component> and <Route render> in the same route; <Route render> will be ignored'); | |
__WEBPACK_IMPORTED_MODULE_0_warning___default()(!(component && children), 'You should not use <Route component> and <Route children> in the same route; <Route children> will be ignored'); | |
__WEBPACK_IMPORTED_MODULE_0_warning___default()(!(render && children), 'You should not use <Route render> and <Route children> in the same route; <Route children> will be ignored'); | |
}; | |
Route.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps, nextContext) { | |
__WEBPACK_IMPORTED_MODULE_0_warning___default()(!(nextProps.location && !this.props.location), '<Route> elements should not change from uncontrolled to controlled (or vice versa). You initially used no "location" prop and then provided one on a subsequent render.'); | |
__WEBPACK_IMPORTED_MODULE_0_warning___default()(!(!nextProps.location && this.props.location), '<Route> elements should not change from controlled to uncontrolled (or vice versa). You provided a "location" prop initially but omitted it on a subsequent render.'); | |
this.setState({ | |
match: this.computeMatch(nextProps, nextContext.router) | |
}); | |
}; | |
Route.prototype.render = function render() { | |
var match = this.state.match; | |
var _props2 = this.props, | |
children = _props2.children, | |
component = _props2.component, | |
render = _props2.render; | |
var _context$router = this.context.router, | |
history = _context$router.history, | |
route = _context$router.route, | |
staticContext = _context$router.staticContext; | |
var location = this.props.location || route.location; | |
var props = { match: match, location: location, history: history, staticContext: staticContext }; | |
return component ? // component prop gets first priority, only called if there's a match | |
match ? __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(component, props) : null : render ? // render prop is next, only called if there's a match | |
match ? render(props) : null : children ? // children come last, always called | |
typeof children === 'function' ? children(props) : !Array.isArray(children) || children.length ? // Preact defaults to empty children array | |
__WEBPACK_IMPORTED_MODULE_1_react___default.a.Children.only(children) : null : null; | |
}; | |
return Route; | |
}(__WEBPACK_IMPORTED_MODULE_1_react___default.a.Component); | |
Route.propTypes = { | |
computedMatch: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object, // private, from <Switch> | |
path: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.string, | |
exact: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool, | |
strict: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool, | |
component: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func, | |
render: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func, | |
children: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.node]), | |
location: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object | |
}; | |
Route.contextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.shape({ | |
history: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object.isRequired, | |
route: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object.isRequired, | |
staticContext: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object | |
}) | |
}; | |
Route.childContextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object.isRequired | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (Route); | |
/***/ }), | |
/* 7 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* Copyright 2013-2015, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
*/ | |
/** | |
* 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 (false) { | |
if (format === undefined) { | |
throw new Error('invariant requires an error message argument'); | |
} | |
} | |
if (!condition) { | |
var error; | |
if (format === undefined) { | |
error = new Error( | |
'Minified exception occurred; use the non-minified dev environment ' + | |
'for the full error message and additional helpful warnings.' | |
); | |
} else { | |
var args = [a, b, c, d, e, f]; | |
var argIndex = 0; | |
error = new Error( | |
format.replace(/%s/g, function() { return args[argIndex++]; }) | |
); | |
error.name = 'Invariant Violation'; | |
} | |
error.framesToPop = 1; // we don't care about invariant's own frame | |
throw error; | |
} | |
}; | |
module.exports = invariant; | |
/***/ }), | |
/* 8 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_history_createMemoryHistory__ = __webpack_require__(18); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_history_createMemoryHistory___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_history_createMemoryHistory__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Router__ = __webpack_require__(3); | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
/** | |
* The public API for a <Router> that stores location in memory. | |
*/ | |
var MemoryRouter = function (_React$Component) { | |
_inherits(MemoryRouter, _React$Component); | |
function MemoryRouter() { | |
var _temp, _this, _ret; | |
_classCallCheck(this, MemoryRouter); | |
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
args[_key] = arguments[_key]; | |
} | |
return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.history = __WEBPACK_IMPORTED_MODULE_2_history_createMemoryHistory___default()(_this.props), _temp), _possibleConstructorReturn(_this, _ret); | |
} | |
MemoryRouter.prototype.render = function render() { | |
return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3__Router__["a" /* default */], { history: this.history, children: this.props.children }); | |
}; | |
return MemoryRouter; | |
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component); | |
MemoryRouter.propTypes = { | |
initialEntries: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array, | |
initialIndex: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, | |
getUserConfirmation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, | |
keyLength: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, | |
children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (MemoryRouter); | |
/***/ }), | |
/* 9 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__); | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
/** | |
* The public API for prompting the user before navigating away | |
* from a screen with a component. | |
*/ | |
var Prompt = function (_React$Component) { | |
_inherits(Prompt, _React$Component); | |
function Prompt() { | |
_classCallCheck(this, Prompt); | |
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments)); | |
} | |
Prompt.prototype.enable = function enable(message) { | |
if (this.unblock) this.unblock(); | |
this.unblock = this.context.router.history.block(message); | |
}; | |
Prompt.prototype.disable = function disable() { | |
if (this.unblock) { | |
this.unblock(); | |
this.unblock = null; | |
} | |
}; | |
Prompt.prototype.componentWillMount = function componentWillMount() { | |
if (this.props.when) this.enable(this.props.message); | |
}; | |
Prompt.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { | |
if (nextProps.when) { | |
if (!this.props.when || this.props.message !== nextProps.message) this.enable(nextProps.message); | |
} else { | |
this.disable(); | |
} | |
}; | |
Prompt.prototype.componentWillUnmount = function componentWillUnmount() { | |
this.disable(); | |
}; | |
Prompt.prototype.render = function render() { | |
return null; | |
}; | |
return Prompt; | |
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component); | |
Prompt.propTypes = { | |
when: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, | |
message: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string]).isRequired | |
}; | |
Prompt.defaultProps = { | |
when: true | |
}; | |
Prompt.contextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ | |
history: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ | |
block: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func.isRequired | |
}).isRequired | |
}).isRequired | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (Prompt); | |
/***/ }), | |
/* 10 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__); | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
/** | |
* The public API for updating the location programatically | |
* with a component. | |
*/ | |
var Redirect = function (_React$Component) { | |
_inherits(Redirect, _React$Component); | |
function Redirect() { | |
_classCallCheck(this, Redirect); | |
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments)); | |
} | |
Redirect.prototype.isStatic = function isStatic() { | |
return this.context.router && this.context.router.staticContext; | |
}; | |
Redirect.prototype.componentWillMount = function componentWillMount() { | |
if (this.isStatic()) this.perform(); | |
}; | |
Redirect.prototype.componentDidMount = function componentDidMount() { | |
if (!this.isStatic()) this.perform(); | |
}; | |
Redirect.prototype.perform = function perform() { | |
var history = this.context.router.history; | |
var _props = this.props, | |
push = _props.push, | |
to = _props.to; | |
if (push) { | |
history.push(to); | |
} else { | |
history.replace(to); | |
} | |
}; | |
Redirect.prototype.render = function render() { | |
return null; | |
}; | |
return Redirect; | |
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component); | |
Redirect.propTypes = { | |
push: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, | |
from: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, | |
to: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object]) | |
}; | |
Redirect.defaultProps = { | |
push: false | |
}; | |
Redirect.contextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ | |
history: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ | |
push: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func.isRequired, | |
replace: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func.isRequired | |
}).isRequired, | |
staticContext: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object | |
}).isRequired | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (Redirect); | |
/***/ }), | |
/* 11 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_invariant__ = __webpack_require__(7); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_invariant___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_invariant__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_prop_types__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_history_PathUtils__ = __webpack_require__(5); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_history_PathUtils___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_history_PathUtils__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__Router__ = __webpack_require__(3); | |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; | |
function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
var normalizeLocation = function normalizeLocation(object) { | |
var _object$pathname = object.pathname, | |
pathname = _object$pathname === undefined ? '/' : _object$pathname, | |
_object$search = object.search, | |
search = _object$search === undefined ? '' : _object$search, | |
_object$hash = object.hash, | |
hash = _object$hash === undefined ? '' : _object$hash; | |
return { | |
pathname: pathname, | |
search: search === '?' ? '' : search, | |
hash: hash === '#' ? '' : hash | |
}; | |
}; | |
var addBasename = function addBasename(basename, location) { | |
if (!basename) return location; | |
return _extends({}, location, { | |
pathname: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_history_PathUtils__["addLeadingSlash"])(basename) + location.pathname | |
}); | |
}; | |
var stripBasename = function stripBasename(basename, location) { | |
if (!basename) return location; | |
var base = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_history_PathUtils__["addLeadingSlash"])(basename); | |
if (location.pathname.indexOf(base) !== 0) return location; | |
return _extends({}, location, { | |
pathname: location.pathname.substr(base.length) | |
}); | |
}; | |
var createLocation = function createLocation(location) { | |
return typeof location === 'string' ? __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_history_PathUtils__["parsePath"])(location) : normalizeLocation(location); | |
}; | |
var createURL = function createURL(location) { | |
return typeof location === 'string' ? location : __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_history_PathUtils__["createPath"])(location); | |
}; | |
var staticHandler = function staticHandler(methodName) { | |
return function () { | |
__WEBPACK_IMPORTED_MODULE_0_invariant___default()(false, 'You cannot %s with <StaticRouter>', methodName); | |
}; | |
}; | |
var noop = function noop() {}; | |
/** | |
* The public top-level API for a "static" <Router>, so-called because it | |
* can't actually change the current location. Instead, it just records | |
* location changes in a context object. Useful mainly in testing and | |
* server-rendering scenarios. | |
*/ | |
var StaticRouter = function (_React$Component) { | |
_inherits(StaticRouter, _React$Component); | |
function StaticRouter() { | |
var _temp, _this, _ret; | |
_classCallCheck(this, StaticRouter); | |
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
args[_key] = arguments[_key]; | |
} | |
return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.createHref = function (path) { | |
return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_history_PathUtils__["addLeadingSlash"])(_this.props.basename + createURL(path)); | |
}, _this.handlePush = function (location) { | |
var _this$props = _this.props, | |
basename = _this$props.basename, | |
context = _this$props.context; | |
context.action = 'PUSH'; | |
context.location = addBasename(basename, createLocation(location)); | |
context.url = createURL(context.location); | |
}, _this.handleReplace = function (location) { | |
var _this$props2 = _this.props, | |
basename = _this$props2.basename, | |
context = _this$props2.context; | |
context.action = 'REPLACE'; | |
context.location = addBasename(basename, createLocation(location)); | |
context.url = createURL(context.location); | |
}, _this.handleListen = function () { | |
return noop; | |
}, _this.handleBlock = function () { | |
return noop; | |
}, _temp), _possibleConstructorReturn(_this, _ret); | |
} | |
StaticRouter.prototype.getChildContext = function getChildContext() { | |
return { | |
router: { | |
staticContext: this.props.context | |
} | |
}; | |
}; | |
StaticRouter.prototype.render = function render() { | |
var _props = this.props, | |
basename = _props.basename, | |
context = _props.context, | |
location = _props.location, | |
props = _objectWithoutProperties(_props, ['basename', 'context', 'location']); | |
var history = { | |
createHref: this.createHref, | |
action: 'POP', | |
location: stripBasename(basename, createLocation(location)), | |
push: this.handlePush, | |
replace: this.handleReplace, | |
go: staticHandler('go'), | |
goBack: staticHandler('goBack'), | |
goForward: staticHandler('goForward'), | |
listen: this.handleListen, | |
block: this.handleBlock | |
}; | |
return __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_4__Router__["a" /* default */], _extends({}, props, { history: history })); | |
}; | |
return StaticRouter; | |
}(__WEBPACK_IMPORTED_MODULE_1_react___default.a.Component); | |
StaticRouter.propTypes = { | |
basename: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.string, | |
context: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object.isRequired, | |
location: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object]) | |
}; | |
StaticRouter.defaultProps = { | |
basename: '', | |
location: '/' | |
}; | |
StaticRouter.childContextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object.isRequired | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (StaticRouter); | |
/***/ }), | |
/* 12 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_warning__ = __webpack_require__(2); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_warning__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__matchPath__ = __webpack_require__(4); | |
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
/** | |
* The public API for rendering the first <Route> that matches. | |
*/ | |
var Switch = function (_React$Component) { | |
_inherits(Switch, _React$Component); | |
function Switch() { | |
_classCallCheck(this, Switch); | |
return _possibleConstructorReturn(this, _React$Component.apply(this, arguments)); | |
} | |
Switch.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { | |
__WEBPACK_IMPORTED_MODULE_2_warning___default()(!(nextProps.location && !this.props.location), '<Switch> elements should not change from uncontrolled to controlled (or vice versa). You initially used no "location" prop and then provided one on a subsequent render.'); | |
__WEBPACK_IMPORTED_MODULE_2_warning___default()(!(!nextProps.location && this.props.location), '<Switch> elements should not change from controlled to uncontrolled (or vice versa). You provided a "location" prop initially but omitted it on a subsequent render.'); | |
}; | |
Switch.prototype.render = function render() { | |
var route = this.context.router.route; | |
var children = this.props.children; | |
var location = this.props.location || route.location; | |
var match = void 0, | |
child = void 0; | |
__WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(children, function (element) { | |
if (!__WEBPACK_IMPORTED_MODULE_0_react___default.a.isValidElement(element)) return; | |
var _element$props = element.props, | |
pathProp = _element$props.path, | |
exact = _element$props.exact, | |
strict = _element$props.strict, | |
from = _element$props.from; | |
var path = pathProp || from; | |
if (match == null) { | |
child = element; | |
match = path ? __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3__matchPath__["a" /* default */])(location.pathname, { path: path, exact: exact, strict: strict }) : route.match; | |
} | |
}); | |
return match ? __WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(child, { location: location, computedMatch: match }) : null; | |
}; | |
return Switch; | |
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component); | |
Switch.contextTypes = { | |
router: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ | |
route: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object.isRequired | |
}).isRequired | |
}; | |
Switch.propTypes = { | |
children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node, | |
location: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (Switch); | |
/***/ }), | |
/* 13 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(0); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_hoist_non_react_statics__ = __webpack_require__(20); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_hoist_non_react_statics___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_hoist_non_react_statics__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Route__ = __webpack_require__(6); | |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; | |
function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } | |
/** | |
* A public higher-order component to access the imperative API | |
*/ | |
var withRouter = function withRouter(Component) { | |
var C = function C(props) { | |
var wrappedComponentRef = props.wrappedComponentRef, | |
remainingProps = _objectWithoutProperties(props, ['wrappedComponentRef']); | |
return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3__Route__["a" /* default */], { render: function render(routeComponentProps) { | |
return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(Component, _extends({}, remainingProps, routeComponentProps, { ref: wrappedComponentRef })); | |
} }); | |
}; | |
C.displayName = 'withRouter(' + (Component.displayName || Component.name) + ')'; | |
C.WrappedComponent = Component; | |
C.propTypes = { | |
wrappedComponentRef: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func | |
}; | |
return __WEBPACK_IMPORTED_MODULE_2_hoist_non_react_statics___default()(C, Component); | |
}; | |
/* harmony default export */ __webpack_exports__["a"] = (withRouter); | |
/***/ }), | |
/* 14 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__MemoryRouter__ = __webpack_require__(8); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "MemoryRouter", function() { return __WEBPACK_IMPORTED_MODULE_0__MemoryRouter__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Prompt__ = __webpack_require__(9); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Prompt", function() { return __WEBPACK_IMPORTED_MODULE_1__Prompt__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Redirect__ = __webpack_require__(10); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Redirect", function() { return __WEBPACK_IMPORTED_MODULE_2__Redirect__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Route__ = __webpack_require__(6); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Route", function() { return __WEBPACK_IMPORTED_MODULE_3__Route__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__Router__ = __webpack_require__(3); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Router", function() { return __WEBPACK_IMPORTED_MODULE_4__Router__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__StaticRouter__ = __webpack_require__(11); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "StaticRouter", function() { return __WEBPACK_IMPORTED_MODULE_5__StaticRouter__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__Switch__ = __webpack_require__(12); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Switch", function() { return __WEBPACK_IMPORTED_MODULE_6__Switch__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__matchPath__ = __webpack_require__(4); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "matchPath", function() { return __WEBPACK_IMPORTED_MODULE_7__matchPath__["a"]; }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__withRouter__ = __webpack_require__(13); | |
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "withRouter", function() { return __WEBPACK_IMPORTED_MODULE_8__withRouter__["a"]; }); | |
/***/ }), | |
/* 15 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* Copyright (c) 2013-present, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
* | |
* | |
*/ | |
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. | |
*/ | |
var emptyFunction = function emptyFunction() {}; | |
emptyFunction.thatReturns = makeEmptyFunction; | |
emptyFunction.thatReturnsFalse = makeEmptyFunction(false); | |
emptyFunction.thatReturnsTrue = makeEmptyFunction(true); | |
emptyFunction.thatReturnsNull = makeEmptyFunction(null); | |
emptyFunction.thatReturnsThis = function () { | |
return this; | |
}; | |
emptyFunction.thatReturnsArgument = function (arg) { | |
return arg; | |
}; | |
module.exports = emptyFunction; | |
/***/ }), | |
/* 16 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* Copyright (c) 2013-present, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
* | |
*/ | |
/** | |
* 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 validateFormat = function validateFormat(format) {}; | |
if (false) { | |
validateFormat = function validateFormat(format) { | |
if (format === undefined) { | |
throw new Error('invariant requires an error message argument'); | |
} | |
}; | |
} | |
function invariant(condition, format, a, b, c, d, e, f) { | |
validateFormat(format); | |
if (!condition) { | |
var error; | |
if (format === undefined) { | |
error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); | |
} else { | |
var args = [a, b, c, d, e, f]; | |
var argIndex = 0; | |
error = new Error(format.replace(/%s/g, function () { | |
return args[argIndex++]; | |
})); | |
error.name = 'Invariant Violation'; | |
} | |
error.framesToPop = 1; // we don't care about invariant's own frame | |
throw error; | |
} | |
} | |
module.exports = invariant; | |
/***/ }), | |
/* 17 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
exports.__esModule = true; | |
exports.locationsAreEqual = exports.createLocation = undefined; | |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; | |
var _resolvePathname = __webpack_require__(25); | |
var _resolvePathname2 = _interopRequireDefault(_resolvePathname); | |
var _valueEqual = __webpack_require__(26); | |
var _valueEqual2 = _interopRequireDefault(_valueEqual); | |
var _PathUtils = __webpack_require__(5); | |
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
var createLocation = exports.createLocation = function createLocation(path, state, key, currentLocation) { | |
var location = void 0; | |
if (typeof path === 'string') { | |
// Two-arg form: push(path, state) | |
location = (0, _PathUtils.parsePath)(path); | |
location.state = state; | |
} else { | |
// One-arg form: push(location) | |
location = _extends({}, path); | |
if (location.pathname === undefined) location.pathname = ''; | |
if (location.search) { | |
if (location.search.charAt(0) !== '?') location.search = '?' + location.search; | |
} else { | |
location.search = ''; | |
} | |
if (location.hash) { | |
if (location.hash.charAt(0) !== '#') location.hash = '#' + location.hash; | |
} else { | |
location.hash = ''; | |
} | |
if (state !== undefined && location.state === undefined) location.state = state; | |
} | |
try { | |
location.pathname = decodeURI(location.pathname); | |
} catch (e) { | |
if (e instanceof URIError) { | |
throw new URIError('Pathname "' + location.pathname + '" could not be decoded. ' + 'This is likely caused by an invalid percent-encoding.'); | |
} else { | |
throw e; | |
} | |
} | |
if (key) location.key = key; | |
if (currentLocation) { | |
// Resolve incomplete/relative pathname relative to current location. | |
if (!location.pathname) { | |
location.pathname = currentLocation.pathname; | |
} else if (location.pathname.charAt(0) !== '/') { | |
location.pathname = (0, _resolvePathname2.default)(location.pathname, currentLocation.pathname); | |
} | |
} else { | |
// When there is no prior location and pathname is empty, set it to / | |
if (!location.pathname) { | |
location.pathname = '/'; | |
} | |
} | |
return location; | |
}; | |
var locationsAreEqual = exports.locationsAreEqual = function locationsAreEqual(a, b) { | |
return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash && a.key === b.key && (0, _valueEqual2.default)(a.state, b.state); | |
}; | |
/***/ }), | |
/* 18 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
exports.__esModule = true; | |
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; | |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; | |
var _warning = __webpack_require__(2); | |
var _warning2 = _interopRequireDefault(_warning); | |
var _PathUtils = __webpack_require__(5); | |
var _LocationUtils = __webpack_require__(17); | |
var _createTransitionManager = __webpack_require__(19); | |
var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager); | |
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
var clamp = function clamp(n, lowerBound, upperBound) { | |
return Math.min(Math.max(n, lowerBound), upperBound); | |
}; | |
/** | |
* Creates a history object that stores locations in memory. | |
*/ | |
var createMemoryHistory = function createMemoryHistory() { | |
var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; | |
var getUserConfirmation = props.getUserConfirmation, | |
_props$initialEntries = props.initialEntries, | |
initialEntries = _props$initialEntries === undefined ? ['/'] : _props$initialEntries, | |
_props$initialIndex = props.initialIndex, | |
initialIndex = _props$initialIndex === undefined ? 0 : _props$initialIndex, | |
_props$keyLength = props.keyLength, | |
keyLength = _props$keyLength === undefined ? 6 : _props$keyLength; | |
var transitionManager = (0, _createTransitionManager2.default)(); | |
var setState = function setState(nextState) { | |
_extends(history, nextState); | |
history.length = history.entries.length; | |
transitionManager.notifyListeners(history.location, history.action); | |
}; | |
var createKey = function createKey() { | |
return Math.random().toString(36).substr(2, keyLength); | |
}; | |
var index = clamp(initialIndex, 0, initialEntries.length - 1); | |
var entries = initialEntries.map(function (entry) { | |
return typeof entry === 'string' ? (0, _LocationUtils.createLocation)(entry, undefined, createKey()) : (0, _LocationUtils.createLocation)(entry, undefined, entry.key || createKey()); | |
}); | |
// Public interface | |
var createHref = _PathUtils.createPath; | |
var push = function push(path, state) { | |
(0, _warning2.default)(!((typeof path === 'undefined' ? 'undefined' : _typeof(path)) === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored'); | |
var action = 'PUSH'; | |
var location = (0, _LocationUtils.createLocation)(path, state, createKey(), history.location); | |
transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { | |
if (!ok) return; | |
var prevIndex = history.index; | |
var nextIndex = prevIndex + 1; | |
var nextEntries = history.entries.slice(0); | |
if (nextEntries.length > nextIndex) { | |
nextEntries.splice(nextIndex, nextEntries.length - nextIndex, location); | |
} else { | |
nextEntries.push(location); | |
} | |
setState({ | |
action: action, | |
location: location, | |
index: nextIndex, | |
entries: nextEntries | |
}); | |
}); | |
}; | |
var replace = function replace(path, state) { | |
(0, _warning2.default)(!((typeof path === 'undefined' ? 'undefined' : _typeof(path)) === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored'); | |
var action = 'REPLACE'; | |
var location = (0, _LocationUtils.createLocation)(path, state, createKey(), history.location); | |
transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { | |
if (!ok) return; | |
history.entries[history.index] = location; | |
setState({ action: action, location: location }); | |
}); | |
}; | |
var go = function go(n) { | |
var nextIndex = clamp(history.index + n, 0, history.entries.length - 1); | |
var action = 'POP'; | |
var location = history.entries[nextIndex]; | |
transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) { | |
if (ok) { | |
setState({ | |
action: action, | |
location: location, | |
index: nextIndex | |
}); | |
} else { | |
// Mimic the behavior of DOM histories by | |
// causing a render after a cancelled POP. | |
setState(); | |
} | |
}); | |
}; | |
var goBack = function goBack() { | |
return go(-1); | |
}; | |
var goForward = function goForward() { | |
return go(1); | |
}; | |
var canGo = function canGo(n) { | |
var nextIndex = history.index + n; | |
return nextIndex >= 0 && nextIndex < history.entries.length; | |
}; | |
var block = function block() { | |
var prompt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; | |
return transitionManager.setPrompt(prompt); | |
}; | |
var listen = function listen(listener) { | |
return transitionManager.appendListener(listener); | |
}; | |
var history = { | |
length: entries.length, | |
action: 'POP', | |
location: entries[index], | |
index: index, | |
entries: entries, | |
createHref: createHref, | |
push: push, | |
replace: replace, | |
go: go, | |
goBack: goBack, | |
goForward: goForward, | |
canGo: canGo, | |
block: block, | |
listen: listen | |
}; | |
return history; | |
}; | |
exports.default = createMemoryHistory; | |
/***/ }), | |
/* 19 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
exports.__esModule = true; | |
var _warning = __webpack_require__(2); | |
var _warning2 = _interopRequireDefault(_warning); | |
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
var createTransitionManager = function createTransitionManager() { | |
var prompt = null; | |
var setPrompt = function setPrompt(nextPrompt) { | |
(0, _warning2.default)(prompt == null, 'A history supports only one prompt at a time'); | |
prompt = nextPrompt; | |
return function () { | |
if (prompt === nextPrompt) prompt = null; | |
}; | |
}; | |
var confirmTransitionTo = function confirmTransitionTo(location, action, getUserConfirmation, callback) { | |
// TODO: If another transition starts while we're still confirming | |
// the previous one, we may end up in a weird state. Figure out the | |
// best way to handle this. | |
if (prompt != null) { | |
var result = typeof prompt === 'function' ? prompt(location, action) : prompt; | |
if (typeof result === 'string') { | |
if (typeof getUserConfirmation === 'function') { | |
getUserConfirmation(result, callback); | |
} else { | |
(0, _warning2.default)(false, 'A history needs a getUserConfirmation function in order to use a prompt message'); | |
callback(true); | |
} | |
} else { | |
// Return false from a transition hook to cancel the transition. | |
callback(result !== false); | |
} | |
} else { | |
callback(true); | |
} | |
}; | |
var listeners = []; | |
var appendListener = function appendListener(fn) { | |
var isActive = true; | |
var listener = function listener() { | |
if (isActive) fn.apply(undefined, arguments); | |
}; | |
listeners.push(listener); | |
return function () { | |
isActive = false; | |
listeners = listeners.filter(function (item) { | |
return item !== listener; | |
}); | |
}; | |
}; | |
var notifyListeners = function notifyListeners() { | |
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { | |
args[_key] = arguments[_key]; | |
} | |
listeners.forEach(function (listener) { | |
return listener.apply(undefined, args); | |
}); | |
}; | |
return { | |
setPrompt: setPrompt, | |
confirmTransitionTo: confirmTransitionTo, | |
appendListener: appendListener, | |
notifyListeners: notifyListeners | |
}; | |
}; | |
exports.default = createTransitionManager; | |
/***/ }), | |
/* 20 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* Copyright 2015, Yahoo! Inc. | |
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. | |
*/ | |
var REACT_STATICS = { | |
childContextTypes: true, | |
contextTypes: true, | |
defaultProps: true, | |
displayName: true, | |
getDefaultProps: true, | |
mixins: true, | |
propTypes: true, | |
type: true | |
}; | |
var KNOWN_STATICS = { | |
name: true, | |
length: true, | |
prototype: true, | |
caller: true, | |
arguments: true, | |
arity: true | |
}; | |
var isGetOwnPropertySymbolsAvailable = typeof Object.getOwnPropertySymbols === 'function'; | |
module.exports = function hoistNonReactStatics(targetComponent, sourceComponent, customStatics) { | |
if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components | |
var keys = Object.getOwnPropertyNames(sourceComponent); | |
/* istanbul ignore else */ | |
if (isGetOwnPropertySymbolsAvailable) { | |
keys = keys.concat(Object.getOwnPropertySymbols(sourceComponent)); | |
} | |
for (var i = 0; i < keys.length; ++i) { | |
if (!REACT_STATICS[keys[i]] && !KNOWN_STATICS[keys[i]] && (!customStatics || !customStatics[keys[i]])) { | |
try { | |
targetComponent[keys[i]] = sourceComponent[keys[i]]; | |
} catch (error) { | |
} | |
} | |
} | |
} | |
return targetComponent; | |
}; | |
/***/ }), | |
/* 21 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var isarray = __webpack_require__(22) | |
/** | |
* Expose `pathToRegexp`. | |
*/ | |
module.exports = pathToRegexp | |
module.exports.parse = parse | |
module.exports.compile = compile | |
module.exports.tokensToFunction = tokensToFunction | |
module.exports.tokensToRegExp = tokensToRegExp | |
/** | |
* The main path matching regexp utility. | |
* | |
* @type {RegExp} | |
*/ | |
var PATH_REGEXP = new RegExp([ | |
// Match escaped characters that would otherwise appear in future matches. | |
// This allows the user to escape special characters that won't transform. | |
'(\\\\.)', | |
// Match Express-style parameters and un-named parameters with a prefix | |
// and optional suffixes. Matches appear as: | |
// | |
// "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined] | |
// "/route(\\d+)" => [undefined, undefined, undefined, "\d+", undefined, undefined] | |
// "/*" => ["/", undefined, undefined, undefined, undefined, "*"] | |
'([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))' | |
].join('|'), 'g') | |
/** | |
* Parse a string for the raw tokens. | |
* | |
* @param {string} str | |
* @param {Object=} options | |
* @return {!Array} | |
*/ | |
function parse (str, options) { | |
var tokens = [] | |
var key = 0 | |
var index = 0 | |
var path = '' | |
var defaultDelimiter = options && options.delimiter || '/' | |
var res | |
while ((res = PATH_REGEXP.exec(str)) != null) { | |
var m = res[0] | |
var escaped = res[1] | |
var offset = res.index | |
path += str.slice(index, offset) | |
index = offset + m.length | |
// Ignore already escaped sequences. | |
if (escaped) { | |
path += escaped[1] | |
continue | |
} | |
var next = str[index] | |
var prefix = res[2] | |
var name = res[3] | |
var capture = res[4] | |
var group = res[5] | |
var modifier = res[6] | |
var asterisk = res[7] | |
// Push the current path onto the tokens. | |
if (path) { | |
tokens.push(path) | |
path = '' | |
} | |
var partial = prefix != null && next != null && next !== prefix | |
var repeat = modifier === '+' || modifier === '*' | |
var optional = modifier === '?' || modifier === '*' | |
var delimiter = res[2] || defaultDelimiter | |
var pattern = capture || group | |
tokens.push({ | |
name: name || key++, | |
prefix: prefix || '', | |
delimiter: delimiter, | |
optional: optional, | |
repeat: repeat, | |
partial: partial, | |
asterisk: !!asterisk, | |
pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?') | |
}) | |
} | |
// Match any characters still remaining. | |
if (index < str.length) { | |
path += str.substr(index) | |
} | |
// If the path exists, push it onto the end. | |
if (path) { | |
tokens.push(path) | |
} | |
return tokens | |
} | |
/** | |
* Compile a string to a template function for the path. | |
* | |
* @param {string} str | |
* @param {Object=} options | |
* @return {!function(Object=, Object=)} | |
*/ | |
function compile (str, options) { | |
return tokensToFunction(parse(str, options)) | |
} | |
/** | |
* Prettier encoding of URI path segments. | |
* | |
* @param {string} | |
* @return {string} | |
*/ | |
function encodeURIComponentPretty (str) { | |
return encodeURI(str).replace(/[\/?#]/g, function (c) { | |
return '%' + c.charCodeAt(0).toString(16).toUpperCase() | |
}) | |
} | |
/** | |
* Encode the asterisk parameter. Similar to `pretty`, but allows slashes. | |
* | |
* @param {string} | |
* @return {string} | |
*/ | |
function encodeAsterisk (str) { | |
return encodeURI(str).replace(/[?#]/g, function (c) { | |
return '%' + c.charCodeAt(0).toString(16).toUpperCase() | |
}) | |
} | |
/** | |
* Expose a method for transforming tokens into the path function. | |
*/ | |
function tokensToFunction (tokens) { | |
// Compile all the tokens into regexps. | |
var matches = new Array(tokens.length) | |
// Compile all the patterns before compilation. | |
for (var i = 0; i < tokens.length; i++) { | |
if (typeof tokens[i] === 'object') { | |
matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$') | |
} | |
} | |
return function (obj, opts) { | |
var path = '' | |
var data = obj || {} | |
var options = opts || {} | |
var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent | |
for (var i = 0; i < tokens.length; i++) { | |
var token = tokens[i] | |
if (typeof token === 'string') { | |
path += token | |
continue | |
} | |
var value = data[token.name] | |
var segment | |
if (value == null) { | |
if (token.optional) { | |
// Prepend partial segment prefixes. | |
if (token.partial) { | |
path += token.prefix | |
} | |
continue | |
} else { | |
throw new TypeError('Expected "' + token.name + '" to be defined') | |
} | |
} | |
if (isarray(value)) { | |
if (!token.repeat) { | |
throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`') | |
} | |
if (value.length === 0) { | |
if (token.optional) { | |
continue | |
} else { | |
throw new TypeError('Expected "' + token.name + '" to not be empty') | |
} | |
} | |
for (var j = 0; j < value.length; j++) { | |
segment = encode(value[j]) | |
if (!matches[i].test(segment)) { | |
throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`') | |
} | |
path += (j === 0 ? token.prefix : token.delimiter) + segment | |
} | |
continue | |
} | |
segment = token.asterisk ? encodeAsterisk(value) : encode(value) | |
if (!matches[i].test(segment)) { | |
throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"') | |
} | |
path += token.prefix + segment | |
} | |
return path | |
} | |
} | |
/** | |
* Escape a regular expression string. | |
* | |
* @param {string} str | |
* @return {string} | |
*/ | |
function escapeString (str) { | |
return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1') | |
} | |
/** | |
* Escape the capturing group by escaping special characters and meaning. | |
* | |
* @param {string} group | |
* @return {string} | |
*/ | |
function escapeGroup (group) { | |
return group.replace(/([=!:$\/()])/g, '\\$1') | |
} | |
/** | |
* Attach the keys as a property of the regexp. | |
* | |
* @param {!RegExp} re | |
* @param {Array} keys | |
* @return {!RegExp} | |
*/ | |
function attachKeys (re, keys) { | |
re.keys = keys | |
return re | |
} | |
/** | |
* Get the flags for a regexp from the options. | |
* | |
* @param {Object} options | |
* @return {string} | |
*/ | |
function flags (options) { | |
return options.sensitive ? '' : 'i' | |
} | |
/** | |
* Pull out keys from a regexp. | |
* | |
* @param {!RegExp} path | |
* @param {!Array} keys | |
* @return {!RegExp} | |
*/ | |
function regexpToRegexp (path, keys) { | |
// Use a negative lookahead to match only capturing groups. | |
var groups = path.source.match(/\((?!\?)/g) | |
if (groups) { | |
for (var i = 0; i < groups.length; i++) { | |
keys.push({ | |
name: i, | |
prefix: null, | |
delimiter: null, | |
optional: false, | |
repeat: false, | |
partial: false, | |
asterisk: false, | |
pattern: null | |
}) | |
} | |
} | |
return attachKeys(path, keys) | |
} | |
/** | |
* Transform an array into a regexp. | |
* | |
* @param {!Array} path | |
* @param {Array} keys | |
* @param {!Object} options | |
* @return {!RegExp} | |
*/ | |
function arrayToRegexp (path, keys, options) { | |
var parts = [] | |
for (var i = 0; i < path.length; i++) { | |
parts.push(pathToRegexp(path[i], keys, options).source) | |
} | |
var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options)) | |
return attachKeys(regexp, keys) | |
} | |
/** | |
* Create a path regexp from string input. | |
* | |
* @param {string} path | |
* @param {!Array} keys | |
* @param {!Object} options | |
* @return {!RegExp} | |
*/ | |
function stringToRegexp (path, keys, options) { | |
return tokensToRegExp(parse(path, options), keys, options) | |
} | |
/** | |
* Expose a function for taking tokens and returning a RegExp. | |
* | |
* @param {!Array} tokens | |
* @param {(Array|Object)=} keys | |
* @param {Object=} options | |
* @return {!RegExp} | |
*/ | |
function tokensToRegExp (tokens, keys, options) { | |
if (!isarray(keys)) { | |
options = /** @type {!Object} */ (keys || options) | |
keys = [] | |
} | |
options = options || {} | |
var strict = options.strict | |
var end = options.end !== false | |
var route = '' | |
// Iterate over the tokens and create our regexp string. | |
for (var i = 0; i < tokens.length; i++) { | |
var token = tokens[i] | |
if (typeof token === 'string') { | |
route += escapeString(token) | |
} else { | |
var prefix = escapeString(token.prefix) | |
var capture = '(?:' + token.pattern + ')' | |
keys.push(token) | |
if (token.repeat) { | |
capture += '(?:' + prefix + capture + ')*' | |
} | |
if (token.optional) { | |
if (!token.partial) { | |
capture = '(?:' + prefix + '(' + capture + '))?' | |
} else { | |
capture = prefix + '(' + capture + ')?' | |
} | |
} else { | |
capture = prefix + '(' + capture + ')' | |
} | |
route += capture | |
} | |
} | |
var delimiter = escapeString(options.delimiter || '/') | |
var endsWithDelimiter = route.slice(-delimiter.length) === delimiter | |
// In non-strict mode we allow a slash at the end of match. If the path to | |
// match already ends with a slash, we remove it for consistency. The slash | |
// is valid at the end of a path match, not in the middle. This is important | |
// in non-ending mode, where "/test/" shouldn't match "/test//route". | |
if (!strict) { | |
route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?' | |
} | |
if (end) { | |
route += '$' | |
} else { | |
// In non-ending mode, we need the capturing groups to match as much as | |
// possible by using a positive lookahead to the end or next path segment. | |
route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)' | |
} | |
return attachKeys(new RegExp('^' + route, flags(options)), keys) | |
} | |
/** | |
* Normalize the given path string, returning a regular expression. | |
* | |
* An empty array can be passed in for the keys, which will hold the | |
* placeholder key descriptions. For example, using `/user/:id`, `keys` will | |
* contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`. | |
* | |
* @param {(string|RegExp|Array)} path | |
* @param {(Array|Object)=} keys | |
* @param {Object=} options | |
* @return {!RegExp} | |
*/ | |
function pathToRegexp (path, keys, options) { | |
if (!isarray(keys)) { | |
options = /** @type {!Object} */ (keys || options) | |
keys = [] | |
} | |
options = options || {} | |
if (path instanceof RegExp) { | |
return regexpToRegexp(path, /** @type {!Array} */ (keys)) | |
} | |
if (isarray(path)) { | |
return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options) | |
} | |
return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options) | |
} | |
/***/ }), | |
/* 22 */ | |
/***/ (function(module, exports) { | |
module.exports = Array.isArray || function (arr) { | |
return Object.prototype.toString.call(arr) == '[object Array]'; | |
}; | |
/***/ }), | |
/* 23 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* Copyright 2013-present, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
*/ | |
var emptyFunction = __webpack_require__(15); | |
var invariant = __webpack_require__(16); | |
var ReactPropTypesSecret = __webpack_require__(24); | |
module.exports = function() { | |
function shim(props, propName, componentName, location, propFullName, secret) { | |
if (secret === ReactPropTypesSecret) { | |
// It is still safe when called from React. | |
return; | |
} | |
invariant( | |
false, | |
'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + | |
'Use PropTypes.checkPropTypes() to call them. ' + | |
'Read more at http://fb.me/use-check-prop-types' | |
); | |
}; | |
shim.isRequired = shim; | |
function getShim() { | |
return shim; | |
}; | |
// Important! | |
// Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. | |
var ReactPropTypes = { | |
array: shim, | |
bool: shim, | |
func: shim, | |
number: shim, | |
object: shim, | |
string: shim, | |
symbol: shim, | |
any: shim, | |
arrayOf: getShim, | |
element: shim, | |
instanceOf: getShim, | |
node: shim, | |
objectOf: getShim, | |
oneOf: getShim, | |
oneOfType: getShim, | |
shape: getShim | |
}; | |
ReactPropTypes.checkPropTypes = emptyFunction; | |
ReactPropTypes.PropTypes = ReactPropTypes; | |
return ReactPropTypes; | |
}; | |
/***/ }), | |
/* 24 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
/** | |
* Copyright 2013-present, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
*/ | |
var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; | |
module.exports = ReactPropTypesSecret; | |
/***/ }), | |
/* 25 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
var isAbsolute = function isAbsolute(pathname) { | |
return pathname.charAt(0) === '/'; | |
}; | |
// About 1.5x faster than the two-arg version of Array#splice() | |
var spliceOne = function spliceOne(list, index) { | |
for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) { | |
list[i] = list[k]; | |
}list.pop(); | |
}; | |
// This implementation is based heavily on node's url.parse | |
var resolvePathname = function resolvePathname(to) { | |
var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; | |
var toParts = to && to.split('/') || []; | |
var fromParts = from && from.split('/') || []; | |
var isToAbs = to && isAbsolute(to); | |
var isFromAbs = from && isAbsolute(from); | |
var mustEndAbs = isToAbs || isFromAbs; | |
if (to && isAbsolute(to)) { | |
// to is absolute | |
fromParts = toParts; | |
} else if (toParts.length) { | |
// to is relative, drop the filename | |
fromParts.pop(); | |
fromParts = fromParts.concat(toParts); | |
} | |
if (!fromParts.length) return '/'; | |
var hasTrailingSlash = void 0; | |
if (fromParts.length) { | |
var last = fromParts[fromParts.length - 1]; | |
hasTrailingSlash = last === '.' || last === '..' || last === ''; | |
} else { | |
hasTrailingSlash = false; | |
} | |
var up = 0; | |
for (var i = fromParts.length; i >= 0; i--) { | |
var part = fromParts[i]; | |
if (part === '.') { | |
spliceOne(fromParts, i); | |
} else if (part === '..') { | |
spliceOne(fromParts, i); | |
up++; | |
} else if (up) { | |
spliceOne(fromParts, i); | |
up--; | |
} | |
} | |
if (!mustEndAbs) for (; up--; up) { | |
fromParts.unshift('..'); | |
}if (mustEndAbs && fromParts[0] !== '' && (!fromParts[0] || !isAbsolute(fromParts[0]))) fromParts.unshift(''); | |
var result = fromParts.join('/'); | |
if (hasTrailingSlash && result.substr(-1) !== '/') result += '/'; | |
return result; | |
}; | |
module.exports = resolvePathname; | |
/***/ }), | |
/* 26 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
exports.__esModule = true; | |
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; | |
var valueEqual = function valueEqual(a, b) { | |
if (a === b) return true; | |
if (a == null || b == null) return false; | |
if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every(function (item, index) { | |
return valueEqual(item, b[index]); | |
}); | |
var aType = typeof a === 'undefined' ? 'undefined' : _typeof(a); | |
var bType = typeof b === 'undefined' ? 'undefined' : _typeof(b); | |
if (aType !== bType) return false; | |
if (aType === 'object') { | |
var aValue = a.valueOf(); | |
var bValue = b.valueOf(); | |
if (aValue !== a || bValue !== b) return valueEqual(aValue, bValue); | |
var aKeys = Object.keys(a); | |
var bKeys = Object.keys(b); | |
if (aKeys.length !== bKeys.length) return false; | |
return aKeys.every(function (key) { | |
return valueEqual(a[key], b[key]); | |
}); | |
} | |
return false; | |
}; | |
exports.default = valueEqual; | |
/***/ }) | |
/******/ ]); | |
}); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment