mobx 5.7.0 → 5.9.4

package/CHANGELOG.md

@@ -1,3 +1,48 @@
+# 5.9.4 / 4.9.4
+
+* Allow symbol keys in `ObservableMap`, see [#1930](https://github.com/mobxjs/mobx/pull/1930) by [pimterry](https://github.com/pimterry)
+* Fixed type definitions of `toStringTag` for Maps and Sets, see [#1929](https://github.com/mobxjs/mobx/pull/1929) by [lennerd](https://github.com/mobxjs/mobx/pull/1929)
+
+# 4.9.3
+
+* Fixed `observable.set` compatibility with IE 11, see [#1917](https://github.com/mobxjs/mobx/pull/1917) by [kalmi](https://github.com/kalmi)
+
+# 4.9.2
+
+* Fixed regression [#1878](https://github.com/mobxjs/mobx/issues/1878), accidental use of `Symbol` breaking Internet Explorer / React Native compatibility.
+
+# 4.9.1
+
+* Fixed regression in `toJS`: observable maps were not properly serialized. Fixes [#1875](https://github.com/mobxjs/mobx/issues/1875)
+
+# 5.9.0 / 4.9.0
+
+**Features**
+
+* Introduced support for observable sets! Through [#1592](https://github.com/mobxjs/mobx/pull/1592) by [@newraina](https://github.com/newraina)
+* `observable.box` now accepts an `equals` option, to be able to pass a custom comparision function. Through [#1862](https://github.com/mobxjs/mobx/pull/1862), [#1874](https://github.com/mobxjs/mobx/pull/1874) by [@fi3ework](https://github.com/fi3ework). Fixes [#1580](https://github.com/mobxjs/mobx/issues/1580)
+* Improved logging of reactions; if an action throws an exception, errors in reactions that react to that are only logged as warnings. Fixes [#1836](https://github.com/mobxjs/mobx/issues/1836)
+
+**Fixes**
+
+* Improved typings for `flow`, see [#1827](https://github.com/mobxjs/mobx/pull/1827) by [@xaviergonz](https://github.com/xaviergonz)
+* Don't allow subclassing map, fixes [#1858](https://github.com/mobxjs/mobx/issues/1858)
+* Fixed `trace(true)` not being able to handle multi-line comments in traced function. Fixes [#1850](https://github.com/mobxjs/mobx/issues/1850)
+* `@computed` now introduces non-configurable properties, to fail fast on incorrect inheritance or property deletion. Fixes [#1867](https://github.com/mobxjs/mobx/issues/1867)
+* The options `enforceActions` and `isolateGlobalState` now work correctly when used together. Fixes [#1869](https://github.com/mobxjs/mobx/issues/1869)
+
+# 5.8.0 / 4.8.0
+
+* MobX now requires TypeScript 3 (this was already the case in 5.7.0, but in this version the difference is actually noticeable in the typings). 
+* Fixed array dehancer sometimes skipping. Fixes [#1839](https://github.com/mobxjs/mobx/issues/1839) through [#1841](https://github.com/mobxjs/mobx/pull/1841) by [k-g-a](https://github.com/k-g-a) 
+* Fixed issue where webpack 4 wouldn't use the ESM module [#1834](https://github.com/mobxjs/mobx/pull/1834) by [mrtnbroder](https://github.com/mrtnbroder)
+* Improved type inference for `flow` in TypeScript 3. Fixes [#1816](https://github.com/mobxjs/mobx/issue/1816) through [#1825](https://github.com/mobxjs/mobx/pull/1825) by [ismailhabib](https://github.com/ismailhabib)
+* Introduced support for global environment variable `IGNORE_MOBX_MINIFIY_WARNING=true` to skip the built-in minification warning. See [#1835](https://github.com/mobxjs/mobx/pull/1835) by [fi3ework](https://github.com/fi3ework)
+* Fixed onBecome(Un)Observed dispoer cleanup. Fixes [#1537](https://github.com/mobxjs/mobx/issues/1537) through [#1833](https://github.com/mobxjs/mobx/pull/1833) by [fi3ework](https://github.com/fi3ework)
+
+# 5.7.1 / 4.7.1
+* Fixed [#1839](https://github.com/mobxjs/mobx/issues/1839), ObservableArrayAdministration.dehanceValues does not dehance last value.
+
 # 5.7.0 / 4.7.0
 
 * Upgraded typings to TypeScript 3
@@ -122,6 +167,7 @@ _Note June 7th, 2018:_ Both issues are already in Jest master and should be rele
   * Don't `slice()` arrays when passing them to external libraries. (Note you still shouldn't pass observable data structures to non-`observer` React components, which is an orthogonal concept)
   * You could replace observable maps with observable objects if you are only using string-based keys.
 * Don't call the `reverse` or `sort` operations directly on observableArray's anymore, as it's behavior slightly differed from the built-in implementations of those methods. Instead use `observableArray.slice().sort()` to perform the sort on a copy. This gives no additional performance overhead compared to MobX 4. (The reason behind this is that built-in `sort` updates the array in place, but the observable array implementation always performed the sort on a defensive copy, and this change makes that explicit).
+* you may remove usages of `isArrayLike()` since `Array.isArray()` will now return true for observable arrays
 
 
 ### API's that have been dropped

package/README.md

@@ -12,12 +12,18 @@ _Simple, scalable state management_
 [![OpenCollective](https://opencollective.com/mobx/sponsors/badge.svg)](#sponsors)
 [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 
-MobX is proudly sponsored by Mendix, Coinbase, Facebook Open Source, Canva, Algolia, Guilded and many [individual sponsors](#backers)
-
-<img src="docs/mendix-logo.png" align="center" width="100" title="Mendix" alt="Mendix" /> <img src="docs/coinbase.jpeg" align="center" width="100" title="Coinbase" alt="Coinbase" /> <img src="docs/fbos.jpeg" align="center" width="100" title="Facebook Open Source" alt="Facebook Open Source" />
-<img src="docs/canva.png" align="center" width="100" title="Canva" alt="Canva" />
-<img src="docs/algolia.jpg" align="center" width="100" title="Algolia" alt="Algolia" />
-<img src="docs/guilded.jpg" align="center" width="100" title="Guilded" alt="Guilded" />
+MobX is proudly sponsored by Mendix, Coinbase, Facebook Open Source, Canva, Algolia, Guilded, Auction Frontier, Mantro and TalentPlot for 100$/month or more! And beyond that by many [individual backers](#backers) and through [one time contributions](https://github.com/mobxjs/mobx/blob/master/sponsors.md).
+
+<a href="https://mendix.com/"><img src="docs/mendix-logo.png" align="center" width="100" title="Mendix" alt="Mendix" /></a>
+<a href="https://coinbase.com/"><img src="docs/coinbase.jpeg" align="center" width="100" title="Coinbase" alt="Coinbase" /></a>
+<a href="https://opensource.facebook.com/"><img src="docs/fbos.jpeg" align="center" width="100" title="Facebook Open Source" alt="Facebook Open Source" /></a>
+<a href="https://www.canva.com/"><img src="docs/canva.png" align="center" width="100" title="Canva" alt="Canva" /></a>
+<a href="https://www.algolia.com/"><img src="docs/algolia.jpg" align="center" width="100" title="Algolia" alt="Algolia" /></a>
+<a href="https://www.guilded.gg/"><img src="docs/guilded.jpg" align="center" width="100" title="Guilded" alt="Guilded" /></a>
+<a href="http://auctionfrontier.com/"><img src="docs/auctionfrontier.jpeg" align="center" width="100" title="Auction Frontier" alt="Auction Frontier"></a>
+<a href="https://mantro.net/jobs/warlock"><img src="docs/mantro.png" align="center" width="100" title="mantro GmbH" alt="mantro GmbH"></a>
+<a href="https://talentplot.com/"><img src="docs/talentplot.png" align="center" width="100" title="talentplot" alt="talentplot"></a>
+<a href="https://www.codefirst.co.uk/"><img src="https://mobx.js.org/docs/codefirst.png" align="center" width="100" title="CodeFirst" alt="CodeFirst"/></a>
 
 # Installation
 
@@ -33,11 +39,11 @@ _Tip: Consider using the faster and smaller ES6 build if targetting a modern env
 
 | MobX version | Actively supported  | Supported browsers | GitHub branch |
 | ----- | ----- | --- | --- |
-| 5.* | Yes | Any browser that supports [ES6 Proxies](https://kangax.github.io/compat-table/es6/#test-Proxy) (non polyfillable). _NOT:_ IE 11 and lower, Node 5 and lower | `master` |
+| 5.* | Yes | Any browser that supports [ES6 Proxies](https://kangax.github.io/compat-table/es6/#test-Proxy) (non polyfillable). _NOT:_ IE 11 and lower, Node 5 and lower, Google's crawler bot | `master` |
 | 4.* | Yes (LTS) | Any ES5 compliant browser | `mobx4-master` |
 | 1-3.* | No |  Any ES5 compliant browser | No active branch |
 
-* MobX >=5 runs on any browser with [ES6 proxy support](https://kangax.github.io/compat-table/es6/#test-Proxy). It will throw an error on startup on older environments such as IE11, Node.js <6 or React Native Android on old JavaScriptCore [how-to-upgrade](https://github.com/react-community/jsc-android-buildscripts#how-to-use-it-with-my-react-native-app). _Warning: since upgrading JSC is non-trivial, and decorators can be [troublesome](https://github.com/mobxjs/mobx/issues/1777) as well in React Native, for now it is recommended to stick to MobX 4.x for for React Native Android development_.
+* MobX >=5 runs on any browser with [ES6 proxy support](https://kangax.github.io/compat-table/es6/#test-Proxy). It will throw an error on startup on older environments such as IE11, Node.js <6 or React Native Android on old JavaScriptCore [how-to-upgrade](https://github.com/react-community/jsc-android-buildscripts#how-to-use-it-with-my-react-native-app). _Warning: since upgrading JSC is non-trivial, and decorators can be [troublesome](https://github.com/mobxjs/mobx/issues/1777) as well in React Native, for now it is recommended to stick to MobX 4.x for React Native Android development_.
 * MobX 4 runs on any ES5 browser and will be actively maintained. The MobX 4 and 5 api's are the same and semantically can achieve the same, but MobX 4 has some [limitations](#mobx-4-vs-mobx-5).
 
 
@@ -88,11 +94,11 @@ MobX adds observable capabilities to existing data structures like objects, arra
 This can simply be done by annotating your class properties with the [@observable](http://mobxjs.github.io/mobx/refguide/observable-decorator.html) decorator (ES.Next).
 
 ```javascript
-import { observable } from "mobx"
+import { observable } from 'mobx';
 
 class Todo {
     id = Math.random();
-    @observable title = "";
+    @observable title = '';
     @observable finished = false;
 }
 ```
@@ -106,11 +112,11 @@ Or you can skip them altoghether, as MobX can be used fine without decorator _sy
 Many MobX users prefer the slightly more concise decorator syntax, but the following snippet achieves the same:
 
 ```javascript
-import { decorate, observable } from "mobx"
+import { decorate, observable } from 'mobx';
 
 class Todo {
     id = Math.random();
-    title = "";
+    title = '';
     finished = false;
 }
 decorate(Todo, {
@@ -173,7 +179,7 @@ class TodoListView extends Component {
 const TodoView = observer(({todo}) =>
     <li>
         <input
-            type="checkbox"
+            type='checkbox'
             checked={todo.finished}
             onClick={() => todo.finished = !todo.finished}
         />{todo.title}
@@ -197,7 +203,7 @@ For example the following `autorun` prints a log message each time the amount of
 
 ```javascript
 autorun(() => {
-    console.log("Tasks left: " + todos.unfinishedTodoCount)
+    console.log(`Tasks left: ${ todos.unfinishedTodoCount }`)
 })
 ```
 
@@ -227,8 +233,8 @@ There is no technical need for firing events, calling a dispatcher, etc. A React
 
 ```javascript
 store.todos.push(
-    new Todo("Get Coffee"),
-    new Todo("Write simpler code")
+    new Todo('Get Coffee'),
+    new Todo('Write simpler code')
 );
 store.todos[0].finished = true;
 ```
@@ -311,10 +317,14 @@ And finally, kudos to all the people that believed in, tried, validated and even
 
 > The #mobx is the way I always want things to be! It's really surprising simple and fast! Totally awesome! Don't miss it!
 
+> I've been using MobX for over 2 years now, and it *still* feels like cheating! 😎
+
 ## Contributing
 
 * Feel free to send small pull requests. Please discuss new features or big changes in a GitHub issue first.
-* Use `npm test` to run the basic test suite, `npm run coverage` for the test suite with coverage and `npm run test:performance` for the performance tests.
+* Use `yarn test` to run the basic test suite.
+* Use `yarn test:travis` for the test suite with coverage.
+* and `yarn test:performance` for the performance tests.
 * Please note that if you want to backport a feature / fix to MobX 4 a second PR needs to be opened to the mobx4-master branch.
 
 # MobX 4 vs MobX 5

package/lib/api/action.d.ts

@@ -18,7 +18,7 @@ export interface IActionFactory {
     (target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
     bound(target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
 }
-export declare var action: IActionFactory;
+export declare const action: IActionFactory;
 export declare function runInAction<T>(block: () => T): T;
 export declare function runInAction<T>(name: string, block: () => T): T;
 export declare function isAction(thing: any): boolean;

package/lib/api/actiondecorator.d.ts

@@ -1,6 +1,17 @@
 import { BabelDescriptor } from "../internal";
 declare function dontReassignFields(): void;
-export declare function namedActionDecorator(name: string): (target: any, prop: any, descriptor: BabelDescriptor) => any;
+export declare function namedActionDecorator(name: string): (target: any, prop: any, descriptor: BabelDescriptor) => void | {
+    value: Function & import("../internal").IAction;
+    enumerable: boolean;
+    configurable: boolean;
+    writable: boolean;
+} | {
+    enumerable: boolean;
+    configurable: boolean;
+    writable: boolean;
+    initializer(): Function & import("../internal").IAction;
+    value?: undefined;
+};
 export declare function actionFieldDecorator(name: string): (target: any, prop: any, descriptor: any) => void;
 export declare function boundActionDecorator(target: any, propertyName: any, descriptor: any, applyToInstance?: boolean): {
     configurable: boolean;

package/lib/api/become-observed.d.ts

@@ -1,5 +1,5 @@
-import { IComputedValue, IObservable, IObservableArray, Lambda, ObservableMap } from "../internal";
-export declare function onBecomeObserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any>, listener: Lambda): Lambda;
+import { IComputedValue, IObservable, IObservableArray, Lambda, ObservableMap, ObservableSet } from "../internal";
+export declare function onBecomeObserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any> | ObservableSet<any>, listener: Lambda): Lambda;
 export declare function onBecomeObserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, listener: Lambda): Lambda;
-export declare function onBecomeUnobserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any>, listener: Lambda): Lambda;
+export declare function onBecomeUnobserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any> | ObservableSet<any>, listener: Lambda): Lambda;
 export declare function onBecomeUnobserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, listener: Lambda): Lambda;

package/lib/api/computed.d.ts

@@ -11,4 +11,4 @@ export declare const computedDecorator: Function;
  * Decorator for class properties: @computed get value() { return expr; }.
  * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
  */
-export declare var computed: IComputed;
+export declare const computed: IComputed;

package/lib/api/flow.d.ts

@@ -1,17 +1,12 @@
 export declare type CancellablePromise<T> = Promise<T> & {
     cancel(): void;
 };
-export interface FlowIterator<T> {
-    next(value?: any): IteratorResult<T> | Promise<IteratorResult<T>>;
-    return?(value?: any): IteratorResult<T> | Promise<IteratorResult<T>>;
-    throw?(e?: any): IteratorResult<T> | Promise<IteratorResult<T>>;
+export interface FlowYield {
+    "!!flowYield": undefined;
 }
-export declare function flow<R>(generator: () => FlowIterator<any>): () => CancellablePromise<R>;
-export declare function flow<A1>(generator: (a1: A1) => FlowIterator<any>): (a1: A1) => CancellablePromise<any>;
-export declare function flow<A1, A2>(generator: (a1: A1, a2: A2) => FlowIterator<any>): (a1: A1, a2: A2) => CancellablePromise<any>;
-export declare function flow<A1, A2, A3>(generator: (a1: A1, a2: A2, a3: A3) => FlowIterator<any>): (a1: A1, a2: A2, a3: A3) => CancellablePromise<any>;
-export declare function flow<A1, A2, A3, A4>(generator: (a1: A1, a2: A2, a3: A3, a4: A4) => FlowIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4) => CancellablePromise<any>;
-export declare function flow<A1, A2, A3, A4, A5>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => FlowIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => CancellablePromise<any>;
-export declare function flow<A1, A2, A3, A4, A5, A6>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => FlowIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) => CancellablePromise<any>;
-export declare function flow<A1, A2, A3, A4, A5, A6, A7>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => FlowIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) => CancellablePromise<any>;
-export declare function flow<A1, A2, A3, A4, A5, A6, A7, A8>(generator: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => FlowIterator<any>): (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8) => CancellablePromise<any>;
+export interface FlowReturn<T> {
+    "!!flowReturn": T;
+}
+export declare type FlowReturnType<R> = IfAllAreFlowYieldThenVoid<R extends FlowReturn<infer FR> ? FR extends Promise<infer FRP> ? FRP : FR : R extends Promise<any> ? FlowYield : R>;
+export declare type IfAllAreFlowYieldThenVoid<R> = Exclude<R, FlowYield> extends never ? void : Exclude<R, FlowYield>;
+export declare function flow<R, Args extends any[]>(generator: (...args: Args) => IterableIterator<R>): (...args: Args) => CancellablePromise<FlowReturnType<R>>;

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

@@ -1,7 +1,8 @@
-import { IObservableArray, IObservableValue, Lambda, ObservableMap } from "../internal";
+import { IObservableArray, IObservableValue, Lambda, ObservableMap, ObservableSet } from "../internal";
 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;
 export declare function interceptReads<T>(observableArray: IObservableArray<T>, handler: ReadInterceptor<T>): Lambda;
 export declare function interceptReads<K, V>(observableMap: ObservableMap<K, V>, handler: ReadInterceptor<V>): Lambda;
+export declare function interceptReads<V>(observableSet: ObservableSet<V>, handler: ReadInterceptor<V>): Lambda;
 export declare function interceptReads(object: Object, property: string, handler: ReadInterceptor<any>): Lambda;

package/lib/api/intercept.d.ts

@@ -1,7 +1,8 @@
-import { IArrayWillChange, IArrayWillSplice, IInterceptor, IMapWillChange, IObjectWillChange, IObservableArray, IObservableValue, IValueWillChange, Lambda, ObservableMap } from "../internal";
+import { IArrayWillChange, IArrayWillSplice, IInterceptor, IMapWillChange, IObjectWillChange, IObservableArray, IObservableValue, IValueWillChange, Lambda, ObservableMap, ObservableSet, ISetWillChange } from "../internal";
 export declare function intercept<T>(value: IObservableValue<T>, handler: IInterceptor<IValueWillChange<T>>): Lambda;
 export declare function intercept<T>(observableArray: IObservableArray<T>, handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
 export declare function intercept<K, V>(observableMap: ObservableMap<K, V>, handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
+export declare function intercept<V>(observableMap: ObservableSet<V>, handler: IInterceptor<ISetWillChange<V>>): Lambda;
 export declare function intercept<K, V>(observableMap: ObservableMap<K, V>, property: K, handler: IInterceptor<IValueWillChange<V>>): Lambda;
 export declare function intercept(object: Object, handler: IInterceptor<IObjectWillChange>): Lambda;
 export declare function intercept<T extends Object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<any>>): Lambda;

package/lib/api/object-api.d.ts

@@ -1,11 +1,14 @@
-import { IObservableArray, ObservableMap } from "../internal";
+import { IObservableArray, ObservableMap, ObservableSet } from "../internal";
 export declare function keys<K>(map: ObservableMap<K, any>): ReadonlyArray<K>;
 export declare function keys<T>(ar: IObservableArray<T>): ReadonlyArray<number>;
+export declare function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>;
 export declare function keys<T extends Object>(obj: T): ReadonlyArray<string>;
 export declare function values<K, T>(map: ObservableMap<K, T>): ReadonlyArray<T>;
+export declare function values<T>(set: ObservableSet<T>): ReadonlyArray<T>;
 export declare function values<T>(ar: IObservableArray<T>): ReadonlyArray<T>;
 export declare function values<T = any>(obj: T): ReadonlyArray<any>;
 export declare function entries<K, T>(map: ObservableMap<K, T>): ReadonlyArray<[K, T]>;
+export declare function entries<T>(set: ObservableSet<T>): ReadonlyArray<[T, T]>;
 export declare function entries<T>(ar: IObservableArray<T>): ReadonlyArray<[number, T]>;
 export declare function entries<T = any>(obj: T): ReadonlyArray<[string, any]>;
 export declare function set<V>(obj: ObservableMap<string, V>, values: {
@@ -18,9 +21,11 @@ export declare function set<T extends Object>(obj: T, values: {
 }): any;
 export declare function set<T extends Object>(obj: T, key: string, value: any): any;
 export declare function remove<K, V>(obj: ObservableMap<K, V>, key: K): any;
+export declare function remove<T>(obj: ObservableSet<T>, key: T): any;
 export declare function remove<T>(obj: IObservableArray<T>, index: number): any;
 export declare function remove<T extends Object>(obj: T, key: string): any;
 export declare function has<K>(obj: ObservableMap<K, any>, key: K): boolean;
+export declare function has<T>(obj: ObservableSet<T>, key: T): boolean;
 export declare function has<T>(obj: IObservableArray<T>, index: number): boolean;
 export declare function has<T extends Object>(obj: T, key: string): boolean;
 export declare function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined;

package/lib/api/observable.d.ts

@@ -1,6 +1,7 @@
-import { IEnhancer, IObservableArray, IObservableDecorator, IObservableMapInitialValues, IObservableObject, IObservableValue, ObservableMap } from "../internal";
+import { IEnhancer, IEqualsComparer, IObservableArray, IObservableDecorator, IObservableMapInitialValues, IObservableSetInitialValues, IObservableObject, IObservableValue, ObservableMap, ObservableSet } from "../internal";
 export declare type CreateObservableOptions = {
     name?: string;
+    equals?: IEqualsComparer<any>;
     deep?: boolean;
     defaultDecorator?: IObservableDecorator;
     proxy?: boolean;
@@ -21,6 +22,7 @@ export interface IObservableFactory {
 export interface IObservableFactories {
     box<T = any>(value?: T, options?: CreateObservableOptions): IObservableValue<T>;
     array<T = any>(initialValues?: T[], options?: CreateObservableOptions): IObservableArray<T>;
+    set<T = any>(initialValues?: IObservableSetInitialValues<T>, options?: CreateObservableOptions): ObservableSet<T>;
     map<K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
     object<T = any>(props: T, decorators?: {
         [K in keyof T]?: Function;

package/lib/api/observe.d.ts

@@ -1,6 +1,7 @@
-import { IArrayChange, IArraySplice, IComputedValue, IMapDidChange, IObjectDidChange, IObservableArray, IObservableValue, IValueDidChange, Lambda, ObservableMap } from "../internal";
+import { IArrayChange, IArraySplice, IComputedValue, IMapDidChange, IObjectDidChange, IObservableArray, IObservableValue, IValueDidChange, Lambda, ObservableMap, ObservableSet, ISetDidChange } from "../internal";
 export declare function observe<T>(value: IObservableValue<T> | IComputedValue<T>, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
 export declare function observe<T>(observableArray: IObservableArray<T>, listener: (change: IArrayChange<T> | IArraySplice<T>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<V>(observableMap: ObservableSet<V>, listener: (change: ISetDidChange<V>) => void, fireImmediately?: boolean): Lambda;
 export declare function observe<K, V>(observableMap: ObservableMap<K, V>, listener: (change: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
 export declare function observe<K, V>(observableMap: ObservableMap<K, V>, property: K, listener: (change: IValueDidChange<V>) => void, fireImmediately?: boolean): Lambda;
 export declare function observe(object: Object, listener: (change: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;

package/lib/core/action.d.ts

@@ -1,7 +1,7 @@
 export interface IAction {
     isMobxAction: boolean;
 }
-export declare function createAction(actionName: string, fn: Function): Function & IAction;
+export declare function createAction(actionName: string, fn: Function, ref?: Object): Function & IAction;
 export declare function executeAction(actionName: string, fn: Function, scope?: any, args?: IArguments): any;
 export declare function allowStateChanges<T>(allowStateChanges: boolean, func: () => T): T;
 export declare function allowStateChangesStart(allowStateChanges: boolean): boolean;

package/lib/core/atom.d.ts

@@ -1,4 +1,5 @@
 import { IDerivationState, IObservable } from "../internal";
+import { Lambda } from "../utils/utils";
 export declare const $mobx: unique symbol;
 export interface IAtom extends IObservable {
     reportObserved(): any;
@@ -17,8 +18,10 @@ export declare class Atom implements IAtom {
      * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
      */
     constructor(name?: string);
-    onBecomeUnobserved(): void;
+    onBecomeObservedListeners: Set<Lambda> | undefined;
+    onBecomeUnobservedListeners: Set<Lambda> | undefined;
     onBecomeObserved(): void;
+    onBecomeUnobserved(): void;
     /**
      * Invoke this method to notify mobx that your atom has been used somehow.
      * Returns true if there is currently a reactive context.

package/lib/core/computedvalue.d.ts

@@ -71,8 +71,10 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
      */
     constructor(options: IComputedValueOptions<T>);
     onBecomeStale(): void;
-    onBecomeUnobserved(): void;
+    onBecomeObservedListeners: Set<Lambda> | undefined;
+    onBecomeUnobservedListeners: Set<Lambda> | undefined;
     onBecomeObserved(): void;
+    onBecomeUnobserved(): void;
     /**
      * Returns the current value of this computed value.
      * Will evaluate its computation first if needed.

package/lib/core/globalstate.d.ts

@@ -74,6 +74,7 @@ export declare class MobXGlobals {
      */
     computedRequiresReaction: boolean;
     disableErrorBoundaries: boolean;
+    suppressReactionErrors: boolean;
 }
 export declare let globalState: MobXGlobals;
 export declare function isolateGlobalState(): void;

package/lib/core/observable.d.ts

@@ -1,4 +1,4 @@
-import { IDerivation, IDerivationState } from "../internal";
+import { Lambda, IDerivation, IDerivationState } from "../internal";
 export interface IDepTreeNode {
     name: string;
     observing?: IObservable[];
@@ -17,6 +17,8 @@ export interface IObservable extends IDepTreeNode {
     observers: Set<IDerivation>;
     onBecomeUnobserved(): void;
     onBecomeObserved(): void;
+    onBecomeUnobservedListeners: Set<Lambda> | undefined;
+    onBecomeObservedListeners: Set<Lambda> | undefined;
 }
 export declare function hasObservers(observable: IObservable): boolean;
 export declare function getObservers(observable: IObservable): Set<IDerivation>;

package/lib/internal.d.ts

@@ -38,6 +38,7 @@ export * from "./types/intercept-utils";
 export * from "./types/listen-utils";
 export * from "./types/observablearray";
 export * from "./types/observablemap";
+export * from "./types/observableset";
 export * from "./types/observableobject";
 export * from "./types/type-utils";
 export * from "./utils/eq";

package/lib/mobx.d.ts

@@ -15,4 +15,4 @@
  * - utils/   Utility stuff.
  *
  */
-export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, IDerivation, untracked, IDerivationState, IAtom, createAtom, IAction, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, IObservableObject, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, Lambda, isArrayLike, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions } from "./internal";
+export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, IDerivation, untracked, IDerivationState, IAtom, createAtom, IAction, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, IObservableObject, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, Lambda, isArrayLike, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions } from "./internal";