mobx 6.6.1 → 6.7.0

package/dist/types/observablemap.d.ts

@@ -3,7 +3,9 @@ export interface IKeyValueMap<V = any> {
     [key: string]: V;
 }
 export declare type IMapEntry<K = any, V = any> = [K, V];
+export declare type IReadonlyMapEntry<K = any, V = any> = readonly [K, V];
 export declare type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];
+export declare type IReadonlyMapEntries<K = any, V = any> = IReadonlyMapEntry<K, V>[];
 export declare type IMapDidChange<K = any, V = any> = {
     observableKind: "map";
     debugObjectName: string;
@@ -32,7 +34,7 @@ export interface IMapWillChange<K = any, V = any> {
 }
 export declare const ADD = "add";
 export declare const DELETE = "delete";
-export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
+export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IReadonlyMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
 export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
     enhancer_: IEnhancer<V>;
     name_: string;

package/package.json

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

package/src/api/decorators.ts

@@ -51,7 +51,7 @@ function assertNotDecorated(prototype: object, annotation: Annotation, key: Prop
             `Cannot apply '@${requestedAnnotationType}' to '${fieldName}':` +
                 `\nThe field is already decorated with '@${currentAnnotationType}'.` +
                 `\nRe-decorating fields is not allowed.` +
-                `\nUse '@override' decorator for methods overriden by subclass.`
+                `\nUse '@override' decorator for methods overridden by subclass.`
         )
     }
 }

package/src/api/when.ts

@@ -13,6 +13,7 @@ export interface IWhenOptions {
     name?: string
     timeout?: number
     onError?: (error: any) => void
+    signal?: AbortSignal
 }
 
 export function when(
@@ -74,14 +75,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/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/legacyobservablearray.ts

@@ -14,6 +14,21 @@ import {
     defineProperty
 } 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
@@ -57,6 +72,12 @@ class LegacyObservableArray<T> extends StubArray {
             this.spliceWithArray(0, 0, initialValues)
             allowStateChangesEnd(prev)
         }
+
+        if (safariPrototypeSetterInheritanceBug) {
+            // Seems that Safari won't use numeric prototype setter untill 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[] {

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/observablemap.ts

@@ -43,7 +43,9 @@ export interface IKeyValueMap<V = any> {
 }
 
 export type IMapEntry<K = any, V = any> = [K, V]
+export type IReadonlyMapEntry<K = any, V = any> = readonly [K, V]
 export type IMapEntries<K = any, V = any> = IMapEntry<K, V>[]
+export type IReadonlyMapEntries<K = any, V = any> = IReadonlyMapEntry<K, V>[]
 
 export type IMapDidChange<K = any, V = any> = { observableKind: "map"; debugObjectName: string } & (
     | {
@@ -81,14 +83,14 @@ export const DELETE = "delete"
 
 export type IObservableMapInitialValues<K = any, V = any> =
     | IMapEntries<K, V>
+    | IReadonlyMapEntries<K, V>
     | IKeyValueMap<V>
     | Map<K, V>
 
 // just extend Map? See also https://gist.github.com/nestharus/13b4d74f2ef4a2f4357dbd3fc23c1e54
 // But: https://github.com/mobxjs/mobx/issues/1556
 export class ObservableMap<K = any, V = any>
-    implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable
-{
+    implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
     [$mobx] = ObservableMapMarker
     data_: Map<K, ObservableValue<V>>
     hasMap_: Map<K, ObservableValue<boolean>> // hasMap, not hashMap >-).

package/src/types/observableobject.ts

@@ -776,7 +776,7 @@ function assertAnnotable(
             `Cannot apply '${requestedAnnotationType}' to '${fieldName}':` +
                 `\nThe field is already annotated with '${currentAnnotationType}'.` +
                 `\nRe-annotating fields is not allowed.` +
-                `\nUse 'override' annotation for methods overriden by subclass.`
+                `\nUse 'override' annotation for methods overridden by subclass.`
         )
     }
 }