mobx 6.7.0 → 6.9.0

package/dist/types/observableset.d.ts

@@ -1,4 +1,4 @@
-import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor } from "../internal";
+import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor, IAtom } from "../internal";
 export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
 export declare type ISetDidChange<T = any> = {
     object: ObservableSet<T>;
@@ -26,7 +26,7 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     name_: string;
     [$mobx]: {};
     private data_;
-    private atom_;
+    atom_: IAtom;
     changeListeners_: any;
     interceptors_: any;
     dehancer: any;

package/dist/types/observablevalue.d.ts

@@ -9,21 +9,19 @@ export declare type IValueDidChange<T = any> = {
     observableKind: "value";
     object: IObservableValue<T>;
     debugObjectName: string;
-    newValue: unknown;
-    oldValue: unknown;
+    newValue: T;
+    oldValue: T | undefined;
 };
 export declare type IBoxDidChange<T = any> = {
     type: "create";
     observableKind: "value";
     object: IObservableValue<T>;
     debugObjectName: string;
-    newValue: unknown;
+    newValue: T;
 } | IValueDidChange<T>;
 export interface IObservableValue<T> {
     get(): T;
     set(value: T): void;
-    intercept_(handler: IInterceptor<IValueWillChange<T>>): Lambda;
-    observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
 }
 export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
     enhancer: IEnhancer<T>;

package/package.json

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

package/src/api/observable.ts

@@ -134,7 +134,7 @@ function createObservable(v: any, arg2?: any, arg3?: any) {
     // anything else
     return observable.box(v, arg2)
 }
-Object.assign(createObservable, observableDecoratorAnnotation)
+assign(createObservable, observableDecoratorAnnotation)
 
 export interface IObservableValueFactory {
     <T>(value: T, options?: CreateObservableOptions): IObservableValue<T>

package/src/api/when.ts

@@ -9,11 +9,19 @@ import {
     allowStateChanges
 } from "../internal"
 
+// https://github.com/mobxjs/mobx/issues/3582
+interface GenericAbortSignal {
+    readonly aborted: boolean
+    onabort?: ((...args: any) => any) | null
+    addEventListener?: (...args: any) => any
+    removeEventListener?: (...args: any) => any
+}
+
 export interface IWhenOptions {
     name?: string
     timeout?: number
     onError?: (error: any) => void
-    signal?: AbortSignal
+    signal?: GenericAbortSignal
 }
 
 export function when(
@@ -90,8 +98,8 @@ function whenPromise(
             disposer()
             reject(new Error("WHEN_ABORTED"))
         }
-        opts?.signal?.addEventListener("abort", abort)
-    }).finally(() => opts?.signal?.removeEventListener("abort", abort))
+        opts?.signal?.addEventListener?.("abort", abort)
+    }).finally(() => opts?.signal?.removeEventListener?.("abort", abort))
     ;(res as any).cancel = cancel
     return res as any
 }

package/src/core/action.ts

@@ -14,7 +14,8 @@ import {
     ACTION,
     EMPTY_ARRAY,
     die,
-    getDescriptor
+    getDescriptor,
+    defineProperty
 } from "../internal"
 
 // we don't use globalState for these in order to avoid possible issues with multiple
@@ -51,7 +52,7 @@ export function createAction(
     res.isMobxAction = true
     if (isFunctionNameConfigurable) {
         tmpNameDescriptor.value = actionName
-        Object.defineProperty(res, "name", tmpNameDescriptor)
+        defineProperty(res, "name", tmpNameDescriptor)
     }
     return res
 }

package/src/core/atom.ts

@@ -11,7 +11,8 @@ import {
     propagateChanged,
     reportObserved,
     startBatch,
-    Lambda
+    Lambda,
+    globalState
 } from "../internal"
 
 export const $mobx = Symbol("mobx administration")
@@ -66,6 +67,12 @@ export class Atom implements IAtom {
     public reportChanged() {
         startBatch()
         propagateChanged(this)
+        // We could update state version only at the end of batch,
+        // but we would still have to switch some global flag here to signal a change.
+        globalState.stateVersion =
+            globalState.stateVersion < Number.MAX_SAFE_INTEGER
+                ? globalState.stateVersion + 1
+                : Number.MIN_SAFE_INTEGER
         endBatch()
     }
 

package/src/core/computedvalue.ts

@@ -35,7 +35,6 @@ import {
 export interface IComputedValue<T> {
     get(): T
     set(value: T): void
-    observe_(listener: (change: IComputedDidChange<T>) => void, fireImmediately?: boolean): Lambda
 }
 
 export interface IComputedValueOptions<T> {

package/src/core/globalstate.ts

@@ -150,6 +150,11 @@ export class MobXGlobals {
      * configurable: true
      */
     safeDescriptors = true
+
+    /**
+     * Changes with each state update, used by useSyncExternalStore
+     */
+    stateVersion = Number.MIN_SAFE_INTEGER
 }
 
 let canMergeGlobalState = true

package/src/types/observableset.ts

@@ -65,7 +65,7 @@ export type ISetWillChange<T = any> =
 export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
     [$mobx] = ObservableSetMarker
     private data_: Set<any> = new Set()
-    private atom_: IAtom
+    atom_: IAtom
     changeListeners_
     interceptors_
     dehancer: any

package/src/types/observablevalue.ts

@@ -37,8 +37,8 @@ export type IValueDidChange<T = any> = {
     observableKind: "value"
     object: IObservableValue<T>
     debugObjectName: string
-    newValue: unknown
-    oldValue: unknown
+    newValue: T
+    oldValue: T | undefined
 }
 export type IBoxDidChange<T = any> =
     | {
@@ -46,15 +46,13 @@ export type IBoxDidChange<T = any> =
           observableKind: "value"
           object: IObservableValue<T>
           debugObjectName: string
-          newValue: unknown
+          newValue: T
       }
     | IValueDidChange<T>
 
 export interface IObservableValue<T> {
     get(): T
     set(value: T): void
-    intercept_(handler: IInterceptor<IValueWillChange<T>>): Lambda
-    observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda
 }
 
 const CREATE = "create"

package/src/types/type-utils.ts

@@ -22,7 +22,7 @@ export function getAtom(thing: any, property?: PropertyKey): IDepTreeNode {
             return (thing as any)[$mobx].atom_
         }
         if (isObservableSet(thing)) {
-            return (thing as any)[$mobx]
+            return thing.atom_
         }
         if (isObservableMap(thing)) {
             if (property === undefined) {