mobx 6.3.9 → 6.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.3.9",
+    "version": "6.3.13",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/api/tojs.ts

@@ -62,7 +62,10 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
 }
 
 /**
- * Basically, a deep clone, so that no reactive property will exist anymore.
+ * Recursively converts an observable to it's non-observable native counterpart.
+ * It does NOT recurse into non-observables, these are left as they are, even if they contain observables.
+ * Computed and other non-enumerable properties are completely ignored.
+ * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.
  */
 export function toJS<T>(source: T, options?: any): T {
     if (__DEV__ && options) die("toJS no longer supports options")

package/src/types/flowannotation.ts

@@ -7,7 +7,8 @@ import {
     isFlow,
     isFunction,
     globalState,
-    MakeResult
+    MakeResult,
+    hasProp
 } from "../internal"
 
 export function createFlowAnnotation(name: string, options?: object): Annotation {
@@ -33,7 +34,7 @@ function make_(
     }
     // prototype
     // bound - must annotate protos to support super.flow()
-    if (this.options_?.bound && !isFlow(adm.target_[key])) {
+    if (this.options_?.bound && (!hasProp(adm.target_, key) || !isFlow(adm.target_[key]))) {
         if (this.extend_(adm, key, descriptor, false) === null) return MakeResult.Cancel
     }
     if (isFlow(descriptor.value)) {
@@ -81,11 +82,18 @@ function createFlowDescriptor(
 ): PropertyDescriptor {
     assertFlowDescriptor(adm, annotation, key, descriptor)
     let { value } = descriptor
+    // In case of flow.bound, the descriptor can be from already annotated prototype
+    if (!isFlow(value)) {
+        value = flow(value)
+    }
     if (bound) {
+        // We do not keep original function around, so we bind the existing flow
         value = value.bind(adm.proxy_ ?? adm.target_)
+        // This is normally set by `flow`, but `bind` returns new function...
+        value.isMobXFlow = true
     }
     return {
-        value: flow(value),
+        value,
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass
         configurable: safeDescriptors ? adm.isPlainObject_ : true,

package/src/types/observablemap.ts

@@ -34,7 +34,8 @@ import {
     isFunction,
     UPDATE,
     IAtom,
-    PureSpyEvent
+    PureSpyEvent,
+    allowStateChanges
 } from "../internal"
 
 export interface IKeyValueMap<V = any> {
@@ -107,7 +108,9 @@ export class ObservableMap<K = any, V = any>
         this.keysAtom_ = createAtom(__DEV__ ? `${this.name_}.keys()` : "ObservableMap.keys()")
         this.data_ = new Map()
         this.hasMap_ = new Map()
-        this.merge(initialData)
+        allowStateChanges(true, () => {
+            this.merge(initialData)
+        })
     }
 
     private has_(key: K): boolean {

package/src/utils/eq.ts

@@ -28,7 +28,7 @@ function eq(a: any, b: any, depth: number, aStack?: any[], bStack?: any[]) {
     if (a !== a) return b !== b
     // Exhaust primitive checks
     const type = typeof a
-    if (!isFunction(type) && type !== "object" && typeof b != "object") return false
+    if (type !== "function" && type !== "object" && typeof b != "object") return false
 
     // Compare `[[Class]]` names.
     const className = toString.call(a)