mobx 4.15.0 → 4.15.4

package/lib/core/reaction.d.ts

@@ -1,63 +1,63 @@
-import { IDerivation, IDerivationState, TraceMode, IObservable, Lambda } from "../internal";
-/**
- * Reactions are a special kind of derivations. Several things distinguishes them from normal reactive computations
- *
- * 1) They will always run, whether they are used by other computations or not.
- * This means that they are very suitable for triggering side effects like logging, updating the DOM and making network requests.
- * 2) They are not observable themselves
- * 3) They will always run after any 'normal' derivations
- * 4) They are allowed to change the state and thereby triggering themselves again, as long as they make sure the state propagates to a stable state in a reasonable amount of iterations.
- *
- * The state machine of a Reaction is as follows:
- *
- * 1) after creating, the reaction should be started by calling `runReaction` or by scheduling it (see also `autorun`)
- * 2) the `onInvalidate` handler should somehow result in a call to `this.track(someFunction)`
- * 3) all observables accessed in `someFunction` will be observed by this reaction.
- * 4) as soon as some of the dependencies has changed the Reaction will be rescheduled for another run (after the current mutation or transaction). `isScheduled` will yield true once a dependency is stale and during this period
- * 5) `onInvalidate` will be called, and we are back at step 1.
- *
- */
-export interface IReactionPublic {
-    dispose(): void;
-    trace(enterBreakPoint?: boolean): void;
-}
-export interface IReactionDisposer {
-    (): void;
-    $mobx: Reaction;
-}
-export declare class Reaction implements IDerivation, IReactionPublic {
-    name: string;
-    private onInvalidate;
-    private errorHandler?;
-    requiresObservable: boolean;
-    observing: IObservable[];
-    newObserving: IObservable[];
-    dependenciesState: IDerivationState;
-    diffValue: number;
-    runId: number;
-    unboundDepsCount: number;
-    __mapid: string;
-    isDisposed: boolean;
-    _isScheduled: boolean;
-    _isTrackPending: boolean;
-    _isRunning: boolean;
-    isTracing: TraceMode;
-    constructor(name: string, onInvalidate: () => void, errorHandler?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable?: boolean);
-    onBecomeStale(): void;
-    schedule(): void;
-    isScheduled(): boolean;
-    /**
-     * internal, use schedule() if you intend to kick off a reaction
-     */
-    runReaction(): void;
-    track(fn: () => void): void;
-    reportExceptionInDerivation(error: any): void;
-    dispose(): void;
-    getDisposer(): IReactionDisposer;
-    toString(): string;
-    trace(enterBreakPoint?: boolean): void;
-}
-export declare function onReactionError(handler: (error: any, derivation: IDerivation) => void): Lambda;
-export declare function runReactions(): void;
-export declare const isReaction: (x: any) => x is Reaction;
-export declare function setReactionScheduler(fn: (f: () => void) => void): void;
+import { IDerivation, IDerivationState, TraceMode, IObservable, Lambda } from "../internal";
+/**
+ * Reactions are a special kind of derivations. Several things distinguishes them from normal reactive computations
+ *
+ * 1) They will always run, whether they are used by other computations or not.
+ * This means that they are very suitable for triggering side effects like logging, updating the DOM and making network requests.
+ * 2) They are not observable themselves
+ * 3) They will always run after any 'normal' derivations
+ * 4) They are allowed to change the state and thereby triggering themselves again, as long as they make sure the state propagates to a stable state in a reasonable amount of iterations.
+ *
+ * The state machine of a Reaction is as follows:
+ *
+ * 1) after creating, the reaction should be started by calling `runReaction` or by scheduling it (see also `autorun`)
+ * 2) the `onInvalidate` handler should somehow result in a call to `this.track(someFunction)`
+ * 3) all observables accessed in `someFunction` will be observed by this reaction.
+ * 4) as soon as some of the dependencies has changed the Reaction will be rescheduled for another run (after the current mutation or transaction). `isScheduled` will yield true once a dependency is stale and during this period
+ * 5) `onInvalidate` will be called, and we are back at step 1.
+ *
+ */
+export interface IReactionPublic {
+    dispose(): void;
+    trace(enterBreakPoint?: boolean): void;
+}
+export interface IReactionDisposer {
+    (): void;
+    $mobx: Reaction;
+}
+export declare class Reaction implements IDerivation, IReactionPublic {
+    name: string;
+    private onInvalidate;
+    private errorHandler?;
+    requiresObservable: boolean;
+    observing: IObservable[];
+    newObserving: IObservable[];
+    dependenciesState: IDerivationState;
+    diffValue: number;
+    runId: number;
+    unboundDepsCount: number;
+    __mapid: string;
+    isDisposed: boolean;
+    _isScheduled: boolean;
+    _isTrackPending: boolean;
+    _isRunning: boolean;
+    isTracing: TraceMode;
+    constructor(name: string, onInvalidate: () => void, errorHandler?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable?: boolean);
+    onBecomeStale(): void;
+    schedule(): void;
+    isScheduled(): boolean;
+    /**
+     * internal, use schedule() if you intend to kick off a reaction
+     */
+    runReaction(): void;
+    track(fn: () => void): void;
+    reportExceptionInDerivation(error: any): void;
+    dispose(): void;
+    getDisposer(): IReactionDisposer;
+    toString(): string;
+    trace(enterBreakPoint?: boolean): void;
+}
+export declare function onReactionError(handler: (error: any, derivation: IDerivation) => void): Lambda;
+export declare function runReactions(): void;
+export declare const isReaction: (x: any) => x is Reaction;
+export declare function setReactionScheduler(fn: (f: () => void) => void): void;

package/lib/core/spy.d.ts

@@ -1,6 +1,6 @@
-import { Lambda } from "../internal";
-export declare function isSpyEnabled(): boolean;
-export declare function spyReport(event: any): void;
-export declare function spyReportStart(event: any): void;
-export declare function spyReportEnd(change?: any): void;
-export declare function spy(listener: (change: any) => void): Lambda;
+import { Lambda } from "../internal";
+export declare function isSpyEnabled(): boolean;
+export declare function spyReport(event: any): void;
+export declare function spyReportStart(event: any): void;
+export declare function spyReportEnd(change?: any): void;
+export declare function spy(listener: (change: any) => void): Lambda;

package/lib/index.js

@@ -0,0 +1,7 @@
+
+if (typeof process !== 'undefined' && process.env.NODE_ENV === 'production') {
+    module.exports = require('./mobx.min.js');
+} else {
+    module.exports = require('./mobx.js');
+}
+        

package/lib/internal.d.ts

@@ -1,44 +1,44 @@
-export * from "./utils/utils";
-export * from "./utils/iterable";
-export * from "./core/atom";
-export * from "./utils/comparer";
-export * from "./utils/decorators2";
-export * from "./types/modifiers";
-export * from "./api/observabledecorator";
-export * from "./api/observable";
-export * from "./api/computed";
-export * from "./core/action";
-export * from "./types/observablevalue";
-export * from "./core/computedvalue";
-export * from "./core/derivation";
-export * from "./core/globalstate";
-export * from "./core/observable";
-export * from "./core/reaction";
-export * from "./core/spy";
-export * from "./api/actiondecorator";
-export * from "./api/action";
-export * from "./api/autorun";
-export * from "./api/become-observed";
-export * from "./api/configure";
-export * from "./api/decorate";
-export * from "./api/extendobservable";
-export * from "./api/extras";
-export * from "./api/flow";
-export * from "./api/intercept-read";
-export * from "./api/intercept";
-export * from "./api/iscomputed";
-export * from "./api/isobservable";
-export * from "./api/object-api";
-export * from "./api/observe";
-export * from "./api/tojs";
-export * from "./api/trace";
-export * from "./api/transaction";
-export * from "./api/when";
-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";
+export * from "./utils/utils";
+export * from "./utils/iterable";
+export * from "./core/atom";
+export * from "./utils/comparer";
+export * from "./utils/decorators2";
+export * from "./types/modifiers";
+export * from "./api/observabledecorator";
+export * from "./api/observable";
+export * from "./api/computed";
+export * from "./core/action";
+export * from "./types/observablevalue";
+export * from "./core/computedvalue";
+export * from "./core/derivation";
+export * from "./core/globalstate";
+export * from "./core/observable";
+export * from "./core/reaction";
+export * from "./core/spy";
+export * from "./api/actiondecorator";
+export * from "./api/action";
+export * from "./api/autorun";
+export * from "./api/become-observed";
+export * from "./api/configure";
+export * from "./api/decorate";
+export * from "./api/extendobservable";
+export * from "./api/extras";
+export * from "./api/flow";
+export * from "./api/intercept-read";
+export * from "./api/intercept";
+export * from "./api/iscomputed";
+export * from "./api/isobservable";
+export * from "./api/object-api";
+export * from "./api/observe";
+export * from "./api/tojs";
+export * from "./api/trace";
+export * from "./api/transaction";
+export * from "./api/when";
+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

@@ -1,19 +1,19 @@
-/**
- * (c) Michel Weststrate 2015 - 2019
- * MIT Licensed
- *
- * Welcome to the mobx sources! To get an global overview of how MobX internally works,
- * this is a good place to start:
- * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
- *
- * Source folders:
- * ===============
- *
- * - api/     Most of the public static methods exposed by the module can be found here.
- * - core/    Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.
- * - types/   All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.
- * - 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, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, extendShallowObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, FlowCancellationError, isFlowCancellationError, 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, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction } from "./internal";
-export declare const $mobx = "$mobx";
+/**
+ * (c) Michel Weststrate 2015 - 2019
+ * MIT Licensed
+ *
+ * Welcome to the mobx sources! To get an global overview of how MobX internally works,
+ * this is a good place to start:
+ * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
+ *
+ * Source folders:
+ * ===============
+ *
+ * - api/     Most of the public static methods exposed by the module can be found here.
+ * - core/    Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.
+ * - types/   All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.
+ * - 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, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, extendShallowObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, FlowCancellationError, isFlowCancellationError, 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, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd } from "./internal";
+export declare const $mobx = "$mobx";