Fixed circular dependency problem with Atoms

src/core/atom.ts

@@ -1,62 +1,74 @@
-export interface IAtom extends IObservable {}
+export interface IAtom extends IObservable {
+    reportObserved()
+    reportChanged()
+}
 
 /**
  * Anything that can be used to _store_ state is an Atom in mobx. Atoms have two important jobs
  *
  * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used
  * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.
  */
-export class BaseAtom implements IAtom {
-    isPendingUnobservation = false // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
-    isBeingObserved = false
-    observers = []
-    observersIndexes = {}
+export let Atom: new (name: string) => IAtom
+export let isAtom: (thing: any) => thing is IAtom
+
+export function declareAtom() {
+    if (Atom) return
+
+    Atom = class AtomImpl implements IAtom {
+        isPendingUnobservation = false // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed
+        isBeingObserved = false
+        observers = []
+        observersIndexes = {}
 
-    diffValue = 0
-    lastAccessedBy = 0
-    lowestObserverState = IDerivationState.NOT_TRACKING
-    /**
+        diffValue = 0
+        lastAccessedBy = 0
+        lowestObserverState = IDerivationState.NOT_TRACKING
+        /**
      * 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(public name = "Atom@" + getNextId()) {}
+        constructor(public name = "Atom@" + getNextId()) {}
 
-    public onBecomeUnobserved() {
-        // noop
-    }
+        public onBecomeUnobserved() {
+            // noop
+        }
 
-    public onBecomeObserved() {
-        /* noop */
-    }
+        public onBecomeObserved() {
+            /* noop */
+        }
 
-    /**
+        /**
      * Invoke this method to notify mobx that your atom has been used somehow.
      * Returns true if there is currently a reactive context.
      */
-    public reportObserved(): boolean {
-        return reportObserved(this)
-    }
+        public reportObserved(): boolean {
+            return reportObserved(this)
+        }
 
-    /**
+        /**
      * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.
      */
-    public reportChanged() {
-        startBatch()
-        propagateChanged(this)
-        endBatch()
-    }
+        public reportChanged() {
+            startBatch()
+            propagateChanged(this)
+            endBatch()
+        }
 
-    toString() {
-        return this.name
+        toString() {
+            return this.name
+        }
     }
+
+    isAtom = createInstanceofPredicate("Atom", Atom)
 }
 
 export function createAtom(
     name: string,
     onBecomeObservedHandler: () => void = noop,
     onBecomeUnobservedHandler: () => void = noop
 ): IAtom {
-    const atom = new BaseAtom(name)
+    const atom = new Atom(name)
     onBecomeObserved(atom, onBecomeObservedHandler)
     onBecomeUnobserved(atom, onBecomeUnobservedHandler)
     return atom
@@ -67,5 +79,3 @@ import { IObservable, propagateChanged, reportObserved, startBatch, endBatch } f
 import { IDerivationState } from "./derivation"
 import { createInstanceofPredicate, noop, getNextId } from "../utils/utils"
 import { onBecomeObserved, onBecomeUnobserved } from "../api/become-observed"
-
-export const isAtom = createInstanceofPredicate("Atom", BaseAtom)

src/mobx.ts

@@ -15,16 +15,9 @@
  * - utils/   Utility stuff.
  *
  */
-
 export { IObservable, IDepTreeNode } from "./core/observable"
 export { Reaction, IReactionPublic, IReactionDisposer } from "./core/reaction"
 export { IDerivation, untracked, IDerivationState } from "./core/derivation"
-
-// NOTE: For some reason, rollup's dependency tracker gets confused
-// if this line is above the previous 3, and will produce out of order
-// class definitions where BaseAtom is undefined, causing an error.
-// It's not ideal, but for now we can just make sure this line comes after
-// the ones above
 export { IAtom, createAtom } from "./core/atom"
 
 export { useStrict, IAction } from "./core/action"
@@ -35,13 +28,13 @@ export { IEqualsComparer, comparer } from "./types/comparer"
 export { IModifierDescriptor, IEnhancer, isModifierDescriptor } from "./types/modifiers"
 export { IInterceptable, IInterceptor } from "./types/intercept-utils"
 export { IListenable } from "./types/listen-utils"
+
 export {
     IObjectWillChange,
     IObjectChange,
     IObservableObject,
     isObservableObject
 } from "./types/observableobject"
-
 export {
     IValueDidChange,
     IValueWillChange,

src/types/observablearray.ts

@@ -9,7 +9,7 @@ import {
     addHiddenProp,
     invariant
 } from "../utils/utils"
-import { BaseAtom } from "../core/atom"
+import { Atom, IAtom } from "../core/atom"
 import { checkIfStateModificationsAreAllowed } from "../core/derivation"
 import {
     IInterceptable,
@@ -147,7 +147,7 @@ if (Object.isFrozen(Array)) {
 
 class ObservableArrayAdministration<T>
     implements IInterceptable<IArrayWillChange<T> | IArrayWillSplice<T>>, IListenable {
-    atom: BaseAtom
+    atom: IAtom
     values: T[] = []
     lastKnownLength: number = 0
     interceptors = null
@@ -161,7 +161,7 @@ class ObservableArrayAdministration<T>
         public array: IObservableArray<T>,
         public owned: boolean
     ) {
-        this.atom = new BaseAtom(name || "ObservableArray@" + getNextId())
+        this.atom = new Atom(name || "ObservableArray@" + getNextId())
         this.enhancer = (newV, oldV) => enhancer(newV, oldV, name + "[..]")
     }
 

src/types/observablevalue.ts

@@ -1,4 +1,4 @@
-import { BaseAtom } from "../core/atom"
+import { Atom, declareAtom } from "../core/atom"
 import { checkIfStateModificationsAreAllowed } from "../core/derivation"
 import {
     Lambda,
@@ -41,7 +41,9 @@ export interface IObservableValue<T> {
 
 declare var Symbol
 
-export class ObservableValue<T> extends BaseAtom
+declareAtom()
+
+export class ObservableValue<T> extends Atom
     implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
     hasUnreportedChange = false
     interceptors