mobx 5.8.0 → 5.9.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
+# 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)

package/README.md

@@ -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;
 ```

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,9 +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<T, U extends any[]>(generator: (...args: U) => FlowIterator<any>): (...args: U) => CancellablePromise<T>;
+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/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/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";