mobx 6.16.0 → 7.0.0

package/src/types/observablearray.ts

@@ -5,9 +5,7 @@ import {
     IAtom,
     IEnhancer,
     IInterceptable,
-    IInterceptor,
     IListenable,
-    Lambda,
     addHiddenFinalProp,
     checkIfStateModificationsAreAllowed,
     createInstanceofPredicate,
@@ -18,12 +16,8 @@ import {
     isObject,
     isSpyEnabled,
     notifyListeners,
-    registerInterceptor,
-    registerListener,
     spyReportEnd,
     spyReportStart,
-    assertProxies,
-    reserveArrayBuffer,
     hasProp,
     die,
     globalState,
@@ -130,8 +124,7 @@ export class ObservableArrayAdministration
     constructor(
         name = __DEV__ ? "ObservableArray@" + getNextId() : "ObservableArray",
         enhancer: IEnhancer<any>,
-        public owned_: boolean,
-        public legacyMode_: boolean
+        public owned_: boolean
     ) {
         this.atom_ = new Atom(name)
         this.enhancer_ = (newV, oldV) =>
@@ -152,30 +145,6 @@ export class ObservableArrayAdministration
         return values
     }
 
-    intercept_(handler: IInterceptor<IArrayWillChange<any> | IArrayWillSplice<any>>): Lambda {
-        return registerInterceptor<IArrayWillChange<any> | IArrayWillSplice<any>>(this, handler)
-    }
-
-    observe_(
-        listener: (changeData: IArrayDidChange<any>) => void,
-        fireImmediately = false
-    ): Lambda {
-        if (fireImmediately) {
-            listener(<IArraySplice<any>>{
-                observableKind: "array",
-                object: this.proxy_ as any,
-                debugObjectName: this.atom_.name_,
-                type: "splice",
-                index: 0,
-                added: this.values_.slice(),
-                addedCount: this.values_.length,
-                removed: [],
-                removedCount: 0
-            })
-        }
-        return registerListener(this, listener)
-    }
-
     getArrayLength_(): number {
         this.atom_.reportObserved()
         return this.values_.length
@@ -183,16 +152,13 @@ export class ObservableArrayAdministration
 
     setArrayLength_(newLength: number) {
         if (typeof newLength !== "number" || isNaN(newLength) || newLength < 0) {
-            die("Out of range: " + newLength)
+            die(40, newLength)
         }
         let currentLength = this.values_.length
         if (newLength === currentLength) {
             return
         } else if (newLength > currentLength) {
-            const newItems = new Array(newLength - currentLength)
-            for (let i = 0; i < newLength - currentLength; i++) {
-                newItems[i] = undefined
-            } // No Array.fill everywhere...
+            const newItems = Array.from({ length: newLength - currentLength })
             this.spliceWithArray_(currentLength, 0, newItems)
         } else {
             this.spliceWithArray_(newLength, currentLength - newLength)
@@ -204,9 +170,6 @@ export class ObservableArrayAdministration
             die(16)
         }
         this.lastKnownLength_ += delta
-        if (this.legacyMode_ && delta > 0) {
-            reserveArrayBuffer(oldLength + delta + 1)
-        }
     }
 
     spliceWithArray_(index: number, deleteCount?: number, newItems?: any[]): any[] {
@@ -250,7 +213,7 @@ export class ObservableArrayAdministration
 
         newItems =
             newItems.length === 0 ? newItems : newItems.map(v => this.enhancer_(v, undefined))
-        if (this.legacyMode_ || __DEV__) {
+        if (__DEV__) {
             const lengthDelta = newItems.length - deleteCount
             this.updateArrayLength_(length, lengthDelta) // checks if internal array wasn't modified
         }
@@ -283,7 +246,7 @@ export class ObservableArrayAdministration
     }
 
     notifyArrayChildUpdate_(index: number, newValue: any, oldValue: any) {
-        const notifySpy = !this.owned_ && isSpyEnabled()
+        const notifySpy = __DEV__ && !this.owned_ && isSpyEnabled()
         const notify = hasListeners(this)
         const change: IArrayDidChange | null =
             notify || notifySpy
@@ -313,7 +276,7 @@ export class ObservableArrayAdministration
     }
 
     notifyArraySplice_(index: number, added: any[], removed: any[]) {
-        const notifySpy = !this.owned_ && isSpyEnabled()
+        const notifySpy = __DEV__ && !this.owned_ && isSpyEnabled()
         const notify = hasListeners(this)
         const change: IArraySplice | null =
             notify || notifySpy
@@ -344,24 +307,12 @@ export class ObservableArrayAdministration
     }
 
     get_(index: number): any | undefined {
-        if (this.legacyMode_ && index >= this.values_.length) {
-            console.warn(
-                __DEV__
-                    ? `[mobx.array] Attempt to read an array index (${index}) that is out of bounds (${this.values_.length}). Please check length first. Out of bound indices will not be tracked by MobX`
-                    : `[mobx] Out of bounds read: ${index}`
-            )
-            return undefined
-        }
         this.atom_.reportObserved()
         return this.dehanceValue_(this.values_[index])
     }
 
     set_(index: number, newValue: any) {
         const values = this.values_
-        if (this.legacyMode_ && index > values.length) {
-            // out of bounds
-            die(17, index, values.length)
-        }
         if (index < values.length) {
             // update at index in range
             checkIfStateModificationsAreAllowed(this.atom_)
@@ -388,10 +339,7 @@ export class ObservableArrayAdministration
             // For out of bound index, we don't create an actual sparse array,
             // but rather fill the holes with undefined (same as setArrayLength_).
             // This could be considered a bug.
-            const newItems = new Array(index + 1 - values.length)
-            for (let i = 0; i < newItems.length - 1; i++) {
-                newItems[i] = undefined
-            } // No Array.fill everywhere...
+            const newItems = Array.from({ length: index + 1 - values.length })
             newItems[newItems.length - 1] = newValue
             this.spliceWithArray_(values.length, 0, newItems)
         }
@@ -404,9 +352,8 @@ export function createObservableArray<T>(
     name = __DEV__ ? "ObservableArray@" + getNextId() : "ObservableArray",
     owned = false
 ): IObservableArray<T> {
-    assertProxies()
     return initObservable(() => {
-        const adm = new ObservableArrayAdministration(name, enhancer, owned, false)
+        const adm = new ObservableArrayAdministration(name, enhancer, owned)
         addHiddenFinalProp(adm.values_, $mobx, adm)
         const proxy = new Proxy(adm.values_, arrayTraps) as any
         adm.proxy_ = proxy

package/src/types/observablemap.ts

@@ -2,9 +2,7 @@ import {
     $mobx,
     IEnhancer,
     IInterceptable,
-    IInterceptor,
     IListenable,
-    Lambda,
     ObservableValue,
     checkIfStateModificationsAreAllowed,
     createAtom,
@@ -22,17 +20,13 @@ import {
     isSpyEnabled,
     notifyListeners,
     referenceEnhancer,
-    registerInterceptor,
-    registerListener,
     spyReportEnd,
     spyReportStart,
     stringifyKey,
     transaction,
     untracked,
-    onBecomeUnobserved,
     globalState,
     die,
-    isFunction,
     UPDATE,
     IAtom,
     PureSpyEvent,
@@ -106,9 +100,6 @@ export class ObservableMap<K = any, V = any>
         public enhancer_: IEnhancer<V> = deepEnhancer,
         public name_ = __DEV__ ? "ObservableMap@" + getNextId() : "ObservableMap"
     ) {
-        if (!isFunction(Map)) {
-            die(18)
-        }
         initObservable(() => {
             this.keysAtom_ = createAtom(__DEV__ ? `${this.name_}.keys()` : "ObservableMap.keys()")
             this.data_ = new Map()
@@ -137,7 +128,7 @@ export class ObservableMap<K = any, V = any>
                 false
             ))
             this.hasMap_.set(key, newEntry)
-            onBecomeUnobserved(newEntry, () => this.hasMap_.delete(key))
+            newEntry.onBUOL = new Set([() => this.hasMap_.delete(key)])
         }
 
         return entry.get()
@@ -178,7 +169,7 @@ export class ObservableMap<K = any, V = any>
             }
         }
         if (this.has_(key)) {
-            const notifySpy = isSpyEnabled()
+            const notifySpy = __DEV__ && isSpyEnabled()
             const notify = hasListeners(this)
             const change: IMapDidChange<K, V> | null =
                 notify || notifySpy
@@ -217,7 +208,7 @@ export class ObservableMap<K = any, V = any>
         const observable = this.data_.get(key)!
         newValue = (observable as any).prepareNewValue_(newValue) as V
         if (newValue !== globalState.UNCHANGED) {
-            const notifySpy = isSpyEnabled()
+            const notifySpy = __DEV__ && isSpyEnabled()
             const notify = hasListeners(this)
             const change: IMapDidChange<K, V> | null =
                 notify || notifySpy
@@ -258,7 +249,7 @@ export class ObservableMap<K = any, V = any>
             this.hasMap_.get(key)?.setNewValue_(true)
             this.keysAtom_.reportChanged()
         })
-        const notifySpy = isSpyEnabled()
+        const notifySpy = __DEV__ && isSpyEnabled()
         const notify = hasListeners(this)
         const change: IMapDidChange<K, V> | null =
             notify || notifySpy
@@ -481,22 +472,6 @@ export class ObservableMap<K = any, V = any>
     get [Symbol.toStringTag]() {
         return "Map"
     }
-
-    /**
-     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
-     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
-     * for callback details
-     */
-    observe_(listener: (changes: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda {
-        if (__DEV__ && fireImmediately === true) {
-            die("`observe` doesn't support fireImmediately=true in combination with maps.")
-        }
-        return registerListener(this, listener)
-    }
-
-    intercept_(handler: IInterceptor<IMapWillChange<K, V>>): Lambda {
-        return registerInterceptor(this, handler)
-    }
 }
 
 // eslint-disable-next-line

package/src/types/observableobject.ts

@@ -12,7 +12,6 @@ import {
     IEnhancer,
     IInterceptable,
     IListenable,
-    Lambda,
     ObservableValue,
     addHiddenProp,
     createInstanceofPredicate,
@@ -26,8 +25,6 @@ import {
     isSpyEnabled,
     notifyListeners,
     referenceEnhancer,
-    registerInterceptor,
-    registerListener,
     spyReportEnd,
     spyReportStart,
     startBatch,
@@ -38,16 +35,14 @@ import {
     die,
     hasProp,
     getDescriptor,
-    storedAnnotationsSymbol,
     ownKeys,
     isOverride,
     defineProperty,
     autoAnnotation,
     getAdministration,
     getDebugName,
-    objectPrototype,
-    MakeResult,
-    checkIfStateModificationsAreAllowed
+    checkIfStateModificationsAreAllowed,
+    assign
 } from "../internal"
 
 const descriptorCache = Object.create(null)
@@ -274,47 +269,6 @@ export class ObservableObjectAdministration
         return entry.get()
     }
 
-    /**
-     * @param {PropertyKey} key
-     * @param {Annotation|boolean} annotation true - use default annotation, false - ignore prop
-     */
-    make_(key: PropertyKey, annotation: Annotation | boolean): void {
-        if (annotation === true) {
-            annotation = this.defaultAnnotation_
-        }
-        if (annotation === false) {
-            return
-        }
-        assertAnnotable(this, annotation, key)
-        if (!(key in this.target_)) {
-            // 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.
-            if (this.target_[storedAnnotationsSymbol]?.[key]) {
-                return // will be annotated by subclass constructor
-            } else {
-                die(1, annotation.annotationType_, `${this.name_}.${key.toString()}`)
-            }
-        }
-        let source = this.target_
-        while (source && source !== objectPrototype) {
-            const descriptor = getDescriptor(source, key)
-            if (descriptor) {
-                const outcome = annotation.make_(this, key, descriptor, source)
-                if (outcome === MakeResult.Cancel) {
-                    return
-                }
-                if (outcome === MakeResult.Break) {
-                    break
-                }
-            }
-            source = Object.getPrototypeOf(source)
-        }
-        recordAnnotationApplied(this, annotation, key)
-    }
-
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
@@ -377,10 +331,9 @@ export class ObservableObjectAdministration
                 }
                 const { newValue } = change as any
                 if (descriptor.value !== newValue) {
-                    descriptor = {
-                        ...descriptor,
+                    descriptor = assign({}, descriptor, {
                         value: newValue
-                    }
+                    })
                 }
             }
 
@@ -618,22 +571,6 @@ export class ObservableObjectAdministration
         return true
     }
 
-    /**
-     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
-     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
-     * for callback details
-     */
-    observe_(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda {
-        if (__DEV__ && fireImmediately === true) {
-            die("`observe` doesn't support the fire immediately property for observable objects.")
-        }
-        return registerListener(this, callback)
-    }
-
-    intercept_(handler): Lambda {
-        return registerInterceptor(this, handler)
-    }
-
     notifyPropertyAddition_(key: PropertyKey, value: any) {
         const notify = hasListeners(this)
         const notifySpy = __DEV__ && isSpyEnabled()
@@ -765,11 +702,9 @@ export function recordAnnotationApplied(
     if (__DEV__) {
         adm.appliedAnnotations_![key] = annotation
     }
-    // Remove applied decorator annotation so we don't try to apply it again in subclass constructor
-    delete adm.target_[storedAnnotationsSymbol]?.[key]
 }
 
-function assertAnnotable(
+export function assertAnnotable(
     adm: ObservableObjectAdministration,
     annotation: Annotation,
     key: PropertyKey

package/src/types/observableset.ts

@@ -7,8 +7,6 @@ import {
     isSpyEnabled,
     hasListeners,
     IListenable,
-    registerListener,
-    Lambda,
     spyReportStart,
     notifyListeners,
     spyReportEnd,
@@ -17,8 +15,6 @@ import {
     hasInterceptors,
     interceptChange,
     IInterceptable,
-    IInterceptor,
-    registerInterceptor,
     checkIfStateModificationsAreAllowed,
     untracked,
     transaction,
@@ -27,7 +23,6 @@ import {
     DELETE,
     ADD,
     die,
-    isFunction,
     initObservable
 } from "../internal"
 
@@ -55,16 +50,14 @@ export type ISetWillDeleteChange<T = any> = {
     type: "delete"
     object: ObservableSet<T>
     oldValue: T
-};
+}
 export type ISetWillAddChange<T = any> = {
     type: "add"
     object: ObservableSet<T>
     newValue: T
-};
+}
 
-export type ISetWillChange<T = any> =
-    | ISetWillDeleteChange<T>
-    | ISetWillAddChange<T>
+export type ISetWillChange<T = any> = ISetWillDeleteChange<T> | ISetWillAddChange<T>
 
 export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
     [$mobx] = ObservableSetMarker
@@ -80,9 +73,6 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
         enhancer: IEnhancer<T> = deepEnhancer,
         public name_ = __DEV__ ? "ObservableSet@" + getNextId() : "ObservableSet"
     ) {
-        if (!isFunction(Set)) {
-            die(22)
-        }
         this.enhancer_ = (newV, oldV) => enhancer(newV, oldV, name_)
         initObservable(() => {
             this.atom_ = createAtom(this.name_)
@@ -133,8 +123,7 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
             }
 
             // implemented reassignment same as it's done for ObservableMap
-            value = change.newValue!;
-
+            value = change.newValue!
         }
         if (!this.has(value)) {
             transaction(() => {
@@ -304,24 +293,12 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
                 this.clear()
                 other.forEach(value => this.add(value))
             } else if (other !== null && other !== undefined) {
-                die("Cannot initialize set from " + other)
+                die(41, other)
             }
         })
 
         return this
     }
-    observe_(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda {
-        // ... 'fireImmediately' could also be true?
-        if (__DEV__ && fireImmediately === true) {
-            die("`observe` doesn't support fireImmediately=true in combination with sets.")
-        }
-        return registerListener(this, listener)
-    }
-
-    intercept_(handler: IInterceptor<ISetWillChange<T>>): Lambda {
-        return registerInterceptor(this, handler)
-    }
-
     toJSON(): T[] {
         return Array.from(this)
     }

package/src/types/observablevalue.ts

@@ -3,11 +3,9 @@ import {
     IEnhancer,
     IInterceptable,
     IEqualsComparer,
-    IInterceptor,
     IListenable,
-    Lambda,
     checkIfStateModificationsAreAllowed,
-    comparer,
+    compareDefault,
     createInstanceofPredicate,
     getNextId,
     hasInterceptors,
@@ -15,8 +13,6 @@ import {
     interceptChange,
     isSpyEnabled,
     notifyListeners,
-    registerInterceptor,
-    registerListener,
     spyReport,
     spyReportEnd,
     spyReportStart,
@@ -69,13 +65,13 @@ export class ObservableValue<T>
 
     constructor(
         value: T,
-        public enhancer: IEnhancer<T>,
+        public enhancer_: IEnhancer<T>,
         public name_ = __DEV__ ? "ObservableValue@" + getNextId() : "ObservableValue",
         notifySpy = true,
-        private equals: IEqualsComparer<any> = comparer.default
+        private equals_: IEqualsComparer<any> = compareDefault
     ) {
         super(name_)
-        this.value_ = enhancer(value, undefined, name_)
+        this.value_ = enhancer_(value, undefined, name_)
         if (__DEV__ && notifySpy && isSpyEnabled()) {
             // only notify spy if this is a stand-alone observable
             spyReport({
@@ -99,7 +95,7 @@ export class ObservableValue<T>
         const oldValue = this.value_
         newValue = this.prepareNewValue_(newValue) as any
         if (newValue !== globalState.UNCHANGED) {
-            const notifySpy = isSpyEnabled()
+            const notifySpy = __DEV__ && isSpyEnabled()
             if (__DEV__ && notifySpy) {
                 spyReportStart({
                     type: UPDATE,
@@ -131,8 +127,8 @@ export class ObservableValue<T>
             newValue = change.newValue
         }
         // apply modifier
-        newValue = this.enhancer(newValue, this.value_, this.name_)
-        return this.equals(this.value_, newValue) ? globalState.UNCHANGED : newValue
+        newValue = this.enhancer_(newValue, this.value_, this.name_)
+        return this.equals_(this.value_, newValue) ? globalState.UNCHANGED : newValue
     }
 
     setNewValue_(newValue: T) {
@@ -154,24 +150,6 @@ export class ObservableValue<T>
         return this.dehanceValue(this.value_)
     }
 
-    intercept_(handler: IInterceptor<IValueWillChange<T>>): Lambda {
-        return registerInterceptor(this, handler)
-    }
-
-    observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda {
-        if (fireImmediately) {
-            listener({
-                observableKind: "value",
-                debugObjectName: this.name_,
-                object: this,
-                type: UPDATE,
-                newValue: this.value_,
-                oldValue: undefined
-            })
-        }
-        return registerListener(this, listener)
-    }
-
     raw() {
         // used by MST ot get undehanced value
         return this.value_

package/src/types/overrideannotation.ts

@@ -1,23 +1,12 @@
-import {
-    die,
-    Annotation,
-    hasProp,
-    createDecoratorAnnotation,
-    ObservableObjectAdministration,
-    MakeResult
-} from "../internal"
-
-import type { ClassMethodDecorator } from "./decorator_fills"
+import { die, Annotation, hasProp, ObservableObjectAdministration, MakeResult } from "../internal"
 
 const OVERRIDE = "override"
 
-export const override: Annotation & PropertyDecorator & ClassMethodDecorator =
-    createDecoratorAnnotation({
-        annotationType_: OVERRIDE,
-        make_,
-        extend_,
-        decorate_20223_
-    })
+export const override: Annotation = {
+    annotationType_: OVERRIDE,
+    make_,
+    extend_
+}
 
 export function isOverride(annotation: Annotation): boolean {
     return annotation.annotationType_ === OVERRIDE
@@ -42,9 +31,5 @@ function make_(this: Annotation, adm: ObservableObjectAdministration, key): Make
 }
 
 function extend_(this: Annotation, adm, key, descriptor, proxyTrap): boolean {
-    die(`'${this.annotationType_}' can only be used with 'makeObservable'`)
-}
-
-function decorate_20223_(this: Annotation, desc, context: DecoratorContext) {
-    console.warn(`'${this.annotationType_}' cannot be used with decorators - this is a no-op`)
+    die(44, this.annotationType_)
 }

package/src/types/type-utils.ts

@@ -111,13 +111,15 @@ export function getDebugName(thing: any, property?: string): string {
  */
 export function initObservable<T>(cb: () => T): T {
     const derivation = untrackedStart()
-    const allowStateChanges = allowStateChangesStart(true)
+    const allowStateChanges = __DEV__ ? allowStateChangesStart(true) : true
     startBatch()
     try {
         return cb()
     } finally {
         endBatch()
-        allowStateChangesEnd(allowStateChanges)
+        if (__DEV__) {
+            allowStateChangesEnd(allowStateChanges)
+        }
         untrackedEnd(derivation)
     }
 }

package/src/utils/comparer.ts

@@ -4,29 +4,16 @@ export interface IEqualsComparer<T> {
     (a: T, b: T): boolean
 }
 
-function identityComparer(a: any, b: any): boolean {
+export function compareIdentity(a: any, b: any): boolean {
     return a === b
 }
 
-function structuralComparer(a: any, b: any): boolean {
+export function compareStructural(a: any, b: any): boolean {
     return deepEqual(a, b)
 }
 
-function shallowComparer(a: any, b: any): boolean {
+export function compareShallow(a: any, b: any): boolean {
     return deepEqual(a, b, 1)
 }
 
-function defaultComparer(a: any, b: any): boolean {
-    if (Object.is) {
-        return Object.is(a, b)
-    }
-
-    return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b
-}
-
-export const comparer = {
-    identity: identityComparer,
-    structural: structuralComparer,
-    default: defaultComparer,
-    shallow: shallowComparer
-}
+export const compareDefault = Object.is

package/src/utils/iterable.ts

@@ -1,14 +1,13 @@
-import { getGlobal } from "../internal"
+import { assign } from "./utils"
 
 // safely get iterator prototype if available
-const global = getGlobal()
-const maybeIteratorPrototype = global.Iterator?.prototype || {}
+const maybeIteratorPrototype = (globalThis as any).Iterator?.prototype || {}
 
 export function makeIterable<T, TReturn = unknown>(
     iterator: Iterator<T>
 ): IteratorObject<T, TReturn> {
     iterator[Symbol.iterator] = getSelf
-    return Object.assign(Object.create(maybeIteratorPrototype), iterator)
+    return assign(Object.create(maybeIteratorPrototype), iterator)
 }
 
 function getSelf() {