Add npm build

Author: mjackson

build/npm/README.md

@@ -0,0 +1,139 @@
+[![npm package](https://img.shields.io/npm/v/react-router.svg?style=flat-square)](https://www.npmjs.org/package/react-router)
+[![build status](https://img.shields.io/travis/rackt/react-router/master.svg?style=flat-square)](https://travis-ci.org/rackt/react-router)
+[![dependency status](https://img.shields.io/david/rackt/react-router.svg?style=flat-square)](https://david-dm.org/rackt/react-router)
+
+React Router
+============
+
+A complete routing library for React.
+
+Docs
+----
+
+- [Guide: Overview](/docs/guides/overview.md)
+- [API](/docs/api/)
+
+Important Notes
+---------------
+
+### SemVer
+
+Before our `1.0` release, breaking API changes will cause a bump to
+`0.x`. For example, `0.4.1` and `0.4.8` will have the same API, but
+`0.5.0` will have breaking changes.
+
+Please refer to the [upgrade guide](/UPGRADE_GUIDE.md) and
+[changelog](/CHANGELOG.md) when upgrading.
+
+Installation
+------------
+
+```sh
+npm install react-router
+# or
+bower install react-router
+```
+
+This library is written with CommonJS modules. If you are using
+browserify, webpack, or similar, you can consume it like anything else
+installed from npm.
+
+There is also a global build available on bower, find the library on
+`window.ReactRouter`.
+
+The library is also available on the popular CDN [cdnjs](https://cdnjs.com/libraries/react-router).
+
+Features
+--------
+
+- Nested views mapped to nested routes
+- Modular construction of route hierarchy
+- Sync and async transition hooks
+- Transition abort / redirect / retry
+- Dynamic segments
+- Query parameters
+- Links with automatic `.active` class when their route is active
+- Multiple root routes
+- Hash or HTML5 history (with fallback) URLs
+- Declarative Redirect routes
+- Declarative NotFound routes
+- Browser scroll behavior with transitions
+
+Check out the `examples` directory to see how simple previously complex UI
+and workflows are to create.
+
+What's it look like?
+--------------------
+
+```js
+var routes = (
+  <Route handler={App} path="/">
+    <DefaultRoute handler={Home} />
+    <Route name="about" handler={About} />
+    <Route name="users" handler={Users}>
+      <Route name="recent-users" path="recent" handler={RecentUsers} />
+      <Route name="user" path="/user/:userId" handler={User} />
+      <NotFoundRoute handler={UserRouteNotFound}/>
+    </Route>
+    <NotFoundRoute handler={NotFound}/>
+    <Redirect from="company" to="about" />
+  </Route>
+);
+
+Router.run(routes, function (Handler) {
+  React.render(<Handler/>, document.body);
+});
+
+// Or, if you'd like to use the HTML5 history API for cleaner URLs:
+
+Router.run(routes, Router.HistoryLocation, function (Handler) {
+  React.render(<Handler/>, document.body);
+});
+```
+
+See more in the [overview guide](/docs/guides/overview.md).
+
+Benefits of this Approach
+-------------------------
+
+1. **Incredible screen-creation productivity** - There is only one
+   use-case when a user visits a route: render something. Every user
+   interface has layers (or nesting) whether it's a simple navbar or
+   multiple levels of master-detail. Coupling nested routes to these
+   nested views gets rid of a ton of work for the developer to wire all
+   of it together when the user switches routes. Adding new screens
+   could not get faster.
+
+2. **Immediate understanding of application structure** - When routes
+   are declared in one place, developers can easily construct a mental
+   image of the application. It's essentially a sitemap. There's not a
+   better way to get so much information about your app this quickly.
+
+3. **Code tractability** - When a developer gets a ticket to fix a bug
+   at as specific url they simply 1) look at the route config, then 2)
+   go find the handler for that route. Every entry point into your
+   application is represented by these routes.
+
+4. **URLs are your first thought, not an after-thought** - With React
+   Router, you don't get UI on the page without configuring a url first.
+   Fortunately, it's wildly productive this way, too.
+
+Related Modules
+---------------
+
+- [rnr-constrained-route](https://github.com/bjyoungblood/rnr-constrained-route) - validate paths
+  and parameters on route handlers.
+- [react-router-bootstrap](https://github.com/mtscout6/react-router-bootstrap) - Integration with [react-bootstrap](https://github.com/react-bootstrap/react-bootstrap) components.
+
+Contributing
+------------
+
+Please see [CONTRIBUTING](CONTRIBUTING.md)
+
+Thanks, Ember
+-------------
+
+This library is highly inspired by the Ember.js routing API. In general,
+it's a translation of the Ember router api to React. Huge thanks to the
+Ember team for solving the hardest part already.
+

build/npm/lib/Cancellation.js

@@ -0,0 +1,9 @@
+"use strict";
+
+/**
+ * Represents a cancellation caused by navigating away
+ * before the previous transition has fully resolved.
+ */
+function Cancellation() {}
+
+module.exports = Cancellation;

build/npm/lib/Configuration.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var warning = require("react/lib/warning");
+var invariant = require("react/lib/invariant");
+
+function checkPropTypes(componentName, propTypes, props) {
+  for (var propName in propTypes) {
+    if (propTypes.hasOwnProperty(propName)) {
+      var error = propTypes[propName](props, propName, componentName);
+
+      if (error instanceof Error) warning(false, error.message);
+    }
+  }
+}
+
+var Configuration = {
+
+  statics: {
+
+    validateProps: function validateProps(props) {
+      checkPropTypes(this.displayName, this.propTypes, props);
+    }
+
+  },
+
+  render: function render() {
+    invariant(false, "%s elements are for router configuration only and should not be rendered", this.constructor.displayName);
+  }
+
+};
+
+module.exports = Configuration;

build/npm/lib/History.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var invariant = require("react/lib/invariant");
+var canUseDOM = require("react/lib/ExecutionEnvironment").canUseDOM;
+
+var History = {
+
+  /**
+   * The current number of entries in the history.
+   *
+   * Note: This property is read-only.
+   */
+  length: 1,
+
+  /**
+   * Sends the browser back one entry in the history.
+   */
+  back: function back() {
+    invariant(canUseDOM, "Cannot use History.back without a DOM");
+
+    // Do this first so that History.length will
+    // be accurate in location change listeners.
+    History.length -= 1;
+
+    window.history.back();
+  }
+
+};
+
+module.exports = History;

build/npm/lib/Match.js

@@ -0,0 +1,62 @@
+"use strict";
+
+/* jshint -W084 */
+
+var Path = require("./utils/Path");
+
+function Match(pathname, params, query, routes) {
+  this.pathname = pathname;
+  this.params = params;
+  this.query = query;
+  this.routes = routes;
+}
+
+function deepSearch(route, pathname, query) {
+  // Check the subtree first to find the most deeply-nested match.
+  var childRoutes = route.childRoutes;
+  if (childRoutes) {
+    var match, childRoute;
+    for (var i = 0, len = childRoutes.length; i < len; ++i) {
+      childRoute = childRoutes[i];
+
+      if (childRoute.isDefault || childRoute.isNotFound) continue; // Check these in order later.
+
+      if (match = deepSearch(childRoute, pathname, query)) {
+        // A route in the subtree matched! Add this route and we're done.
+        match.routes.unshift(route);
+        return match;
+      }
+    }
+  }
+
+  // No child routes matched; try the default route.
+  var defaultRoute = route.defaultRoute;
+  if (defaultRoute && (params = Path.extractParams(defaultRoute.path, pathname))) {
+    return new Match(pathname, params, query, [route, defaultRoute]);
+  } // Does the "not found" route match?
+  var notFoundRoute = route.notFoundRoute;
+  if (notFoundRoute && (params = Path.extractParams(notFoundRoute.path, pathname))) {
+    return new Match(pathname, params, query, [route, notFoundRoute]);
+  } // Last attempt: check this route.
+  var params = Path.extractParams(route.path, pathname);
+  if (params) {
+    return new Match(pathname, params, query, [route]);
+  }return null;
+}
+
+/**
+ * Attempts to match depth-first a route in the given route's
+ * subtree against the given path and returns the match if it
+ * succeeds, null if no match can be made.
+ */
+Match.findMatchForPath = function (routes, path) {
+  var pathname = Path.withoutQuery(path);
+  var query = Path.extractQuery(path);
+  var match = null;
+
+  for (var i = 0, len = routes.length; match == null && i < len; ++i) match = deepSearch(routes[i], pathname, query);
+
+  return match;
+};
+
+module.exports = Match;

build/npm/lib/Navigation.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var PropTypes = require("./PropTypes");
+
+/**
+ * A mixin for components that modify the URL.
+ *
+ * Example:
+ *
+ *   var MyLink = React.createClass({
+ *     mixins: [ Router.Navigation ],
+ *     handleClick: function (event) {
+ *       event.preventDefault();
+ *       this.transitionTo('aRoute', { the: 'params' }, { the: 'query' });
+ *     },
+ *     render: function () {
+ *       return (
+ *         <a onClick={this.handleClick}>Click me!</a>
+ *       );
+ *     }
+ *   });
+ */
+var Navigation = {
+
+  contextTypes: {
+    makePath: PropTypes.func.isRequired,
+    makeHref: PropTypes.func.isRequired,
+    transitionTo: PropTypes.func.isRequired,
+    replaceWith: PropTypes.func.isRequired,
+    goBack: PropTypes.func.isRequired
+  },
+
+  /**
+   * Returns an absolute URL path created from the given route
+   * name, URL parameters, and query values.
+   */
+  makePath: function makePath(to, params, query) {
+    return this.context.makePath(to, params, query);
+  },
+
+  /**
+   * Returns a string that may safely be used as the href of a
+   * link to the route with the given name.
+   */
+  makeHref: function makeHref(to, params, query) {
+    return this.context.makeHref(to, params, query);
+  },
+
+  /**
+   * Transitions to the URL specified in the arguments by pushing
+   * a new URL onto the history stack.
+   */
+  transitionTo: function transitionTo(to, params, query) {
+    this.context.transitionTo(to, params, query);
+  },
+
+  /**
+   * Transitions to the URL specified in the arguments by replacing
+   * the current URL in the history stack.
+   */
+  replaceWith: function replaceWith(to, params, query) {
+    this.context.replaceWith(to, params, query);
+  },
+
+  /**
+   * Transitions to the previous URL.
+   */
+  goBack: function goBack() {
+    return this.context.goBack();
+  }
+
+};
+
+module.exports = Navigation;

build/npm/lib/NavigationContext.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var PropTypes = require("./PropTypes");
+
+/**
+ * Provides the router with context for Router.Navigation.
+ */
+var NavigationContext = {
+
+  childContextTypes: {
+    makePath: PropTypes.func.isRequired,
+    makeHref: PropTypes.func.isRequired,
+    transitionTo: PropTypes.func.isRequired,
+    replaceWith: PropTypes.func.isRequired,
+    goBack: PropTypes.func.isRequired
+  },
+
+  getChildContext: function getChildContext() {
+    return {
+      makePath: this.constructor.makePath.bind(this.constructor),
+      makeHref: this.constructor.makeHref.bind(this.constructor),
+      transitionTo: this.constructor.transitionTo.bind(this.constructor),
+      replaceWith: this.constructor.replaceWith.bind(this.constructor),
+      goBack: this.constructor.goBack.bind(this.constructor)
+    };
+  }
+
+};
+
+module.exports = NavigationContext;