mobx 6.16.1 → 7.0.1

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(() => {
@@ -244,21 +233,11 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     }
 
     intersection<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T & U> {
-        if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
-            return otherSet.intersection(this)
-        } else {
-            const dehancedSet = new Set(this)
-            return dehancedSet.intersection(otherSet)
-        }
+        return new Set(this).intersection(otherSet)
     }
 
     union<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U> {
-        if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
-            return otherSet.union(this)
-        } else {
-            const dehancedSet = new Set(this)
-            return dehancedSet.union(otherSet)
-        }
+        return new Set(this).union(otherSet)
     }
 
     difference<U>(otherSet: ReadonlySetLike<U>): Set<T> {
@@ -266,12 +245,7 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     }
 
     symmetricDifference<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U> {
-        if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
-            return otherSet.symmetricDifference(this)
-        } else {
-            const dehancedSet = new Set(this)
-            return dehancedSet.symmetricDifference(otherSet)
-        }
+        return new Set(this).symmetricDifference(otherSet)
     }
 
     isSubsetOf(otherSet: ReadonlySetLike<unknown>): boolean {
@@ -283,12 +257,7 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
     }
 
     isDisjointFrom(otherSet: ReadonlySetLike<unknown> | Set<unknown>): boolean {
-        if (isES6Set(otherSet) && !isObservableSet(otherSet)) {
-            return otherSet.isDisjointFrom(this)
-        } else {
-            const dehancedSet = new Set(this)
-            return dehancedSet.isDisjointFrom(otherSet)
-        }
+        return new Set(this).isDisjointFrom(otherSet)
     }
 
     replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T> {
@@ -304,24 +273,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() {

package/src/utils/utils.ts

@@ -1,4 +1,4 @@
-import { globalState, die } from "../internal"
+import { globalState } from "../internal"
 
 // We shorten anything used > 5 times
 export const assign = Object.assign
@@ -17,28 +17,8 @@ export interface Lambda {
     name?: string
 }
 
-const hasProxy = typeof Proxy !== "undefined"
 const plainObjectString = Object.toString()
 
-export function assertProxies() {
-    if (!hasProxy) {
-        die(
-            __DEV__
-                ? "`Proxy` objects are not available in the current environment. Please configure MobX to enable a fallback implementation.`"
-                : "Proxy not available"
-        )
-    }
-}
-
-export function warnAboutProxyRequirement(msg: string) {
-    if (__DEV__ && globalState.verifyProxies) {
-        die(
-            "MobX is currently configured to be able to run in ES5 mode, but in ES5 MobX won't be able to " +
-                msg
-        )
-    }
-}
-
 export function getNextId() {
     return ++globalState.mobxGuid
 }
@@ -90,7 +70,7 @@ export function isPlainObject(value: any) {
     if (proto == null) {
         return true
     }
-    const protoConstructor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor
+    const protoConstructor = hasProp(proto, "constructor") && proto.constructor
     return (
         typeof protoConstructor === "function" && protoConstructor.toString() === plainObjectString
     )
@@ -164,17 +144,11 @@ export function isES6Set(thing: unknown): thing is Set<any> {
     return thing != null && Object.prototype.toString.call(thing) === "[object Set]"
 }
 
-const hasGetOwnPropertySymbols = typeof Object.getOwnPropertySymbols !== "undefined"
-
 /**
  * Returns the following: own enumerable keys and symbols.
  */
 export function getPlainObjectKeys(object: any) {
     const keys = Object.keys(object)
-    // Not supported in IE, so there are not going to be symbol props anyway...
-    if (!hasGetOwnPropertySymbols) {
-        return keys
-    }
     const symbols = Object.getOwnPropertySymbols(object)
     if (!symbols.length) {
         return keys
@@ -184,12 +158,7 @@ export function getPlainObjectKeys(object: any) {
 
 // From Immer utils
 // Returns all own keys, including non-enumerable and symbolic
-export const ownKeys: (target: any) => Array<string | symbol> =
-    typeof Reflect !== "undefined" && Reflect.ownKeys
-        ? Reflect.ownKeys
-        : hasGetOwnPropertySymbols
-        ? obj => Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj) as any)
-        : /* istanbul ignore next */ Object.getOwnPropertyNames
+export const ownKeys: (target: any) => Array<string | symbol> = Reflect.ownKeys
 
 export function stringifyKey(key: any): string {
     if (typeof key === "string") {
@@ -209,18 +178,7 @@ export function hasProp(target: Object, prop: PropertyKey): boolean {
     return objectPrototype.hasOwnProperty.call(target, prop)
 }
 
-// From Immer utils
-export const getOwnPropertyDescriptors =
-    Object.getOwnPropertyDescriptors ||
-    function getOwnPropertyDescriptors(target: any) {
-        // Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274
-        const res: any = {}
-        // Note: without polyfill for ownKeys, symbols won't be picked up
-        ownKeys(target).forEach(key => {
-            res[key] = getDescriptor(target, key)
-        })
-        return res
-    }
+export const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors
 
 export function getFlag(flags: number, mask: number) {
     return !!(flags & mask)

package/dist/api/trace.d.ts

@@ -1,3 +0,0 @@
-export declare function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): void;
-export declare function trace(thing?: any, enterBreakPoint?: boolean): void;
-export declare function trace(enterBreakPoint?: boolean): void;

package/dist/types/legacyobservablearray.d.ts

@@ -1,14 +0,0 @@
-import { IEnhancer, IObservableArray } from "../internal";
-declare class StubArray {
-}
-export declare class LegacyObservableArray<T> extends StubArray {
-    constructor(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string, owned?: boolean);
-    concat(...arrays: T[][]): T[];
-    get length(): number;
-    set length(newLength: number);
-    get [Symbol.toStringTag](): string;
-    [Symbol.iterator](): IteratorObject<any, unknown, unknown>;
-}
-export declare function reserveArrayBuffer(max: number): void;
-export declare function createLegacyArray<T>(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string): IObservableArray<T>;
-export {};

package/dist/utils/global.d.ts

@@ -1 +0,0 @@
-export declare function getGlobal(): any;

package/src/api/trace.ts

@@ -1,35 +0,0 @@
-import { TraceMode, die, getAtom, globalState } from "../internal"
-
-export function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): void
-export function trace(thing?: any, enterBreakPoint?: boolean): void
-export function trace(enterBreakPoint?: boolean): void
-export function trace(...args: any[]): void {
-    if (!__DEV__) {
-        return
-    }
-    let enterBreakPoint = false
-    if (typeof args[args.length - 1] === "boolean") {
-        enterBreakPoint = args.pop()
-    }
-    const derivation = getAtomFromArgs(args)
-    if (!derivation) {
-        return die(
-            `'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly`
-        )
-    }
-    if (derivation.isTracing_ === TraceMode.NONE) {
-        console.log(`[mobx.trace] '${derivation.name_}' tracing enabled`)
-    }
-    derivation.isTracing_ = enterBreakPoint ? TraceMode.BREAK : TraceMode.LOG
-}
-
-function getAtomFromArgs(args): any {
-    switch (args.length) {
-        case 0:
-            return globalState.trackingDerivation
-        case 1:
-            return getAtom(args[0])
-        case 2:
-            return getAtom(args[0], args[1])
-    }
-}

package/src/types/legacyobservablearray.ts

@@ -1,155 +0,0 @@
-import {
-    getNextId,
-    addHiddenFinalProp,
-    makeIterable,
-    addHiddenProp,
-    ObservableArrayAdministration,
-    $mobx,
-    arrayExtensions,
-    IEnhancer,
-    isObservableArray,
-    IObservableArray,
-    defineProperty,
-    initObservable
-} 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
- * properties on the fly.
- */
-let OBSERVABLE_ARRAY_BUFFER_SIZE = 0
-
-// Typescript workaround to make sure ObservableArray extends Array
-class StubArray {}
-function inherit(ctor, proto) {
-    if (Object.setPrototypeOf) {
-        Object.setPrototypeOf(ctor.prototype, proto)
-    } else if (ctor.prototype.__proto__ !== undefined) {
-        ctor.prototype.__proto__ = proto
-    } else {
-        ctor.prototype = proto
-    }
-}
-inherit(StubArray, Array.prototype)
-
-// Weex proto freeze protection was here,
-// but it is unclear why the hack is need as MobX never changed the prototype
-// anyway, so removed it in V6
-
-export class LegacyObservableArray<T> extends StubArray {
-    constructor(
-        initialValues: T[] | undefined,
-        enhancer: IEnhancer<T>,
-        name = __DEV__ ? "ObservableArray@" + getNextId() : "ObservableArray",
-        owned = false
-    ) {
-        super()
-        initObservable(() => {
-            const adm = new ObservableArrayAdministration(name, enhancer, owned, true)
-            adm.proxy_ = this as any
-            addHiddenFinalProp(this, $mobx, adm)
-
-            if (initialValues && initialValues.length) {
-                // @ts-ignore
-                this.spliceWithArray(0, 0, initialValues)
-            }
-
-            if (safariPrototypeSetterInheritanceBug) {
-                // Seems that Safari won't use numeric prototype setter until 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[] {
-        ;(this[$mobx] as ObservableArrayAdministration).atom_.reportObserved()
-        return Array.prototype.concat.apply(
-            (this as any).slice(),
-            //@ts-ignore
-            arrays.map(a => (isObservableArray(a) ? a.slice() : a))
-        )
-    }
-
-    get length(): number {
-        return (this[$mobx] as ObservableArrayAdministration).getArrayLength_()
-    }
-
-    set length(newLength: number) {
-        ;(this[$mobx] as ObservableArrayAdministration).setArrayLength_(newLength)
-    }
-
-    get [Symbol.toStringTag]() {
-        return "Array"
-    }
-
-    [Symbol.iterator]() {
-        const self = this
-        let nextIndex = 0
-        return makeIterable({
-            next() {
-                return nextIndex < self.length
-                    ? { value: self[nextIndex++], done: false }
-                    : { done: true, value: undefined }
-            }
-        })
-    }
-}
-
-Object.entries(arrayExtensions).forEach(([prop, fn]) => {
-    if (prop !== "concat") {
-        addHiddenProp(LegacyObservableArray.prototype, prop, fn)
-    }
-})
-
-function createArrayEntryDescriptor(index: number) {
-    return {
-        enumerable: false,
-        configurable: true,
-        get: function () {
-            return this[$mobx].get_(index)
-        },
-        set: function (value) {
-            this[$mobx].set_(index, value)
-        }
-    }
-}
-
-function createArrayBufferItem(index: number) {
-    defineProperty(LegacyObservableArray.prototype, "" + index, createArrayEntryDescriptor(index))
-}
-
-export function reserveArrayBuffer(max: number) {
-    if (max > OBSERVABLE_ARRAY_BUFFER_SIZE) {
-        for (let index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max + 100; index++) {
-            createArrayBufferItem(index)
-        }
-        OBSERVABLE_ARRAY_BUFFER_SIZE = max
-    }
-}
-
-reserveArrayBuffer(1000)
-
-export function createLegacyArray<T>(
-    initialValues: T[] | undefined,
-    enhancer: IEnhancer<T>,
-    name?: string
-): IObservableArray<T> {
-    return new LegacyObservableArray(initialValues, enhancer, name) as any
-}

package/src/utils/global.ts

@@ -1,20 +0,0 @@
-declare const window: any
-declare const self: any
-
-const mockGlobal = {}
-
-export function getGlobal() {
-    if (typeof globalThis !== "undefined") {
-        return globalThis
-    }
-    if (typeof window !== "undefined") {
-        return window
-    }
-    if (typeof global !== "undefined") {
-        return global
-    }
-    if (typeof self !== "undefined") {
-        return self
-    }
-    return mockGlobal
-}