Merge branch '6.1.0.reversion'

.gitignore

@@ -2,5 +2,3 @@ node_modules
 coverage
 built
 .DS_Store
-interactive-tests/.cache
-interactive-tests/dist

README.md

@@ -6,6 +6,12 @@ _Define a computed by returning a Promise_
 
 *"People starting with MobX tend to use reactions [*autorun*] too often. The golden rule is: if you want to create a value based on the current state, use computed."* - [MobX - Concepts & Principles](http://mobxjs.github.io/mobx/intro/concepts.html)
 
+# About MobX 6
+
+An attempt was made, then abandoned, to quick-fix this library to work with MobX 6, but it didn't work out (to put it mildly). Any suggestions for how to fix it are welcome! For now it only works with MobX versions 3.0 to 5.x.
+
+It's possible the API may need to be cut down to something a bit simpler with fewer guarantees but still achieving the basic goal.
+
 # What is this for?
 
 A `computed` in MobX is defined by a function, which consumes other observable values and is automatically re-evaluated, like a spreadsheet cell containing a calculation.
@@ -27,10 +33,11 @@ creditScore = promisedComputed(0, async () => {
 
 [Further explanation, rationale, etc.](../../wiki)
 
-# New in Version 6.0.0...
+# New in Version 3.0.0...
 
-* Breaking change: the old API (deprecated for over three years, seems fair!) has been removed. Stay tuned for a migration guide below.
-* Support for MobX 6
+There is a completely new API, much more modular and made of simple, testable pieces. The
+old API is deprecated, though is still available for now. First here's how the current 
+features work. Stay tuned for a migration guide below.
 
 ----
 
@@ -55,11 +62,9 @@ The returned object also has a `busy` property that is true while a promise is s
 It also has a `refresh` method that can be called to force a new promise to be requested
 immediately (bypassing the delay time).
 
-There is also a method `getNonReactive()` which can be used outside reactive contexts. It is
-a convenience for writing unit tests. Note that it will return the most recent value that was
-computed while the `asyncComputed` was being observed.
-
-[Generated references docs](http://earwicker.com/computed-async-mobx/typedoc/modules/_asynccomputed_.html)
+**New in 4.2.0:** there is also a method `getNonReactive()` which can be used outside reactive
+contexts. It is a convenience for writing unit tests. Note that it will return the most recent
+value that was computed while the `asyncComputed` was being observed.
 
 ### Example
 
@@ -93,8 +98,6 @@ of being fully synchronous if the `compute` function returns a plain value.
 
 Exactly as `asyncComputed`.
 
-[Generated references docs](http://earwicker.com/computed-async-mobx/typedoc/modules/_promisedcomputed_.html)
-
 ### Example
 
 ```ts
@@ -115,7 +118,8 @@ If the `this.userName` property is an observable and is modified, the
 ## throttledComputed
 
 Like the standard `computed` but with support for delaying for a specified number of 
-milliseconds before re-evaluation.
+milliseconds before re-evaluation. It is like a computed version of the standard 
+`autorunAsync`; the advantage is that you don't have to manually dispose it.
 
 (Note that `throttledComputed` has no special functionality for handling promises.)
 
@@ -133,11 +137,6 @@ every time you request the value.
 
 It also has a `refresh` method that *immediately* (synchronously) re-evaluates the function.
 
-The value returned from `get` is always a value obtained from the provided `compute` function,
-never silently substituted.
-
-[Generated references docs](http://earwicker.com/computed-async-mobx/typedoc/modules/_throttledcomputed_.html)
-
 ### Example
 
 ```ts
@@ -156,8 +155,8 @@ least 500 milliseconds.
 
 ## autorunThrottled
 
-Much like the standard `autorun` with the `delay` option, except that the initial run of 
-the function happens synchronously.
+Much like the standard `autorunAsync`, except that the initial run of the function happens
+synchronously.
 
 (This is used by `throttledComputed` to allow it to be synchronously initialized.)
 
@@ -176,8 +175,6 @@ is an observable, so it can be used from other MobX contexts. It can also be use
 MobX reactive contexts but (like standard `computed`) it reverts to simply re-evaluating 
 every time you request the value.
 
-[Generated references docs](http://earwicker.com/computed-async-mobx/typedoc/modules/_autorunthrottled_.html)
-
 ----
 
 # Installation
@@ -224,11 +221,6 @@ class Person {
      get percentage() {
          return Math.round(this.creditScore.get() / 10);
      }
-
-     // For MobX 6
-     constructor() {
-         makeObservable(this);
-     }
 }
 ```
 
@@ -246,13 +238,11 @@ For example, here we fetch two pieces of data to combine them together:
 
 ```ts
 answer = asyncComputed(0, 1000, async () => {
-
-    // Don't do this!!
     const part1 = await fetch(this.part1Uri),
           part2 = await fetch(this.part2Uri);
 
     // combine part1 and part2 into a result somehow...
-    return part1 + part2;
+    return result;
 });
 ```
 
@@ -279,7 +269,7 @@ When in doubt, move all your gathering of observable values to the start of the
 
 # Migration
 
-Versions prior to 3.0.0 had a different API. It was a single `computedAsync` function that had all the
+The API of previous versions is still available. It was a single `computedAsync` function that had all the
 capabilities, like a Swiss-Army Knife, making it difficult to test, maintain and use. It also had some
 built-in functionality that could just as easily be provided by user code, which is pointless and only
 creates obscurity.