mobx 3.6.1 → 3.6.2

package/CHANGELOG.md

@@ -1,4 +1,8 @@
 
+# 3.6.2
+
+* Fixed accidental dependency on the `node` typings. Fixes [#1387](https://github.com/mobxjs/mobx/issues/1387) / [#1362](https://github.com/mobxjs/mobx/issues/1387)
+
 # 3.6.1
 
 * Fixed [#1358](https://github.com/mobxjs/mobx/pull/1359): Deep comparison failing on IE11. By [le0nik](https://github.com/le0nik) through [#1359](https://github.com/mobxjs/mobx/pull/1359)

package/lib/core/computedvalue.d.ts

@@ -79,4 +79,4 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     valueOf(): T;
     whyRun(): string;
 }
-export declare const isComputedValue: (x: any) => x is ComputedValue<any>;
+export declare const isComputedValue: (x: any) => x is ComputedValue<{}>;

package/lib/mobx.d.ts

@@ -48,84 +48,90 @@ export { whyRun, trace } from "./api/whyrun";
 export { Lambda, isArrayLike } from "./utils/utils";
 export { Iterator } from "./utils/iterable";
 export { IObserverTree, IDependencyTree } from "./api/extras";
-import { IDerivation } from "./core/derivation";
-import { IDepTreeNode } from "./core/observable";
-import { IObserverTree, IDependencyTree } from "./api/extras";
-import { Lambda } from "./utils/utils";
-import { IObservableArray } from "./types/observablearray";
+import { resetGlobalState, shareGlobalState, getGlobalState, isolateGlobalState } from "./core/globalstate";
+import { getDependencyTree, getObserverTree } from "./api/extras";
+import { getDebugName, getAtom, getAdministration } from "./types/type-utils";
+import { allowStateChanges } from "./core/action";
+import { spyReport, spyReportEnd, spyReportStart, isSpyEnabled } from "./core/spy";
+import { deepEqual } from "./utils/eq";
+import { isComputingDerivation } from "./core/derivation";
+import { setReactionScheduler, onReactionError } from "./core/reaction";
+import { reserveArrayBuffer } from "./types/observablearray";
+import { interceptReads } from "./api/intercept-read";
 import { ObservableMap } from "./types/observablemap";
 import { IObservableValue } from "./types/observablevalue";
 export declare const extras: {
-    allowStateChanges: <T>(allowStateChanges: boolean, func: () => T) => T;
-    deepEqual: (a: any, b: any) => boolean;
-    getAtom: (thing: any, property?: string | undefined) => IDepTreeNode;
-    getDebugName: (thing: any, property?: string | undefined) => string;
-    getDependencyTree: (thing: any, property?: string | undefined) => IDependencyTree;
-    getAdministration: (thing: any, property?: string | undefined) => any;
-    getGlobalState: () => any;
-    getObserverTree: (thing: any, property?: string | undefined) => IObserverTree;
-    interceptReads: {
-        <T>(value: IObservableValue<T>, handler: (value: any) => T): Lambda;
-        <T>(observableArray: IObservableArray<T>, handler: (value: any) => T): Lambda;
-        <T>(observableMap: ObservableMap<T>, handler: (value: any) => T): Lambda;
-        (object: Object, property: string, handler: (value: any) => any): Lambda;
-    };
-    isComputingDerivation: () => boolean;
-    isSpyEnabled: () => boolean;
-    onReactionError: (handler: (error: any, derivation: IDerivation) => void) => () => void;
-    reserveArrayBuffer: (max: number) => void;
-    resetGlobalState: () => void;
-    isolateGlobalState: () => void;
-    shareGlobalState: () => void;
-    spyReport: (event: any) => void;
-    spyReportEnd: (change?: any) => void;
-    spyReportStart: (event: any) => void;
-    setReactionScheduler: (fn: (f: () => void) => void) => void;
+    allowStateChanges: typeof allowStateChanges;
+    deepEqual: typeof deepEqual;
+    getAtom: typeof getAtom;
+    getDebugName: typeof getDebugName;
+    getDependencyTree: typeof getDependencyTree;
+    getAdministration: typeof getAdministration;
+    getGlobalState: typeof getGlobalState;
+    getObserverTree: typeof getObserverTree;
+    interceptReads: typeof interceptReads;
+    isComputingDerivation: typeof isComputingDerivation;
+    isSpyEnabled: typeof isSpyEnabled;
+    onReactionError: typeof onReactionError;
+    reserveArrayBuffer: typeof reserveArrayBuffer;
+    resetGlobalState: typeof resetGlobalState;
+    isolateGlobalState: typeof isolateGlobalState;
+    shareGlobalState: typeof shareGlobalState;
+    spyReport: typeof spyReport;
+    spyReportEnd: typeof spyReportEnd;
+    spyReportStart: typeof spyReportStart;
+    setReactionScheduler: typeof setReactionScheduler;
 };
-import { Reaction, IReactionPublic, IReactionDisposer } from "./core/reaction";
+import { Reaction } from "./core/reaction";
+import { untracked } from "./core/derivation";
 import { Atom, BaseAtom } from "./core/atom";
-import { IComputedValue } from "./core/computedvalue";
-import { IModifierDescriptor } from "./types/modifiers";
-import { IInterceptor } from "./types/intercept-utils";
-import { IObjectWillChange, IObjectChange, IObservableObject } from "./types/observableobject";
-import { IValueDidChange, IValueWillChange } from "./types/observablevalue";
-import { IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice } from "./types/observablearray";
-import { IKeyValueMap, IMapWillChange, IMapChange, IMap } from "./types/observablemap";
+import { useStrict, isStrictModeEnabled } from "./core/action";
+import { spy } from "./core/spy";
+import { asReference, asFlat, asStructure, asMap } from "./types/modifiers-old";
+import { isModifierDescriptor } from "./types/modifiers";
+import { isObservableObject } from "./types/observableobject";
+import { isObservableArray } from "./types/observablearray";
+import { map } from "./types/observablemap";
+import { transaction } from "./api/transaction";
 import { IObservableFactory, IObservableFactories } from "./api/observable";
 import { IComputed } from "./api/computed";
-import { IReactionOptions } from "./api/autorun";
-import { IActionFactory } from "./api/action";
-import { ITransformer } from "./api/createtransformer";
+import { isObservable } from "./api/isobservable";
+import { isComputed } from "./api/iscomputed";
+import { extendObservable, extendShallowObservable } from "./api/extendobservable";
+import { observe } from "./api/observe";
+import { intercept } from "./api/intercept";
+import { autorun, autorunAsync, when, reaction } from "./api/autorun";
+import { isAction, runInAction, IActionFactory } from "./api/action";
+import { expr } from "./api/expr";
+import { toJS } from "./api/tojs";
+import { createTransformer } from "./api/createtransformer";
+import { whyRun } from "./api/whyrun";
+import { isArrayLike } from "./utils/utils";
 declare const everything: {
     Reaction: typeof Reaction;
-    untracked: <T>(action: () => T) => T;
+    untracked: typeof untracked;
     Atom: typeof Atom;
     BaseAtom: typeof BaseAtom;
-    useStrict: (strict: boolean) => void;
-    isStrictModeEnabled: () => boolean;
-    spy: (listener: (change: any) => void) => Lambda;
+    useStrict: typeof useStrict;
+    isStrictModeEnabled: typeof isStrictModeEnabled;
+    spy: typeof spy;
     comparer: {
         identity: (a: any, b: any) => boolean;
         structural: (a: any, b: any) => boolean;
         default: (a: any, b: any) => boolean;
     };
-    asReference: <T>(value: T) => T;
-    asFlat: <T>(value: T) => T;
-    asStructure: <T>(value: T) => T;
-    asMap: {
-        (): ObservableMap<any>;
-        <T>(): ObservableMap<T>;
-        <T>(entries: [string, T][]): ObservableMap<T>;
-        <T>(data: IKeyValueMap<T>): ObservableMap<T>;
-    };
-    isModifierDescriptor: (thing: any) => thing is IModifierDescriptor<any>;
-    isObservableObject: (thing: any) => thing is IObservableObject;
+    asReference: typeof asReference;
+    asFlat: typeof asFlat;
+    asStructure: typeof asStructure;
+    asMap: typeof asMap;
+    isModifierDescriptor: typeof isModifierDescriptor;
+    isObservableObject: typeof isObservableObject;
     isBoxedObservable: (x: any) => x is IObservableValue<any>;
-    isObservableArray: (thing: any) => thing is IObservableArray<any>;
+    isObservableArray: typeof isObservableArray;
     ObservableMap: typeof ObservableMap;
     isObservableMap: (thing: any) => thing is ObservableMap<any>;
-    map: <V>(initialValues?: [string, V][] | IKeyValueMap<V> | IMap<string, V> | undefined) => ObservableMap<V>;
-    transaction: <T>(action: () => T, thisArg?: undefined) => T;
+    map: typeof map;
+    transaction: typeof transaction;
     observable: IObservableFactory & IObservableFactories & {
         deep: {
             struct<T>(initialValue?: T | undefined): T;
@@ -135,83 +141,45 @@ declare const everything: {
         };
     };
     computed: IComputed;
-    isObservable: (value: any, property?: string | undefined) => boolean;
-    isComputed: (value: any, property?: string | undefined) => boolean;
-    extendObservable: <A extends Object, B extends Object>(target: A, ...properties: B[]) => A & B;
-    extendShallowObservable: <A extends Object, B extends Object>(target: A, ...properties: B[]) => A & B;
-    observe: {
-        <T>(value: IObservableValue<T> | IComputedValue<T>, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean | undefined): Lambda;
-        <T>(observableArray: IObservableArray<T>, listener: (change: IArrayChange<T> | IArraySplice<T>) => void, fireImmediately?: boolean | undefined): Lambda;
-        <T>(observableMap: ObservableMap<T>, listener: (change: IMapChange<T>) => void, fireImmediately?: boolean | undefined): Lambda;
-        <T>(observableMap: ObservableMap<T>, property: string, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean | undefined): Lambda;
-        (object: Object, listener: (change: IObjectChange) => void, fireImmediately?: boolean | undefined): Lambda;
-        (object: Object, property: string, listener: (change: IValueDidChange<any>) => void, fireImmediately?: boolean | undefined): Lambda;
-    };
-    intercept: {
-        <T>(value: IObservableValue<T>, handler: IInterceptor<IValueWillChange<T>>): Lambda;
-        <T>(observableArray: IObservableArray<T>, handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
-        <T>(observableMap: ObservableMap<T>, handler: IInterceptor<IMapWillChange<T>>): Lambda;
-        <T>(observableMap: ObservableMap<T>, property: string, handler: IInterceptor<IValueWillChange<T>>): Lambda;
-        (object: Object, handler: IInterceptor<IObjectWillChange>): Lambda;
-        <T extends Object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<any>>): Lambda;
-    };
-    autorun: {
-        (view: (r: IReactionPublic) => any, scope?: any): IReactionDisposer;
-        (name: string, view: (r: IReactionPublic) => any, scope?: any): IReactionDisposer;
-    };
-    autorunAsync: {
-        (name: string, func: (r: IReactionPublic) => any, delay?: number | undefined, scope?: any): IReactionDisposer;
-        (func: (r: IReactionPublic) => any, delay?: number | undefined, scope?: any): IReactionDisposer;
-    };
-    when: {
-        (name: string, predicate: () => boolean, effect: Lambda, scope?: any): IReactionDisposer;
-        (predicate: () => boolean, effect: Lambda, scope?: any): IReactionDisposer;
-    };
-    reaction: {
-        <T>(expression: (r: IReactionPublic) => T, effect: (arg: T, r: IReactionPublic) => void, opts?: IReactionOptions | undefined): IReactionDisposer;
-        <T>(expression: (r: IReactionPublic) => T, effect: (arg: T, r: IReactionPublic) => void, fireImmediately?: boolean | undefined): IReactionDisposer;
-    };
+    isObservable: typeof isObservable;
+    isComputed: typeof isComputed;
+    extendObservable: typeof extendObservable;
+    extendShallowObservable: typeof extendShallowObservable;
+    observe: typeof observe;
+    intercept: typeof intercept;
+    autorun: typeof autorun;
+    autorunAsync: typeof autorunAsync;
+    when: typeof when;
+    reaction: typeof reaction;
     action: IActionFactory;
-    isAction: (thing: any) => boolean;
-    runInAction: {
-        <T>(block: () => T, scope?: any): T;
-        <T>(name: string, block: () => T, scope?: any): T;
-    };
-    expr: <T>(expr: () => T, scope?: any) => T;
-    toJS: {
-        <T>(source: T, detectCycles?: boolean | undefined): T;
-        (source: any, detectCycles?: boolean | undefined): any;
-        (source: any, detectCycles: boolean, __alreadySeen: [any, any][]): any;
-    };
-    createTransformer: <A, B>(transformer: ITransformer<A, B>, onCleanup?: ((resultObject: B | undefined, sourceObject?: A | undefined) => void) | undefined) => ITransformer<A, B>;
-    whyRun: (thing?: any, prop?: string | undefined) => string;
-    isArrayLike: (x: any) => x is any[] | IObservableArray<any>;
+    isAction: typeof isAction;
+    runInAction: typeof runInAction;
+    expr: typeof expr;
+    toJS: typeof toJS;
+    createTransformer: typeof createTransformer;
+    whyRun: typeof whyRun;
+    isArrayLike: typeof isArrayLike;
     extras: {
-        allowStateChanges: <T>(allowStateChanges: boolean, func: () => T) => T;
-        deepEqual: (a: any, b: any) => boolean;
-        getAtom: (thing: any, property?: string | undefined) => IDepTreeNode;
-        getDebugName: (thing: any, property?: string | undefined) => string;
-        getDependencyTree: (thing: any, property?: string | undefined) => IDependencyTree;
-        getAdministration: (thing: any, property?: string | undefined) => any;
-        getGlobalState: () => any;
-        getObserverTree: (thing: any, property?: string | undefined) => IObserverTree;
-        interceptReads: {
-            <T>(value: IObservableValue<T>, handler: (value: any) => T): Lambda;
-            <T>(observableArray: IObservableArray<T>, handler: (value: any) => T): Lambda;
-            <T>(observableMap: ObservableMap<T>, handler: (value: any) => T): Lambda;
-            (object: Object, property: string, handler: (value: any) => any): Lambda;
-        };
-        isComputingDerivation: () => boolean;
-        isSpyEnabled: () => boolean;
-        onReactionError: (handler: (error: any, derivation: IDerivation) => void) => () => void;
-        reserveArrayBuffer: (max: number) => void;
-        resetGlobalState: () => void;
-        isolateGlobalState: () => void;
-        shareGlobalState: () => void;
-        spyReport: (event: any) => void;
-        spyReportEnd: (change?: any) => void;
-        spyReportStart: (event: any) => void;
-        setReactionScheduler: (fn: (f: () => void) => void) => void;
+        allowStateChanges: typeof allowStateChanges;
+        deepEqual: typeof deepEqual;
+        getAtom: typeof getAtom;
+        getDebugName: typeof getDebugName;
+        getDependencyTree: typeof getDependencyTree;
+        getAdministration: typeof getAdministration;
+        getGlobalState: typeof getGlobalState;
+        getObserverTree: typeof getObserverTree;
+        interceptReads: typeof interceptReads;
+        isComputingDerivation: typeof isComputingDerivation;
+        isSpyEnabled: typeof isSpyEnabled;
+        onReactionError: typeof onReactionError;
+        reserveArrayBuffer: typeof reserveArrayBuffer;
+        resetGlobalState: typeof resetGlobalState;
+        isolateGlobalState: typeof isolateGlobalState;
+        shareGlobalState: typeof shareGlobalState;
+        spyReport: typeof spyReport;
+        spyReportEnd: typeof spyReportEnd;
+        spyReportStart: typeof spyReportStart;
+        setReactionScheduler: typeof setReactionScheduler;
     };
 };
 export default everything;

package/lib/mobx.js

@@ -35,7 +35,7 @@ function __extends(d, b) {
  * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used
  * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.
  */
-var BaseAtom = (function () {
+var BaseAtom = /** @class */ (function () {
     /**
      * Create a new atom. For debugging purposes it is recommended to give it a name.
      * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
@@ -72,7 +72,7 @@ var BaseAtom = (function () {
     };
     return BaseAtom;
 }());
-var Atom = (function (_super) {
+var Atom = /** @class */ (function (_super) {
     __extends(Atom, _super);
     /**
      * Create a new atom. For debugging purposes it is recommended to give it a name.
@@ -238,7 +238,7 @@ var safariPrototypeSetterInheritanceBug = (function () {
  */
 var OBSERVABLE_ARRAY_BUFFER_SIZE = 0;
 // Typescript workaround to make sure ObservableArray extends Array
-var StubArray = (function () {
+var StubArray = /** @class */ (function () {
     function StubArray() {
     }
     return StubArray;
@@ -281,7 +281,7 @@ if (Object.isFrozen(Array)) {
         });
     });
 }
-var ObservableArrayAdministration = (function () {
+var ObservableArrayAdministration = /** @class */ (function () {
     function ObservableArrayAdministration(name, enhancer, array, owned) {
         this.array = array;
         this.owned = owned;
@@ -444,7 +444,7 @@ var ObservableArrayAdministration = (function () {
     };
     return ObservableArrayAdministration;
 }());
-var ObservableArray = (function (_super) {
+var ObservableArray = /** @class */ (function (_super) {
     __extends(ObservableArray, _super);
     function ObservableArray(initialValues, enhancer, name, owned) {
         if (name === void 0) { name = "ObservableArray@" + getNextId(); }
@@ -757,7 +757,7 @@ function isObservableArray(thing) {
 }
 
 var UNCHANGED = {};
-var ObservableValue = (function (_super) {
+var ObservableValue = /** @class */ (function (_super) {
     __extends(ObservableValue, _super);
     function ObservableValue(value, enhancer, name, notifySpy) {
         if (name === void 0) { name = "ObservableValue@" + getNextId(); }
@@ -998,18 +998,18 @@ function allowStateChangesEnd(prev) {
  * This means that these properties despite being enumerable might not show up in Object.keys() (but they will show up in for...in loops).
  */
 function createClassPropertyDecorator(
-    /**
-     * This function is invoked once, when the property is added to a new instance.
-     * When this happens is not strictly determined due to differences in TS and Babel:
-     * Typescript: Usually when constructing the new instance
-     * Babel, sometimes Typescript: during the first get / set
-     * Both: when calling `runLazyInitializers(instance)`
-     */
-    onInitialize, get, set, enumerable, 
-    /**
-     * Can this decorator invoked with arguments? e.g. @decorator(args)
-     */
-    allowCustomArguments) {
+/**
+ * This function is invoked once, when the property is added to a new instance.
+ * When this happens is not strictly determined due to differences in TS and Babel:
+ * Typescript: Usually when constructing the new instance
+ * Babel, sometimes Typescript: during the first get / set
+ * Both: when calling `runLazyInitializers(instance)`
+ */
+onInitialize, get, set, enumerable, 
+/**
+ * Can this decorator invoked with arguments? e.g. @decorator(args)
+ */
+allowCustomArguments) {
     function classPropertyDecorator(target, key, descriptor, customArgs, argLen) {
         if (argLen === void 0) { argLen = 0; }
         invariant(allowCustomArguments || quacksLikeADecorator(arguments), "This function is a decorator, but it wasn't invoked like a decorator");
@@ -1171,10 +1171,11 @@ function defineBoundAction(target, propertyName, fn) {
     addHiddenProp(target, propertyName, res);
 }
 
-// Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289
+var toString = Object.prototype.toString;
 function deepEqual(a, b) {
     return eq(a, b);
 }
+// Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289
 // Internal recursive comparison function for `isEqual`.
 function eq(a, b, aStack, bStack) {
     // Identical objects are equal. `0 === -0`, but they aren't identical.
@@ -1193,7 +1194,6 @@ function eq(a, b, aStack, bStack) {
         return false;
     return deepEq(a, b, aStack, bStack);
 }
-var toString = Object.prototype.toString;
 // Internal recursive comparison function for `isEqual`.
 function deepEq(a, b, aStack, bStack) {
     // Unwrap any wrapped objects.
@@ -1484,7 +1484,7 @@ function reaction(expression, effect, arg3) {
  *
  * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
  */
-var ComputedValue = (function () {
+var ComputedValue = /** @class */ (function () {
     /**
      * Create a new computed value based on a function expression.
      *
@@ -1666,7 +1666,7 @@ var ComputedValue = (function () {
 ComputedValue.prototype[primitiveSymbol()] = ComputedValue.prototype.valueOf;
 var isComputedValue = createInstanceofPredicate("ComputedValue", ComputedValue);
 
-var ObservableObjectAdministration = (function () {
+var ObservableObjectAdministration = /** @class */ (function () {
     function ObservableObjectAdministration(target, name) {
         this.target = target;
         this.name = name;
@@ -2166,7 +2166,7 @@ function transaction(action, thisArg) {
 }
 
 var ObservableMapMarker = {};
-var ObservableMap = (function () {
+var ObservableMap = /** @class */ (function () {
     function ObservableMap(initialData, enhancer, name) {
         if (enhancer === void 0) { enhancer = deepEnhancer; }
         if (name === void 0) { name = "ObservableMap@" + getNextId(); }
@@ -2615,7 +2615,7 @@ function toPrimitive(value) {
  * These values will persist if global state is reset
  */
 var persistentKeys = ["mobxGuid", "resetId", "spyListeners", "strictMode", "runId"];
-var MobXGlobals = (function () {
+var MobXGlobals = /** @class */ (function () {
     function MobXGlobals() {
         /**
          * MobXGlobals version.
@@ -2699,7 +2699,7 @@ var warnedAboutMultipleInstances = false;
                 warnedAboutMultipleInstances = true;
                 console.warn("[mobx] Warning: there are multiple mobx instances active. This might lead to unexpected results. See https://github.com/mobxjs/mobx/issues/1082 for details.");
             }
-        });
+        }, 1);
     }
 }
 function isolateGlobalState() {
@@ -3036,7 +3036,7 @@ var TraceMode;
     TraceMode[TraceMode["LOG"] = 1] = "LOG";
     TraceMode[TraceMode["BREAK"] = 2] = "BREAK";
 })(TraceMode || (TraceMode = {}));
-var CaughtException = (function () {
+var CaughtException = /** @class */ (function () {
     function CaughtException(cause) {
         this.cause = cause;
         // Empty
@@ -3265,7 +3265,7 @@ function getAtomFromArgs(args) {
     }
 }
 
-var Reaction = (function () {
+var Reaction = /** @class */ (function () {
     function Reaction(name, onInvalidate) {
         if (name === void 0) { name = "Reaction@" + getNextId(); }
         this.name = name;
@@ -3618,7 +3618,7 @@ function createTransformer(transformer, onCleanup) {
     // This construction is used to avoid leaking refs to the objectCache directly
     var resetId = globalState.resetId;
     // Local transformer class specifically for this transformer
-    var Transformer = (function (_super) {
+    var Transformer = /** @class */ (function (_super) {
         __extends(Transformer, _super);
         function Transformer(sourceIdentifier, sourceObject) {
             var _this = _super.call(this, function () { return transformer(sourceObject); }, undefined, comparer.default, "Transformer-" + transformer.name + "-" + sourceIdentifier, undefined) || this;