0.2.0 - Mid migration

web/node_modules/redux-thunk/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present Dan Abramov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/redux-thunk/README.md

@@ -0,0 +1,323 @@
+Redux Thunk
+=============
+
+Thunk [middleware](https://redux.js.org/advanced/middleware) for Redux.
+
+[![build status](https://img.shields.io/travis/reduxjs/redux-thunk/master.svg?style=flat-square)](https://travis-ci.org/reduxjs/redux-thunk) 
+[![npm version](https://img.shields.io/npm/v/redux-thunk.svg?style=flat-square)](https://www.npmjs.com/package/redux-thunk)
+[![npm downloads](https://img.shields.io/npm/dm/redux-thunk.svg?style=flat-square)](https://www.npmjs.com/package/redux-thunk)
+
+```js
+npm install --save redux-thunk
+```
+
+## Note on 2.x Update
+
+Most tutorials today assume Redux Thunk 1.x so you might run into an issue when running their code with 2.x.  
+**If you use Redux Thunk 2.x in CommonJS environment, [don’t forget to add `.default` to your import](https://github.com/reduxjs/redux-thunk/releases/tag/v2.0.0):**
+
+```diff
+- var ReduxThunk = require('redux-thunk')
++ var ReduxThunk = require('redux-thunk').default
+```
+
+If you used ES modules, you’re already all good:
+
+```js
+import ReduxThunk from 'redux-thunk' // no changes here 😀
+```
+
+Additionally, since 2.x, we also support a [UMD build](https://unpkg.com/redux-thunk/dist/redux-thunk.min.js):
+
+```js
+var ReduxThunk = window.ReduxThunk.default
+```
+
+As you can see, it also requires `.default` at the end.
+
+## Why Do I Need This?
+
+If you’re not sure whether you need it, you probably don’t.
+
+**[Read this for an in-depth introduction to thunks in Redux.](http://stackoverflow.com/questions/35411423/how-to-dispatch-a-redux-action-with-a-timeout/35415559#35415559)**
+
+## Motivation
+
+Redux Thunk [middleware](https://github.com/reactjs/redux/blob/master/docs/advanced/Middleware.md) allows you to write action creators that return a function instead of an action. The thunk can be used to delay the dispatch of an action, or to dispatch only if a certain condition is met. The inner function receives the store methods `dispatch` and `getState` as parameters.
+
+An action creator that returns a function to perform asynchronous dispatch:
+
+```js
+const INCREMENT_COUNTER = 'INCREMENT_COUNTER';
+
+function increment() {
+  return {
+    type: INCREMENT_COUNTER
+  };
+}
+
+function incrementAsync() {
+  return dispatch => {
+    setTimeout(() => {
+      // Yay! Can invoke sync or async actions with `dispatch`
+      dispatch(increment());
+    }, 1000);
+  };
+}
+```
+
+An action creator that returns a function to perform conditional dispatch:
+
+```js
+function incrementIfOdd() {
+  return (dispatch, getState) => {
+    const { counter } = getState();
+
+    if (counter % 2 === 0) {
+      return;
+    }
+
+    dispatch(increment());
+  };
+}
+```
+
+## What’s a thunk?!
+
+A [thunk](https://en.wikipedia.org/wiki/Thunk) is a function that wraps an expression to delay its evaluation.
+
+```js
+// calculation of 1 + 2 is immediate
+// x === 3
+let x = 1 + 2;
+
+// calculation of 1 + 2 is delayed
+// foo can be called later to perform the calculation
+// foo is a thunk!
+let foo = () => 1 + 2;
+```
+
+The term [originated](https://en.wikipedia.org/wiki/Thunk#cite_note-1) as a humorous past-tense version of "think". 
+
+## Installation
+
+```
+npm install --save redux-thunk
+```
+
+Then, to enable Redux Thunk, use [`applyMiddleware()`](https://redux.js.org/api-reference/applymiddleware):
+
+```js
+import { createStore, applyMiddleware } from 'redux';
+import thunk from 'redux-thunk';
+import rootReducer from './reducers/index';
+
+// Note: this API requires redux@>=3.1.0
+const store = createStore(
+  rootReducer,
+  applyMiddleware(thunk)
+);
+```
+
+## Composition
+
+Any return value from the inner function will be available as the return value of `dispatch` itself. This is convenient for orchestrating an asynchronous control flow with thunk action creators dispatching each other and returning Promises to wait for each other’s completion:
+
+```js
+import { createStore, applyMiddleware } from 'redux';
+import thunk from 'redux-thunk';
+import rootReducer from './reducers';
+
+// Note: this API requires redux@>=3.1.0
+const store = createStore(
+  rootReducer,
+  applyMiddleware(thunk)
+);
+
+function fetchSecretSauce() {
+  return fetch('https://www.google.com/search?q=secret+sauce');
+}
+
+// These are the normal action creators you have seen so far.
+// The actions they return can be dispatched without any middleware.
+// However, they only express “facts” and not the “async flow”.
+
+function makeASandwich(forPerson, secretSauce) {
+  return {
+    type: 'MAKE_SANDWICH',
+    forPerson,
+    secretSauce
+  };
+}
+
+function apologize(fromPerson, toPerson, error) {
+  return {
+    type: 'APOLOGIZE',
+    fromPerson,
+    toPerson,
+    error
+  };
+}
+
+function withdrawMoney(amount) {
+  return {
+    type: 'WITHDRAW',
+    amount
+  };
+}
+
+// Even without middleware, you can dispatch an action:
+store.dispatch(withdrawMoney(100));
+
+// But what do you do when you need to start an asynchronous action,
+// such as an API call, or a router transition?
+
+// Meet thunks.
+// A thunk is a function that returns a function.
+// This is a thunk.
+
+function makeASandwichWithSecretSauce(forPerson) {
+
+  // Invert control!
+  // Return a function that accepts `dispatch` so we can dispatch later.
+  // Thunk middleware knows how to turn thunk async actions into actions.
+
+  return function (dispatch) {
+    return fetchSecretSauce().then(
+      sauce => dispatch(makeASandwich(forPerson, sauce)),
+      error => dispatch(apologize('The Sandwich Shop', forPerson, error))
+    );
+  };
+}
+
+// Thunk middleware lets me dispatch thunk async actions
+// as if they were actions!
+
+store.dispatch(
+  makeASandwichWithSecretSauce('Me')
+);
+
+// It even takes care to return the thunk’s return value
+// from the dispatch, so I can chain Promises as long as I return them.
+
+store.dispatch(
+  makeASandwichWithSecretSauce('My wife')
+).then(() => {
+  console.log('Done!');
+});
+
+// In fact I can write action creators that dispatch
+// actions and async actions from other action creators,
+// and I can build my control flow with Promises.
+
+function makeSandwichesForEverybody() {
+  return function (dispatch, getState) {
+    if (!getState().sandwiches.isShopOpen) {
+
+      // You don’t have to return Promises, but it’s a handy convention
+      // so the caller can always call .then() on async dispatch result.
+
+      return Promise.resolve();
+    }
+
+    // We can dispatch both plain object actions and other thunks,
+    // which lets us compose the asynchronous actions in a single flow.
+
+    return dispatch(
+      makeASandwichWithSecretSauce('My Grandma')
+    ).then(() =>
+      Promise.all([
+        dispatch(makeASandwichWithSecretSauce('Me')),
+        dispatch(makeASandwichWithSecretSauce('My wife'))
+      ])
+    ).then(() =>
+      dispatch(makeASandwichWithSecretSauce('Our kids'))
+    ).then(() =>
+      dispatch(getState().myMoney > 42 ?
+        withdrawMoney(42) :
+        apologize('Me', 'The Sandwich Shop')
+      )
+    );
+  };
+}
+
+// This is very useful for server side rendering, because I can wait
+// until data is available, then synchronously render the app.
+
+store.dispatch(
+  makeSandwichesForEverybody()
+).then(() =>
+  response.send(ReactDOMServer.renderToString(<MyApp store={store} />))
+);
+
+// I can also dispatch a thunk async action from a component
+// any time its props change to load the missing data.
+
+import { connect } from 'react-redux';
+import { Component } from 'react';
+
+class SandwichShop extends Component {
+  componentDidMount() {
+    this.props.dispatch(
+      makeASandwichWithSecretSauce(this.props.forPerson)
+    );
+  }
+
+  componentDidUpdate(prevProps) {
+    if (prevProps.forPerson !== this.props.forPerson) {
+      this.props.dispatch(
+        makeASandwichWithSecretSauce(this.props.forPerson)
+      );
+    }
+  }
+
+  render() {
+    return <p>{this.props.sandwiches.join('mustard')}</p>
+  }
+}
+
+export default connect(
+  state => ({
+    sandwiches: state.sandwiches
+  })
+)(SandwichShop);
+```
+
+## Injecting a Custom Argument
+
+Since 2.1.0, Redux Thunk supports injecting a custom argument using the `withExtraArgument` function:
+
+```js
+const store = createStore(
+  reducer,
+  applyMiddleware(thunk.withExtraArgument(api))
+)
+
+// later
+function fetchUser(id) {
+  return (dispatch, getState, api) => {
+    // you can use api here
+  }
+}
+```
+
+To pass multiple things, just wrap them in a single object and use destructuring:
+
+```js
+const store = createStore(
+  reducer,
+  applyMiddleware(thunk.withExtraArgument({ api, whatever }))
+)
+
+// later
+function fetchUser(id) {
+  return (dispatch, getState, { api, whatever }) => {
+    // you can use api and something else here
+  }
+}
+```
+
+
+## License
+
+MIT

web/node_modules/redux-thunk/dist/redux-thunk.js

@@ -0,0 +1,91 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["ReduxThunk"] = factory();
+	else
+		root["ReduxThunk"] = factory();
+})(this, function() {
+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] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+	module.exports = __webpack_require__(1);
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports) {
+
+	'use strict';
+
+	exports.__esModule = true;
+	function createThunkMiddleware(extraArgument) {
+	  return function (_ref) {
+	    var dispatch = _ref.dispatch,
+	        getState = _ref.getState;
+	    return function (next) {
+	      return function (action) {
+	        if (typeof action === 'function') {
+	          return action(dispatch, getState, extraArgument);
+	        }
+
+	        return next(action);
+	      };
+	    };
+	  };
+	}
+
+	var thunk = createThunkMiddleware();
+	thunk.withExtraArgument = createThunkMiddleware;
+
+	exports['default'] = thunk;
+
+/***/ })
+/******/ ])
+});
+;

web/node_modules/redux-thunk/dist/redux-thunk.min.js

@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ReduxThunk=e():t.ReduxThunk=e()}(this,function(){return function(t){function e(o){if(n[o])return n[o].exports;var r=n[o]={exports:{},id:o,loaded:!1};return t[o].call(r.exports,r,r.exports,e),r.loaded=!0,r.exports}var n={};return e.m=t,e.c=n,e.p="",e(0)}([function(t,e,n){t.exports=n(1)},function(t,e){"use strict";function n(t){return function(e){var n=e.dispatch,o=e.getState;return function(e){return function(r){return"function"==typeof r?r(n,o,t):e(r)}}}}e.__esModule=!0;var o=n();o.withExtraArgument=n,e.default=o}])});

web/node_modules/redux-thunk/es/index.js

@@ -0,0 +1,20 @@
+function createThunkMiddleware(extraArgument) {
+  return function (_ref) {
+    var dispatch = _ref.dispatch,
+        getState = _ref.getState;
+    return function (next) {
+      return function (action) {
+        if (typeof action === 'function') {
+          return action(dispatch, getState, extraArgument);
+        }
+
+        return next(action);
+      };
+    };
+  };
+}
+
+var thunk = createThunkMiddleware();
+thunk.withExtraArgument = createThunkMiddleware;
+
+export default thunk;

web/node_modules/redux-thunk/index.d.ts

@@ -0,0 +1,20 @@
+import { Middleware, Action, AnyAction } from "redux";
+
+export interface ThunkDispatch<S, E, A extends Action> {
+  <T extends A>(action: T): T;
+  <R>(asyncAction: ThunkAction<R, S, E, A>): R;
+}
+
+export type ThunkAction<R, S, E, A extends Action> = (
+  dispatch: ThunkDispatch<S, E, A>,
+  getState: () => S,
+  extraArgument: E
+) => R;
+
+export type ThunkMiddleware<S = {}, A extends Action = AnyAction, E = undefined> = Middleware<ThunkDispatch<S, E, A>, S, ThunkDispatch<S, E, A>>;
+
+declare const thunk: ThunkMiddleware & {
+  withExtraArgument<E>(extraArgument: E): ThunkMiddleware<{}, AnyAction, E>
+}
+
+export default thunk;

web/node_modules/redux-thunk/lib/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+exports.__esModule = true;
+function createThunkMiddleware(extraArgument) {
+  return function (_ref) {
+    var dispatch = _ref.dispatch,
+        getState = _ref.getState;
+    return function (next) {
+      return function (action) {
+        if (typeof action === 'function') {
+          return action(dispatch, getState, extraArgument);
+        }
+
+        return next(action);
+      };
+    };
+  };
+}
+
+var thunk = createThunkMiddleware();
+thunk.withExtraArgument = createThunkMiddleware;
+
+exports['default'] = thunk;

web/node_modules/redux-thunk/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "redux-thunk",
+  "version": "2.3.0",
+  "license": "MIT",
+  "description": "Thunk middleware for Redux.",
+  "repository": "github:reduxjs/redux-thunk",
+  "bugs": "https://github.com/reduxjs/redux-thunk/issues",
+  "homepage": "https://github.com/reduxjs/redux-thunk",
+  "keywords": [
+    "redux",
+    "thunk",
+    "middleware",
+    "redux-middleware",
+    "flux"
+  ],
+  "author": "Dan Abramov <dan.abramov@me.com>",
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "typings": "./index.d.ts",
+  "files": [
+    "lib",
+    "es",
+    "src",
+    "dist",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "clean": "rimraf lib dist es",
+    "prepare": "npm run clean && npm run lint && npm run test && npm run build",
+    "lint": "eslint src test",
+    "test": "cross-env BABEL_ENV=commonjs mocha --compilers js:babel-core/register --reporter spec test/*.js",
+    "build": "npm run build:commonjs && npm run build:umd && npm run build:umd:min && npm run build:es",
+    "build:commonjs": "cross-env BABEL_ENV=commonjs babel src --out-dir lib",
+    "build:es": "cross-env BABEL_ENV=es babel src --out-dir es",
+    "build:umd": "cross-env BABEL_ENV=commonjs NODE_ENV=development webpack",
+    "build:umd:min": "cross-env BABEL_ENV=commonjs NODE_ENV=production webpack"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.6.5",
+    "babel-core": "^6.6.5",
+    "babel-eslint": "^5.0.0-beta4",
+    "babel-loader": "^6.2.4",
+    "babel-plugin-check-es2015-constants": "^6.6.5",
+    "babel-plugin-transform-es2015-arrow-functions": "^6.5.2",
+    "babel-plugin-transform-es2015-block-scoped-functions": "^6.6.5",
+    "babel-plugin-transform-es2015-block-scoping": "^6.6.5",
+    "babel-plugin-transform-es2015-classes": "^6.6.5",
+    "babel-plugin-transform-es2015-computed-properties": "^6.6.5",
+    "babel-plugin-transform-es2015-destructuring": "^6.6.5",
+    "babel-plugin-transform-es2015-for-of": "^6.6.0",
+    "babel-plugin-transform-es2015-function-name": "^6.5.0",
+    "babel-plugin-transform-es2015-literals": "^6.5.0",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.6.5",
+    "babel-plugin-transform-es2015-object-super": "^6.6.5",
+    "babel-plugin-transform-es2015-parameters": "^6.6.5",
+    "babel-plugin-transform-es2015-shorthand-properties": "^6.5.0",
+    "babel-plugin-transform-es2015-spread": "^6.6.5",
+    "babel-plugin-transform-es2015-sticky-regex": "^6.5.0",
+    "babel-plugin-transform-es2015-template-literals": "^6.6.5",
+    "babel-plugin-transform-es2015-unicode-regex": "^6.5.0",
+    "babel-plugin-transform-es3-member-expression-literals": "^6.5.0",
+    "babel-plugin-transform-es3-property-literals": "^6.5.0",
+    "chai": "^3.2.0",
+    "cross-env": "^1.0.7",
+    "eslint": "^1.10.2",
+    "eslint-config-airbnb": "1.0.2",
+    "eslint-plugin-react": "^4.1.0",
+    "mocha": "^2.2.5",
+    "redux": "~4.0.0",
+    "rimraf": "^2.5.2",
+    "typescript": "~2.6.2",
+    "typings-tester": "^0.3.1",
+    "webpack": "^1.12.14"
+  }
+}

web/node_modules/redux-thunk/src/index.js

@@ -0,0 +1,14 @@
+function createThunkMiddleware(extraArgument) {
+  return ({ dispatch, getState }) => next => action => {
+    if (typeof action === 'function') {
+      return action(dispatch, getState, extraArgument);
+    }
+
+    return next(action);
+  };
+}
+
+const thunk = createThunkMiddleware();
+thunk.withExtraArgument = createThunkMiddleware;
+
+export default thunk;