mobx
Version:
Simple, scalable state management.
63 lines (62 loc) • 2.84 kB
TypeScript
import { IDerivation, IDerivationState, IObservable, Lambda, TraceMode } 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?;
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);
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;