mobx-keystone 2.0.0 → 2.2.0

package/src/utils/index.ts

@@ -267,15 +267,6 @@ export function assertIsObject(value: unknown, argName: string): asserts value i
   }
 }
 
-/**
- * @internal
- */
-export function assertIsPlainObject(value: unknown, argName: string): asserts value is object {
-  if (!isPlainObject(value)) {
-    throw failure(`${argName} must be a plain object`)
-  }
-}
-
 /**
  * @internal
  */
@@ -342,15 +333,6 @@ export function assertIsPrimitive(
   }
 }
 
-/**
- * @internal
- */
-export function assertIsString(value: unknown, argName: string): asserts value is string {
-  if (typeof value !== "string") {
-    throw failure(`${argName} must be a string`)
-  }
-}
-
 /**
  * @internal
  */
@@ -372,8 +354,7 @@ export function addLateInitializationFunction(
   fn: (instance: any) => void
 ) {
   let array: LateInitializationFunctionsArray | undefined = target[symbol]
-  // biome-ignore lint/suspicious/noPrototypeBuiltins: support old browsers
-  if (!(array && Object.prototype.hasOwnProperty.call(target, symbol))) {
+  if (!(array && hasOwnProp(target, symbol))) {
     // leave base array unmodified, create new array in the derived class
     array = array ? array.slice() : []
     addHiddenProp(target, symbol, array)
@@ -558,6 +539,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

package/src/utils/types.ts

@@ -46,3 +46,8 @@ export type IsNeverType<T, IfNever, IfNotNever> = [T] extends [never] ? IfNever
  * @ignore
  */
 export type Flatten<T> = T extends Record<any, any> ? { [P in keyof T]: T[P] } : T
+
+/**
+ * @ignore
+ */
+export type SimplifyObject<T> = { [P in keyof T]: T[P] } & {}

package/src/wrappers/ArraySet.ts

@@ -8,6 +8,15 @@ import { typesArray } from "../types/arrayBased/typesArray"
 import { tProp } from "../types/tProp"
 import { typesUnchecked } from "../types/utility/typesUnchecked"
 import { namespace } from "../utils"
+import {
+  isSetLikeDisjointFrom,
+  isSetLikeSubsetOf,
+  isSetLikeSupersetOf,
+  setLikeDifference,
+  setLikeIntersection,
+  setLikeSymmetricDifference,
+  setLikeUnion,
+} from "../utils/setLike"
 
 const arraySetBase = Model({
   [modelIdKey]: idProp,
@@ -96,39 +105,43 @@ export class ArraySet<V> extends arraySetBase implements Set<V> {
 
   readonly [Symbol.toStringTag] = "ArraySet"
 
+  // `has` scans the items, so the set operations look values up in a set built
+  // on the first lookup instead (not before, since many of them never look up)
+  private toSetLike(): ReadonlySetLike<V> {
+    let lookup: Set<V> | undefined
+    return {
+      size: this.items.length,
+      has: (value) => (lookup ??= new Set(this.items)).has(value),
+      keys: () => this.values(),
+    }
+  }
+
   union<U>(other: ReadonlySetLike<U>): Set<V | U> {
-    const s = new Set(this)
-    return s.union(other)
+    return setLikeUnion(this.toSetLike(), other)
   }
 
   intersection<U>(other: ReadonlySetLike<U>): Set<V & U> {
-    const s = new Set(this)
-    return s.intersection(other)
+    return setLikeIntersection(this.toSetLike(), other)
   }
 
   difference<U>(other: ReadonlySetLike<U>): Set<V> {
-    const s = new Set(this)
-    return s.difference(other)
+    return setLikeDifference(this.toSetLike(), other)
   }
 
   symmetricDifference<U>(other: ReadonlySetLike<U>): Set<V | U> {
-    const s = new Set(this)
-    return s.symmetricDifference(other)
+    return setLikeSymmetricDifference(this.toSetLike(), other)
   }
 
   isSubsetOf(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isSubsetOf(other)
+    return isSetLikeSubsetOf(this.toSetLike(), other)
   }
 
   isSupersetOf(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isSupersetOf(other)
+    return isSetLikeSupersetOf(this.toSetLike(), other)
   }
 
   isDisjointFrom(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isDisjointFrom(other)
+    return isSetLikeDisjointFrom(this.toSetLike(), other)
   }
 }
 

package/src/wrappers/ObjectMap.ts

@@ -70,12 +70,7 @@ export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
   }
 
   getOrInsert(key: string, defaultValue: V): V {
-    if (this.has(key)) {
-      return this.get(key) as V
-    }
-
-    this.set(key, defaultValue)
-    return this.get(key) as V
+    return this.getOrInsertComputed(key, () => defaultValue)
   }
 
   getOrInsertComputed(key: string, callback: (key: string) => V): V {

package/src/wrappers/asMap.ts

@@ -4,8 +4,6 @@ import {
   type IObjectDidChange,
   type IObservableArray,
   intercept,
-  isObservableArray,
-  isObservableObject,
   type ObservableMap,
   observable,
   observe,
@@ -21,7 +19,6 @@ import {
   failure,
   getMobxVersion,
   hasOwnProp,
-  inDevMode,
   isArray,
   isEqualOrBothNaN,
   setProtoProp,
@@ -44,12 +41,7 @@ function addTs6MapExtras<K, V>(map: ObservableMap<K, V>): ObservableMap<K, V> &
 
   if (!mapWithExtras.getOrInsert) {
     mapWithExtras.getOrInsert = function (key: K, defaultValue: V): V {
-      if (this.has(key)) {
-        return this.get(key) as V
-      }
-
-      this.set(key, defaultValue)
-      return this.get(key) as V
+      return this.getOrInsertComputed(key, () => defaultValue)
     }
   }
 
@@ -70,12 +62,6 @@ function addTs6MapExtras<K, V>(map: ObservableMap<K, V>): ObservableMap<K, V> &
 
 const observableMapBackedByObservableObject = action(
   <T>(obj: object): ObservableMapWithDataObject<string, T, typeof obj> => {
-    if (inDevMode) {
-      if (!isObservableObject(obj)) {
-        throw failure("assertion failed: expected an observable object")
-      }
-    }
-
     const map = transaction(() =>
       untracked(() => {
         const map = observable.map<string, T>(undefined, { deep: false })
@@ -175,12 +161,6 @@ const observableMapBackedByObservableObject = action(
 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<K, T> = untracked(() => {
     if (getMobxVersion() >= 6) {
       return observable.map<K, T>(array, { deep: false })

package/src/wrappers/asSet.ts

@@ -3,7 +3,6 @@ import {
   type IObservableArray,
   type ISetWillChange,
   intercept,
-  isObservableArray,
   type ObservableSet,
   observable,
   observe,
@@ -16,7 +15,6 @@ import {
   assertIsSet,
   failure,
   getMobxVersion,
-  inDevMode,
   isEqualOrBothNaN,
 } from "../utils"
 import { tag } from "../utils/tag"
@@ -24,12 +22,6 @@ import { tag } from "../utils/tag"
 const observableSetBackedByObservableArray = <T>(
   array: IObservableArray<T>
 ): ObservableSet<T> & { dataObject: typeof array } => {
-  if (inDevMode) {
-    if (!isObservableArray(array)) {
-      throw failure("assertion failed: expected an observable array")
-    }
-  }
-
   const set = transaction(() =>
     untracked(() => {
       if (getMobxVersion() >= 6) {