mobx 3.2.2 → 3.3.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 3.3.0
+
+* Undeprecated `transaction`, see [#1139](https://github.com/mobxjs/mobx/issues/1139)
+* Fixed typings of reaction [#1136](https://github.com/mobxjs/mobx/issues/1136)
+* It is now possible to re-define a computed property [#1121](https://github.com/mobxjs/mobx/issues/1121)
+* Print an helpful error message when using `@action` on a getter [#971](https://github.com/mobxjs/mobx/issues/971)
+* Improved typings of intercept [#1119](https://github.com/mobxjs/mobx/issues/1119)
+* Made code base Prettier [#1103](https://github.com/mobxjs/mobx/issues/1103)
+* react-native will now by default use the es module build as well.
+* Added support for Weex, see [#1163](https://github.com/mobxjs/mobx/pull/1163/)
+* Added workaround for Firefox issue causing MobX to crash, see [#614](https://github.com/mobxjs/mobx/issues/614)
+
 # 3.2.2
 
 * Fixes a bug (or a known limitation) described in [#1092](https://github.com/mobxjs/mobx/issue/1092/). It is now possible to have different observable administration on different levels of the prototype chain. By @guillaumeleclerc

package/README.md

@@ -11,6 +11,7 @@ _Simple, scalable state management_
 [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://mobxjs.github.io/mobx/donate.html)
 [![OpenCollective](https://opencollective.com/mobx/backers/badge.svg)](#backers)
 [![OpenCollective](https://opencollective.com/mobx/sponsors/badge.svg)](#sponsors)
+[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 
 ![npm install mobx](https://nodei.co/npm/mobx.png?downloadRank=true&downloads=true)
 
@@ -55,7 +56,7 @@ Both React and MobX provide very optimal and unique solutions to common problems
 
 ## Core concepts
 
-MobX has only a few core concepts. The following snippets can be tried online using [JSFiddle](https://jsfiddle.net/mweststrate/wv3yopo0/) (or [without ES6 and JSX](https://jsfiddle.net/rubyred/55oc981v/)).
+MobX has only a few core concepts. The following snippets can be tried online using [JSFiddle](https://jsfiddle.net/mweststrate/f0dptdau/2/) (or [without ES6 and JSX](https://jsfiddle.net/rubyred/55oc981v/)).
 
 ### Observable state
 

package/lib/api/expr.d.ts

@@ -1,15 +1,15 @@
 /**
-    * expr can be used to create temporarily views inside views.
-    * This can be improved to improve performance if a value changes often, but usually doesn't affect the outcome of an expression.
-    *
-    * In the following example the expression prevents that a component is rerender _each time_ the selection changes;
-    * instead it will only rerenders when the current todo is (de)selected.
-    *
-    * reactiveComponent((props) => {
-    *     const todo = props.todo;
-    *     const isSelected = mobx.expr(() => props.viewState.selection === todo);
-    *     return <div className={isSelected ? "todo todo-selected" : "todo"}>{todo.title}</div>
-    * });
-    *
-    */
+ * expr can be used to create temporarily views inside views.
+ * This can be improved to improve performance if a value changes often, but usually doesn't affect the outcome of an expression.
+ *
+ * In the following example the expression prevents that a component is rerender _each time_ the selection changes;
+ * instead it will only rerenders when the current todo is (de)selected.
+ *
+ * reactiveComponent((props) => {
+ *     const todo = props.todo;
+ *     const isSelected = mobx.expr(() => props.viewState.selection === todo);
+ *     return <div className={isSelected ? "todo todo-selected" : "todo"}>{todo.title}</div>
+ * });
+ *
+ */
 export declare function expr<T>(expr: () => T, scope?: any): T;

package/lib/api/intercept-read.d.ts

@@ -1,7 +1,7 @@
-import { Lambda } from '../utils/utils';
-import { IObservableArray } from '../types/observablearray';
-import { ObservableMap } from '../types/observablemap';
-import { IObservableValue } from '../types/observablevalue';
+import { Lambda } from "../utils/utils";
+import { IObservableArray } from "../types/observablearray";
+import { ObservableMap } from "../types/observablemap";
+import { IObservableValue } from "../types/observablevalue";
 export declare type ReadInterceptor<T> = (value: any) => T;
 /** Experimental feature right now, tested indirectly via Mobx-State-Tree */
 export declare function interceptReads<T>(value: IObservableValue<T>, handler: ReadInterceptor<T>): Lambda;

package/lib/api/intercept.d.ts

@@ -9,4 +9,4 @@ export declare function intercept<T>(observableArray: IObservableArray<T>, handl
 export declare function intercept<T>(observableMap: ObservableMap<T>, handler: IInterceptor<IMapWillChange<T>>): Lambda;
 export declare function intercept<T>(observableMap: ObservableMap<T>, property: string, handler: IInterceptor<IValueWillChange<T>>): Lambda;
 export declare function intercept(object: Object, handler: IInterceptor<IObjectWillChange>): Lambda;
-export declare function intercept(object: Object, property: string, handler: IInterceptor<IValueWillChange<any>>): Lambda;
+export declare function intercept<T extends Object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<any>>): Lambda;

package/lib/api/isobservable.d.ts

@@ -1,6 +1,6 @@
 /**
-    * Returns true if the provided value is reactive.
-    * @param value object, function or array
-    * @param property if property is specified, checks whether value.property is reactive.
-    */
+ * Returns true if the provided value is reactive.
+ * @param value object, function or array
+ * @param property if property is specified, checks whether value.property is reactive.
+ */
 export declare function isObservable(value: any, property?: string): boolean;

package/lib/api/tojs.d.ts

@@ -1,6 +1,6 @@
 /**
-    * Basically, a deep clone, so that no reactive property will exist anymore.
-    */
+ * Basically, a deep clone, so that no reactive property will exist anymore.
+ */
 export declare function toJS<T>(source: T, detectCycles?: boolean): T;
 export declare function toJS(source: any, detectCycles?: boolean): any;
 export declare function toJS(source: any, detectCycles: boolean, __alreadySeen: [any, any][]): any;

package/lib/core/computedvalue.d.ts

@@ -11,7 +11,9 @@ export interface IComputedValue<T> {
 /**
  * A node in the state dependency root that observes other nodes, and can be observed itself.
  *
- * ComputedValue will remember result of the computation for duration of a batch, or being observed
+ * ComputedValue will remember the result of the computation for the duration of the batch, or
+ * while being observed.
+ *
  * During this time it will recompute only when one of its direct dependencies changed,
  * but only when it is being accessed with `ComputedValue.get()`.
  *

package/lib/mobx.d.ts

@@ -153,7 +153,7 @@ declare const everything: {
         <T>(observableMap: ObservableMap<T>, handler: IInterceptor<IMapWillChange<T>>): Lambda;
         <T>(observableMap: ObservableMap<T>, property: string, handler: IInterceptor<IValueWillChange<T>>): Lambda;
         (object: Object, handler: IInterceptor<IObjectWillChange>): Lambda;
-        (object: Object, property: string, handler: IInterceptor<IValueWillChange<any>>): Lambda;
+        <T extends Object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<any>>): Lambda;
     };
     autorun: {
         (view: (r: IReactionPublic) => any, scope?: any): IReactionDisposer;