mobx 4.15.0 → 4.15.4

package/lib/core/computedvalue.d.ts

@@ -1,93 +1,93 @@
-import { IObservable, IValueDidChange, Lambda, IEqualsComparer, IDerivation, IDerivationState, CaughtException, TraceMode } from "../internal";
-export interface IComputedValue<T> {
-    get(): T;
-    set(value: T): void;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-}
-export interface IComputedValueOptions<T> {
-    get?: () => T;
-    set?: (value: T) => void;
-    name?: string;
-    equals?: IEqualsComparer<T>;
-    context?: any;
-    requiresReaction?: boolean;
-    keepAlive?: boolean;
-}
-/**
- * A node in the state dependency root that observes other nodes, and can be observed itself.
- *
- * ComputedValue will remember the result of the computation for the duration of the batch, or
- * while being observed.
- *
- * During this time it will recompute only when one of its direct dependencies changed,
- * but only when it is being accessed with `ComputedValue.get()`.
- *
- * Implementation description:
- * 1. First time it's being accessed it will compute and remember result
- *    give back remembered result until 2. happens
- * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.
- * 3. When it's being accessed, recompute if any shallow dependency changed.
- *    if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.
- *    go to step 2. either way
- *
- * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
- */
-export declare class ComputedValue<T> implements IObservable, IComputedValue<T>, IDerivation {
-    dependenciesState: IDerivationState;
-    observing: IObservable[];
-    newObserving: null;
-    isBeingObserved: boolean;
-    isPendingUnobservation: boolean;
-    observers: never[];
-    observersIndexes: {};
-    diffValue: number;
-    runId: number;
-    lastAccessedBy: number;
-    lowestObserverState: IDerivationState;
-    unboundDepsCount: number;
-    __mapid: string;
-    protected value: T | undefined | CaughtException;
-    name: string;
-    triggeredBy: string;
-    isComputing: boolean;
-    isRunningSetter: boolean;
-    derivation: () => T;
-    setter: (value: T) => void;
-    isTracing: TraceMode;
-    scope: Object | undefined;
-    private equals;
-    private requiresReaction;
-    private keepAlive;
-    /**
-     * Create a new computed value based on a function expression.
-     *
-     * The `name` property is for debug purposes only.
-     *
-     * The `equals` property specifies the comparer function to use to determine if a newly produced
-     * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`
-     * compares based on identity comparison (===), and `structualComparer` deeply compares the structure.
-     * Structural comparison can be convenient if you always produce a new aggregated object and
-     * don't want to notify observers if it is structurally the same.
-     * This is useful for working with vectors, mouse coordinates etc.
-     */
-    constructor(options: IComputedValueOptions<T>);
-    onBecomeStale(): void;
-    onBecomeUnobserved(): void;
-    onBecomeObserved(): void;
-    /**
-     * Returns the current value of this computed value.
-     * Will evaluate its computation first if needed.
-     */
-    get(): T;
-    peek(): T;
-    set(value: T): void;
-    private trackAndCompute;
-    computeValue(track: boolean): T | CaughtException;
-    suspend(): void;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-    warnAboutUntrackedRead(): void;
-    toJSON(): T;
-    toString(): string;
-    valueOf(): T;
-}
-export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;
+import { IObservable, IValueDidChange, Lambda, IEqualsComparer, IDerivation, IDerivationState, CaughtException, TraceMode } from "../internal";
+export interface IComputedValue<T> {
+    get(): T;
+    set(value: T): void;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+}
+export interface IComputedValueOptions<T> {
+    get?: () => T;
+    set?: (value: T) => void;
+    name?: string;
+    equals?: IEqualsComparer<T>;
+    context?: any;
+    requiresReaction?: boolean;
+    keepAlive?: boolean;
+}
+/**
+ * A node in the state dependency root that observes other nodes, and can be observed itself.
+ *
+ * ComputedValue will remember the result of the computation for the duration of the batch, or
+ * while being observed.
+ *
+ * During this time it will recompute only when one of its direct dependencies changed,
+ * but only when it is being accessed with `ComputedValue.get()`.
+ *
+ * Implementation description:
+ * 1. First time it's being accessed it will compute and remember result
+ *    give back remembered result until 2. happens
+ * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.
+ * 3. When it's being accessed, recompute if any shallow dependency changed.
+ *    if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.
+ *    go to step 2. either way
+ *
+ * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
+ */
+export declare class ComputedValue<T> implements IObservable, IComputedValue<T>, IDerivation {
+    dependenciesState: IDerivationState;
+    observing: IObservable[];
+    newObserving: null;
+    isBeingObserved: boolean;
+    isPendingUnobservation: boolean;
+    observers: never[];
+    observersIndexes: {};
+    diffValue: number;
+    runId: number;
+    lastAccessedBy: number;
+    lowestObserverState: IDerivationState;
+    unboundDepsCount: number;
+    __mapid: string;
+    protected value: T | undefined | CaughtException;
+    name: string;
+    triggeredBy?: string;
+    isComputing: boolean;
+    isRunningSetter: boolean;
+    derivation: () => T;
+    setter?: (value: T) => void;
+    isTracing: TraceMode;
+    scope: Object | undefined;
+    private equals;
+    private requiresReaction;
+    private keepAlive;
+    /**
+     * Create a new computed value based on a function expression.
+     *
+     * The `name` property is for debug purposes only.
+     *
+     * The `equals` property specifies the comparer function to use to determine if a newly produced
+     * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`
+     * compares based on identity comparison (===), and `structualComparer` deeply compares the structure.
+     * Structural comparison can be convenient if you always produce a new aggregated object and
+     * don't want to notify observers if it is structurally the same.
+     * This is useful for working with vectors, mouse coordinates etc.
+     */
+    constructor(options: IComputedValueOptions<T>);
+    onBecomeStale(): void;
+    onBecomeUnobserved(): void;
+    onBecomeObserved(): void;
+    /**
+     * Returns the current value of this computed value.
+     * Will evaluate its computation first if needed.
+     */
+    get(): T;
+    peek(): T;
+    set(value: T): void;
+    private trackAndCompute;
+    computeValue(track: boolean): T | CaughtException;
+    suspend(): void;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+    warnAboutUntrackedRead(): void;
+    toJSON(): T;
+    toString(): string;
+    valueOf(): T;
+}
+export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;

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;