Update docs to mobx 3 #725

mweststrate · 2016-12-27T14:02:12Z

nuf said

dmitriid · 2016-12-27T15:01:14Z

docs/refguide/action.md

+
+	@action.bound
+	increment() {
+		this.tick++ // 'this' will always be correct


Please explain why this might not be correct using plain action

dmitriid · 2016-12-27T15:02:17Z

docs/refguide/action.md

+## Bound actions
+
+The `action` decorator / function follows the normal rules for binding in javascript.
+However, Mobx 3 introduces `action.bound` to automatically bind actions to the targeted object.


Please shortly explain the difference as in:

The action decorator / function follows the normal rules for binding in javascript... That is it [only] binds this and that
... action.bound to automatically bind actions to the targeted object. That is in this and that situation

dmitriid · 2016-12-27T15:03:35Z

docs/refguide/api.md

 The following conversion rules are applied, but can be fine-tuned by using *modifiers*. See below.

-1. If *value* is wrapped in the *modifier* `asMap`: a new [Observable Map](map.md) will be returned. Observable maps are very useful if you don't want to react just to the change of a specific entry, but also to the addition or removal of entries.
+1. If *value* is an wrapped is an instance of an [ES6 Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map): a new [Observable Map](map.md) will be returned. Observable maps are very useful if you don't want to react just to the change of a specific entry, but also to the addition or removal of entries.


is an wrapped is an instance

should probably be

is a wrapped instance

dmitriid · 2016-12-27T15:07:29Z

docs/refguide/computed-decorator.md


-`@computed` can be parameterized. `@computed({asStructure: true})` makes sure that the result of a derivation is compared structurally instead of referentially with its preview value. This makes sure that observers of the computation don't re-evaluate if new structures are returned that are structurally equal to the original ones. This is very useful when working with point, vector or color structures for example. It behaves the same as the `asStructure` modifier for observable values.
+If your environment doesn't support decorators, use the `computed(expression)` modifier incombination with `extendObservable` / `observable` to introduce new computed properties.


incombination

dmitriid · 2016-12-27T15:09:15Z

docs/refguide/api.md

 ## Computed values

 Usage:
 * `computed(() => expression)`
+* `computed(() => expression, (newValue) => void)`


computed(() => expression, (newValue) => void) isn't explained in the computed docs, only computed(() => expression) and computed(() => expression, options) are explained

Yes, does the setter behave as an action?

dmitriid · 2016-12-27T15:11:34Z

docs/refguide/extend-observable.md

+## Modifiers
+
+[Modifiers](modifiers.md) can be used to define special behavior for certain properties.
+For example `observable.ref` creates an observable reference which doesn't automatically convert it's values into observables, and `computed` introduces a derived property:


it's -> its

dmitriid · 2016-12-27T15:12:52Z

docs/refguide/map.md

-`observable(asMap(values?, modifier?))` (and `map(values?, modifier?)`) creates a dynamic keyed observable map.
+## `observable.map(values)`
+
+`observable.map(values?)` creates a dynamic keyed observable map.


It probably makes sense to add

To create dynamically keyed objects always use maps!

here as well. You can never have too few warnings :)

dmitriid · 2016-12-27T15:14:05Z

docs/refguide/modifiers.md

-In general, this should just do what you need, but if you want you can override the default behavior using _modifiers_.
-Note that modifiers are 'sticky', they are interpreted as being annotations.
-They do not only apply to the current value, but also to all values that are assigned in the future to the same attribute.
+Modifiers can be used decorator or in combination with `extendObservable` and `observable.object` to change the autoconversion rules for specific properties.


can be used decorator -> can be used as decorators

dmitriid · 2016-12-27T15:15:46Z

docs/refguide/modifiers.md

-If this modifier is used, `observable` will not attempt to make the value observable.
-Use this for example if you want to store a reference to a function, instead of creating a view based on that function.
-You can also use it to prevent that plain objects or arrays are made observable automatically.
+    // ficitonal example, if author is immutable, we just need to store a reference and shouldn't turn it into an mutable, observable object


ficitonal -> fictional

dmitriid · 2016-12-27T15:16:57Z

docs/refguide/modifiers.md


-To use the `asStructure` modifier in combination with the `@computed` decorator, use the following:
+`action`, `action.bound`, `computed` and `computed.struct` can be used as modifiers as well.
+See [`computed`](computed-decorator.md) respectively [`action`](action.md).


See computed and action respectively
(word order)

RoyalIcing · 2016-12-27T22:05:16Z

docs/refguide/action.md

+setInterval(ticker.increment, 1000)
+```
+
+_Note: don't use *action.bind* with arrow functions; arrow functions are already bound and cannot be rebound._


Typo: should sayaction.bound

RoyalIcing · 2016-12-27T22:12:23Z

docs/refguide/api.md

 ## Computed values

 Usage:
 * `computed(() => expression)`
+* `computed(() => expression, (newValue) => void)`


Yes, does the setter behave as an action?

RoyalIcing · 2016-12-27T22:19:30Z

docs/refguide/computed-decorator.md

-So they will not be invoked when their input parameters didn't modifiy or if they are not observed by some other computed value or autorun.
+This automatic suspension is very convenient; it means that a computed value that is not observed anymore (for example because the UI in which it was used has disappeared)
+can automatically be garbabged collected by MobX, and unlike `autorun`'s you don't have to dispose them yourself.
+This sometimes confuses people new to MobX; if you create a computed property but don't use it anywhere in a reaction, it will not cache it's value and recompute more often than seems necesarray.


Typo: it's -> its
Typo: necesarray -> necessary

RoyalIcing · 2016-12-27T22:28:48Z

docs/refguide/modifiers.md

 ```
+
+After these assignments:


This is a great example!

RoyalIcing · 2016-12-27T22:29:20Z

docs/refguide/object.md

-If a plain JavaScript object is passed to `observable` all properties inside that object will be made observable.
-(A plain object is an object that wasn't created using a constructor function)
+If a plain JavaScript object is passed to `observable` all properties inside will be copied into a clone and made observable.
+(A plain object is an object that wasn't created using a constructor function / but has `Object` as it's prototype, or no prototype at all.)


RoyalIcing · 2016-12-27T22:42:58Z

docs/refguide/reaction.md

 The side effect can be debounced, just like `autorunAsync`.
 `reaction` returns a disposer function.
-If a string is passed as first argument to `reaction`, it will be used as debug name.
-The functions passed to `when` will receive one argument when invoked, the current reaction, which can be used to dispose the when during execution.
+The functions passed to `reaction` will receive one argument when invoked, the current reaction, which can be used to dispose the when during execution.


dispose the when?

mweststrate added 2 commits December 27, 2016 14:43

Updated docs for MobX 3

e39ffbf

improved action docs

7c917aa

dmitriid reviewed Dec 27, 2016

View reviewed changes

RoyalIcing reviewed Dec 27, 2016

View reviewed changes

mweststrate merged commit 7c917aa into gh-pages Jan 9, 2017

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Update docs to mobx 3 #725

Update docs to mobx 3 #725

mweststrate commented Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

RoyalIcing Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

dmitriid Dec 27, 2016

RoyalIcing Dec 27, 2016

RoyalIcing Dec 27, 2016

RoyalIcing Dec 27, 2016

RoyalIcing Dec 27, 2016

RoyalIcing Dec 27, 2016

RoyalIcing Dec 27, 2016


		`@computed` can be parameterized. `@computed({asStructure: true})` makes sure that the result of a derivation is compared structurally instead of referentially with its preview value. This makes sure that observers of the computation don't re-evaluate if new structures are returned that are structurally equal to the original ones. This is very useful when working with point, vector or color structures for example. It behaves the same as the `asStructure` modifier for observable values.
		If your environment doesn't support decorators, use the `computed(expression)` modifier incombination with `extendObservable` / `observable` to introduce new computed properties.

Update docs to mobx 3 #725

Update docs to mobx 3 #725

Conversation

mweststrate commented Dec 27, 2016

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment