Version 1.0, huge refactor and re-write of pieces

.gitignore

@@ -1,6 +1,8 @@
+.DS_Store
 node_modules
 .cache
-dist
 .nyc_output
+dist
 coverage
 examples/**/package-lock.json
+ferp.js

.npmignore

@@ -0,0 +1,10 @@
+.nyc_output
+.cache
+coverage
+examples
+src/**/*.test.js
+.babelrc
+.eslint*
+.nvmrc
+.travis.yml
+rollup.config.js

CHANGELOG.md

@@ -0,0 +1,88 @@
+# Ferp Changelog
+
+## Unreleased - 2018-09-XX - [git](#https://github.com/mrozbarry/ferp/compare/619723b8b35676acaa1196629c35331bcb978b0f...todo)
+
+### Breaking changes
+
+ - Renames `Effect.map` to `Effect.batch`
+ - Removes `ferp.types.Effect`
+ - Moves effect primitives into `ferp.effects` as `none()`, `batch([])`, `defer(promise)`, and **new** `thunk(method)`
+ - Disables `ferp.types.Result` - It may come back, or be removed in a future release
+ - Changes `ferp.effects.delay`
+   - Exposed as a single function that delays for n milliseconds
+   - Reverses param order to be `ferp.effects.delay(message, milliseconds)` to align with the raf effect
+ - Changes `ferp.subscriptions.every`
+   - Exposed as a single function that ticks every n milliseconds
+   - Reverses param order to be `ferp.subscriptions.every(message, milliseconds)` to align with `effects.raf` and `effects.delay`
+
+### Features
+
+ - Adds a changelog
+ - Huge test coverage improvement
+ - Many internal changes that simplify the `ferp.app` function
+ - Adds `ferp.util.combineReducers` to manage nested reducers that run effects
+ - Adds `ferp.effects.thunk` effect primitive
+
+
+## v0.1.1 - 2018-09-20 - [git](https://github.com/mrozbarry/ferp/compare/4e1dbd1e8e82c8197be87ee59c7de827a6ca4741...619723b8b35676acaa1196629c35331bcb978b0f)
+
+### Features
+
+ - Adds tests around subscriptionHandler
+
+### Fixes
+
+ - Issue where subscriptions that immediately dispatch could cause an infinite loop
+
+
+## v0.1.0 - 2018-09-16 - [git](https://github.com/mrozbarry/ferp/compare/da884fdcfeb8746af2e5b366cc1a7395c64f103d...4e1dbd1e8e82c8197be87ee59c7de827a6ca4741)
+
+### Breaking changes
+
+ - Updated subscriptions to not require an id prefix
+
+
+## v0.0.5 - 2018-09-09 - [git](https://github.com/mrozbarry/ferp/compare/9a51d0da69d68ddbbe2f86dbb325bb0e7f2e1e4e...da884fdcfeb8746af2e5b366cc1a7395c64f103d)
+
+### Features
+
+ - Further linting
+ - Adds test for effect ordering
+
+### Fixes
+
+ - Fixes issue with effects not running in a deterministic order
+
+
+## v0.0.4 - 2018-09-08 - [git](https://github.com/mrozbarry/ferp/compare/4053daee2e434a9a66ad88d9de056e9d2621243b...9a51d0da69d68ddbbe2f86dbb325bb0e7f2e1e4e)
+
+### Features
+
+ - Many fixes and touch-ups to the game-input example
+
+### Fixes
+
+ - Issue where mapped effects weren't being executed properly
+
+
+## v0.0.3 - 2018-09-07 - [git](https://github.com/mrozbarry/ferp/compare/1efebd9c67e9ab76c4c44c63d2ab021af1cd2f96...4053daee2e434a9a66ad88d9de056e9d2621243b)
+
+### Features
+
+ - General code cleanup
+ - Adds `effects.delay.raf` to requestAnimationFrame
+
+### Fixes
+
+ - Fixed ava tests that were being cached unexpectedly
+
+
+## v0.0.2 - 2018-09-03 - [git](https://github.com/mrozbarry/ferp/compare/6b9a97ac89f8496a2efe865ea9197bcdf9856da3...1efebd9c67e9ab76c4c44c63d2ab021af1cd2f96)
+
+### Features
+
+ - Adds testing with ava
+ - Adds linting with eslint
+ - Adds game-input example
+ - Adds rollup and config
+ - Upgrades code to use es6 imports, since ava already brings in babel dependencies

INTERNALS.md

@@ -0,0 +1,73 @@
+# Ferp Internals
+
+## Initializing your app
+
+| Param    | Type        | Required |
+| -------- | ----------- | -------- |
+| init     | Array/Tuple | Yes      |
+
+The `init` array/tuple lets you establish initial state, and run an initial [effect](./src/effects).
+The structure of this data **must** be `[initialState, initialEffect]` where initialState is the state you want your app to start with, and initialEffect is an [effect](./src/effects) that tells the app how to proceed.
+
+
+## Keeping up to date
+
+| Param    | Type     | Required |
+| -------- | -------- | -------- |
+| update   | Function | Yes      |
+
+The `update(message, state)` function gives you the opportunity to make changes to your state.
+All updates **must** return the array `[updatedState, effect]`, where:
+
+ - `updatedState` is a new copy of state with any changes you have made
+ - `effect` is any effect you want to trigger. See [effects](./src/effects) for more information on what they are and how to use them.
+
+
+## Subscribe to third-party events
+
+| Param         | Type     | Required |
+| ------------- | -------- | -------- |
+| subscribe     | Function | No       |
+
+The `subscribe(state)` function describes which [subscriptions](./src/subscriptions) are active and inactive.
+This function is run each update, and can and should react to the new state to turn on and off subscriptions.
+`subscribe` should return an array in the following format:
+
+```javascript
+subscribe: (state) => {
+  return [
+    [subscriptionMethod, param1, param2, param3, ...],
+    [subMethod, param1, param2, param3, ...],
+    ...
+  ]
+}
+```
+
+Each subscription needs at least a subscription method.
+You can use boolean operations to toggle subscriptions on and off like this:
+
+```javascript
+subscribe: (state) => {
+  return [
+    state.somethingMeaningful && [subscriptionMethod, param1, param2, param3, ...],
+  ]
+}
+```
+
+If you want to write your own subscription, methods should look like the following:
+
+```javascript
+const myCoolSubscription = (param1, param2, param3) => (dispatch) => {
+  // Start subscription here
+  // ...
+
+  return () => {
+    // Clean up subscription here
+    // ...
+  };
+};
+```
+
+When a subscription is deactivated, ferp will run it's cleanup callback, and when it is (re-)activated, it will run a fresh copy of your subscription.
+Subscriptions aren't re-used in ferp, so re-activating a subscription will not remember any internal state your subscription previously handled.
+If you need your subscription to remember a previous state between activations, you may want to store that data in your state, and run an effect as your subscription ends to store that latest subscription state in your app state.

MIGRATION.md

@@ -0,0 +1,144 @@
+# Migrating from ferp 0.x to 1.x
+
+## Minor changes to app initialization
+
+Previously, your app entry code may have looked like this:
+
+```javascript
+const ferp = require('ferp');
+
+ferp.app({
+  init: () => [initialState, initialEffect],
+  update: (message, previousState) => [previousState, ferp.types.Effect.none()],
+  subscribe: (state) => [],
+});
+```
+
+Most of this is the same, but init is not a function any more, and effects have been move (more on this below).
+Now the same code should look like this:
+
+```javascript
+const ferp = require('ferp');
+
+ferp.app({
+  init: [initialState, initialEffect],
+  update: (message, previousState) => [previousState, ferp.effects.none()],
+  subscribe: (state) => [],
+});
+```
+
+## Effects have moved, and they have some new friends
+
+Previously, to use an effect, your code may have looked like one of these:
+
+```javascript
+const ferp = require('ferp');
+const { Effect } = ferp.types;
+
+const myNoOpEffect = Effect.none();
+
+const myImmediateAsyncEffect = new Effect((done) => {
+  // Do something
+  done({ type: 'MESSAGE YOU WANT TO SEND' });
+});
+
+const myManyEffects = Effect.map([
+  someEffect1,
+  someEffect2,
+]);
+
+const myMessageEffect = Effect.immediate({ type: 'MESSAGE FOR RIGHT NOW' });
+
+const { dispatch, effect } = Effect.defer();
+const myDeferredAsyncEffect = effect;
+// some other code calls dispatch({ type: 'MESSAGE DEFERRED' })
+```
+
+Now the same code looks like this:
+
+```javascript
+const ferp = require('ferp');
+const { effects } = ferp;
+
+const myNoOpEffect = effects.none(); // Looks mostly the same on the outside, much different on the inside.
+
+const myImmediateAsyncEffect = effects.defer(new Promise((done) => { // You can provide your own promise now. Works much better for doing fetches and other things.
+  // Do something
+  done({ type: 'MESSAGE YOU WANT TO SEND' });
+}));
+
+const myManyEffects = effects.batch([ // Note the rename from map to batch
+  someEffect1,
+  someEffect2,
+]);
+
+const myMessageEffect = { type: 'MESSAGE FOR RIGHT NOW' }; // No wrapping effect now
+
+let dispatch = () => {}; // A little more complicated solution here, but I think externally resolved promises like this will be unusual.
+const deferredPromise = new Promise((done) => { dispatch = done });
+const myDeferredAsyncEffect = effects.defer(deferredPromise);
+// some other code calls dispatch({ type: 'MESSAGE DEFERRED' });
+```
+
+With a bonus, we have a new effect - introducing `effects.thunk`.
+A thunk is a way to only evaluate an effect when it's handled internally.
+For example, if you were to compose a new effect with delays, you'd want the inner delay to run after the external delay.
+Here's a non-working version:
+
+```javascript
+const myDelayEffect = (innerEffect, milliseconds) => effects.defer(new Promise((done) => {
+  setTimeout(() => {
+    done(innerEffect);
+  }, milliseconds);
+}));
+
+const composedEffect = myDelay(myDelay({ type: 'INNER' }, 1000), 1000);
+```
+
+You would expect the `{ type: 'INNER' }` to be dispatched after 2000 milliseconds, but this is not the case.
+Both effects would run almost immediately, and take a total of about 1010 milliseconds.
+This is because the setTimeout will run as soon as the promise is created, even though we may not wait for it until later.
+To fix this, we could use a thunk like this:
+
+```javascript
+const myDelayEffect = (innerEffect, milliseconds) => effects.thunk(() => effects.defer(new Promise((done) => {
+  setTimeout(() => {
+    done(innerEffect);
+  }, milliseconds);
+})));
+
+const composedEffect = myDelay(myDelay({ type: 'INNER' }, 1000), 1000);
+```
+
+The thunk prevents the promise from even being created until it's evaluated by ferp during a dispatch.
+
+## As seen above, composable core effects
+
+The previous effect implementation made composing effects hard.
+Effects have been completely re-written from the ground up to support powerful composition.
+
+## Timer param orderings
+
+Doing `effects.delay`, `effects.raf`, and `subsciptions.every` have had their params re-ordered to be all consistent, `message, timeInformation`,
+where `timeInformation` is the length of a delay for `effects.delay`, the last timestamp (or null) for `effects.raf` to calculate deltas, and millisecond interval for `subscriptions.every`.
+
+## Removed timer helpers
+
+Previously, `effects.delay` and `subscriptions.every` exported modules with `milliseconds`, `seconds`, `minutes`, and `hours` being options in how the delay would be timed.
+These have been removed, and the exported `delay` and `every` are just the millisecond function variants that were previously available.
+
+## No more types
+
+Effects, as seen above, are first class citizens now, but more importantly, I removed the `Result` type. You can read more about that decision [on PR#7](https://github.com/mrozbarry/ferp/pull/7).
+There are various enum and result type libraries available for javascript, and maybe one of those will be a good replacement if you have been using `Result`s.
+
+## No more middleware
+
+Middleware was a hard decision because many libraries like ferp have the concept of middleware in one form or another.
+After much thought, I have decided to remove it for a few reasons:
+
+ - Middleware makes sense when a library provides both state and UI, since you may want to intercept state changes before it reaches the UI. Ferp doesn't provide a UI, so it makes this useless.
+ - The implementation I chose for ferp originally was inefficient, and allowed state mutations, but of which were hard to justify in an immutable functional app.
+ - Functional programming promotes the idea of high-order functions, so if it were absolutely necessary to have a middleware for ferp, it is easy enough to write a wrapping function for your update function.
+
+You can read more on it [on PR#7](https://github.com/mrozbarry/ferp/pull/7)