mobx 4.15.3 → 4.15.7

package/lib/core/derivation.d.ts

@@ -1,74 +1,74 @@
-import { IDepTreeNode, IObservable, IAtom } from "../internal";
-export declare enum IDerivationState {
-    NOT_TRACKING = -1,
-    UP_TO_DATE = 0,
-    POSSIBLY_STALE = 1,
-    STALE = 2
-}
-export declare enum TraceMode {
-    NONE = 0,
-    LOG = 1,
-    BREAK = 2
-}
-/**
- * A derivation is everything that can be derived from the state (all the atoms) in a pure manner.
- * See https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
- */
-export interface IDerivation extends IDepTreeNode {
-    observing: IObservable[];
-    newObserving: null | IObservable[];
-    dependenciesState: IDerivationState;
-    /**
-     * Id of the current run of a derivation. Each time the derivation is tracked
-     * this number is increased by one. This number is globally unique
-     */
-    runId: number;
-    /**
-     * amount of dependencies used by the derivation in this run, which has not been bound yet.
-     */
-    unboundDepsCount: number;
-    __mapid: string;
-    onBecomeStale(): void;
-    isTracing: TraceMode;
-    /**
-     *  warn if the derivation has no dependencies after creation/update
-     */
-    requiresObservable?: boolean;
-}
-export declare class CaughtException {
-    cause: any;
-    constructor(cause: any);
-}
-export declare function isCaughtException(e: any): e is CaughtException;
-/**
- * Finds out whether any dependency of the derivation has actually changed.
- * If dependenciesState is 1 then it will recalculate dependencies,
- * if any dependency changed it will propagate it by changing dependenciesState to 2.
- *
- * By iterating over the dependencies in the same order that they were reported and
- * stopping on the first change, all the recalculations are only called for ComputedValues
- * that will be tracked by derivation. That is because we assume that if the first x
- * dependencies of the derivation doesn't change then the derivation should run the same way
- * up until accessing x-th dependency.
- */
-export declare function shouldCompute(derivation: IDerivation): boolean;
-export declare function isComputingDerivation(): boolean;
-export declare function checkIfStateModificationsAreAllowed(atom: IAtom): void;
-export declare function checkIfStateReadsAreAllowed(observable: IObservable): void;
-/**
- * Executes the provided function `f` and tracks which observables are being accessed.
- * The tracking information is stored on the `derivation` object and the derivation is registered
- * as observer of any of the accessed observables.
- */
-export declare function trackDerivedFunction<T>(derivation: IDerivation, f: () => T, context: any): any;
-export declare function clearObserving(derivation: IDerivation): void;
-export declare function untracked<T>(action: () => T): T;
-export declare function untrackedStart(): IDerivation | null;
-export declare function untrackedEnd(prev: IDerivation | null): void;
-export declare function allowStateReadsStart(allowStateReads: boolean): boolean;
-export declare function allowStateReadsEnd(prev: boolean): void;
-/**
- * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0
- *
- */
-export declare function changeDependenciesStateTo0(derivation: IDerivation): void;
+import { IDepTreeNode, IObservable, IAtom } from "../internal";
+export declare enum IDerivationState {
+    NOT_TRACKING = -1,
+    UP_TO_DATE = 0,
+    POSSIBLY_STALE = 1,
+    STALE = 2
+}
+export declare enum TraceMode {
+    NONE = 0,
+    LOG = 1,
+    BREAK = 2
+}
+/**
+ * A derivation is everything that can be derived from the state (all the atoms) in a pure manner.
+ * See https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
+ */
+export interface IDerivation extends IDepTreeNode {
+    observing: IObservable[];
+    newObserving: null | IObservable[];
+    dependenciesState: IDerivationState;
+    /**
+     * Id of the current run of a derivation. Each time the derivation is tracked
+     * this number is increased by one. This number is globally unique
+     */
+    runId: number;
+    /**
+     * amount of dependencies used by the derivation in this run, which has not been bound yet.
+     */
+    unboundDepsCount: number;
+    __mapid: string;
+    onBecomeStale(): void;
+    isTracing: TraceMode;
+    /**
+     *  warn if the derivation has no dependencies after creation/update
+     */
+    requiresObservable?: boolean;
+}
+export declare class CaughtException {
+    cause: any;
+    constructor(cause: any);
+}
+export declare function isCaughtException(e: any): e is CaughtException;
+/**
+ * Finds out whether any dependency of the derivation has actually changed.
+ * If dependenciesState is 1 then it will recalculate dependencies,
+ * if any dependency changed it will propagate it by changing dependenciesState to 2.
+ *
+ * By iterating over the dependencies in the same order that they were reported and
+ * stopping on the first change, all the recalculations are only called for ComputedValues
+ * that will be tracked by derivation. That is because we assume that if the first x
+ * dependencies of the derivation doesn't change then the derivation should run the same way
+ * up until accessing x-th dependency.
+ */
+export declare function shouldCompute(derivation: IDerivation): boolean;
+export declare function isComputingDerivation(): boolean;
+export declare function checkIfStateModificationsAreAllowed(atom: IAtom): void;
+export declare function checkIfStateReadsAreAllowed(observable: IObservable): void;
+/**
+ * Executes the provided function `f` and tracks which observables are being accessed.
+ * The tracking information is stored on the `derivation` object and the derivation is registered
+ * as observer of any of the accessed observables.
+ */
+export declare function trackDerivedFunction<T>(derivation: IDerivation, f: () => T, context: any): any;
+export declare function clearObserving(derivation: IDerivation): void;
+export declare function untracked<T>(action: () => T): T;
+export declare function untrackedStart(): IDerivation | null;
+export declare function untrackedEnd(prev: IDerivation | null): void;
+export declare function allowStateReadsStart(allowStateReads: boolean): boolean;
+export declare function allowStateReadsEnd(prev: boolean): void;
+/**
+ * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0
+ *
+ */
+export declare function changeDependenciesStateTo0(derivation: IDerivation): void;

package/lib/core/globalstate.d.ts

@@ -1,106 +1,106 @@
-import { IDerivation, IObservable, Reaction } from "../internal";
-export declare type IUNCHANGED = {};
-export declare class MobXGlobals {
-    /**
-     * MobXGlobals version.
-     * MobX compatiblity with other versions loaded in memory as long as this version matches.
-     * It indicates that the global state still stores similar information
-     *
-     * N.B: this version is unrelated to the package version of MobX, and is only the version of the
-     * internal state storage of MobX, and can be the same across many different package versions
-     */
-    version: number;
-    /**
-     * globally unique token to signal unchanged
-     */
-    UNCHANGED: IUNCHANGED;
-    /**
-     * Currently running derivation
-     */
-    trackingDerivation: IDerivation | null;
-    /**
-     * Are we running a computation currently? (not a reaction)
-     */
-    computationDepth: number;
-    /**
-     * Each time a derivation is tracked, it is assigned a unique run-id
-     */
-    runId: number;
-    /**
-     * 'guid' for general purpose. Will be persisted amongst resets.
-     */
-    mobxGuid: number;
-    /**
-     * Are we in a batch block? (and how many of them)
-     */
-    inBatch: number;
-    /**
-     * Observables that don't have observers anymore, and are about to be
-     * suspended, unless somebody else accesses it in the same batch
-     *
-     * @type {IObservable[]}
-     */
-    pendingUnobservations: IObservable[];
-    /**
-     * List of scheduled, not yet executed, reactions.
-     */
-    pendingReactions: Reaction[];
-    /**
-     * Are we currently processing reactions?
-     */
-    isRunningReactions: boolean;
-    /**
-     * Is it allowed to change observables at this point?
-     * In general, MobX doesn't allow that when running computations and React.render.
-     * To ensure that those functions stay pure.
-     */
-    allowStateChanges: boolean;
-    /**
-     * Is it allowed to read observables at this point?
-     * Used to hold the state needed for `observableRequiresReaction`
-     */
-    allowStateReads: boolean;
-    /**
-     * If strict mode is enabled, state changes are by default not allowed
-     */
-    enforceActions: boolean | "strict";
-    /**
-     * Spy callbacks
-     */
-    spyListeners: {
-        (change: any): void;
-    }[];
-    /**
-     * Globally attached error handlers that react specifically to errors in reactions
-     */
-    globalReactionErrorHandlers: ((error: any, derivation: IDerivation) => void)[];
-    /**
-     * Warn if computed values are accessed outside a reactive context
-     */
-    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;
-    /**
-     * Allows overwriting of computed properties, useful in tests but not prod as it can cause
-     * memory leaks. See https://github.com/mobxjs/mobx/issues/1867
-     */
-    computedConfigurable: boolean;
-    disableErrorBoundaries: boolean;
-    suppressReactionErrors: boolean;
-}
-export declare let globalState: MobXGlobals;
-export declare function isolateGlobalState(): void;
-export declare function getGlobalState(): any;
-/**
- * For testing purposes only; this will break the internal state of existing observables,
- * but can be used to get back at a stable state after throwing errors
- */
-export declare function resetGlobalState(): void;
+import { IDerivation, IObservable, Reaction } from "../internal";
+export declare type IUNCHANGED = {};
+export declare class MobXGlobals {
+    /**
+     * MobXGlobals version.
+     * MobX compatiblity with other versions loaded in memory as long as this version matches.
+     * It indicates that the global state still stores similar information
+     *
+     * N.B: this version is unrelated to the package version of MobX, and is only the version of the
+     * internal state storage of MobX, and can be the same across many different package versions
+     */
+    version: number;
+    /**
+     * globally unique token to signal unchanged
+     */
+    UNCHANGED: IUNCHANGED;
+    /**
+     * Currently running derivation
+     */
+    trackingDerivation: IDerivation | null;
+    /**
+     * Are we running a computation currently? (not a reaction)
+     */
+    computationDepth: number;
+    /**
+     * Each time a derivation is tracked, it is assigned a unique run-id
+     */
+    runId: number;
+    /**
+     * 'guid' for general purpose. Will be persisted amongst resets.
+     */
+    mobxGuid: number;
+    /**
+     * Are we in a batch block? (and how many of them)
+     */
+    inBatch: number;
+    /**
+     * Observables that don't have observers anymore, and are about to be
+     * suspended, unless somebody else accesses it in the same batch
+     *
+     * @type {IObservable[]}
+     */
+    pendingUnobservations: IObservable[];
+    /**
+     * List of scheduled, not yet executed, reactions.
+     */
+    pendingReactions: Reaction[];
+    /**
+     * Are we currently processing reactions?
+     */
+    isRunningReactions: boolean;
+    /**
+     * Is it allowed to change observables at this point?
+     * In general, MobX doesn't allow that when running computations and React.render.
+     * To ensure that those functions stay pure.
+     */
+    allowStateChanges: boolean;
+    /**
+     * Is it allowed to read observables at this point?
+     * Used to hold the state needed for `observableRequiresReaction`
+     */
+    allowStateReads: boolean;
+    /**
+     * If strict mode is enabled, state changes are by default not allowed
+     */
+    enforceActions: boolean | "strict";
+    /**
+     * Spy callbacks
+     */
+    spyListeners: {
+        (change: any): void;
+    }[];
+    /**
+     * Globally attached error handlers that react specifically to errors in reactions
+     */
+    globalReactionErrorHandlers: ((error: any, derivation: IDerivation) => void)[];
+    /**
+     * Warn if computed values are accessed outside a reactive context
+     */
+    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;
+    /**
+     * Allows overwriting of computed properties, useful in tests but not prod as it can cause
+     * memory leaks. See https://github.com/mobxjs/mobx/issues/1867
+     */
+    computedConfigurable: boolean;
+    disableErrorBoundaries: boolean;
+    suppressReactionErrors: boolean;
+}
+export declare let globalState: MobXGlobals;
+export declare function isolateGlobalState(): void;
+export declare function getGlobalState(): any;
+/**
+ * For testing purposes only; this will break the internal state of existing observables,
+ * but can be used to get back at a stable state after throwing errors
+ */
+export declare function resetGlobalState(): void;

package/lib/core/observable.d.ts

@@ -1,44 +1,44 @@
-import { IDerivation, IDerivationState } from "../internal";
-export interface IDepTreeNode {
-    name: string;
-    observing?: IObservable[];
-}
-export interface IObservable extends IDepTreeNode {
-    diffValue: number;
-    /**
-     * Id of the derivation *run* that last accessed this observable.
-     * If this id equals the *run* id of the current derivation,
-     * the dependency is already established
-     */
-    lastAccessedBy: number;
-    isBeingObserved: boolean;
-    lowestObserverState: IDerivationState;
-    isPendingUnobservation: boolean;
-    observers: IDerivation[];
-    observersIndexes: {};
-    onBecomeUnobserved(): void;
-    onBecomeObserved(): void;
-}
-export declare function hasObservers(observable: IObservable): boolean;
-export declare function getObservers(observable: IObservable): IDerivation[];
-export declare function addObserver(observable: IObservable, node: IDerivation): void;
-export declare function removeObserver(observable: IObservable, node: IDerivation): void;
-export declare function queueForUnobservation(observable: IObservable): void;
-/**
- * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.
- * During a batch `onBecomeUnobserved` will be called at most once per observable.
- * Avoids unnecessary recalculations.
- */
-export declare function startBatch(): void;
-export declare function endBatch(): void;
-export declare function reportObserved(observable: IObservable): boolean;
-/**
- * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly
- * It will propagate changes to observers from previous run
- * It's hard or maybe impossible (with reasonable perf) to get it right with current approach
- * Hopefully self reruning autoruns aren't a feature people should depend on
- * Also most basic use cases should be ok
- */
-export declare function propagateChanged(observable: IObservable): void;
-export declare function propagateChangeConfirmed(observable: IObservable): void;
-export declare function propagateMaybeChanged(observable: IObservable): void;
+import { IDerivation, IDerivationState } from "../internal";
+export interface IDepTreeNode {
+    name: string;
+    observing?: IObservable[];
+}
+export interface IObservable extends IDepTreeNode {
+    diffValue: number;
+    /**
+     * Id of the derivation *run* that last accessed this observable.
+     * If this id equals the *run* id of the current derivation,
+     * the dependency is already established
+     */
+    lastAccessedBy: number;
+    isBeingObserved: boolean;
+    lowestObserverState: IDerivationState;
+    isPendingUnobservation: boolean;
+    observers: IDerivation[];
+    observersIndexes: {};
+    onBecomeUnobserved(): void;
+    onBecomeObserved(): void;
+}
+export declare function hasObservers(observable: IObservable): boolean;
+export declare function getObservers(observable: IObservable): IDerivation[];
+export declare function addObserver(observable: IObservable, node: IDerivation): void;
+export declare function removeObserver(observable: IObservable, node: IDerivation): void;
+export declare function queueForUnobservation(observable: IObservable): void;
+/**
+ * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.
+ * During a batch `onBecomeUnobserved` will be called at most once per observable.
+ * Avoids unnecessary recalculations.
+ */
+export declare function startBatch(): void;
+export declare function endBatch(): void;
+export declare function reportObserved(observable: IObservable): boolean;
+/**
+ * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly
+ * It will propagate changes to observers from previous run
+ * It's hard or maybe impossible (with reasonable perf) to get it right with current approach
+ * Hopefully self reruning autoruns aren't a feature people should depend on
+ * Also most basic use cases should be ok
+ */
+export declare function propagateChanged(observable: IObservable): void;
+export declare function propagateChangeConfirmed(observable: IObservable): void;
+export declare function propagateMaybeChanged(observable: IObservable): void;

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');
+}
+