mobx 5.5.2 → 5.9.0

package/CHANGELOG.md

@@ -1,3 +1,45 @@
+# 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
+* Fixed [#1742](https://github.com/mobxjs/mobx/issues/1742), change detection fails when multiple mobx instances were active.
+* Fixed [#1624](https://github.com/mobxjs/mobx/issues/1624), use built-in flow types for iterators
+* Fixed [#1777](https://github.com/mobxjs/mobx/issues/1777) through [#1826](https://github.com/mobxjs/mobx/pull/1826), stack overflow exception, in development mode, when using `@computed` on a React component. The MobX 5 behavior here has been reverted to the MobX 4 behavior.
+
+
+# 5.6.0 / 4.6.0
+
+* `keepAlive` has become smarter and won't recomputed computed values that are kept alive, as long as they aren't read. Implements [#1534](https://github.com/mobxjs/mobx/issues/1534)
+* Fixed [#1796](https://github.com/mobxjs/mobx/issues/1796), undeleting a property that had an initial value of `undefined` was undetected
+* Improved Flow typings, see [#1794](https://github.com/mobxjs/mobx/pull/1794) and [#1786](https://github.com/mobxjs/mobx/pull/1786)
+
 # 5.5.2 / 4.5.2
 
 * Fixed bug in `toJS` not handling `null` values correctly. Fixes [#1557](https://github.com/mobxjs/mobx/issues/1557) through [#1783](https://github.com/mobxjs/mobx/pull/1783) by [@wangyiz4262](https://github.com/wangyiz4262)

package/README.md

@@ -12,19 +12,19 @@ _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, Algolia, Guilded, Canva and many [individual sponsors](#backers)
+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" />
-<img src="docs/canva.png" align="center" width="100" title="Canva" alt="Canva" />
 
 # Installation
 
 * Installation: `npm install mobx --save`. React bindings: `npm install mobx-react --save`. To enable ESNext decorators (optional), see below.
 * CDN:
-- https://unpkg.com/mobx/lib/mobx.umd.js
-- https://cdnjs.com/libraries/mobx
+   * https://unpkg.com/mobx/lib/mobx.umd.js
+   * https://cdnjs.com/libraries/mobx
 
 
 _Tip: Consider using the faster and smaller ES6 build if targetting a modern environment: `lib/mobx.es6.js`. For example by setting up a webpack alias: `resolve: { alias: { mobx: __dirname + "/node_modules/mobx/lib/mobx.es6.js" }}`_
@@ -88,11 +88,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 +106,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 +173,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 +197,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 +227,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,6 +311,8 @@ 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.

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/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/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

@@ -57,7 +57,6 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     private equals;
     private requiresReaction;
     private keepAlive;
-    private firstGet;
     /**
      * Create a new computed value based on a function expression.
      *
@@ -72,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

@@ -1,4 +1,5 @@
 import { IDerivation, IObservable, Reaction } from "../internal";
+export declare type IUNCHANGED = {};
 export declare class MobXGlobals {
     /**
      * MobXGlobals version.
@@ -9,6 +10,10 @@ export declare class MobXGlobals {
      * internal state storage of MobX, and can be the same across many different package versions
      */
     version: number;
+    /**
+     * globally unique token to signal unchanged
+     */
+    UNCHANGED: IUNCHANGED;
     /**
      * Currently running derivation
      */
@@ -69,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";