mobx-keystone 1.25.0 → 2.1.0

package/src/types/utility/typesMap.ts

@@ -1,5 +1,5 @@
 import type { ModelPropTransform } from "../../modelShared/prop"
-import { isMap } from "../../utils"
+import { isMap, setProtoProp } from "../../utils"
 import { asMap } from "../../wrappers/asMap"
 import { typesArray } from "../arrayBased/typesArray"
 import { typesTuple } from "../arrayBased/typesTuple"
@@ -19,6 +19,15 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
   keyAdapter: RuntimeAdapter<TKeyStored, TKeyRuntime>,
   valueAdapter: RuntimeAdapter<TValueStored, TValueRuntime>
 ): Map<TKeyRuntime, TValueRuntime> {
+  // Writes through the decoded value must land back on the entry it came from.
+  const toRuntimeValue = (storedKey: TKeyStored, storedValue: TValueStored): TValueRuntime =>
+    valueAdapter.toRuntime(storedValue, (newStoredValue) => {
+      storedMap.set(storedKey, newStoredValue)
+    })
+
+  const getValue = (storedKey: TKeyStored): TValueRuntime =>
+    toRuntimeValue(storedKey, storedMap.get(storedKey) as TValueStored)
+
   return new Proxy(storedMap, {
     get(target, prop, receiver) {
       switch (prop) {
@@ -29,43 +38,24 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
               return undefined
             }
 
-            return valueAdapter.toRuntime(
-              target.get(storedKey) as TValueStored,
-              (newStoredValue) => {
-                target.set(storedKey, newStoredValue)
-              }
-            )
+            return getValue(storedKey)
           }
         case "getOrInsert":
           return (key: TKeyRuntime, defaultValue: TValueRuntime) => {
             const storedKey = keyAdapter.toStored(key)
-            if (target.has(storedKey)) {
-              return valueAdapter.toRuntime(
-                target.get(storedKey) as TValueStored,
-                (newStoredValue) => {
-                  target.set(storedKey, newStoredValue)
-                }
-              )
+            if (!target.has(storedKey)) {
+              target.set(storedKey, valueAdapter.toStored(defaultValue))
             }
-
-            target.set(storedKey, valueAdapter.toStored(defaultValue))
-            return defaultValue
+            return getValue(storedKey)
           }
         case "getOrInsertComputed":
           return (key: TKeyRuntime, callback: (key: TKeyRuntime) => TValueRuntime) => {
             const storedKey = keyAdapter.toStored(key)
-            if (target.has(storedKey)) {
-              return valueAdapter.toRuntime(
-                target.get(storedKey) as TValueStored,
-                (newStoredValue) => {
-                  target.set(storedKey, newStoredValue)
-                }
-              )
+            if (!target.has(storedKey)) {
+              const value = callback(key)
+              target.set(storedKey, valueAdapter.toStored(value))
             }
-
-            const value = callback(key)
-            target.set(storedKey, valueAdapter.toStored(value))
-            return value
+            return getValue(storedKey)
           }
         case "set":
           return (key: TKeyRuntime, value: TValueRuntime) => {
@@ -92,9 +82,7 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
             target.forEach((value, key) => {
               callback.call(
                 thisArg,
-                valueAdapter.toRuntime(value, (newStoredValue) => {
-                  target.set(key, newStoredValue)
-                }),
+                toRuntimeValue(key, value),
                 keyAdapter.toRuntime(key),
                 receiver
               )
@@ -104,12 +92,7 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
         case Symbol.iterator:
           return function* () {
             for (const [key, value] of target.entries()) {
-              yield [
-                keyAdapter.toRuntime(key),
-                valueAdapter.toRuntime(value, (newStoredValue) => {
-                  target.set(key, newStoredValue)
-                }),
-              ] as const
+              yield [keyAdapter.toRuntime(key), toRuntimeValue(key, value)] as const
             }
           }
         case "keys":
@@ -121,9 +104,7 @@ function makeMapProxy<TKeyStored, TKeyRuntime, TValueStored, TValueRuntime>(
         case "values":
           return function* () {
             for (const [key, value] of target.entries()) {
-              yield valueAdapter.toRuntime(value, (newStoredValue) => {
-                target.set(key, newStoredValue)
-              })
+              yield toRuntimeValue(key, value)
             }
           }
         default:
@@ -158,7 +139,9 @@ function makeObjectBackedMapTransform<TStoredValue, TRuntimeValue>(
 
       const result: Record<string, TStoredValue> = {}
       transformedValue.forEach((value, key) => {
-        result[key] = valueAdapter.toStored(value)
+        const storedValue = valueAdapter.toStored(value)
+        if (key === "__proto__") setProtoProp(result, storedValue)
+        else result[key] = storedValue
       })
       return result
     },

package/src/types/utility/typesRefinement.ts

@@ -41,8 +41,8 @@ import {
  * @template T Base type.
  * @param baseType Base type.
  * @param checkFn Function that will receive the data (if it passes the base type
- * check) and return null or false if there were no errors or either a TypeCheckError instance or
- * true if there were.
+ * check) and return null or true if there were no errors or either a TypeCheckError instance or
+ * false if there were.
  * @returns
  */
 export function typesRefinement<T extends AnyType>(
@@ -89,6 +89,7 @@ export function typesRefinement<T extends AnyType>(
           // override typeCheckedValue
           return new TypeCheckError({
             path: refinementErr.path,
+            modelTrail: refinementErr.modelTrail,
             expectedTypeName: refinementErr.expectedTypeName,
             actualValue: refinementErr.actualValue,
             typeCheckedValue,

package/src/types/utility/typesSet.ts

@@ -1,6 +1,15 @@
 import type { ObservableSet } from "mobx"
 import type { ModelPropTransform } from "../../modelShared/prop"
 import { isSet } from "../../utils"
+import {
+  isSetLikeDisjointFrom,
+  isSetLikeSubsetOf,
+  isSetLikeSupersetOf,
+  setLikeDifference,
+  setLikeIntersection,
+  setLikeSymmetricDifference,
+  setLikeUnion,
+} from "../../utils/setLike"
 import { asSet } from "../../wrappers/asSet"
 import { typesArray } from "../arrayBased/typesArray"
 import type { AnyType, ArrayType, TypeToData } from "../schemas"
@@ -52,6 +61,21 @@ function makeArrayBackedSetTransform<TStored, TRuntime>(
                   callback.call(thisArg, runtimeValue, runtimeValue, receiver)
                 })
               }
+            case "union":
+              return (other: ReadonlySetLike<unknown>) => setLikeUnion(receiver, other)
+            case "intersection":
+              return (other: ReadonlySetLike<unknown>) => setLikeIntersection(receiver, other)
+            case "difference":
+              return (other: ReadonlySetLike<unknown>) => setLikeDifference(receiver, other)
+            case "symmetricDifference":
+              return (other: ReadonlySetLike<unknown>) =>
+                setLikeSymmetricDifference(receiver, other)
+            case "isSubsetOf":
+              return (other: ReadonlySetLike<unknown>) => isSetLikeSubsetOf(receiver, other)
+            case "isSupersetOf":
+              return (other: ReadonlySetLike<unknown>) => isSetLikeSupersetOf(receiver, other)
+            case "isDisjointFrom":
+              return (other: ReadonlySetLike<unknown>) => isSetLikeDisjointFrom(receiver, other)
             case "entries":
               return function* () {
                 for (const value of target.values()) {

package/src/utils/ModelPool.ts

@@ -6,25 +6,45 @@ import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName } from "../modelShared/modelInfo"
 import { dataToModelNode } from "../parent/core"
 import {
-  getDeepObjectChildren,
+  type DeepObjectChildrenExtensionAccessor,
+  type PinnedDeepObjectChildrenExtensionData,
   registerDeepObjectChildrenExtension,
 } from "../parent/coreObjectChildren"
+import { getOrCreate } from "./mapUtils"
 
 type ModelsById = Map<string, AnyModel>
 type ModelsByTypeAndId = Map<string, ModelsById>
 
+interface DeepChildrenModels {
+  readonly byTypeAndId: ModelsByTypeAndId
+  /** Id each model is indexed under, since ids can change later. */
+  readonly indexedIds: Map<AnyModel, string>
+  /** Whether some model was shadowed by another one with the same type and id. */
+  hasDuplicates: boolean
+}
+
+/**
+ * A view of the models under a node, as they were when the pool was created.
+ * Must be released once no longer used.
+ */
 export class ModelPool {
-  private pool: ReadonlyMap<string, ReadonlyMap<string, AnyModel>>
+  private readonly pool: ReadonlyMap<string, ReadonlyMap<string, AnyModel>>
+  private readonly pinned: PinnedDeepObjectChildrenExtensionData<DeepChildrenModels>
 
   constructor(root: object) {
     // make sure we don't use the sub-data $ object
     root = dataToModelNode(root)
 
-    this.pool = getDeepChildrenModels(getDeepObjectChildren(root))
+    this.pinned = getDeepChildrenModels().pin(root)
+    this.pool = this.pinned.data.byTypeAndId
+  }
+
+  release(): void {
+    this.pinned.release()
   }
 
   findModelByTypeAndId(modelType: string, modelId: string | undefined): AnyModel | undefined {
-    return modelId ? this.pool.get(modelType)?.get(modelId) : undefined
+    return modelId !== undefined ? this.pool.get(modelType)?.get(modelId) : undefined
   }
 
   findModelForSnapshot(sn: any): AnyModel | undefined {
@@ -36,39 +56,75 @@ export class ModelPool {
     const modelInfo = getModelInfoForName(modelType)!
     const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
 
-    return modelIdPropertyName
+    return modelIdPropertyName !== undefined
       ? this.findModelByTypeAndId(modelType, (sn as any)[modelIdPropertyName])
       : undefined
   }
 }
 
-type GetDeepChildrenModels = (data: ReturnType<typeof getDeepObjectChildren>) => ModelsByTypeAndId
+let deepChildrenModels: DeepObjectChildrenExtensionAccessor<DeepChildrenModels> | undefined
 
-let getDeepChildrenModels: GetDeepChildrenModels = (data) => {
-  // Register on first use to keep ModelPool out of the coreObjectChildren
-  // module-initialization cycle. The extension getter backfills its index from
-  // data.deep, so registering after a deep-children set already exists is safe.
-  const getRegisteredDeepChildrenModels = registerDeepObjectChildrenExtension<ModelsByTypeAndId>({
+// Registered on first use to keep ModelPool out of the coreObjectChildren
+// module-initialization cycle.
+function getDeepChildrenModels() {
+  deepChildrenModels ??= registerDeepObjectChildrenExtension<DeepChildrenModels>({
     initData() {
-      return new Map()
+      return {
+        byTypeAndId: new Map(),
+        indexedIds: new Map(),
+        hasDuplicates: false,
+      }
     },
 
-    addNode(node, extensionData) {
+    // last one wins when rebuilding
+    addNode(node, data) {
       if (isModel(node)) {
         const id = node[modelIdKey]
-        if (id) {
-          const modelType = node[modelTypeKey]
-          let modelsById = extensionData.get(modelType)
-          if (!modelsById) {
-            modelsById = new Map()
-            extensionData.set(modelType, modelsById)
+        if (id !== undefined) {
+          const modelsById = getOrCreate(data.byTypeAndId, node[modelTypeKey], () => new Map())
+          const previous = modelsById.get(id)
+          if (previous) {
+            data.hasDuplicates = true
+            data.indexedIds.delete(previous)
           }
           modelsById.set(id, node)
+          data.indexedIds.set(node, id)
         }
       }
     },
-  })
 
-  getDeepChildrenModels = getRegisteredDeepChildrenModels
-  return getRegisteredDeepChildrenModels(data)
+    addNodeIncrementally(node, data) {
+      if (isModel(node)) {
+        const id = node[modelIdKey]
+        if (id !== undefined) {
+          const modelsById = getOrCreate(data.byTypeAndId, node[modelTypeKey], () => new Map())
+          if (modelsById.has(id)) {
+            // which duplicate wins depends on the deep children order
+            return false
+          }
+          modelsById.set(id, node)
+          data.indexedIds.set(node, id)
+        }
+      }
+      return true
+    },
+
+    removeNode(node, data) {
+      if (isModel(node)) {
+        if (data.hasDuplicates) {
+          // a shadowed duplicate might need to take its place
+          return false
+        }
+        const id = data.indexedIds.get(node)
+        if (id !== undefined) {
+          data.indexedIds.delete(node)
+          data.byTypeAndId.get(node[modelTypeKey])!.delete(id)
+        }
+      }
+      return true
+    },
+
+    dependsOnModelIds: true,
+  })
+  return deepChildrenModels
 }

package/src/utils/chainFns.ts

@@ -4,6 +4,10 @@ export function chainFns<F extends Function>(...fns: (F | undefined)[]): F | und
     return undefined
   }
 
+  if (definedFns.length === 1) {
+    return definedFns[0]
+  }
+
   const chainedFn = (v: any, ...args: any[]) => {
     let ret = v
 

package/src/utils/chunks.ts

@@ -0,0 +1,271 @@
+/**
+ * Target size of the chunks large collections are split in, so a change only
+ * needs to revisit one chunk instead of every item.
+ *
+ * @internal
+ */
+export const chunkSize = 128
+
+/**
+ * @internal
+ */
+export interface SequenceChunk<T> {
+  items: T[]
+}
+
+/**
+ * An ordered sequence split in chunks, which splices keep near `chunkSize`:
+ * chunks are split above twice that size and merged below a quarter of it.
+ * Subclasses decide what a chunk keeps track of through the hooks.
+ *
+ * @internal
+ */
+export abstract class ChunkedSequence<T, C extends SequenceChunk<T>> {
+  chunks: C[] = []
+
+  protected abstract createChunk(items: T[]): C
+
+  /**
+   * Called once items were removed from or inserted into a chunk, before
+   * resizing it. The items from `from` on changed their position in it.
+   */
+  protected abstract onSpliced(chunk: C, from: number): void
+
+  /**
+   * Called when a resize moves items to another chunk, starting at `from`.
+   * The chunk they come from was already passed to `onSpliced`.
+   */
+  protected abstract onItemsMoved(chunk: C, from: number): void
+
+  /** Called for each chunk after the spliced ones when a splice changes the length. */
+  protected onShifted(_chunk: C): void {}
+
+  /** Splits items in new chunks, appended to the current ones. */
+  protected appendChunks(items: readonly T[]): void {
+    for (let i = 0; i < items.length; i += chunkSize) {
+      this.chunks.push(this.createChunk(items.slice(i, i + chunkSize)))
+    }
+  }
+
+  /** Replaces every chunk with new ones for the items. */
+  protected reset(items: readonly T[]): void {
+    this.chunks = []
+    this.appendChunks(items)
+  }
+
+  /** Chunk containing the index, and the index within it. Appends go to the last chunk. */
+  locate(index: number): [number, number] {
+    const chunks = this.chunks
+    let c = 0
+    let local = index
+    while (c < chunks.length - 1 && local >= chunks[c].items.length) {
+      local -= chunks[c].items.length
+      c++
+    }
+    return [c, local]
+  }
+
+  /**
+   * Removes and inserts items, like `Array.prototype.splice`. `onRemoved` is
+   * called with each removed item, the chunk it was in and its index there.
+   */
+  protected splice(
+    index: number,
+    removedCount: number,
+    added: readonly T[],
+    onRemoved?: (item: T, chunk: C, local: number) => void
+  ): void {
+    const chunks = this.chunks
+    if (chunks.length === 0) {
+      if (added.length === 0) {
+        return
+      }
+      chunks.push(this.createChunk([]))
+    }
+
+    const [first, start] = this.locate(index)
+    let last = first
+    let remaining = removedCount
+    let local = start
+    for (let c = first; remaining > 0; c++) {
+      const chunk = chunks[c]
+      const count = Math.min(remaining, chunk.items.length - local)
+      const removed = chunk.items.splice(local, count)
+      if (onRemoved) {
+        for (let i = 0; i < removed.length; i++) {
+          onRemoved(removed[i], chunk, local + i)
+        }
+      }
+      remaining -= count
+      local = 0
+      last = c
+    }
+
+    const firstChunk = chunks[first]
+    if (added.length > 0) {
+      firstChunk.items = firstChunk.items
+        .slice(0, start)
+        .concat(added as T[], firstChunk.items.slice(start))
+    }
+
+    this.onSpliced(firstChunk, start + added.length)
+    for (let c = first + 1; c <= last; c++) {
+      this.onSpliced(chunks[c], 0)
+    }
+    if (added.length !== removedCount) {
+      for (let c = last + 1; c < chunks.length; c++) {
+        this.onShifted(chunks[c])
+      }
+    }
+
+    // backwards, so merging or splitting a chunk does not move the ones left to visit
+    for (let c = last; c >= first; c--) {
+      this.resize(c)
+    }
+  }
+
+  /** Splits, merges or drops a changed chunk to keep its size near the target. */
+  private resize(c: number) {
+    const chunks = this.chunks
+    const chunk = chunks[c]
+    const length = chunk.items.length
+
+    if (length > 2 * chunkSize) {
+      const pieceCount = Math.ceil(length / chunkSize)
+      const pieceSize = Math.ceil(length / pieceCount)
+      const pieces: C[] = []
+      for (let i = pieceSize; i < length; i += pieceSize) {
+        const piece = this.createChunk(chunk.items.slice(i, i + pieceSize))
+        this.onItemsMoved(piece, 0)
+        pieces.push(piece)
+      }
+      chunk.items = chunk.items.slice(0, pieceSize)
+      this.chunks = chunks.slice(0, c + 1).concat(pieces, chunks.slice(c + 1))
+    } else if (length < chunkSize / 4) {
+      const previous = chunks[c - 1] as C | undefined
+      const next = chunks[c + 1] as C | undefined
+      if (previous && previous.items.length + length <= 2 * chunkSize) {
+        const from = previous.items.length
+        previous.items = previous.items.concat(chunk.items)
+        this.onItemsMoved(previous, from)
+        chunks.splice(c, 1)
+      } else if (next && next.items.length + length <= 2 * chunkSize) {
+        next.items = chunk.items.concat(next.items)
+        this.onItemsMoved(next, 0)
+        chunks.splice(c, 1)
+      } else if (length === 0) {
+        chunks.splice(c, 1)
+      }
+    }
+  }
+}
+
+/**
+ * An unordered set split in chunks. Items are added to the last chunk, and a
+ * chunk left under a quarter of `chunkSize` by removals is merged into a
+ * neighbor (or dropped once empty). Subclasses decide what a chunk keeps track
+ * of through the hooks.
+ *
+ * @internal
+ */
+export abstract class ChunkedSet<T, C extends SequenceChunk<T>> {
+  chunks: C[] = []
+  /** Chunk of each item, only needed (and kept) once an item is looked up. */
+  private chunkOf: Map<T, C> | undefined
+
+  protected abstract createChunk(items: T[]): C
+
+  /** Called when items were added to or removed from a chunk. */
+  protected abstract onChunkChanged(chunk: C): void
+
+  /** Called when chunks were added or removed. */
+  protected abstract onChunksChanged(): void
+
+  /** Called for a chunk removed after its items were moved to another one. */
+  protected onChunkDropped(_chunk: C): void {}
+
+  /** Splits items in new chunks, appended to the current ones. */
+  protected appendChunks(items: readonly T[]): void {
+    for (let i = 0; i < items.length; i += chunkSize) {
+      this.chunks.push(this.createChunk(items.slice(i, i + chunkSize)))
+    }
+  }
+
+  /** Replaces every chunk with new ones for the items. */
+  protected reset(items: readonly T[]): void {
+    this.chunks = []
+    this.chunkOf = undefined
+    this.appendChunks(items)
+  }
+
+  add(item: T): void {
+    let chunk = this.chunks[this.chunks.length - 1] as C | undefined
+    if (chunk && chunk.items.length < chunkSize) {
+      chunk.items.push(item)
+      this.onChunkChanged(chunk)
+    } else {
+      chunk = this.createChunk([item])
+      this.chunks.push(chunk)
+      this.onChunksChanged()
+    }
+    this.chunkOf?.set(item, chunk)
+  }
+
+  /** Chunk containing the item, if any. */
+  getChunkOf(item: T): C | undefined {
+    return this.getChunkOfMap().get(item)
+  }
+
+  private getChunkOfMap(): Map<T, C> {
+    if (!this.chunkOf) {
+      this.chunkOf = new Map()
+      for (const chunk of this.chunks) {
+        for (const i of chunk.items) {
+          this.chunkOf.set(i, chunk)
+        }
+      }
+    }
+    return this.chunkOf
+  }
+
+  /** Returns false if the item was not in the set. */
+  delete(item: T): boolean {
+    const chunkOf = this.getChunkOfMap()
+    const chunk = chunkOf.get(item)
+    if (!chunk) {
+      return false
+    }
+    chunkOf.delete(item)
+    // (the order within a chunk does not matter, so the last item fills the gap)
+    const items = chunk.items
+    const last = items.pop()!
+    if (last !== item) {
+      items[items.lastIndexOf(item)] = last
+    }
+    this.onChunkChanged(chunk)
+    if (chunk.items.length >= chunkSize / 4) {
+      return true
+    }
+
+    // merge it into a neighbor, or drop it once empty
+    const chunks = this.chunks
+    const c = chunks.indexOf(chunk)
+    if (chunk.items.length > 0) {
+      const neighbor = [chunks[c - 1], chunks[c + 1]].find(
+        (n) => n && n.items.length + chunk.items.length <= 2 * chunkSize
+      )
+      if (!neighbor) {
+        return true
+      }
+      for (const i of chunk.items) {
+        chunkOf.set(i, neighbor)
+      }
+      neighbor.items = neighbor.items.concat(chunk.items)
+      this.onChunkChanged(neighbor)
+    }
+    chunks.splice(c, 1)
+    this.onChunkDropped(chunk)
+    this.onChunksChanged()
+    return true
+  }
+}

package/src/utils/decorators.ts

@@ -110,7 +110,7 @@ export function decorateWrapMethodOrField(
     const baseDescriptor: PropertyDescriptor | undefined = args[2]
 
     checkModelDecoratorTaget(decoratorName, target)
-    checkDecoratorContext("transaction", propertyKey, false)
+    checkDecoratorContext(decoratorName, propertyKey, false)
 
     const data = getActionNameAndContextOverride(target, propertyKey, true)
 

package/src/utils/errorDiagnostics.ts

@@ -190,7 +190,7 @@ function formatErrorPathForMessage(path: Path | undefined = getErrorPathSnapshot
 /**
  * @internal
  */
-function getSafeErrorValuePreview(value: unknown, maxLen = 200): string {
+export function getSafeErrorValuePreview(value: unknown, maxLen = 200): string {
   let str: string | undefined
   try {
     str = JSON.stringify(value)
@@ -203,7 +203,11 @@ function getSafeErrorValuePreview(value: unknown, maxLen = 200): string {
     try {
       str = String(value)
     } catch {
-      str = Object.prototype.toString.call(value)
+      try {
+        str = Object.prototype.toString.call(value)
+      } catch {
+        str = "<unprintable value>"
+      }
     }
   }