mobx-keystone 1.25.0 → 2.1.0

package/src/utils/forEachWithDelayedThrow.ts

@@ -0,0 +1,83 @@
+import { MobxKeystoneAggregateError } from "./index"
+
+/**
+ * A failure kept aside while the rest of a delivery runs. It is boxed so that a thrown
+ * `undefined` / `null` can still be rethrown as is, and holds a `MobxKeystoneAggregateError`
+ * once more than one callback of the same delivery has failed.
+ * @internal
+ */
+export type DelayedError =
+  | { value: unknown; aggregateErrors?: undefined }
+  | { value: MobxKeystoneAggregateError; aggregateErrors: unknown[] }
+  | undefined
+
+/**
+ * Adds a failure to the ones already kept aside for the same delivery: a lone failure is kept
+ * as is, several are grouped in a `MobxKeystoneAggregateError`. Nested delivery is flattened,
+ * so `errors` is always a flat list of callback failures. The accumulator is updated in place.
+ * @internal
+ */
+export function addDelayedError(
+  current: DelayedError,
+  error: unknown,
+  msg = "multiple callbacks failed"
+): DelayedError {
+  if (!current) {
+    return { value: error }
+  }
+
+  let errors = current.aggregateErrors
+  if (!errors) {
+    // Start from a copy: an aggregate thrown by a callback is not ours to mutate.
+    errors = flattenDelayedError(current.value)
+    current = { value: new MobxKeystoneAggregateError(errors, msg), aggregateErrors: errors }
+  }
+
+  pushDelayedError(errors, error)
+  return current
+}
+
+/**
+ * Reports the failures kept aside for a delivery, if there were any.
+ * @internal
+ */
+export function throwDelayedError(delayedError: DelayedError): void {
+  if (delayedError) {
+    throw delayedError.value
+  }
+}
+
+/**
+ * Runs every callback, then reports the failures (if any) once delivery has finished.
+ * Iterates the collection directly, so appended array items are also visited.
+ * @internal
+ */
+export function forEachWithDelayedThrow<T>(items: Iterable<T>, fn: (item: T) => void): void {
+  let delayedError: DelayedError
+  for (const item of items) {
+    try {
+      fn(item)
+    } catch (error) {
+      delayedError = addDelayedError(delayedError, error)
+    }
+  }
+  throwDelayedError(delayedError)
+}
+
+/** @internal */
+export function flattenDelayedError(error: unknown): unknown[] {
+  return error instanceof MobxKeystoneAggregateError ? [...error.errors] : [error]
+}
+
+/** @internal */
+export function pushDelayedError(errors: unknown[], error: unknown): void {
+  if (error instanceof MobxKeystoneAggregateError) {
+    const nestedErrors = error.errors
+    const length = nestedErrors.length
+    for (let i = 0; i < length; i++) {
+      errors.push(nestedErrors[i])
+    }
+  } else {
+    errors.push(error)
+  }
+}

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
@@ -526,6 +558,43 @@ function isStandardDecoratorContext(value: unknown): boolean {
   )
 }
 
+/**
+ * Options for the observable objects of tree nodes. Their values are never
+ * functions nor getters, so the shared `observable.ref` annotation (MobX 7
+ * `observableRef`) is equivalent to `deep: false` alone, which MobX 6+ would
+ * allocate an annotation for on every object.
+ *
+ * @internal
+ */
+export const nodeObservableOptions = {
+  deep: false,
+  defaultDecorator:
+    // (computed so bundlers do not warn about the export missing in MobX < 7)
+    (mobx as any)[["observable", "Ref"].join("")] ?? (mobx.observable as any).ref,
+}
+
+// the key MobX 6 stores legacy decorator annotations under (null if unknown)
+let storedMobxAnnotationsKey: symbol | null | undefined
+
+/**
+ * Whether an instance has legacy decorator annotations for MobX 6
+ * `makeObservable` to apply. When their key cannot be found it answers true,
+ * so `makeObservable` is still called.
+ *
+ * @internal
+ */
+export function hasStoredMobxAnnotations(instance: object): boolean {
+  if (storedMobxAnnotationsKey === undefined) {
+    // a legacy decorator call stores its annotation under that key
+    const probe = {}
+    ;(mobx.observable as any)(probe, "probe")
+    storedMobxAnnotationsKey = Object.getOwnPropertySymbols(probe)[0] ?? null
+  }
+  return (
+    storedMobxAnnotationsKey === null || (instance as any)[storedMobxAnnotationsKey] !== undefined
+  )
+}
+
 /**
  * Calls `makeObservable` across MobX versions. MobX 7 requires an annotations
  * object, while MobX 6 and older versions use decorator metadata when no
@@ -545,7 +614,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