mobx 6.1.8 → 6.9.0

package/src/mobx.ts

@@ -2,7 +2,7 @@
  * (c) Michel Weststrate 2015 - 2020
  * MIT Licensed
  *
- * Welcome to the mobx sources! To get an global overview of how MobX internally works,
+ * Welcome to the mobx sources! To get a global overview of how MobX internally works,
  * this is a good place to start:
  * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
  *
@@ -17,7 +17,7 @@
  */
 import { die } from "./errors"
 import { getGlobal } from "./utils/global"
-;["Symbol", "Map", "Set", "Symbol"].forEach(m => {
+;["Symbol", "Map", "Set"].forEach(m => {
     let g = getGlobal()
     if (typeof g[m] === "undefined") {
         die(`MobX requires global '${m}' to be available or polyfilled`)
@@ -75,6 +75,7 @@ export {
     IObservableFactory,
     CreateObservableOptions,
     computed,
+    IComputedFactory,
     isObservable,
     isObservableProp,
     isComputed,
@@ -99,10 +100,13 @@ export {
     remove,
     has,
     get,
+    apiOwnKeys as ownKeys,
+    apiDefineProperty as defineProperty,
     configure,
     onBecomeObserved,
     onBecomeUnobserved,
     flow,
+    isFlow,
     flowResult,
     FlowCancellationError,
     isFlowCancellationError,

package/src/types/actionannotation.ts

@@ -3,14 +3,11 @@ import {
     createAction,
     isAction,
     defineProperty,
-    getDescriptor,
-    objectPrototype,
     die,
     isFunction,
     Annotation,
-    recordAnnotationApplied,
     globalState,
-    storedAnnotationsSymbol
+    MakeResult
 } from "../internal"
 
 export function createActionAnnotation(name: string, options?: object): Annotation {
@@ -22,54 +19,33 @@ export function createActionAnnotation(name: string, options?: object): Annotati
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let annotated = false
-    let source = adm.target_
-    let bound = this.options_?.bound ?? false
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            // Instance or bound
-            // Keep first because the operation can be intercepted
-            // and we don't want to end up with partially annotated proto chain
-            if (source === adm.target_ || bound) {
-                const actionDescriptor = createActionDescriptor(adm, this, key, descriptor)
-                const definePropertyOutcome = adm.defineProperty_(key, actionDescriptor)
-                if (!definePropertyOutcome) {
-                    // Intercepted
-                    return
-                }
-                annotated = true
-                // Don't annotate protos if bound
-                if (bound) {
-                    break
-                }
-            }
-            // Prototype
-            if (source !== adm.target_) {
-                if (isAction(descriptor.value)) {
-                    // A prototype could have been annotated already by other constructor,
-                    // rest of the proto chain must be annotated already
-                    annotated = true
-                    break
-                }
-                const actionDescriptor = createActionDescriptor(adm, this, key, descriptor, false)
-                defineProperty(source, key, actionDescriptor)
-                annotated = true
-            }
-        }
-        source = Object.getPrototypeOf(source)
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor,
+    source: object
+): MakeResult {
+    // bound
+    if (this.options_?.bound) {
+        return this.extend_(adm, key, descriptor, false) === null
+            ? MakeResult.Cancel
+            : MakeResult.Break
+    }
+    // own
+    if (source === adm.target_) {
+        return this.extend_(adm, key, descriptor, false) === null
+            ? MakeResult.Cancel
+            : MakeResult.Continue
     }
-    if (annotated) {
-        recordAnnotationApplied(adm, this, key)
-    } else if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
-        // Throw on missing key, except for decorators:
-        // Decorator annotations are collected from whole prototype chain.
-        // When called from super() some props may not exist yet.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
+    // prototype
+    if (isAction(descriptor.value)) {
+        // A prototype could have been annotated already by other constructor,
+        // rest of the proto chain must be annotated already
+        return MakeResult.Break
     }
+    const actionDescriptor = createActionDescriptor(adm, this, key, descriptor, false)
+    defineProperty(source, key, actionDescriptor)
+    return MakeResult.Continue
 }
 
 function extend_(
@@ -96,7 +72,7 @@ function assertActionDescriptor(
     }
 }
 
-function createActionDescriptor(
+export function createActionDescriptor(
     adm: ObservableObjectAdministration,
     annotation: Annotation,
     key: PropertyKey,
@@ -113,7 +89,9 @@ function createActionDescriptor(
         value: createAction(
             annotation.options_?.name ?? key.toString(),
             value,
-            annotation.options_?.autoAction ?? false
+            annotation.options_?.autoAction ?? false,
+            // https://github.com/mobxjs/mobx/discussions/3140
+            annotation.options_?.bound ? adm.proxy_ ?? adm.target_ : undefined
         ),
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass

package/src/types/autoannotation.ts

@@ -0,0 +1,107 @@
+import {
+    ObservableObjectAdministration,
+    observable,
+    Annotation,
+    defineProperty,
+    createAction,
+    globalState,
+    flow,
+    computed,
+    autoAction,
+    isGenerator,
+    MakeResult
+} from "../internal"
+
+const AUTO = "true"
+
+export const autoAnnotation: Annotation = createAutoAnnotation()
+
+export function createAutoAnnotation(options?: object): Annotation {
+    return {
+        annotationType_: AUTO,
+        options_: options,
+        make_,
+        extend_
+    }
+}
+
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor,
+    source: object
+): MakeResult {
+    // getter -> computed
+    if (descriptor.get) {
+        return computed.make_(adm, key, descriptor, source)
+    }
+    // lone setter -> action setter
+    if (descriptor.set) {
+        // TODO make action applicable to setter and delegate to action.make_
+        const set = createAction(key.toString(), descriptor.set) as (v: any) => void
+        // own
+        if (source === adm.target_) {
+            return adm.defineProperty_(key, {
+                configurable: globalState.safeDescriptors ? adm.isPlainObject_ : true,
+                set
+            }) === null
+                ? MakeResult.Cancel
+                : MakeResult.Continue
+        }
+        // proto
+        defineProperty(source, key, {
+            configurable: true,
+            set
+        })
+        return MakeResult.Continue
+    }
+    // function on proto -> autoAction/flow
+    if (source !== adm.target_ && typeof descriptor.value === "function") {
+        if (isGenerator(descriptor.value)) {
+            const flowAnnotation = this.options_?.autoBind ? flow.bound : flow
+            return flowAnnotation.make_(adm, key, descriptor, source)
+        }
+        const actionAnnotation = this.options_?.autoBind ? autoAction.bound : autoAction
+        return actionAnnotation.make_(adm, key, descriptor, source)
+    }
+    // other -> observable
+    // Copy props from proto as well, see test:
+    // "decorate should work with Object.create"
+    let observableAnnotation = this.options_?.deep === false ? observable.ref : observable
+    // if function respect autoBind option
+    if (typeof descriptor.value === "function" && this.options_?.autoBind) {
+        descriptor.value = descriptor.value.bind(adm.proxy_ ?? adm.target_)
+    }
+    return observableAnnotation.make_(adm, key, descriptor, source)
+}
+
+function extend_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor,
+    proxyTrap: boolean
+): boolean | null {
+    // getter -> computed
+    if (descriptor.get) {
+        return computed.extend_(adm, key, descriptor, proxyTrap)
+    }
+    // lone setter -> action setter
+    if (descriptor.set) {
+        // TODO make action applicable to setter and delegate to action.extend_
+        return adm.defineProperty_(
+            key,
+            {
+                configurable: globalState.safeDescriptors ? adm.isPlainObject_ : true,
+                set: createAction(key.toString(), descriptor.set) as (v: any) => void
+            },
+            proxyTrap
+        )
+    }
+    // other -> observable
+    // if function respect autoBind option
+    if (typeof descriptor.value === "function" && this.options_?.autoBind) {
+        descriptor.value = descriptor.value.bind(adm.proxy_ ?? adm.target_)
+    }
+    let observableAnnotation = this.options_?.deep === false ? observable.ref : observable
+    return observableAnnotation.extend_(adm, key, descriptor, proxyTrap)
+}

package/src/types/computedannotation.ts

@@ -1,12 +1,4 @@
-import {
-    ObservableObjectAdministration,
-    getDescriptor,
-    objectPrototype,
-    die,
-    Annotation,
-    recordAnnotationApplied,
-    storedAnnotationsSymbol
-} from "../internal"
+import { ObservableObjectAdministration, die, Annotation, MakeResult } from "../internal"
 
 export function createComputedAnnotation(name: string, options?: object): Annotation {
     return {
@@ -17,34 +9,12 @@ export function createComputedAnnotation(name: string, options?: object): Annota
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let source = adm.target_
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            assertComputedDescriptor(adm, this, key, descriptor)
-            const definePropertyOutcome = adm.defineComputedProperty_(key, {
-                ...this.options_,
-                get: descriptor.get,
-                set: descriptor.set
-            })
-            if (!definePropertyOutcome) {
-                // Intercepted
-                return
-            }
-            recordAnnotationApplied(adm, this, key)
-            return
-        }
-        source = Object.getPrototypeOf(source)
-    }
-    if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
-        // Throw on missing key, except for decorators:
-        // Decorator annotations are collected from whole prototype chain.
-        // When called from super() some props may not exist yet.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
-    }
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor
+): MakeResult {
+    return this.extend_(adm, key, descriptor, false) === null ? MakeResult.Cancel : MakeResult.Break
 }
 
 function extend_(

package/src/types/dynamicobject.ts

@@ -19,17 +19,20 @@ function getAdm(target): ObservableObjectAdministration {
 // and skip either the internal values map, or the base object with its property descriptors!
 const objectProxyTraps: ProxyHandler<any> = {
     has(target: IIsObservableObject, name: PropertyKey): boolean {
-        if (__DEV__ && globalState.trackingDerivation)
+        if (__DEV__ && globalState.trackingDerivation) {
             warnAboutProxyRequirement(
                 "detect new properties using the 'in' operator. Use 'has' from 'mobx' instead."
             )
+        }
         return getAdm(target).has_(name)
     },
     get(target: IIsObservableObject, name: PropertyKey): any {
         return getAdm(target).get_(name)
     },
     set(target: IIsObservableObject, name: PropertyKey, value: any): boolean {
-        if (!isStringish(name)) return false
+        if (!isStringish(name)) {
+            return false
+        }
         if (__DEV__ && !getAdm(target).values_.has(name)) {
             warnAboutProxyRequirement(
                 "add a new observable property through direct assignment. Use 'set' from 'mobx' instead."
@@ -44,7 +47,9 @@ const objectProxyTraps: ProxyHandler<any> = {
                 "delete properties from an observable object. Use 'remove' from 'mobx' instead."
             )
         }
-        if (!isStringish(name)) return false
+        if (!isStringish(name)) {
+            return false
+        }
         // null (intercepted) -> true (success)
         return getAdm(target).delete_(name, true) ?? true
     },
@@ -61,11 +66,12 @@ const objectProxyTraps: ProxyHandler<any> = {
         // null (intercepted) -> true (success)
         return getAdm(target).defineProperty_(name, descriptor) ?? true
     },
-    ownKeys(target: IIsObservableObject): PropertyKey[] {
-        if (__DEV__ && globalState.trackingDerivation)
+    ownKeys(target: IIsObservableObject): ArrayLike<string | symbol> {
+        if (__DEV__ && globalState.trackingDerivation) {
             warnAboutProxyRequirement(
-                "iterate keys to detect added / removed properties. Use `keys` from 'mobx' instead."
+                "iterate keys to detect added / removed properties. Use 'keys' from 'mobx' instead."
             )
+        }
         return getAdm(target).ownKeys_()
     },
     preventExtensions(target) {

package/src/types/flowannotation.ts

@@ -2,15 +2,13 @@ import {
     ObservableObjectAdministration,
     Annotation,
     defineProperty,
-    getDescriptor,
-    objectPrototype,
     die,
     flow,
     isFlow,
-    recordAnnotationApplied,
     isFunction,
     globalState,
-    storedAnnotationsSymbol
+    MakeResult,
+    hasProp
 } from "../internal"
 
 export function createFlowAnnotation(name: string, options?: object): Annotation {
@@ -22,44 +20,33 @@ export function createFlowAnnotation(name: string, options?: object): Annotation
     }
 }
 
-function make_(adm: ObservableObjectAdministration, key: PropertyKey): void {
-    let annotated = false
-    let source = adm.target_
-    while (source && source !== objectPrototype) {
-        const descriptor = getDescriptor(source, key)
-        if (descriptor) {
-            if (source !== adm.target_) {
-                // Prototype
-                if (isFlow(descriptor.value)) {
-                    // A prototype could have been annotated already by other constructor,
-                    // rest of the proto chain must be annotated already
-                    annotated = true
-                    break
-                }
-                const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false)
-                defineProperty(source, key, flowDescriptor)
-            } else {
-                const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor)
-                const definePropertyOutcome = adm.defineProperty_(key, flowDescriptor)
-                if (!definePropertyOutcome) {
-                    // Intercepted
-                    return
-                }
-            }
-            annotated = true
+function make_(
+    adm: ObservableObjectAdministration,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor,
+    source: object
+): MakeResult {
+    // own
+    if (source === adm.target_) {
+        return this.extend_(adm, key, descriptor, false) === null
+            ? MakeResult.Cancel
+            : MakeResult.Continue
+    }
+    // prototype
+    // bound - must annotate protos to support super.flow()
+    if (this.options_?.bound && (!hasProp(adm.target_, key) || !isFlow(adm.target_[key]))) {
+        if (this.extend_(adm, key, descriptor, false) === null) {
+            return MakeResult.Cancel
         }
-        source = Object.getPrototypeOf(source)
     }
-    if (annotated) {
-        recordAnnotationApplied(adm, this, key)
-    } else if (!adm.target_[storedAnnotationsSymbol]?.[key]) {
-        // Throw on missing key, except for decorators:
-        // Decorator annotations are collected from whole prototype chain.
-        // When called from super() some props may not exist yet.
-        // However we don't have to worry about missing prop,
-        // because the decorator must have been applied to something.
-        die(1, this.annotationType_, `${adm.name_}.${key.toString()}`)
+    if (isFlow(descriptor.value)) {
+        // A prototype could have been annotated already by other constructor,
+        // rest of the proto chain must be annotated already
+        return MakeResult.Break
     }
+    const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false, false)
+    defineProperty(source, key, flowDescriptor)
+    return MakeResult.Continue
 }
 
 function extend_(
@@ -68,7 +55,7 @@ function extend_(
     descriptor: PropertyDescriptor,
     proxyTrap: boolean
 ): boolean | null {
-    const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor)
+    const flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, this.options_?.bound)
     return adm.defineProperty_(key, flowDescriptor, proxyTrap)
 }
 
@@ -91,12 +78,24 @@ function createFlowDescriptor(
     annotation: Annotation,
     key: PropertyKey,
     descriptor: PropertyDescriptor,
+    bound: boolean,
     // provides ability to disable safeDescriptors for prototypes
     safeDescriptors: boolean = globalState.safeDescriptors
 ): 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(descriptor.value),
+        value,
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass
         configurable: safeDescriptors ? adm.isPlainObject_ : true,

package/src/types/intercept-utils.ts

@@ -18,7 +18,9 @@ export function registerInterceptor<T>(
     interceptors.push(handler)
     return once(() => {
         const idx = interceptors.indexOf(handler)
-        if (idx !== -1) interceptors.splice(idx, 1)
+        if (idx !== -1) {
+            interceptors.splice(idx, 1)
+        }
     })
 }
 
@@ -32,8 +34,12 @@ export function interceptChange<T>(
         const interceptors = [...(interceptable.interceptors_ || [])]
         for (let i = 0, l = interceptors.length; i < l; i++) {
             change = interceptors[i](change)
-            if (change && !(change as any).type) die(14)
-            if (!change) break
+            if (change && !(change as any).type) {
+                die(14)
+            }
+            if (!change) {
+                break
+            }
         }
         return change
     } finally {

package/src/types/legacyobservablearray.ts

@@ -14,6 +14,21 @@ import {
     defineProperty
 } from "../internal"
 
+// Bug in safari 9.* (or iOS 9 safari mobile). See #364
+const ENTRY_0 = createArrayEntryDescriptor(0)
+
+const safariPrototypeSetterInheritanceBug = (() => {
+    let v = false
+    const p = {}
+    Object.defineProperty(p, "0", {
+        set: () => {
+            v = true
+        }
+    })
+    Object.create(p)["0"] = 1
+    return v === false
+})()
+
 /**
  * This array buffer contains two lists of properties, so that all arrays
  * can recycle their property definitions, which significantly improves performance of creating
@@ -57,6 +72,12 @@ class LegacyObservableArray<T> extends StubArray {
             this.spliceWithArray(0, 0, initialValues)
             allowStateChangesEnd(prev)
         }
+
+        if (safariPrototypeSetterInheritanceBug) {
+            // Seems that Safari won't use numeric prototype setter untill any * numeric property is
+            // defined on the instance. After that it works fine, even if this property is deleted.
+            Object.defineProperty(this, "0", ENTRY_0)
+        }
     }
 
     concat(...arrays: T[][]): T[] {
@@ -85,7 +106,6 @@ class LegacyObservableArray<T> extends StubArray {
         let nextIndex = 0
         return makeIterable({
             next() {
-                // @ts-ignore
                 return nextIndex < self.length
                     ? { value: self[nextIndex++], done: false }
                     : { done: true, value: undefined }
@@ -95,7 +115,9 @@ class LegacyObservableArray<T> extends StubArray {
 }
 
 Object.entries(arrayExtensions).forEach(([prop, fn]) => {
-    if (prop !== "concat") addHiddenProp(LegacyObservableArray.prototype, prop, fn)
+    if (prop !== "concat") {
+        addHiddenProp(LegacyObservableArray.prototype, prop, fn)
+    }
 })
 
 function createArrayEntryDescriptor(index: number) {
@@ -117,8 +139,9 @@ function createArrayBufferItem(index: number) {
 
 export function reserveArrayBuffer(max: number) {
     if (max > OBSERVABLE_ARRAY_BUFFER_SIZE) {
-        for (let index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max + 100; index++)
+        for (let index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max + 100; index++) {
             createArrayBufferItem(index)
+        }
         OBSERVABLE_ARRAY_BUFFER_SIZE = max
     }
 }

package/src/types/listen-utils.ts

@@ -13,14 +13,18 @@ export function registerListener(listenable: IListenable, handler: Function): La
     listeners.push(handler)
     return once(() => {
         const idx = listeners.indexOf(handler)
-        if (idx !== -1) listeners.splice(idx, 1)
+        if (idx !== -1) {
+            listeners.splice(idx, 1)
+        }
     })
 }
 
 export function notifyListeners<T>(listenable: IListenable, change: T) {
     const prevU = untrackedStart()
     let listeners = listenable.changeListeners_
-    if (!listeners) return
+    if (!listeners) {
+        return
+    }
     listeners = listeners.slice()
     for (let i = 0, l = listeners.length; i < l; i++) {
         listeners[i](change)