mobx 6.1.8 → 6.3.2

package/dist/types/actionannotation.d.ts

@@ -1,2 +1,8 @@
-import { Annotation } from "../internal";
+import { ObservableObjectAdministration, Annotation } from "../internal";
 export declare function createActionAnnotation(name: string, options?: object): Annotation;
+export declare function createActionDescriptor(adm: ObservableObjectAdministration, annotation: Annotation, key: PropertyKey, descriptor: PropertyDescriptor, safeDescriptors?: boolean): {
+    value: Function;
+    configurable: boolean;
+    enumerable: boolean;
+    writable: boolean;
+};

package/dist/types/autoannotation.d.ts

@@ -0,0 +1,3 @@
+import { Annotation } from "../internal";
+export declare const autoAnnotation: Annotation;
+export declare function createAutoAnnotation(options?: object): Annotation;

package/dist/types/observableobject.d.ts

@@ -1,5 +1,4 @@
 import { CreateObservableOptions, Annotation, ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
-export declare const inferredAnnotationsSymbol: unique symbol;
 export declare type IObjectDidChange<T = any> = {
     observableKind: "object";
     name: PropertyKey;
@@ -31,7 +30,6 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     values_: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>;
     name_: string;
     defaultAnnotation_: Annotation;
-    autoBind_: boolean;
     keysAtom_: IAtom;
     changeListeners_: any;
     interceptors_: any;
@@ -39,14 +37,14 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     isPlainObject_: boolean;
     appliedAnnotations_?: object;
     private pendingKeys_;
-    constructor(target_: any, values_: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation, autoBind_?: boolean);
+    constructor(target_: any, values_: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation);
     getObservablePropValue_(key: PropertyKey): any;
     setObservablePropValue_(key: PropertyKey, newValue: any): boolean | null;
     get_(key: PropertyKey): any;
     /**
      * @param {PropertyKey} key
      * @param {any} value
-     * @param {Annotation|boolean} annotation true - infer from descriptor, false - copy as is
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
      * @param {boolean} proxyTrap whether it's called from proxy trap
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
@@ -54,18 +52,17 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     has_(key: PropertyKey): boolean;
     /**
      * @param {PropertyKey} key
-     * @param {Annotation|boolean} annotation true - infer from object or it's prototype, false - ignore
+     * @param {Annotation|boolean} annotation true - use default annotation, false - ignore prop
      */
     make_(key: PropertyKey, annotation: Annotation | boolean): void;
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
-     * @param {Annotation|boolean} annotation true - infer from descriptor, false - copy as is
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
      * @param {boolean} proxyTrap whether it's called from proxy trap
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
     extend_(key: PropertyKey, descriptor: PropertyDescriptor, annotation: Annotation | boolean, proxyTrap?: boolean): boolean | null;
-    inferAnnotation_(key: PropertyKey): Annotation | false;
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor

package/package.json

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

package/src/api/annotation.ts

@@ -1,17 +1,19 @@
-import {
-    ObservableObjectAdministration,
-    isGenerator,
-    isFunction,
-    autoAction,
-    isAction,
-    flow,
-    computed,
-    isFlow
-} from "../internal"
+import { ObservableObjectAdministration, isFunction } from "../internal"
+
+export const enum MakeResult {
+    Cancel,
+    Break,
+    Continue
+}
 
 export type Annotation = {
     annotationType_: string
-    make_(adm: ObservableObjectAdministration, key: PropertyKey): void
+    make_(
+        adm: ObservableObjectAdministration,
+        key: PropertyKey,
+        descriptor: PropertyDescriptor,
+        source: object
+    ): MakeResult
     extend_(
         adm: ObservableObjectAdministration,
         key: PropertyKey,
@@ -33,37 +35,6 @@ export type AnnotationsMap<T, AdditionalFields extends PropertyKey> = {
 } &
     Record<AdditionalFields, AnnotationMapEntry>
 
-/**
- * Infers the best fitting annotation from property descriptor or false if the field shoudn't be annotated
- * - getter(+setter) -> computed
- * - setter w/o getter -> false (ignore)
- * - flow -> false (ignore)
- * - generator -> flow
- * - action -> false (ignore)
- * - function -> action (optionally bound)
- * - other -> defaultAnnotation
- */
-export function inferAnnotationFromDescriptor(
-    desc: PropertyDescriptor,
-    defaultAnnotation: Annotation,
-    autoBind: boolean
-): Annotation | false {
-    if (desc.get) return computed
-    if (desc.set) return false // ignore lone setter
-    // If already wrapped in action/flow, don't do that another time, but assume it is already set up properly.
-    return isFunction(desc.value)
-        ? isGenerator(desc.value)
-            ? isFlow(desc.value)
-                ? false
-                : flow
-            : isAction(desc.value)
-            ? false
-            : autoBind
-            ? autoAction.bound
-            : autoAction
-        : defaultAnnotation
-}
-
 export function isAnnotation(thing: any) {
     return (
         // Can be function

package/src/api/flow.ts

@@ -6,7 +6,8 @@ import {
     Annotation,
     isStringish,
     storeAnnotation,
-    createFlowAnnotation
+    createFlowAnnotation,
+    createDecoratorAnnotation
 } from "../internal"
 
 export const FLOW = "flow"
@@ -28,9 +29,11 @@ interface Flow extends Annotation, PropertyDecorator {
     <R, Args extends any[]>(
         generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>
     ): (...args: Args) => CancellablePromise<R>
+    bound: Annotation & PropertyDecorator
 }
 
 const flowAnnotation = createFlowAnnotation("flow")
+const flowBoundAnnotation = createFlowAnnotation("flow.bound", { bound: true })
 
 export const flow: Flow = Object.assign(
     function flow(arg1, arg2?) {
@@ -123,6 +126,8 @@ export const flow: Flow = Object.assign(
     flowAnnotation
 )
 
+flow.bound = createDecoratorAnnotation(flowBoundAnnotation)
+
 function cancelPromise(promise) {
     if (isFunction(promise.cancel)) promise.cancel()
 }

package/src/api/makeObservable.ts

@@ -11,9 +11,8 @@ import {
     isObservableObject,
     die,
     ownKeys,
-    objectPrototype,
-    inferredAnnotationsSymbol,
-    extendObservable
+    extendObservable,
+    addHiddenProp
 } from "../internal"
 
 // Hack based on https://github.com/Microsoft/TypeScript/issues/14829#issuecomment-322267089
@@ -42,6 +41,9 @@ export function makeObservable<T extends object, AdditionalKeys extends Property
     return target
 }
 
+// proto[keysSymbol] = new Set<PropertyKey>()
+const keysSymbol = Symbol("mobx-keys")
+
 export function makeAutoObservable<T extends object, AdditionalKeys extends PropertyKey = never>(
     target: T,
     overrides?: AnnotationsMap<T, NoInfer<AdditionalKeys>>,
@@ -54,44 +56,33 @@ export function makeAutoObservable<T extends object, AdditionalKeys extends Prop
             die(`makeAutoObservable can only be used on objects not already made observable`)
     }
 
-    // Optimization (avoids visiting protos)
-    // assumes that annotation.make_/.extend_ works the same for plain objects
+    // Optimization: avoid visiting protos
+    // Assumes that annotation.make_/.extend_ works the same for plain objects
     if (isPlainObject(target)) {
         return extendObservable(target, target, overrides, options)
     }
 
     const adm: ObservableObjectAdministration = asObservableObject(target, options)[$mobx]
+
+    // Optimization: cache keys on proto
+    // Assumes makeAutoObservable can be called only once per object and can't be used in subclass
+    if (!target[keysSymbol]) {
+        const proto = Object.getPrototypeOf(target)
+        const keys = new Set([...ownKeys(target), ...ownKeys(proto)])
+        keys.delete("constructor")
+        keys.delete($mobx)
+        addHiddenProp(proto, keysSymbol, keys)
+    }
+
     startBatch()
     try {
-        // Use cached inferred annotations if available (only in classes)
-        if (target[inferredAnnotationsSymbol]) {
-            target[inferredAnnotationsSymbol].forEach((value, key) => adm.make_(key, value))
-            // Overrides are not cached, unless `true`, see #2832
-            if (overrides) {
-                ownKeys(overrides).forEach(key => {
-                    const annotation = overrides[key]
-                    if (annotation !== true) {
-                        adm.make_(key, annotation)
-                    }
-                })
-            }
-        } else {
-            const ignoreKeys = { [$mobx]: 1, [inferredAnnotationsSymbol]: 1, constructor: 1 }
-            const make = key => {
-                if (ignoreKeys[key]) return
-                ignoreKeys[key] = 1
-                adm.make_(
-                    key,
-                    // must pass "undefined" for { key: undefined }
-                    !overrides ? true : key in overrides ? overrides[key] : true
-                )
-            }
-            let current = target
-            while (current && current !== objectPrototype) {
-                ownKeys(current).forEach(make)
-                current = Object.getPrototypeOf(current)
-            }
-        }
+        target[keysSymbol].forEach(key =>
+            adm.make_(
+                key,
+                // must pass "undefined" for { key: undefined }
+                !overrides ? true : key in overrides ? overrides[key] : true
+            )
+        )
     } finally {
         endBatch()
     }

package/src/api/object-api.ts

@@ -158,3 +158,17 @@ export function get(obj: any, key: any): any {
     }
     die(11)
 }
+
+export function apiDefineProperty(obj: Object, key: PropertyKey, descriptor: PropertyDescriptor) {
+    if (isObservableObject(obj)) {
+        return ((obj as any) as IIsObservableObject)[$mobx].defineProperty_(key, descriptor)
+    }
+    die(39)
+}
+
+export function apiOwnKeys(obj: Object) {
+    if (isObservableObject(obj)) {
+        return ((obj as any) as IIsObservableObject)[$mobx].ownKeys_()
+    }
+    die(38)
+}

package/src/api/observable.ts

@@ -28,7 +28,8 @@ import {
     globalState,
     assign,
     isStringish,
-    createObservableAnnotation
+    createObservableAnnotation,
+    createAutoAnnotation
 } from "../internal"
 
 export const OBSERVABLE = "observable"
@@ -82,13 +83,7 @@ export function getEnhancerFromOptions(options: CreateObservableOptions): IEnhan
 export function getAnnotationFromOptions(
     options?: CreateObservableOptions
 ): Annotation | undefined {
-    return options
-        ? options.deep === true
-            ? observableAnnotation
-            : options.deep === false
-            ? observableRefAnnotation
-            : options.defaultDecorator
-        : undefined
+    return options ? options.defaultDecorator ?? createAutoAnnotation(options) : undefined
 }
 
 export function getEnhancerFromAnnotation(annotation?: Annotation): IEnhancer<any> {

package/src/api/tojs.ts

@@ -1,12 +1,13 @@
 import {
-    keys,
     isObservable,
     isObservableArray,
     isObservableValue,
     isObservableMap,
     isObservableSet,
-    getPlainObjectKeys,
-    die
+    isComputedValue,
+    die,
+    apiOwnKeys,
+    objectPrototype
 } from "../internal"
 
 function cache<K, V>(map: Map<any, any>, key: K, value: V): V {
@@ -23,7 +24,8 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
     )
         return source
 
-    if (isObservableValue(source)) return toJSHelper(source.get(), __alreadySeen)
+    if (isObservableValue(source) || isComputedValue(source))
+        return toJSHelper(source.get(), __alreadySeen)
     if (__alreadySeen.has(source)) {
         return __alreadySeen.get(source)
     }
@@ -49,10 +51,11 @@ function toJSHelper(source, __alreadySeen: Map<any, any>) {
         return res
     } else {
         // must be observable object
-        keys(source) // make sure keys are observed
         const res = cache(__alreadySeen, source, {})
-        getPlainObjectKeys(source).forEach((key: any) => {
-            res[key] = toJSHelper(source[key], __alreadySeen)
+        apiOwnKeys(source).forEach((key: any) => {
+            if (objectPrototype.propertyIsEnumerable.call(source, key)) {
+                res[key] = toJSHelper(source[key], __alreadySeen)
+            }
         })
         return res
     }

package/src/core/observable.ts

@@ -206,12 +206,16 @@ export function propagateChangeConfirmed(observable: IObservable) {
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
     observable.observers_.forEach(d => {
-        if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_)
+        if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_) {
             d.dependenciesState_ = IDerivationState_.STALE_
-        else if (
+            if (__DEV__ && d.isTracing_ !== TraceMode.NONE) {
+                logTraceInfo(d, observable)
+            }
+        } else if (
             d.dependenciesState_ === IDerivationState_.UP_TO_DATE_ // this happens during computing of `d`, just keep lowestObserverState up to date.
-        )
+        ) {
             observable.lowestObserverState_ = IDerivationState_.UP_TO_DATE_
+        }
     })
     // invariantLOS(observable, "confirmed end");
 }
@@ -225,9 +229,6 @@ export function propagateMaybeChanged(observable: IObservable) {
     observable.observers_.forEach(d => {
         if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
             d.dependenciesState_ = IDerivationState_.POSSIBLY_STALE_
-            if (__DEV__ && d.isTracing_ !== TraceMode.NONE) {
-                logTraceInfo(d, observable)
-            }
             d.onBecomeStale_()
         }
     })

package/src/errors.ts

@@ -3,6 +3,17 @@ const niceErrors = {
     1(annotationType, key: PropertyKey) {
         return `Cannot apply '${annotationType}' to '${key.toString()}': Field not found.`
     },
+    /*
+    2(prop) {
+        return `invalid decorator for '${prop.toString()}'`
+    },
+    3(prop) {
+        return `Cannot decorate '${prop.toString()}': action can only be used on properties with a function value.`
+    },
+    4(prop) {
+        return `Cannot decorate '${prop.toString()}': computed can only be used on getter properties.`
+    },
+    */
     5: "'keys()' can only be used on observable objects, arrays, sets and maps",
     6: "'values()' can only be used on observable objects, arrays, sets and maps",
     7: "'entries()' can only be used on observable objects, arrays and maps",
@@ -59,7 +70,9 @@ const niceErrors = {
     36: "isolateGlobalState should be called before MobX is running any reactions",
     37(method) {
         return `[mobx] \`observableArray.${method}()\` mutates the array in-place, which is not allowed inside a derivation. Use \`array.slice().${method}()\` instead`
-    }
+    },
+    38: "'ownKeys()' can only be used on observable objects",
+    39: "'defineProperty()' can only be used on observable objects"
 } as const
 
 const errors: typeof niceErrors = __DEV__ ? niceErrors : ({} as any)

package/src/internal.ts

@@ -17,6 +17,7 @@ export * from "./types/actionannotation"
 export * from "./types/flowannotation"
 export * from "./types/computedannotation"
 export * from "./types/observableannotation"
+export * from "./types/autoannotation"
 export * from "./api/observable"
 export * from "./api/computed"
 export * from "./core/action"

package/src/mobx.ts

@@ -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,

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)
+}