Experimental port to Firebase hosting

public/react-router-dom@4.3.1/es/BrowserRouter.js

@@ -0,0 +1,52 @@
+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; }
+
+import warning from "warning";
+import React from "react";
+import PropTypes from "prop-types";
+import { createBrowserHistory as createHistory } from "history";
+import Router from "./Router";
+
+/**
+ * The public API for a <Router> that uses HTML5 history.
+ */
+
+var BrowserRouter = function (_React$Component) {
+  _inherits(BrowserRouter, _React$Component);
+
+  function BrowserRouter() {
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, BrowserRouter);
+
+    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 = createHistory(_this.props), _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  BrowserRouter.prototype.componentWillMount = function componentWillMount() {
+    warning(!this.props.history, "<BrowserRouter> ignores the history prop. To use a custom history, " + "use `import { Router }` instead of `import { BrowserRouter as Router }`.");
+  };
+
+  BrowserRouter.prototype.render = function render() {
+    return React.createElement(Router, { history: this.history, children: this.props.children });
+  };
+
+  return BrowserRouter;
+}(React.Component);
+
+BrowserRouter.propTypes = {
+  basename: PropTypes.string,
+  forceRefresh: PropTypes.bool,
+  getUserConfirmation: PropTypes.func,
+  keyLength: PropTypes.number,
+  children: PropTypes.node
+};
+
+
+export default BrowserRouter;

public/react-router-dom@4.3.1/es/HashRouter.js

@@ -0,0 +1,51 @@
+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; }
+
+import warning from "warning";
+import React from "react";
+import PropTypes from "prop-types";
+import { createHashHistory as createHistory } from "history";
+import Router from "./Router";
+
+/**
+ * The public API for a <Router> that uses window.location.hash.
+ */
+
+var HashRouter = function (_React$Component) {
+  _inherits(HashRouter, _React$Component);
+
+  function HashRouter() {
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, HashRouter);
+
+    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 = createHistory(_this.props), _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  HashRouter.prototype.componentWillMount = function componentWillMount() {
+    warning(!this.props.history, "<HashRouter> ignores the history prop. To use a custom history, " + "use `import { Router }` instead of `import { HashRouter as Router }`.");
+  };
+
+  HashRouter.prototype.render = function render() {
+    return React.createElement(Router, { history: this.history, children: this.props.children });
+  };
+
+  return HashRouter;
+}(React.Component);
+
+HashRouter.propTypes = {
+  basename: PropTypes.string,
+  getUserConfirmation: PropTypes.func,
+  hashType: PropTypes.oneOf(["hashbang", "noslash", "slash"]),
+  children: PropTypes.node
+};
+
+
+export default HashRouter;

public/react-router-dom@4.3.1/es/Link.js

@@ -0,0 +1,104 @@
+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; }
+
+import React from "react";
+import PropTypes from "prop-types";
+import invariant from "invariant";
+import { createLocation } from "history";
+
+var isModifiedEvent = function isModifiedEvent(event) {
+  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+};
+
+/**
+ * The public API for rendering a history-aware <a>.
+ */
+
+var Link = function (_React$Component) {
+  _inherits(Link, _React$Component);
+
+  function Link() {
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, Link);
+
+    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.handleClick = function (event) {
+      if (_this.props.onClick) _this.props.onClick(event);
+
+      if (!event.defaultPrevented && // onClick prevented default
+      event.button === 0 && // ignore everything but left clicks
+      !_this.props.target && // let browser handle "target=_blank" etc.
+      !isModifiedEvent(event) // ignore clicks with modifier keys
+      ) {
+          event.preventDefault();
+
+          var history = _this.context.router.history;
+          var _this$props = _this.props,
+              replace = _this$props.replace,
+              to = _this$props.to;
+
+
+          if (replace) {
+            history.replace(to);
+          } else {
+            history.push(to);
+          }
+        }
+    }, _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  Link.prototype.render = function render() {
+    var _props = this.props,
+        replace = _props.replace,
+        to = _props.to,
+        innerRef = _props.innerRef,
+        props = _objectWithoutProperties(_props, ["replace", "to", "innerRef"]); // eslint-disable-line no-unused-vars
+
+    invariant(this.context.router, "You should not use <Link> outside a <Router>");
+
+    invariant(to !== undefined, 'You must specify the "to" property');
+
+    var history = this.context.router.history;
+
+    var location = typeof to === "string" ? createLocation(to, null, null, history.location) : to;
+
+    var href = history.createHref(location);
+    return React.createElement("a", _extends({}, props, { onClick: this.handleClick, href: href, ref: innerRef }));
+  };
+
+  return Link;
+}(React.Component);
+
+Link.propTypes = {
+  onClick: PropTypes.func,
+  target: PropTypes.string,
+  replace: PropTypes.bool,
+  to: PropTypes.oneOfType([PropTypes.string, PropTypes.object]).isRequired,
+  innerRef: PropTypes.oneOfType([PropTypes.string, PropTypes.func])
+};
+Link.defaultProps = {
+  replace: false
+};
+Link.contextTypes = {
+  router: PropTypes.shape({
+    history: PropTypes.shape({
+      push: PropTypes.func.isRequired,
+      replace: PropTypes.func.isRequired,
+      createHref: PropTypes.func.isRequired
+    }).isRequired
+  }).isRequired
+};
+
+
+export default Link;

public/react-router-dom@4.3.1/es/MemoryRouter.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import MemoryRouter from "react-router/es/MemoryRouter";
+
+export default MemoryRouter;

public/react-router-dom@4.3.1/es/NavLink.js

@@ -0,0 +1,74 @@
+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 _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; };
+
+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; }
+
+import React from "react";
+import PropTypes from "prop-types";
+import Route from "./Route";
+import Link from "./Link";
+
+/**
+ * A <Link> wrapper that knows if it's "active" or not.
+ */
+var NavLink = function NavLink(_ref) {
+  var to = _ref.to,
+      exact = _ref.exact,
+      strict = _ref.strict,
+      location = _ref.location,
+      activeClassName = _ref.activeClassName,
+      className = _ref.className,
+      activeStyle = _ref.activeStyle,
+      style = _ref.style,
+      getIsActive = _ref.isActive,
+      ariaCurrent = _ref["aria-current"],
+      rest = _objectWithoutProperties(_ref, ["to", "exact", "strict", "location", "activeClassName", "className", "activeStyle", "style", "isActive", "aria-current"]);
+
+  var path = (typeof to === "undefined" ? "undefined" : _typeof(to)) === "object" ? to.pathname : to;
+
+  // Regex taken from: https://github.com/pillarjs/path-to-regexp/blob/master/index.js#L202
+  var escapedPath = path && path.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+
+  return React.createElement(Route, {
+    path: escapedPath,
+    exact: exact,
+    strict: strict,
+    location: location,
+    children: function children(_ref2) {
+      var location = _ref2.location,
+          match = _ref2.match;
+
+      var isActive = !!(getIsActive ? getIsActive(match, location) : match);
+
+      return React.createElement(Link, _extends({
+        to: to,
+        className: isActive ? [className, activeClassName].filter(function (i) {
+          return i;
+        }).join(" ") : className,
+        style: isActive ? _extends({}, style, activeStyle) : style,
+        "aria-current": isActive && ariaCurrent || null
+      }, rest));
+    }
+  });
+};
+
+NavLink.propTypes = {
+  to: Link.propTypes.to,
+  exact: PropTypes.bool,
+  strict: PropTypes.bool,
+  location: PropTypes.object,
+  activeClassName: PropTypes.string,
+  className: PropTypes.string,
+  activeStyle: PropTypes.object,
+  style: PropTypes.object,
+  isActive: PropTypes.func,
+  "aria-current": PropTypes.oneOf(["page", "step", "location", "date", "time", "true"])
+};
+
+NavLink.defaultProps = {
+  activeClassName: "active",
+  "aria-current": "page"
+};
+
+export default NavLink;

public/react-router-dom@4.3.1/es/Prompt.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import Prompt from "react-router/es/Prompt";
+
+export default Prompt;

public/react-router-dom@4.3.1/es/Redirect.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import Redirect from "react-router/es/Redirect";
+
+export default Redirect;

public/react-router-dom@4.3.1/es/Route.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import Route from "react-router/es/Route";
+
+export default Route;

public/react-router-dom@4.3.1/es/Router.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import Router from "react-router/es/Router";
+
+export default Router;

public/react-router-dom@4.3.1/es/RouterContext.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import RouterContext from "react-router/es/RouterContext";
+
+export default RouterContext;

public/react-router-dom@4.3.1/es/StaticRouter.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import StaticRouter from "react-router/es/StaticRouter";
+
+export default StaticRouter;

public/react-router-dom@4.3.1/es/Switch.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import Switch from "react-router/es/Switch";
+
+export default Switch;

public/react-router-dom@4.3.1/es/generatePath.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import generatePath from "react-router/es/generatePath";
+
+export default generatePath;

public/react-router-dom@4.3.1/es/index.js

@@ -0,0 +1,28 @@
+import _BrowserRouter from "./BrowserRouter";
+export { _BrowserRouter as BrowserRouter };
+import _HashRouter from "./HashRouter";
+export { _HashRouter as HashRouter };
+import _Link from "./Link";
+export { _Link as Link };
+import _MemoryRouter from "./MemoryRouter";
+export { _MemoryRouter as MemoryRouter };
+import _NavLink from "./NavLink";
+export { _NavLink as NavLink };
+import _Prompt from "./Prompt";
+export { _Prompt as Prompt };
+import _Redirect from "./Redirect";
+export { _Redirect as Redirect };
+import _Route from "./Route";
+export { _Route as Route };
+import _Router from "./Router";
+export { _Router as Router };
+import _StaticRouter from "./StaticRouter";
+export { _StaticRouter as StaticRouter };
+import _Switch from "./Switch";
+export { _Switch as Switch };
+import _generatePath from "./generatePath";
+export { _generatePath as generatePath };
+import _matchPath from "./matchPath";
+export { _matchPath as matchPath };
+import _withRouter from "./withRouter";
+export { _withRouter as withRouter };

public/react-router-dom@4.3.1/es/matchPath.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import matchPath from "react-router/es/matchPath";
+
+export default matchPath;

public/react-router-dom@4.3.1/es/withRouter.js

@@ -0,0 +1,4 @@
+// Written in this round about way for babel-transform-imports
+import withRouter from "react-router/es/withRouter";
+
+export default withRouter;