mobx 6.6.2 → 6.8.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.6.2",
+    "version": "6.8.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,10 +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?: GenericAbortSignal
 }
 
 export function when(
@@ -74,14 +83,23 @@ function whenPromise(
     if (__DEV__ && opts && opts.onError) {
         return die(`the options 'onError' and 'promise' cannot be combined`)
     }
+    if (opts?.signal?.aborted) {
+        return Object.assign(Promise.reject(new Error("WHEN_ABORTED")), { cancel: () => null })
+    }
     let cancel
+    let abort
     const res = new Promise((resolve, reject) => {
         let disposer = _when(predicate, resolve as Lambda, { ...opts, onError: reject })
         cancel = () => {
             disposer()
             reject(new Error("WHEN_CANCELLED"))
         }
-    })
+        abort = () => {
+            disposer()
+            reject(new Error("WHEN_ABORTED"))
+        }
+        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/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/observable.ts

@@ -151,7 +151,7 @@ export function reportObserved(observable: IObservable): boolean {
                 observable.onBO()
             }
         }
-        return true
+        return observable.isBeingObserved_
     } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {
         queueForUnobservation(observable)
     }

package/src/types/observablearray.ts

@@ -345,19 +345,24 @@ export class ObservableArrayAdministration
     }
 
     get_(index: number): any | undefined {
-        if (index < this.values_.length) {
-            this.atom_.reportObserved()
-            return this.dehanceValue_(this.values_[index])
-        }
-        console.warn(
-            __DEV__
-                ? `[mobx] Out of bounds read: ${index}`
-                : `[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`
-        )
+        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_)
@@ -380,12 +385,16 @@ export class ObservableArrayAdministration
                 values[index] = newValue
                 this.notifyArrayChildUpdate_(index, newValue, oldValue)
             }
-        } else if (index === values.length) {
-            // add a new item
-            this.spliceWithArray_(index, 0, [newValue])
         } else {
-            // out of bounds
-            die(17, index, values.length)
+            // 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...
+            newItems[newItems.length - 1] = newValue
+            this.spliceWithArray_(values.length, 0, newItems)
         }
     }
 }

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) {