mobx 6.10.1 → 6.11.0-pre

package/dist/api/transaction.d.ts

@@ -1,8 +1,8 @@
-/**
- * During a transaction no views are updated until the end of the transaction.
- * The transaction will be run synchronously nonetheless.
- *
- * @param action a function that updates some reactive state
- * @returns any value that was returned by the 'action' parameter.
- */
-export declare function transaction<T>(action: () => T, thisArg?: undefined): T;
+/**
+ * During a transaction no views are updated until the end of the transaction.
+ * The transaction will be run synchronously nonetheless.
+ *
+ * @param action a function that updates some reactive state
+ * @returns any value that was returned by the 'action' parameter.
+ */
+export declare function transaction<T>(action: () => T, thisArg?: undefined): T;

package/dist/api/when.d.ts

@@ -1,11 +1,11 @@
-import { IReactionDisposer, Lambda, GenericAbortSignal } from "../internal";
-export interface IWhenOptions {
-    name?: string;
-    timeout?: number;
-    onError?: (error: any) => void;
-    signal?: GenericAbortSignal;
-}
-export declare function when(predicate: () => boolean, opts?: IWhenOptions): Promise<void> & {
-    cancel(): void;
-};
-export declare function when(predicate: () => boolean, effect: Lambda, opts?: IWhenOptions): IReactionDisposer;
+import { IReactionDisposer, Lambda, GenericAbortSignal } from "../internal";
+export interface IWhenOptions {
+    name?: string;
+    timeout?: number;
+    onError?: (error: any) => void;
+    signal?: GenericAbortSignal;
+}
+export declare function when(predicate: () => boolean, opts?: IWhenOptions): Promise<void> & {
+    cancel(): void;
+};
+export declare function when(predicate: () => boolean, effect: Lambda, opts?: IWhenOptions): IReactionDisposer;

package/dist/core/action.d.ts

@@ -1,20 +1,20 @@
-import { IDerivation } from "../internal";
-export declare function createAction(actionName: string, fn: Function, autoAction?: boolean, ref?: Object): Function;
-export declare function executeAction(actionName: string, canRunAsDerivation: boolean, fn: Function, scope?: any, args?: IArguments): any;
-export interface IActionRunInfo {
-    prevDerivation_: IDerivation | null;
-    prevAllowStateChanges_: boolean;
-    prevAllowStateReads_: boolean;
-    notifySpy_: boolean;
-    startTime_: number;
-    error_?: any;
-    parentActionId_: number;
-    actionId_: number;
-    runAsAction_?: boolean;
-}
-export declare function _startAction(actionName: string, canRunAsDerivation: boolean, // true for autoAction
-scope: any, args?: IArguments): IActionRunInfo;
-export declare function _endAction(runInfo: IActionRunInfo): void;
-export declare function allowStateChanges<T>(allowStateChanges: boolean, func: () => T): T;
-export declare function allowStateChangesStart(allowStateChanges: boolean): boolean;
-export declare function allowStateChangesEnd(prev: boolean): void;
+import { IDerivation } from "../internal";
+export declare function createAction(actionName: string, fn: Function, autoAction?: boolean, ref?: Object): Function;
+export declare function executeAction(actionName: string, canRunAsDerivation: boolean, fn: Function, scope?: any, args?: IArguments): any;
+export interface IActionRunInfo {
+    prevDerivation_: IDerivation | null;
+    prevAllowStateChanges_: boolean;
+    prevAllowStateReads_: boolean;
+    notifySpy_: boolean;
+    startTime_: number;
+    error_?: any;
+    parentActionId_: number;
+    actionId_: number;
+    runAsAction_?: boolean;
+}
+export declare function _startAction(actionName: string, canRunAsDerivation: boolean, // true for autoAction
+scope: any, args?: IArguments): IActionRunInfo;
+export declare function _endAction(runInfo: IActionRunInfo): void;
+export declare function allowStateChanges<T>(allowStateChanges: boolean, func: () => T): T;
+export declare function allowStateChangesStart(allowStateChanges: boolean): boolean;
+export declare function allowStateChangesEnd(prev: boolean): void;

package/dist/core/atom.d.ts

@@ -1,37 +1,37 @@
-import { IDerivationState_, IObservable, IDerivation, Lambda } from "../internal";
-export declare const $mobx: unique symbol;
-export interface IAtom extends IObservable {
-    reportObserved(): boolean;
-    reportChanged(): void;
-}
-export declare class Atom implements IAtom {
-    name_: string;
-    isPendingUnobservation_: boolean;
-    isBeingObserved_: boolean;
-    observers_: Set<IDerivation>;
-    batchId_: number;
-    diffValue_: number;
-    lastAccessedBy_: number;
-    lowestObserverState_: IDerivationState_;
-    /**
-     * 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.
-     */
-    constructor(name_?: string);
-    onBOL: Set<Lambda> | undefined;
-    onBUOL: Set<Lambda> | undefined;
-    onBO(): void;
-    onBUO(): void;
-    /**
-     * Invoke this method to notify mobx that your atom has been used somehow.
-     * Returns true if there is currently a reactive context.
-     */
-    reportObserved(): boolean;
-    /**
-     * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.
-     */
-    reportChanged(): void;
-    toString(): string;
-}
-export declare const isAtom: (x: any) => x is Atom;
-export declare function createAtom(name: string, onBecomeObservedHandler?: () => void, onBecomeUnobservedHandler?: () => void): IAtom;
+import { IDerivationState_, IObservable, IDerivation, Lambda } from "../internal";
+export declare const $mobx: unique symbol;
+export interface IAtom extends IObservable {
+    reportObserved(): boolean;
+    reportChanged(): void;
+}
+export declare class Atom implements IAtom {
+    name_: string;
+    isPendingUnobservation_: boolean;
+    isBeingObserved_: boolean;
+    observers_: Set<IDerivation>;
+    batchId_: number;
+    diffValue_: number;
+    lastAccessedBy_: number;
+    lowestObserverState_: IDerivationState_;
+    /**
+     * 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.
+     */
+    constructor(name_?: string);
+    onBOL: Set<Lambda> | undefined;
+    onBUOL: Set<Lambda> | undefined;
+    onBO(): void;
+    onBUO(): void;
+    /**
+     * Invoke this method to notify mobx that your atom has been used somehow.
+     * Returns true if there is currently a reactive context.
+     */
+    reportObserved(): boolean;
+    /**
+     * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.
+     */
+    reportChanged(): void;
+    toString(): string;
+}
+export declare const isAtom: (x: any) => x is Atom;
+export declare function createAtom(name: string, onBecomeObservedHandler?: () => void, onBecomeUnobservedHandler?: () => void): IAtom;

package/dist/core/computedvalue.d.ts

@@ -1,99 +1,99 @@
-import { CaughtException, IDerivation, IDerivationState_, IEqualsComparer, IObservable, Lambda, TraceMode } from "../internal";
-export interface IComputedValue<T> {
-    get(): T;
-    set(value: T): void;
-}
-export interface IComputedValueOptions<T> {
-    get?: () => T;
-    set?: (value: T) => void;
-    name?: string;
-    equals?: IEqualsComparer<T>;
-    context?: any;
-    requiresReaction?: boolean;
-    keepAlive?: boolean;
-}
-export declare type IComputedDidChange<T = any> = {
-    type: "update";
-    observableKind: "computed";
-    object: unknown;
-    debugObjectName: string;
-    newValue: T;
-    oldValue: T | undefined;
-};
-/**
- * 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_: Set<IDerivation>;
-    diffValue_: number;
-    runId_: number;
-    lastAccessedBy_: number;
-    lowestObserverState_: IDerivationState_;
-    unboundDepsCount_: number;
-    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_;
-    keepAlive_: boolean;
-    /**
-     * 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 `structuralComparer` 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;
-    onBOL: Set<Lambda> | undefined;
-    onBUOL: Set<Lambda> | undefined;
-    onBO(): void;
-    onBUO(): void;
-    /**
-     * Returns the current value of this computed value.
-     * Will evaluate its computation first if needed.
-     */
-    get(): T;
-    set(value: T): void;
-    trackAndCompute(): boolean;
-    computeValue_(track: boolean): T | CaughtException;
-    suspend_(): void;
-    observe_(listener: (change: IComputedDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-    warnAboutUntrackedRead_(): void;
-    toString(): string;
-    valueOf(): T;
-    [Symbol.toPrimitive](): T;
-}
-export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;
+import { CaughtException, IDerivation, IDerivationState_, IEqualsComparer, IObservable, Lambda, TraceMode } from "../internal";
+export interface IComputedValue<T> {
+    get(): T;
+    set(value: T): void;
+}
+export interface IComputedValueOptions<T> {
+    get?: () => T;
+    set?: (value: T) => void;
+    name?: string;
+    equals?: IEqualsComparer<T>;
+    context?: any;
+    requiresReaction?: boolean;
+    keepAlive?: boolean;
+}
+export type IComputedDidChange<T = any> = {
+    type: "update";
+    observableKind: "computed";
+    object: unknown;
+    debugObjectName: string;
+    newValue: T;
+    oldValue: T | undefined;
+};
+/**
+ * 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_: Set<IDerivation>;
+    diffValue_: number;
+    runId_: number;
+    lastAccessedBy_: number;
+    lowestObserverState_: IDerivationState_;
+    unboundDepsCount_: number;
+    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_;
+    keepAlive_: boolean;
+    /**
+     * 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 `structuralComparer` 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;
+    onBOL: Set<Lambda> | undefined;
+    onBUOL: Set<Lambda> | undefined;
+    onBO(): void;
+    onBUO(): void;
+    /**
+     * Returns the current value of this computed value.
+     * Will evaluate its computation first if needed.
+     */
+    get(): T;
+    set(value: T): void;
+    trackAndCompute(): boolean;
+    computeValue_(track: boolean): T | CaughtException;
+    suspend_(): void;
+    observe_(listener: (change: IComputedDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+    warnAboutUntrackedRead_(): void;
+    toString(): string;
+    valueOf(): T;
+    [Symbol.toPrimitive](): T;
+}
+export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;

package/dist/core/derivation.d.ts

@@ -1,73 +1,73 @@
-import { IAtom, IDepTreeNode, IObservable } 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;
-    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 { IAtom, IDepTreeNode, IObservable } 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;
+    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;