mobx-keystone 1.20.0 → 1.22.0

package/src/snapshot/SnapshotProcessingError.ts

@@ -1,45 +1,45 @@
-import { Path } from "../parent/pathTypes"
-import { MobxKeystoneError } from "../utils"
-import {
-  buildErrorMessageWithDiagnostics,
-  getErrorModelTrailSnapshot,
-  getErrorPathSnapshot,
-  noErrorValuePreview,
-} from "../utils/errorDiagnostics"
-
-export interface SnapshotProcessingErrorData {
-  message: string
-  path?: Path
-  actualSnapshot?: any
-  modelTrail?: readonly string[]
-}
-
-/**
- * Thrown when a structural issue is encountered while processing a snapshot (extends `MobxKeystoneError`).
- *
- * Use `instanceof SnapshotProcessingError` to distinguish snapshot processing errors
- * from other `MobxKeystoneError` instances.
- */
-export class SnapshotProcessingError extends MobxKeystoneError {
-  readonly path: Path
-  readonly actualSnapshot?: any
-  readonly modelTrail?: readonly string[]
-
-  constructor(data: SnapshotProcessingErrorData) {
-    const path = data.path ?? getErrorPathSnapshot() ?? []
-    const modelTrail = data.modelTrail ?? getErrorModelTrailSnapshot()
-
-    super(
-      buildErrorMessageWithDiagnostics({
-        message: data.message,
-        path,
-        previewValue: "actualSnapshot" in data ? data.actualSnapshot : noErrorValuePreview,
-        modelTrail,
-      })
-    )
-
-    this.path = path
-    this.actualSnapshot = data.actualSnapshot
-    this.modelTrail = modelTrail
-  }
-}
+import type { Path } from "../parent/pathTypes"
+import { MobxKeystoneError } from "../utils"
+import {
+  buildErrorMessageWithDiagnostics,
+  getErrorModelTrailSnapshot,
+  getErrorPathSnapshot,
+  noErrorValuePreview,
+} from "../utils/errorDiagnostics"
+
+export interface SnapshotProcessingErrorData {
+  message: string
+  path?: Path
+  actualSnapshot?: any
+  modelTrail?: readonly string[]
+}
+
+/**
+ * Thrown when a structural issue is encountered while processing a snapshot (extends `MobxKeystoneError`).
+ *
+ * Use `instanceof SnapshotProcessingError` to distinguish snapshot processing errors
+ * from other `MobxKeystoneError` instances.
+ */
+export class SnapshotProcessingError extends MobxKeystoneError {
+  readonly path: Path
+  readonly actualSnapshot?: any
+  readonly modelTrail?: readonly string[]
+
+  constructor(data: SnapshotProcessingErrorData) {
+    const path = data.path ?? getErrorPathSnapshot() ?? []
+    const modelTrail = data.modelTrail ?? getErrorModelTrailSnapshot()
+
+    super(
+      buildErrorMessageWithDiagnostics({
+        message: data.message,
+        path,
+        previewValue: "actualSnapshot" in data ? data.actualSnapshot : noErrorValuePreview,
+        modelTrail,
+      })
+    )
+
+    this.path = path
+    this.actualSnapshot = data.actualSnapshot
+    this.modelTrail = modelTrail
+  }
+}

package/src/snapshot/applySnapshot.ts

@@ -1,181 +1,177 @@
-import { isObservableObject } from "mobx"
-import { BuiltInAction } from "../action/builtInActions"
-import { ActionContextActionType } from "../action/context"
-import { wrapInAction } from "../action/wrapInAction"
-import { isFrozenSnapshot } from "../frozen/Frozen"
-import type { AnyModel } from "../model/BaseModel"
-import { getModelIdPropertyName } from "../model/getModelMetadata"
-import { modelIdKey, modelTypeKey } from "../model/metadata"
-import { getSnapshotModelType, isModel } from "../model/utils"
-import type { ModelClass } from "../modelShared/BaseModelShared"
-import {
-  getModelInfoForName,
-  getModelNotRegisteredErrorMessage,
-  modelInfoByClass,
-} from "../modelShared/modelInfo"
-import { assertTweakedObject } from "../tweaker/core"
-import { assertIsObject, inDevMode, isArray, isMap, isPlainObject, isSet, lazy } from "../utils"
-import {
-  runWithErrorDiagnosticsContext,
-} from "../utils/errorDiagnostics"
-import { ModelPool } from "../utils/ModelPool"
-import { reconcileSnapshot } from "./reconcileSnapshot"
-import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf"
-import { SnapshotProcessingError } from "./SnapshotProcessingError"
-
-/**
- * Applies a full snapshot over an object, reconciling it with the current contents of the object.
- *
- * @template T Object type.
- * @param node Target object (model object, object or array).
- * @param snapshot Snapshot to apply.
- */
-export function applySnapshot<T extends object>(
-  node: T,
-  snapshot: SnapshotInOf<T> | SnapshotOutOf<T>
-): void
-
-export function applySnapshot(node: object, snapshot: unknown): void {
-  assertTweakedObject(node, "node")
-  assertIsObject(snapshot, "snapshot")
-
-  runWithErrorDiagnosticsContext(() => {
-    wrappedInternalApplySnapshot().call(node, snapshot)
-  })
-}
-
-/**
- * @internal
- */
-export function internalApplySnapshot<T extends object>(
-  this: T,
-  sn: SnapshotInOf<T> | SnapshotOutOf<T>
-): void {
-  const obj = this
-
-  const reconcile = () => {
-    const modelPool = new ModelPool(obj)
-    const ret = reconcileSnapshot(obj, sn, modelPool, undefined)
-
-    if (inDevMode) {
-      if (ret !== obj) {
-        throw new SnapshotProcessingError({
-          message: "assertion failed: reconciled object has to be the same",
-          actualSnapshot: sn,
-        })
-      }
-    }
-  }
-
-  if (isArray(sn)) {
-    if (!isArray(obj)) {
-      throw new SnapshotProcessingError({
-        message: "if the snapshot is an array the target must be an array too",
-        actualSnapshot: sn,
-      })
-    }
-
-    reconcile()
-    return
-  }
-
-  if (isFrozenSnapshot(sn)) {
-    throw new SnapshotProcessingError({
-      message: "applySnapshot cannot be used over frozen objects",
-      actualSnapshot: sn,
-    })
-  }
-
-  // adapt snapshot to target model if possible
-  if (isPlainObject(sn) && (sn as any)[modelTypeKey] === undefined && isModel(obj)) {
-    const modelInfo = modelInfoByClass.get((obj as any).constructor)!
-    sn = { ...sn, [modelTypeKey]: modelInfo.name }
-  }
-
-  const modelType = getSnapshotModelType(sn)
-  if (modelType !== undefined) {
-    const modelInfo = getModelInfoForName(modelType)
-    if (!modelInfo) {
-      throw new SnapshotProcessingError({
-        message: getModelNotRegisteredErrorMessage(modelType),
-        actualSnapshot: sn,
-      })
-    }
-
-    // we don't check by actual instance since the class might be a different one due to hot reloading
-    if (!isModel(obj)) {
-      // not a model instance, no reconciliation possible
-      throw new SnapshotProcessingError({
-        message: "the target for a model snapshot must be a model instance",
-        actualSnapshot: sn,
-      })
-    }
-
-    if (obj[modelTypeKey] !== modelType) {
-      // different kind of model, no reconciliation possible
-      throw new SnapshotProcessingError({
-        message: `snapshot model type '${modelType}' does not match target model type '${
-          (obj as any)[modelTypeKey]
-        }'`,
-        actualSnapshot: sn,
-      })
-    }
-
-    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-    if (modelIdPropertyName) {
-      const id = (sn as any)[modelIdPropertyName]
-      if (obj[modelIdKey] !== id) {
-        // different id, no reconciliation possible
-        throw new SnapshotProcessingError({
-          message: `snapshot model id '${id}' does not match target model id '${
-            obj[modelIdKey]
-          }'`,
-          actualSnapshot: sn,
-        })
-      }
-    }
-
-    reconcile()
-    return
-  }
-
-  if (isPlainObject(sn)) {
-    if (!(isPlainObject(obj) || isObservableObject(obj))) {
-      // no reconciliation possible
-      throw new SnapshotProcessingError({
-        message: "if the snapshot is an object the target must be an object too",
-        actualSnapshot: sn,
-      })
-    }
-
-    reconcile()
-    return
-  }
-
-  if (isMap(sn)) {
-    throw new SnapshotProcessingError({
-      message: "a snapshot must not contain maps",
-      actualSnapshot: sn,
-    })
-  }
-
-  if (isSet(sn)) {
-    throw new SnapshotProcessingError({
-      message: "a snapshot must not contain sets",
-      actualSnapshot: sn,
-    })
-  }
-
-  throw new SnapshotProcessingError({
-    message: "unsupported snapshot",
-    actualSnapshot: sn,
-  })
-}
-
-const wrappedInternalApplySnapshot = lazy(() =>
-  wrapInAction({
-    nameOrNameFn: BuiltInAction.ApplySnapshot,
-    fn: internalApplySnapshot,
-    actionType: ActionContextActionType.Sync,
-  })
-)
+import { isObservableObject } from "mobx"
+import { BuiltInAction } from "../action/builtInActions"
+import { ActionContextActionType } from "../action/context"
+import { wrapInAction } from "../action/wrapInAction"
+import { isFrozenSnapshot } from "../frozen/Frozen"
+import type { AnyModel } from "../model/BaseModel"
+import { getModelIdPropertyName } from "../model/getModelMetadata"
+import { modelIdKey, modelTypeKey } from "../model/metadata"
+import { getSnapshotModelType, isModel } from "../model/utils"
+import type { ModelClass } from "../modelShared/BaseModelShared"
+import {
+  getModelInfoForName,
+  getModelNotRegisteredErrorMessage,
+  modelInfoByClass,
+} from "../modelShared/modelInfo"
+import { assertTweakedObject } from "../tweaker/core"
+import { assertIsObject, inDevMode, isArray, isMap, isPlainObject, isSet, lazy } from "../utils"
+import { runWithErrorDiagnosticsContext } from "../utils/errorDiagnostics"
+import { ModelPool } from "../utils/ModelPool"
+import { reconcileSnapshot } from "./reconcileSnapshot"
+import type { SnapshotInOf, SnapshotOutOf } from "./SnapshotOf"
+import { SnapshotProcessingError } from "./SnapshotProcessingError"
+
+/**
+ * Applies a full snapshot over an object, reconciling it with the current contents of the object.
+ *
+ * @template T Object type.
+ * @param node Target object (model object, object or array).
+ * @param snapshot Snapshot to apply.
+ */
+export function applySnapshot<T extends object>(
+  node: T,
+  snapshot: SnapshotInOf<T> | SnapshotOutOf<T>
+): void
+
+export function applySnapshot(node: object, snapshot: unknown): void {
+  assertTweakedObject(node, "node")
+  assertIsObject(snapshot, "snapshot")
+
+  runWithErrorDiagnosticsContext(() => {
+    wrappedInternalApplySnapshot().call(node, snapshot)
+  })
+}
+
+/**
+ * @internal
+ */
+export function internalApplySnapshot<T extends object>(
+  this: T,
+  sn: SnapshotInOf<T> | SnapshotOutOf<T>
+): void {
+  const obj = this
+
+  const reconcile = () => {
+    const modelPool = new ModelPool(obj)
+    const ret = reconcileSnapshot(obj, sn, modelPool, undefined)
+
+    if (inDevMode) {
+      if (ret !== obj) {
+        throw new SnapshotProcessingError({
+          message: "assertion failed: reconciled object has to be the same",
+          actualSnapshot: sn,
+        })
+      }
+    }
+  }
+
+  if (isArray(sn)) {
+    if (!isArray(obj)) {
+      throw new SnapshotProcessingError({
+        message: "if the snapshot is an array the target must be an array too",
+        actualSnapshot: sn,
+      })
+    }
+
+    reconcile()
+    return
+  }
+
+  if (isFrozenSnapshot(sn)) {
+    throw new SnapshotProcessingError({
+      message: "applySnapshot cannot be used over frozen objects",
+      actualSnapshot: sn,
+    })
+  }
+
+  // adapt snapshot to target model if possible
+  if (isPlainObject(sn) && (sn as any)[modelTypeKey] === undefined && isModel(obj)) {
+    const modelInfo = modelInfoByClass.get((obj as any).constructor)!
+    sn = { ...sn, [modelTypeKey]: modelInfo.name }
+  }
+
+  const modelType = getSnapshotModelType(sn)
+  if (modelType !== undefined) {
+    const modelInfo = getModelInfoForName(modelType)
+    if (!modelInfo) {
+      throw new SnapshotProcessingError({
+        message: getModelNotRegisteredErrorMessage(modelType),
+        actualSnapshot: sn,
+      })
+    }
+
+    // we don't check by actual instance since the class might be a different one due to hot reloading
+    if (!isModel(obj)) {
+      // not a model instance, no reconciliation possible
+      throw new SnapshotProcessingError({
+        message: "the target for a model snapshot must be a model instance",
+        actualSnapshot: sn,
+      })
+    }
+
+    if (obj[modelTypeKey] !== modelType) {
+      // different kind of model, no reconciliation possible
+      throw new SnapshotProcessingError({
+        message: `snapshot model type '${modelType}' does not match target model type '${
+          (obj as any)[modelTypeKey]
+        }'`,
+        actualSnapshot: sn,
+      })
+    }
+
+    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
+    if (modelIdPropertyName) {
+      const id = (sn as any)[modelIdPropertyName]
+      if (obj[modelIdKey] !== id) {
+        // different id, no reconciliation possible
+        throw new SnapshotProcessingError({
+          message: `snapshot model id '${id}' does not match target model id '${obj[modelIdKey]}'`,
+          actualSnapshot: sn,
+        })
+      }
+    }
+
+    reconcile()
+    return
+  }
+
+  if (isPlainObject(sn)) {
+    if (!(isPlainObject(obj) || isObservableObject(obj))) {
+      // no reconciliation possible
+      throw new SnapshotProcessingError({
+        message: "if the snapshot is an object the target must be an object too",
+        actualSnapshot: sn,
+      })
+    }
+
+    reconcile()
+    return
+  }
+
+  if (isMap(sn)) {
+    throw new SnapshotProcessingError({
+      message: "a snapshot must not contain maps",
+      actualSnapshot: sn,
+    })
+  }
+
+  if (isSet(sn)) {
+    throw new SnapshotProcessingError({
+      message: "a snapshot must not contain sets",
+      actualSnapshot: sn,
+    })
+  }
+
+  throw new SnapshotProcessingError({
+    message: "unsupported snapshot",
+    actualSnapshot: sn,
+  })
+}
+
+const wrappedInternalApplySnapshot = lazy(() =>
+  wrapInAction({
+    nameOrNameFn: BuiltInAction.ApplySnapshot,
+    fn: internalApplySnapshot,
+    actionType: ActionContextActionType.Sync,
+  })
+)

package/src/snapshot/cloneTreeValue.ts

@@ -1,30 +1,30 @@
-import { isTweakedObject } from "../tweaker/core"
-import { isArray, isPlainObject, isPrimitive } from "../utils"
-import type { CloneOptions } from "./clone"
-import { clone } from "./clone"
-import { fromSnapshot } from "./fromSnapshot"
-
-/**
- * Clones non-primitive tree-compatible values.
- * Intended to be used with `withSetter(cloneTreeValue)`.
- */
-export function cloneTreeValue<T>(value: T, options?: Partial<CloneOptions>): T {
-  const cloneOptions: CloneOptions = {
-    generateNewIds: true,
-    ...options,
-  }
-
-  if (isPrimitive(value)) {
-    return value
-  }
-
-  if (isTweakedObject(value, false)) {
-    return clone(value, cloneOptions) as T
-  }
-
-  if (isArray(value) || isPlainObject(value)) {
-    return fromSnapshot(value as any, cloneOptions) as T
-  }
-
-  return value
-}
+import { isTweakedObject } from "../tweaker/core"
+import { isArray, isPlainObject, isPrimitive } from "../utils"
+import type { CloneOptions } from "./clone"
+import { clone } from "./clone"
+import { fromSnapshot } from "./fromSnapshot"
+
+/**
+ * Clones non-primitive tree-compatible values.
+ * Intended to be used with `withSetter(cloneTreeValue)`.
+ */
+export function cloneTreeValue<T>(value: T, options?: Partial<CloneOptions>): T {
+  const cloneOptions: CloneOptions = {
+    generateNewIds: true,
+    ...options,
+  }
+
+  if (isPrimitive(value)) {
+    return value
+  }
+
+  if (isTweakedObject(value, false)) {
+    return clone(value, cloneOptions) as T
+  }
+
+  if (isArray(value) || isPlainObject(value)) {
+    return fromSnapshot(value as any, cloneOptions) as T
+  }
+
+  return value
+}

package/src/snapshot/fromArraySnapshot.ts

@@ -1,33 +1,27 @@
-import { observable } from "mobx"
-import { tweakArray } from "../tweaker/tweakArray"
-import { isArray } from "../utils"
-import { withErrorPathSegment } from "../utils/errorDiagnostics"
-import {
-  FromSnapshotContext,
-  internalFromSnapshot,
-  observableOptions,
-  registerSnapshotter,
-} from "./fromSnapshot"
-import { SnapshotInOfObject } from "./SnapshotOf"
-import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
-
-function fromArraySnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): any[] {
-  const arr = observable.array([] as any[], observableOptions)
-  const ln = sn.length
-  for (let i = 0; i < ln; i++) {
-    arr.push(withErrorPathSegment(i, () => internalFromSnapshot(sn[i], ctx)))
-  }
-  return tweakArray(arr, undefined, true)
-}
-
-/**
- * @internal
- */
-export function registerFromArraySnapshotter() {
-  registerSnapshotter(SnapshotterAndReconcilerPriority.Array, (sn, ctx) => {
-    if (isArray(sn)) {
-      return fromArraySnapshot(sn, ctx)
-    }
-    return undefined
-  })
-}
+import { tweakArray } from "../tweaker/tweakArray"
+import { isArray } from "../utils"
+import { withErrorPathSegment } from "../utils/errorDiagnostics"
+import { type FromSnapshotContext, internalFromSnapshot, registerSnapshotter } from "./fromSnapshot"
+import type { SnapshotInOfObject } from "./SnapshotOf"
+import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
+
+function fromArraySnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): any[] {
+  const ln = sn.length
+  const arr: any[] = new Array(ln)
+  for (let i = 0; i < ln; i++) {
+    arr[i] = withErrorPathSegment(i, () => internalFromSnapshot(sn[i], ctx))
+  }
+  return tweakArray(arr, undefined, true)
+}
+
+/**
+ * @internal
+ */
+export function registerFromArraySnapshotter() {
+  registerSnapshotter(SnapshotterAndReconcilerPriority.Array, (sn, ctx) => {
+    if (isArray(sn)) {
+      return fromArraySnapshot(sn, ctx)
+    }
+    return undefined
+  })
+}