mobx 5.15.0 → 5.15.4

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# 5.15.4 / 4.15.4
+
+-   Fix process.env replacement in build [#2267](https://github.com/mobxjs/mobx/pull/2267) by [@fredyc](https://github.com/fredyc)
+
+# 5.15.3 / 4.15.3
+
+-   Define action name to be as the function name [#2262](https://github.com/mobxjs/mobx/pull/2262) by [@nadavkaner](https://github.com/nadavkaner)
+
+# 5.15.2 / 4.15.2
+
+-   Fixed [#2230](https://github.com/mobxjs/mobx/issue/2230) computedvalue: throw error object instead of string when options is empty [#2243](https://github.com/mobxjs/mobx/pull/2243) by [@ramkumarvenkat](https://github.com/ramkumarvenkat)
+-   supports ES6 Sets and Maps in shallow comparer. [#2238](https://github.com/mobxjs/mobx/pull/2238) by [@hearnden](https://github.com/hearnden)
+-   `extendObservable`: can be used existing properties again. Fixes [#2250](https://github.com/mobxjs/mobx/issue/2250) through [#2252](https://github.com/mobxjs/mobx/pull/2252) by [@davefeucht](https://github.com/davefeucht)
+
+# 5.15.1 / 4.15.1
+
+-   Make initial values of observable set accept readonly array [#2202](https://github.com/mobxjs/mobx/pull/2202)
+-   Expose `_allowStateReadsStart` & `_allowStateReadsEnd`. This is low level stuff you shouldn't need that's mostly useful for library creators. [#2233](https://github.com/mobxjs/mobx/pull/2233)
+-   Fixed an issue with `observableRequiresReaction` and updating observable during reaction [#2195](https://github.com/mobxjs/mobx/pull/2196)
+-   Improved type inference for `action` [#2213](https://github.com/mobxjs/mobx/pull/2213) ([see detailed explanation](https://github.com/mobxjs/mobx/pull/2218#discussion_r349889440))
+
 # 5.15.0
 
 **The minimum required TypeScript version is now 3.6**
@@ -5,7 +26,7 @@
 -   Fixed flow typings with Typescript v3.6. This means that version of Typescript is required when using flows.
 -   Cancelled flows now reject with a `FlowCancellationError` instance whose error message is the same as in previous versions (`"FLOW_CANCELLED"`) so this is not breaking. [#2172](https://github.com/mobxjs/mobx/pull/2172) by [@vonovak](https://github.com/vonovak)
 -   Fix running mobx in web worker [#2184](https://github.com/mobxjs/mobx/pull/2184/files) by [@shahata](https://github.com/shahata)
--   Fixed flow typings for Facebook's Flow. A new `CancellablePromise` Flow type is exported. [#2160](https://github.com/mobxjs/mobx/pull/2160) bu [@xaviergonz](https://github.com/xaviergonz)
+-   Fixed flow typings for Facebook's Flow. A new `CancellablePromise` Flow type is exported. [#2164](https://github.com/mobxjs/mobx/pull/2164) by [@vonovak](https://github.com/vonovak)
 -   Added support for symbol keys on observable properties (MobX 5 only). [#2175](https://github.com/mobxjs/mobx/pull/2175) by [@StephenHaney](https://github.com/StephenHaney)
 
 # 5.14.2
@@ -371,7 +392,7 @@ The changes mentioned here are discussed in detail in the [migration notes](http
 -   `observable.shallowObject(values)` has been removed, instead use `observable.object(values, {}, { deep: false })`
 -   `extendShallowObservable(target, props)`, instead use `extendObservable(target, props, {}, { deep: false })`
 -   The decorators `observable.ref`, `observable.shallow`, `observable.deep`, `observable.struct` can no longer be used as functions. Instead, they should be passed as part of the `decorators` param to resp. `observable.object` and `extendObservable`
--   The new signature of `extendObservable` is `extendObservable(target, props, decorators?, options?)`. This also means it is no longer possible to pass multiple bags of properties to `extendObservable`. `extendObservable` can no longer be used to re-declare properties. Use `set` instead to update existing properties (or introduce new ones).
+-   The new signature of `extendObservable` is `extendObservable(target, props, decorators?, options?)`. This also means it is no longer possible to pass multiple bags of properties to `extendObservable`. ~~`extendObservable` can no longer be used to re-declare properties. Use `set` instead to update existing properties (or introduce new ones).~~ Update 13-01-2020: the latter limitation has been reverted in MobX 4.15.2 / 5.15.2
 -   Iterating maps now follows the spec, that is, `map.values()`, `map.entries()`, `map.keys()`, `map[@@iterator]()` and `array[@@iterator]()` no longer return an array, but an iterator. Use `mobx.values(map)` or `Array.from(map)` to convert the iterators to arrays.
 -   dropped `@computed.equals`, instead, you can now use `@computed({ equals: ... })`
 -   `useStrict(boolean)` was dropped, use `configure({ enforceActions: boolean })` instead

package/README.md

@@ -79,7 +79,8 @@ _Tip: Consider using the faster and smaller ES6 build if targetting a modern env
     -   LearnCode.academy MobX tutorial [Part I: MobX + React is AWESOME (7m)](https://www.youtube.com/watch?v=_q50BXqkAfI) [Part II: Computed Values and Nested/Referenced Observables (12m.)](https://www.youtube.com/watch?v=nYvNqKrl69s)
     -   [Screencast: intro to MobX](https://www.youtube.com/watch?v=K8dr8BMU7-8) - 8m
     -   [Talk: State Management Is Easy, React Amsterdam 2016 conf](https://www.youtube.com/watch?v=ApmSsu3qnf0&feature=youtu.be) ([slides](https://speakerdeck.com/mweststrate/state-management-is-easy-introduction-to-mobx))
--   [Boilerplates and related projects](http://mobxjs.github.io/mobx/faq/boilerplates.html)
+-   Boilerplates [MobX awesome list](https://github.com/mobxjs/awesome-mobx#boilerplates)
+-   Related projects [MobX awesome list](https://github.com/mobxjs/awesome-mobx#related-projects-and-utilities)
 -   More tutorials, blogs, videos, and other helpful resources can be found on the [MobX awesome list](https://github.com/mobxjs/awesome-mobx#awesome-mobx)
 
 ## Introduction
@@ -312,11 +313,13 @@ And finally, kudos to all the people that believed in, tried, validated and even
 ## Further resources and documentation
 
 -   <img src="docs/assets/book.jpg" height="80px"/> [The MobX book](https://books.google.nl/books?id=ALFmDwAAQBAJ&pg=PP1&lpg=PP1&dq=michel+weststrate+mobx+quick+start+guide:+supercharge+the+client+state+in+your+react+apps+with+mobx&source=bl&ots=D460fxti0F&sig=ivDGTxsPNwlOjLHrpKF1nweZFl8&hl=nl&sa=X&ved=2ahUKEwiwl8XO--ncAhWPmbQKHWOYBqIQ6AEwAnoECAkQAQ#v=onepage&q=michel%20weststrate%20mobx%20quick%20start%20guide%3A%20supercharge%20the%20client%20state%20in%20your%20react%20apps%20with%20mobx&f=false) by Pavan Podila and Michel Weststrate (which despite its name is in-depth!)
--   [MobX homepage](http://mobxjs.github.io/mobx/faq/blogs.html)
+-   [MobX homepage](http://mobxjs.github.io)
 -   [API overview](http://mobxjs.github.io/mobx/refguide/api.html)
--   [Tutorials, Blogs & Videos](http://mobxjs.github.io/mobx/faq/blogs.html)
--   [Boilerplates](http://mobxjs.github.io/mobx/faq/boilerplates.html)
--   [Related projects](http://mobxjs.github.io/mobx/faq/related.html)
+-   [Tutorials](https://github.com/mobxjs/awesome-mobx#tutorials)
+-   [Blogs](https://github.com/mobxjs/awesome-mobx#blogs)
+-   [Videos](https://github.com/mobxjs/awesome-mobx#videos)
+-   [Boilerplates](https://github.com/mobxjs/awesome-mobx#boilerplates)
+-   [MobX awesome list](https://github.com/mobxjs/awesome-mobx#awesome-mobx)
 
 ## What others are saying...
 

package/lib/api/action.d.ts

@@ -1,25 +1,13 @@
-import { IAction } from "../internal";
-export interface IActionFactory {
-    <A1, R, T extends (a1: A1) => R>(fn: T): T & IAction;
-    <A1, A2, R, T extends (a1: A1, a2: A2) => R>(fn: T): T & IAction;
-    <A1, A2, A3, R, T extends (a1: A1, a2: A2, a3: A3) => R>(fn: T): T & IAction;
-    <A1, A2, A3, A4, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4) => R>(fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => R>(fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, A6, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a6: A6) => R>(fn: T): T & IAction;
-    <A1, R, T extends (a1: A1) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, R, T extends (a1: A1, a2: A2) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, R, T extends (a1: A1, a2: A2, a3: A3) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, A4, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => R>(name: string, fn: T): T & IAction;
-    <A1, A2, A3, A4, A5, A6, R, T extends (a1: A1, a2: A2, a3: A3, a4: A4, a6: A6) => R>(name: string, fn: T): T & IAction;
-    <T extends Function>(fn: T): T & IAction;
-    <T extends Function>(name: string, fn: T): T & IAction;
-    (customName: string): (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor) => void;
-    (target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
-    bound(target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
-}
-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;
-export declare function defineBoundAction(target: any, propertyName: string, fn: Function): void;
+import { IAction } from "../internal";
+export interface IActionFactory {
+    <T extends Function | null | undefined>(fn: T): T & IAction;
+    <T extends Function | null | undefined>(name: string, fn: T): T & IAction;
+    (customName: string): (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor) => void;
+    (target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
+    bound(target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
+}
+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;
+export declare function defineBoundAction(target: any, propertyName: string, fn: Function): void;

package/lib/api/actiondecorator.d.ts

@@ -1,27 +1,27 @@
-import { BabelDescriptor } from "../internal";
-declare function dontReassignFields(): void;
-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;
-    enumerable: boolean;
-    get(): any;
-    set: typeof dontReassignFields;
-} | {
-    enumerable: boolean;
-    configurable: boolean;
-    set(v: any): void;
-    get(): undefined;
-} | null;
-export {};
+import { BabelDescriptor } from "../internal";
+declare function dontReassignFields(): void;
+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;
+    enumerable: boolean;
+    get(): any;
+    set: typeof dontReassignFields;
+} | {
+    enumerable: boolean;
+    configurable: boolean;
+    set(v: any): void;
+    get(): undefined;
+} | null;
+export {};

package/lib/api/autorun.d.ts

@@ -1,24 +1,24 @@
-import { IEqualsComparer, IReactionDisposer, IReactionPublic } from "../internal";
-export interface IAutorunOptions {
-    delay?: number;
-    name?: string;
-    /**
-     * Experimental.
-     * Warns if the view doesn't track observables
-     */
-    requiresObservable?: boolean;
-    scheduler?: (callback: () => void) => any;
-    onError?: (error: any) => void;
-}
-/**
- * Creates a named reactive view and keeps it alive, so that the view is always
- * updated if one of the dependencies changes, even when the view is not further used by something else.
- * @param view The reactive view
- * @returns disposer function, which can be used to stop the view from being updated in the future.
- */
-export declare function autorun(view: (r: IReactionPublic) => any, opts?: IAutorunOptions): IReactionDisposer;
-export declare type IReactionOptions = IAutorunOptions & {
-    fireImmediately?: boolean;
-    equals?: IEqualsComparer<any>;
-};
-export declare function reaction<T>(expression: (r: IReactionPublic) => T, effect: (arg: T, r: IReactionPublic) => void, opts?: IReactionOptions): IReactionDisposer;
+import { IEqualsComparer, IReactionDisposer, IReactionPublic } from "../internal";
+export interface IAutorunOptions {
+    delay?: number;
+    name?: string;
+    /**
+     * Experimental.
+     * Warns if the view doesn't track observables
+     */
+    requiresObservable?: boolean;
+    scheduler?: (callback: () => void) => any;
+    onError?: (error: any) => void;
+}
+/**
+ * Creates a named reactive view and keeps it alive, so that the view is always
+ * updated if one of the dependencies changes, even when the view is not further used by something else.
+ * @param view The reactive view
+ * @returns disposer function, which can be used to stop the view from being updated in the future.
+ */
+export declare function autorun(view: (r: IReactionPublic) => any, opts?: IAutorunOptions): IReactionDisposer;
+export declare type IReactionOptions = IAutorunOptions & {
+    fireImmediately?: boolean;
+    equals?: IEqualsComparer<any>;
+};
+export declare function reaction<T>(expression: (r: IReactionPublic) => T, effect: (arg: T, r: IReactionPublic) => void, opts?: IReactionOptions): IReactionDisposer;

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

@@ -1,5 +1,5 @@
-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> | ObservableSet<any>, listener: Lambda): Lambda;
-export declare function onBecomeUnobserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, 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> | 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

@@ -1,14 +1,14 @@
-import { IComputedValue, IComputedValueOptions } from "../internal";
-export interface IComputed {
-    <T>(options: IComputedValueOptions<T>): any;
-    <T>(func: () => T, setter: (v: T) => void): IComputedValue<T>;
-    <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>;
-    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
-    struct(target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
-}
-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 const computed: IComputed;
+import { IComputedValue, IComputedValueOptions } from "../internal";
+export interface IComputed {
+    <T>(options: IComputedValueOptions<T>): any;
+    <T>(func: () => T, setter: (v: T) => void): IComputedValue<T>;
+    <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>;
+    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
+    struct(target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
+}
+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 const computed: IComputed;

package/lib/api/configure.d.ts

@@ -1,18 +1,18 @@
-export declare function configure(options: {
-    enforceActions?: boolean | "strict" | "never" | "always" | "observed";
-    computedRequiresReaction?: boolean;
-    /**
-     * (Experimental)
-     * Warn if you try to create to derivation / reactive context without accessing any observable.
-     */
-    reactionRequiresObservable?: boolean;
-    /**
-     * (Experimental)
-     * Warn if observables are accessed outside a reactive context
-     */
-    observableRequiresReaction?: boolean;
-    computedConfigurable?: boolean;
-    isolateGlobalState?: boolean;
-    disableErrorBoundaries?: boolean;
-    reactionScheduler?: (f: () => void) => void;
-}): void;
+export declare function configure(options: {
+    enforceActions?: boolean | "strict" | "never" | "always" | "observed";
+    computedRequiresReaction?: boolean;
+    /**
+     * (Experimental)
+     * Warn if you try to create to derivation / reactive context without accessing any observable.
+     */
+    reactionRequiresObservable?: boolean;
+    /**
+     * (Experimental)
+     * Warn if observables are accessed outside a reactive context
+     */
+    observableRequiresReaction?: boolean;
+    computedConfigurable?: boolean;
+    isolateGlobalState?: boolean;
+    disableErrorBoundaries?: boolean;
+    reactionScheduler?: (f: () => void) => void;
+}): void;

package/lib/api/decorate.d.ts

@@ -1,6 +1,6 @@
-export declare function decorate<T>(clazz: new (...args: any[]) => T, decorators: {
-    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
-}): void;
-export declare function decorate<T>(object: T, decorators: {
-    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
-}): T;
+export declare function decorate<T>(clazz: new (...args: any[]) => T, decorators: {
+    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
+}): void;
+export declare function decorate<T>(object: T, decorators: {
+    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
+}): T;

package/lib/api/extendobservable.d.ts

@@ -1,7 +1,7 @@
-import { CreateObservableOptions } from "../internal";
-import { IObservableDecorator } from "./observabledecorator";
-export declare function extendObservable<A extends Object, B extends Object>(target: A, properties?: B, decorators?: {
-    [K in keyof B]?: Function;
-}, options?: CreateObservableOptions): A & B;
-export declare function getDefaultDecoratorFromObjectOptions(options: CreateObservableOptions): IObservableDecorator;
-export declare function extendObservableObjectWithProperties(target: any, properties: any, decorators: any, defaultDecorator: any): void;
+import { CreateObservableOptions } from "../internal";
+import { IObservableDecorator } from "./observabledecorator";
+export declare function extendObservable<A extends Object, B extends Object>(target: A, properties?: B, decorators?: {
+    [K in keyof B]?: Function;
+}, options?: CreateObservableOptions): A & B;
+export declare function getDefaultDecoratorFromObjectOptions(options: CreateObservableOptions): IObservableDecorator;
+export declare function extendObservableObjectWithProperties(target: any, properties: any, decorators: any, defaultDecorator: any): void;

package/lib/api/extras.d.ts

@@ -1,10 +1,10 @@
-export interface IDependencyTree {
-    name: string;
-    dependencies?: IDependencyTree[];
-}
-export interface IObserverTree {
-    name: string;
-    observers?: IObserverTree[];
-}
-export declare function getDependencyTree(thing: any, property?: string): IDependencyTree;
-export declare function getObserverTree(thing: any, property?: string): IObserverTree;
+export interface IDependencyTree {
+    name: string;
+    dependencies?: IDependencyTree[];
+}
+export interface IObserverTree {
+    name: string;
+    observers?: IObserverTree[];
+}
+export declare function getDependencyTree(thing: any, property?: string): IDependencyTree;
+export declare function getObserverTree(thing: any, property?: string): IObserverTree;

package/lib/api/flow.d.ts

@@ -1,8 +1,9 @@
-export declare class FlowCancellationError extends Error {
-    constructor();
-}
-export declare function isFlowCancellationError(error: Error): boolean;
-export declare type CancellablePromise<T> = Promise<T> & {
-    cancel(): void;
-};
-export declare function flow<R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;
+export declare function FlowCancellationError(): void;
+export declare namespace FlowCancellationError {
+    var prototype: any;
+}
+export declare function isFlowCancellationError(error: Error): boolean;
+export declare type CancellablePromise<T> = Promise<T> & {
+    cancel(): void;
+};
+export declare function flow<R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;

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

@@ -1,8 +1,8 @@
-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;
+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,8 +1,8 @@
-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;
+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/iscomputed.d.ts

@@ -1,3 +1,3 @@
-export declare function _isComputed(value: any, property?: string): boolean;
-export declare function isComputed(value: any): boolean;
-export declare function isComputedProp(value: any, propName: string): boolean;
+export declare function _isComputed(value: any, property?: string): boolean;
+export declare function isComputed(value: any): boolean;
+export declare function isComputedProp(value: any, propName: string): boolean;

package/lib/api/isobservable.d.ts

@@ -1,2 +1,2 @@
-export declare function isObservable(value: any): boolean;
-export declare function isObservableProp(value: any, propName: string): boolean;
+export declare function isObservable(value: any): boolean;
+export declare function isObservableProp(value: any, propName: string): boolean;

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

@@ -1,34 +1,34 @@
-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<PropertyKey>;
-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<T extends object ? T[keyof T] : 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, T extends object ? T[keyof T] : any]>;
-export declare function set<V>(obj: ObservableMap<PropertyKey, V>, values: {
-    [key: string]: V;
-}): any;
-export declare function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
-export declare function set<T>(obj: ObservableSet<T>, value: T): any;
-export declare function set<T>(obj: IObservableArray<T>, index: number, value: T): any;
-export declare function set<T extends Object>(obj: T, values: {
-    [key: string]: any;
-}): any;
-export declare function set<T extends Object>(obj: T, key: PropertyKey, 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;
-export declare function get<T>(obj: IObservableArray<T>, index: number): T | undefined;
-export declare function get<T extends Object>(obj: T, key: string): any;
+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<PropertyKey>;
+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<T extends object ? T[keyof T] : 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, T extends object ? T[keyof T] : any]>;
+export declare function set<V>(obj: ObservableMap<PropertyKey, V>, values: {
+    [key: string]: V;
+}): any;
+export declare function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
+export declare function set<T>(obj: ObservableSet<T>, value: T): any;
+export declare function set<T>(obj: IObservableArray<T>, index: number, value: T): any;
+export declare function set<T extends Object>(obj: T, values: {
+    [key: string]: any;
+}): any;
+export declare function set<T extends Object>(obj: T, key: PropertyKey, 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;
+export declare function get<T>(obj: IObservableArray<T>, index: number): T | undefined;
+export declare function get<T extends Object>(obj: T, key: string): any;

package/lib/api/observable.d.ts

@@ -1,44 +1,44 @@
-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;
-};
-export declare const defaultCreateObservableOptions: CreateObservableOptions;
-export declare function asCreateObservableOptions(thing: any): CreateObservableOptions;
-export declare const deepDecorator: IObservableDecorator;
-export declare const refDecorator: IObservableDecorator;
-export interface IObservableFactory {
-    (value: number | string | null | undefined | boolean): never;
-    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): any;
-    <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>;
-    <T = any>(value: Set<T>, options?: CreateObservableOptions): ObservableSet<T>;
-    <K = any, V = any>(value: Map<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
-    <T extends Object>(value: T, decorators?: {
-        [K in keyof T]?: Function;
-    }, options?: CreateObservableOptions): T & IObservableObject;
-}
-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;
-    }, options?: CreateObservableOptions): T & IObservableObject;
-    /**
-     * Decorator that creates an observable that only observes the references, but doesn't try to turn the assigned value into an observable.ts.
-     */
-    ref: IObservableDecorator;
-    /**
-     * Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure
-     */
-    shallow: IObservableDecorator;
-    deep: IObservableDecorator;
-    struct: IObservableDecorator;
-}
-export declare const observable: IObservableFactory & IObservableFactories & {
-    enhancer: IEnhancer<any>;
-};
+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;
+};
+export declare const defaultCreateObservableOptions: CreateObservableOptions;
+export declare function asCreateObservableOptions(thing: any): CreateObservableOptions;
+export declare const deepDecorator: IObservableDecorator;
+export declare const refDecorator: IObservableDecorator;
+export interface IObservableFactory {
+    (value: number | string | null | undefined | boolean): never;
+    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): any;
+    <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>;
+    <T = any>(value: Set<T>, options?: CreateObservableOptions): ObservableSet<T>;
+    <K = any, V = any>(value: Map<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
+    <T extends Object>(value: T, decorators?: {
+        [K in keyof T]?: Function;
+    }, options?: CreateObservableOptions): T & IObservableObject;
+}
+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;
+    }, options?: CreateObservableOptions): T & IObservableObject;
+    /**
+     * Decorator that creates an observable that only observes the references, but doesn't try to turn the assigned value into an observable.ts.
+     */
+    ref: IObservableDecorator;
+    /**
+     * Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure
+     */
+    shallow: IObservableDecorator;
+    deep: IObservableDecorator;
+    struct: IObservableDecorator;
+}
+export declare const observable: IObservableFactory & IObservableFactories & {
+    enhancer: IEnhancer<any>;
+};

package/lib/api/observabledecorator.d.ts

@@ -1,6 +1,6 @@
-import { IEnhancer } from "../internal";
-export declare type IObservableDecorator = {
-    (target: Object, property: string | symbol, descriptor?: PropertyDescriptor): void;
-    enhancer: IEnhancer<any>;
-};
-export declare function createDecoratorForEnhancer(enhancer: IEnhancer<any>): IObservableDecorator;
+import { IEnhancer } from "../internal";
+export declare type IObservableDecorator = {
+    (target: Object, property: string | symbol, descriptor?: PropertyDescriptor): void;
+    enhancer: IEnhancer<any>;
+};
+export declare function createDecoratorForEnhancer(enhancer: IEnhancer<any>): IObservableDecorator;