mobx-keystone 1.24.1 → 2.0.0

package/src/utils/index.ts

@@ -23,6 +23,24 @@ export class MobxKeystoneError extends Error {
   }
 }
 
+/**
+ * A mobx-keystone error that groups several failures that happened while delivering
+ * a single notification, such as multiple patch listeners or root store hooks throwing.
+ *
+ * It is only used when more than one callback failed; a lone failure is rethrown as is.
+ */
+export class MobxKeystoneAggregateError extends MobxKeystoneError {
+  /**
+   * The values thrown by the failing callbacks, in the order they were thrown.
+   */
+  readonly errors: readonly unknown[]
+
+  constructor(errors: readonly unknown[], msg: string) {
+    super(msg)
+    this.errors = errors
+  }
+}
+
 /**
  * @internal
  */
@@ -107,6 +125,18 @@ export let hasOwnProp: (object: object, propName: PropertyKey) => boolean = (
   return impl(object, propName)
 }
 
+/**
+ * Like `===`, except that `NaN` equals `NaN`.
+ * This is the `SameValueZero` equality used by `Map`/`Set` keys and by
+ * `Array.prototype.includes`, so `0` and `-0` are the same value.
+ *
+ * @internal
+ */
+export function isEqualOrBothNaN(a: unknown, b: unknown): boolean {
+  // biome-ignore lint/suspicious/noSelfCompare: NaN check
+  return a === b || (a !== a && b !== b)
+}
+
 /**
  * @internal
  */
@@ -224,7 +254,9 @@ declare const process:
  * @internal
  */
 export const inDevMode =
-  process?.env?.NODE_ENV !== undefined && process.env.NODE_ENV !== "production"
+  typeof process !== "undefined" &&
+  process?.env?.NODE_ENV !== undefined &&
+  process.env.NODE_ENV !== "production"
 
 /**
  * @internal
@@ -545,7 +577,7 @@ export function makeObservableCompat(target: object, annotations?: object): void
  * @internal
  */
 export function propNameToSetterName(propName: string): string {
-  return `set${propName[0].toUpperCase()}${propName.slice(1)}`
+  return `set${propName.charAt(0).toUpperCase()}${propName.slice(1)}`
 }
 
 let cachedMobxVersion: number | undefined

package/src/utils/mapUtils.ts

@@ -1,15 +1,11 @@
 type AnyMap<V = any> = Map<any, V> | WeakMap<any, V>
 
-export function getOrCreate<K, V, C = V>(map: Map<K, V>, key: K, create: () => C): V
-export function getOrCreate<K extends object, V, C = V>(
-  map: WeakMap<K, V>,
-  key: K,
-  create: () => C
-): V
+export function getOrCreate<K, V>(map: Map<K, V>, key: K, create: () => V): V
+export function getOrCreate<K extends object, V>(map: WeakMap<K, V>, key: K, create: () => V): V
 
 export function getOrCreate<V>(map: AnyMap<V>, key: any, create: () => V) {
   let value = map.get(key)
-  if (value === undefined) {
+  if (value === undefined && !map.has(key)) {
     value = create()
     map.set(key, value)
   }

package/src/utils/setIfDifferent.ts

@@ -1,13 +1,14 @@
 import { set } from "mobx"
+import { isEqualOrBothNaN } from "./index"
 
 export function setIfDifferent(target: any, key: PropertyKey, value: unknown): void {
-  if (target[key] !== value || !(key in target)) {
+  if (!isEqualOrBothNaN(target[key], value) || !(key in target)) {
     set(target, key, value)
   }
 }
 
 export function setIfDifferentWithReturn(target: any, key: PropertyKey, value: unknown): boolean {
-  if (target[key] !== value || !(key in target)) {
+  if (!isEqualOrBothNaN(target[key], value) || !(key in target)) {
     set(target, key, value)
     return true
   }

package/src/utils/setLike.ts

@@ -0,0 +1,134 @@
+import { failure } from "./index"
+
+// keys() need only return an iterator, not an iterable. Wrapping it in one also lets
+// for-of close that iterator when a predicate exits early.
+function keysOf<T>(set: ReadonlySetLike<T>): Iterable<T> {
+  return { [Symbol.iterator]: () => set.keys() }
+}
+
+// Read these once, in protocol order, even when a size check can decide the result.
+function getSetRecord<T>(set: ReadonlySetLike<T>) {
+  if ((typeof set !== "object" || set === null) && typeof set !== "function") {
+    throw failure("expected a set-like object")
+  }
+  const numberSize = +set.size
+  if (Number.isNaN(numberSize)) throw failure("set-like size must be a number")
+  const size = Math.trunc(numberSize)
+  if (size < 0) throw failure("set-like size must not be negative")
+  const has = set.has
+  if (typeof has !== "function") throw failure("set-like has must be a function")
+  const keys = set.keys
+  if (typeof keys !== "function") throw failure("set-like keys must be a function")
+  return {
+    size,
+    has: (value: T) => has.call(set, value),
+    keys: { [Symbol.iterator]: () => keys.call(set) } as Iterable<T>,
+  }
+}
+
+/** @internal */
+export function isSetLikeSubsetOf<T>(
+  set: ReadonlySetLike<T>,
+  other: ReadonlySetLike<unknown>
+): boolean {
+  const otherRecord = getSetRecord(other)
+  if (set.size > otherRecord.size) return false
+  for (const value of keysOf(set)) {
+    if (!otherRecord.has(value)) return false
+  }
+  return true
+}
+
+/** @internal */
+export function isSetLikeSupersetOf<T>(
+  set: ReadonlySetLike<T>,
+  other: ReadonlySetLike<unknown>
+): boolean {
+  const otherRecord = getSetRecord(other)
+  if (set.size < otherRecord.size) return false
+  for (const value of otherRecord.keys) {
+    if (!set.has(value as T)) return false
+  }
+  return true
+}
+
+/** @internal */
+export function isSetLikeDisjointFrom<T>(
+  set: ReadonlySetLike<T>,
+  other: ReadonlySetLike<unknown>
+): boolean {
+  const otherRecord = getSetRecord(other)
+  if (set.size <= otherRecord.size) {
+    for (const value of keysOf(set)) {
+      if (otherRecord.has(value)) return false
+    }
+  } else {
+    for (const value of otherRecord.keys) {
+      if (set.has(value as T)) return false
+    }
+  }
+  return true
+}
+
+/** @internal */
+export function setLikeUnion<T, U>(set: ReadonlySetLike<T>, other: ReadonlySetLike<U>): Set<T | U> {
+  const otherRecord = getSetRecord(other)
+  const result = new Set<T | U>(keysOf(set))
+  for (const value of otherRecord.keys) result.add(value)
+  return result
+}
+
+/** @internal */
+export function setLikeIntersection<T, U>(
+  set: ReadonlySetLike<T>,
+  other: ReadonlySetLike<U>
+): Set<T & U> {
+  const otherRecord = getSetRecord(other)
+  const result = new Set<T & U>()
+  if (set.size <= otherRecord.size) {
+    for (const value of keysOf(set)) {
+      if (otherRecord.has(value as unknown as U)) result.add(value as T & U)
+    }
+  } else {
+    for (const value of otherRecord.keys) {
+      if (set.has(value as unknown as T)) result.add(value as T & U)
+    }
+  }
+  return result
+}
+
+/** @internal */
+export function setLikeDifference<T>(
+  set: ReadonlySetLike<T>,
+  other: ReadonlySetLike<unknown>
+): Set<T> {
+  const otherRecord = getSetRecord(other)
+  const result = new Set<T>()
+  if (set.size <= otherRecord.size) {
+    for (const value of keysOf(set)) {
+      if (!otherRecord.has(value)) result.add(value)
+    }
+  } else {
+    for (const value of keysOf(set)) result.add(value)
+    for (const value of otherRecord.keys) result.delete(value as T)
+  }
+  return result
+}
+
+/** @internal */
+export function setLikeSymmetricDifference<T, U>(
+  set: ReadonlySetLike<T>,
+  other: ReadonlySetLike<U>
+): Set<T | U> {
+  const otherRecord = getSetRecord(other)
+  const result = new Set<T | U>(keysOf(set))
+  // Remember keys already processed: duplicate keys must not toggle membership.
+  // Use the decoded result's equality, just like the native Set result.
+  const seen = new Set<U>()
+  for (const value of otherRecord.keys) {
+    if (seen.has(value)) continue
+    seen.add(value)
+    if (!result.delete(value)) result.add(value)
+  }
+  return result
+}

package/src/wrappers/ArraySet.ts

@@ -1,4 +1,3 @@
-import { values } from "mobx"
 import { modelAction } from "../action/modelAction"
 import type { AnyModel } from "../model/BaseModel"
 import { Model } from "../model/Model"
@@ -48,7 +47,7 @@ export class ArraySet<V> extends arraySetBase implements Set<V> {
   delete(value: V): boolean {
     const items = this.items
 
-    const index = items.indexOf(value)
+    const index = Number.isNaN(value) ? items.findIndex(Number.isNaN) : items.indexOf(value)
     if (index >= 0) {
       items.splice(index, 1)
       return true
@@ -75,15 +74,12 @@ export class ArraySet<V> extends arraySetBase implements Set<V> {
     return this.items.length
   }
 
-  *keys(): ReturnType<Set<V>["keys"]> {
-    // yes, values
-    for (const value of values(this.items)) {
-      yield value as V
-    }
+  keys(): ReturnType<Set<V>["keys"]> {
+    return this.values()
   }
 
   *values(): ReturnType<Set<V>["values"]> {
-    for (const value of values(this.items)) {
+    for (const value of this.items) {
       yield value as V
     }
   }
@@ -150,7 +146,7 @@ export interface ArraySet<V> {
  * @param [values] Optional initial values.
  */
 export function arraySet<V>(values?: ReadonlyArray<V> | null): ArraySet<V> {
-  const initialArr: V[] = values ? values.slice() : []
+  const initialArr: V[] = values ? Array.from(new Set(values)) : []
 
   return new ArraySet({ items: initialArr })
 }

package/src/wrappers/ObjectMap.ts

@@ -8,7 +8,7 @@ import { idProp } from "../modelShared/prop"
 import { typesRecord } from "../types/objectBased/typesRecord"
 import { tProp } from "../types/tProp"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
-import { namespace } from "../utils"
+import { namespace, setProtoProp } from "../utils"
 import { setIfDifferent } from "../utils/setIfDifferent"
 
 const objectMapBase = Model({
@@ -34,11 +34,11 @@ export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
   clear(): void {
     const items = this.items
 
-    const keys = Object.keys(items)
-    const len = keys.length
+    // Object.keys is enough here: this is a write, so there is nothing to observe.
+    const itemKeys = Object.keys(items)
+    const len = itemKeys.length
     for (let i = 0; i < len; i++) {
-      const k = keys[i]
-      remove(items, k)
+      remove(items, itemKeys[i])
     }
   }
 
@@ -57,10 +57,10 @@ export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
     // we cannot use the map implementation since we need to pass this as map
     const items = this.items
 
-    const keys = Object.keys(items)
-    const len = keys.length
+    const itemKeys = keys(items)
+    const len = itemKeys.length
     for (let i = 0; i < len; i++) {
-      const k = keys[i]
+      const k = itemKeys[i] as string
       callbackfn.call(thisArg, items[k], k, this)
     }
   }
@@ -75,7 +75,7 @@ export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
     }
 
     this.set(key, defaultValue)
-    return defaultValue
+    return this.get(key) as V
   }
 
   getOrInsertComputed(key: string, callback: (key: string) => V): V {
@@ -85,7 +85,7 @@ export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
 
     const value = callback(key)
     this.set(key, value)
-    return value
+    return this.get(key) as V
   }
 
   has(key: string): boolean {
@@ -147,7 +147,11 @@ export function objectMap<V>(entries?: ReadonlyArray<readonly [string, V]> | nul
     const len = entries.length
     for (let i = 0; i < len; i++) {
       const entry = entries[i]
-      initialObj[entry[0]] = entry[1]
+      if (entry[0] === "__proto__") {
+        setProtoProp(initialObj, entry[1])
+      } else {
+        initialObj[entry[0]] = entry[1]
+      }
     }
   }
 

package/src/wrappers/asMap.ts

@@ -20,8 +20,11 @@ import {
   assertIsObservableObject,
   failure,
   getMobxVersion,
+  hasOwnProp,
   inDevMode,
   isArray,
+  isEqualOrBothNaN,
+  setProtoProp,
 } from "../utils"
 import { setIfDifferent } from "../utils/setIfDifferent"
 import { tag } from "../utils/tag"
@@ -46,7 +49,7 @@ function addTs6MapExtras<K, V>(map: ObservableMap<K, V>): ObservableMap<K, V> &
       }
 
       this.set(key, defaultValue)
-      return defaultValue
+      return this.get(key) as V
     }
   }
 
@@ -58,7 +61,7 @@ function addTs6MapExtras<K, V>(map: ObservableMap<K, V>): ObservableMap<K, V> &
 
       const value = callback(key)
       this.set(key, value)
-      return value
+      return this.get(key) as V
     }
   }
 
@@ -75,7 +78,7 @@ const observableMapBackedByObservableObject = action(
 
     const map = transaction(() =>
       untracked(() => {
-        const map = observable.map<string, T>()
+        const map = observable.map<string, T>(undefined, { deep: false })
 
         const keys = Object.keys(obj)
         for (let i = 0; i < keys.length; i++) {
@@ -143,11 +146,14 @@ const observableMapBackedByObservableObject = action(
             case "add":
             case "update": {
               setIfDifferent(obj, change.name, change.newValue)
+              if (!hasOwnProp(obj, change.name)) return null
+              change.newValue = (obj as Record<string, T>)[change.name]
               break
             }
 
             case "delete": {
               remove(obj, change.name)
+              if (hasOwnProp(obj, change.name)) return null
               break
             }
 
@@ -166,20 +172,20 @@ const observableMapBackedByObservableObject = action(
   }
 )
 
-const observableMapBackedByObservableArray = <T>(
-  array: IObservableArray<[string, T]>
-): ObservableMapWithDataObject<string, T, typeof array> => {
+const observableMapBackedByObservableArray = <K, T>(
+  array: IObservableArray<[K, T]>
+): ObservableMapWithDataObject<K, T, typeof array> => {
   if (inDevMode) {
     if (!isObservableArray(array)) {
       throw failure("assertion failed: expected an observable array")
     }
   }
 
-  const map: ObservableMap<string, T> = untracked(() => {
+  const map: ObservableMap<K, T> = untracked(() => {
     if (getMobxVersion() >= 6) {
-      return observable.map<string, T>(array)
+      return observable.map<K, T>(array, { deep: false })
     } else {
-      const map = observable.map<string, T>()
+      const map = observable.map<K, T>(undefined, { deep: false })
       runInAction(() => {
         array.forEach(([k, v]) => {
           map.set(k, v)
@@ -204,7 +210,7 @@ const observableMapBackedByObservableArray = <T>(
   // when the array changes the map changes
   observe(
     array,
-    action((change: any /*IArrayDidChange<[string, T]>*/) => {
+    action((change: any /*IArrayDidChange<[K, T]>*/) => {
       if (mapAlreadyChanged) {
         return
       }
@@ -248,7 +254,7 @@ const observableMapBackedByObservableArray = <T>(
   // when the map changes also change the array
   intercept(
     map,
-    action((change: IMapWillChange<string, T>) => {
+    action((change: IMapWillChange<K, T>) => {
       if (mapAlreadyChanged) {
         return null
       }
@@ -263,21 +269,23 @@ const observableMapBackedByObservableArray = <T>(
         switch (change.type) {
           case "update": {
             // replace the whole tuple to keep tuple immutability
-            const i = array.findIndex((i) => i[0] === change.name)
+            const i = array.findIndex((entry) => isEqualOrBothNaN(entry[0], change.name))
             array[i] = [change.name, change.newValue!]
+            change.newValue = array[i][1]
             break
           }
 
           case "add": {
+            const oldLength = array.length
             array.push([change.name, change.newValue!])
+            if (array.length === oldLength) return null
+            change.newValue = array[array.length - 1][1]
             break
           }
 
           case "delete": {
-            const i = array.findIndex((i) => i[0] === change.name)
-            if (i >= 0) {
-              array.splice(i, 1)
-            }
+            const i = array.findIndex((entry) => isEqualOrBothNaN(entry[0], change.name))
+            if (i >= 0 && array.splice(i, 1).length === 0) return null
             break
           }
 
@@ -295,7 +303,7 @@ const observableMapBackedByObservableArray = <T>(
   return mapWithExtras as any
 }
 
-const asMapTag = tag((objOrArray: Record<string, any> | Array<[string, any]>) => {
+const asMapTag = tag((objOrArray: Record<string, unknown> | Array<[unknown, unknown]>) => {
   if (isArray(objOrArray)) {
     assertIsObservableArray(objOrArray, "objOrArray")
     return observableMapBackedByObservableArray(objOrArray)
@@ -347,7 +355,11 @@ export function mapToObject<T>(map: Pick<Map<string, T>, "forEach">): Record<str
 
   const obj: Record<string, T> = {}
   map.forEach((v, k) => {
-    obj[k] = v
+    if (k === "__proto__") {
+      setProtoProp(obj, v)
+    } else {
+      obj[k] = v
+    }
   })
 
   return obj

package/src/wrappers/asSet.ts

@@ -11,7 +11,14 @@ import {
   transaction,
   untracked,
 } from "mobx"
-import { assertIsObservableArray, assertIsSet, failure, getMobxVersion, inDevMode } from "../utils"
+import {
+  assertIsObservableArray,
+  assertIsSet,
+  failure,
+  getMobxVersion,
+  inDevMode,
+  isEqualOrBothNaN,
+} from "../utils"
 import { tag } from "../utils/tag"
 
 const observableSetBackedByObservableArray = <T>(
@@ -26,9 +33,9 @@ const observableSetBackedByObservableArray = <T>(
   const set = transaction(() =>
     untracked(() => {
       if (getMobxVersion() >= 6) {
-        return observable.set(array)
+        return observable.set(array, { deep: false })
       } else {
-        const set = observable.set()
+        const set = observable.set<T>(undefined, { deep: false })
         runInAction(() => {
           array.forEach((item) => {
             set.add(item)
@@ -98,28 +105,45 @@ const observableSetBackedByObservableArray = <T>(
   intercept(
     set,
     action((change: ISetWillChange<T>) => {
-      if (setAlreadyChanged) {
-        return null
-      }
-
       if (arrayAlreadyChanged) {
         return change
       }
 
+      if (setAlreadyChanged) {
+        return null
+      }
+
       setAlreadyChanged = true
 
       try {
         switch (change.type) {
           case "add": {
-            array.push(change.newValue)
+            if (!set.has(change.newValue)) {
+              const oldLength = array.length
+              array.push(change.newValue)
+              if (array.length === oldLength) return null
+              const storedValue = array[array.length - 1]
+              if (getMobxVersion() >= 6) {
+                change.newValue = storedValue
+              } else if (!isEqualOrBothNaN(storedValue, change.newValue)) {
+                // MobX 4/5 ignore replacement values returned by set interceptors.
+                arrayAlreadyChanged = true
+                try {
+                  set.add(storedValue)
+                } finally {
+                  arrayAlreadyChanged = false
+                }
+                return null
+              }
+            }
             break
           }
 
           case "delete": {
-            const i = array.indexOf(change.oldValue)
-            if (i >= 0) {
-              array.splice(i, 1)
-            }
+            const i = Number.isNaN(change.oldValue)
+              ? array.findIndex(Number.isNaN)
+              : array.indexOf(change.oldValue)
+            if (i >= 0 && array.splice(i, 1).length === 0) return null
             break
           }
 

package/dist/types/action/modelFlowPromiseGenerator.d.ts

@@ -1 +0,0 @@
-export declare function promiseGenerator(this: Promise<any>): any;