mobx-keystone 1.20.0 → 1.22.0

package/src/actionMiddlewares/actionSerialization/applySerializedAction.ts

@@ -1,172 +1,172 @@
-import { runInAction } from "mobx"
-import { applyAction } from "../../action/applyAction"
-import { frozenKey } from "../../frozen/Frozen"
-import { getModelIdPropertyName } from "../../model/getModelMetadata"
-import { isModel } from "../../model/utils"
-import { resolvePath } from "../../parent/path"
-import type { WritablePath } from "../../parent/pathTypes"
-import { applyPatches } from "../../patch/applyPatches"
-import { onPatches } from "../../patch/emitPatch"
-import type { Patch } from "../../patch/Patch"
-import { assertTweakedObject } from "../../tweaker/core"
-import { failure, isObject } from "../../utils"
-import { deserializeActionCall, SerializedActionCall } from "./actionSerialization"
-
-/**
- * Serialized action call with model ID overrides.
- * Can be generated with `applySerializedActionAndTrackNewModelIds`.
- * To be applied with `applySerializedActionAndSyncNewModelIds`.
- */
-export interface SerializedActionCallWithModelIdOverrides extends SerializedActionCall {
-  /**
-   * Model Id overrides to be applied at the end of applying the action.
-   */
-  readonly modelIdOverrides: ReadonlyArray<Patch>
-}
-
-/**
- * Applies (runs) a serialized action over a target object.
- * In this mode newly generated / modified model IDs will be tracked
- * so they can be later synchronized when applying it on another machine
- * via `applySerializedActionAndSyncNewModelIds`.
- * This means this method is usually used on the server side.
- *
- * If you intend to apply non-serialized actions check `applyAction` instead.
- *
- * @param subtreeRoot Subtree root target object to run the action over.
- * @param call The serialized action, usually as coming from the server/client.
- * @returns The return value of the action, if any, plus a new serialized action
- * with model overrides.
- */
-export function applySerializedActionAndTrackNewModelIds<TRet = any>(
-  subtreeRoot: object,
-  call: SerializedActionCall
-): {
-  returnValue: TRet
-  serializedActionCall: SerializedActionCallWithModelIdOverrides
-} {
-  if (!call.serialized) {
-    throw failure("cannot apply a non-serialized action call, use 'applyAction' instead")
-  }
-
-  assertTweakedObject(subtreeRoot, "subtreeRoot")
-
-  const deserializedCall = deserializeActionCall(call, subtreeRoot)
-
-  const modelIdOverrides: Patch[] = []
-
-  // set a patch listener to track changes to model ids
-  const patchDisposer = onPatches(subtreeRoot, (patches) => {
-    scanPatchesForModelIdChanges(subtreeRoot, modelIdOverrides, patches)
-  })
-
-  try {
-    const returnValue = applyAction(subtreeRoot, deserializedCall)
-
-    return {
-      returnValue,
-      serializedActionCall: {
-        ...call,
-        modelIdOverrides,
-      },
-    }
-  } finally {
-    patchDisposer()
-  }
-}
-
-function scanPatchesForModelIdChanges(root: object, modelIdOverrides: Patch[], patches: Patch[]) {
-  const len = patches.length
-  for (let i = 0; i < len; i++) {
-    const patch = patches[i]
-    if (patch.op === "replace" || patch.op === "add") {
-      deepScanValueForModelIdChanges(
-        root,
-        modelIdOverrides,
-        patch.value,
-        patch.path as WritablePath
-      )
-    }
-  }
-}
-
-function deepScanValueForModelIdChanges(
-  root: object,
-  modelIdOverrides: Patch[],
-  value: any,
-  path: WritablePath
-) {
-  if (path.length > 0 && typeof value === "string") {
-    // ensure the parent is an actual model
-    const parent = resolvePath(root, path.slice(0, path.length - 1)).value
-
-    if (isModel(parent)) {
-      const propertyName = path[path.length - 1]
-      if (propertyName === getModelIdPropertyName(parent.constructor as any)) {
-        // found one
-        modelIdOverrides.push({
-          op: "replace",
-          path: path.slice(),
-          value: value,
-        })
-      }
-    }
-  } else if (Array.isArray(value)) {
-    const len = value.length
-    for (let i = 0; i < len; i++) {
-      path.push(i)
-      deepScanValueForModelIdChanges(root, modelIdOverrides, value[i], path)
-      path.pop()
-    }
-  } else if (isObject(value)) {
-    // skip frozen values
-    if (!value[frozenKey]) {
-      const keys = Object.keys(value)
-      const len = keys.length
-      for (let i = 0; i < len; i++) {
-        const propName = keys[i]
-        const propValue = value[propName]
-
-        path.push(propName)
-        deepScanValueForModelIdChanges(root, modelIdOverrides, propValue, path)
-        path.pop()
-      }
-    }
-  }
-}
-
-/**
- * Applies (runs) a serialized action over a target object.
- * In this mode newly generated / modified model IDs previously tracked
- * by `applySerializedActionAndTrackNewModelIds` will be synchronized after
- * the action is applied.
- * This means this method is usually used on the client side.
- *
- * If you intend to apply non-serialized actions check `applyAction` instead.
- *
- * @param subtreeRoot Subtree root target object to run the action over.
- * @param call The serialized action, usually as coming from the server/client.
- * @returns The return value of the action, if any.
- */
-export function applySerializedActionAndSyncNewModelIds<TRet = any>(
-  subtreeRoot: object,
-  call: SerializedActionCallWithModelIdOverrides
-): TRet {
-  if (!call.serialized) {
-    throw failure("cannot apply a non-serialized action call, use 'applyAction' instead")
-  }
-
-  assertTweakedObject(subtreeRoot, "subtreeRoot")
-
-  const deserializedCall = deserializeActionCall(call, subtreeRoot)
-
-  let returnValue: any
-  runInAction(() => {
-    returnValue = applyAction(subtreeRoot, deserializedCall)
-
-    // apply model id overrides
-    applyPatches(subtreeRoot, call.modelIdOverrides)
-  })
-
-  return returnValue
-}
+import { runInAction } from "mobx"
+import { applyAction } from "../../action/applyAction"
+import { frozenKey } from "../../frozen/Frozen"
+import { getModelIdPropertyName } from "../../model/getModelMetadata"
+import { isModel } from "../../model/utils"
+import { resolvePath } from "../../parent/path"
+import type { WritablePath } from "../../parent/pathTypes"
+import { applyPatches } from "../../patch/applyPatches"
+import { onPatches } from "../../patch/emitPatch"
+import type { Patch } from "../../patch/Patch"
+import { assertTweakedObject } from "../../tweaker/core"
+import { failure, isObject } from "../../utils"
+import { deserializeActionCall, type SerializedActionCall } from "./actionSerialization"
+
+/**
+ * Serialized action call with model ID overrides.
+ * Can be generated with `applySerializedActionAndTrackNewModelIds`.
+ * To be applied with `applySerializedActionAndSyncNewModelIds`.
+ */
+export interface SerializedActionCallWithModelIdOverrides extends SerializedActionCall {
+  /**
+   * Model Id overrides to be applied at the end of applying the action.
+   */
+  readonly modelIdOverrides: ReadonlyArray<Patch>
+}
+
+/**
+ * Applies (runs) a serialized action over a target object.
+ * In this mode newly generated / modified model IDs will be tracked
+ * so they can be later synchronized when applying it on another machine
+ * via `applySerializedActionAndSyncNewModelIds`.
+ * This means this method is usually used on the server side.
+ *
+ * If you intend to apply non-serialized actions check `applyAction` instead.
+ *
+ * @param subtreeRoot Subtree root target object to run the action over.
+ * @param call The serialized action, usually as coming from the server/client.
+ * @returns The return value of the action, if any, plus a new serialized action
+ * with model overrides.
+ */
+export function applySerializedActionAndTrackNewModelIds<TRet = any>(
+  subtreeRoot: object,
+  call: SerializedActionCall
+): {
+  returnValue: TRet
+  serializedActionCall: SerializedActionCallWithModelIdOverrides
+} {
+  if (!call.serialized) {
+    throw failure("cannot apply a non-serialized action call, use 'applyAction' instead")
+  }
+
+  assertTweakedObject(subtreeRoot, "subtreeRoot")
+
+  const deserializedCall = deserializeActionCall(call, subtreeRoot)
+
+  const modelIdOverrides: Patch[] = []
+
+  // set a patch listener to track changes to model ids
+  const patchDisposer = onPatches(subtreeRoot, (patches) => {
+    scanPatchesForModelIdChanges(subtreeRoot, modelIdOverrides, patches)
+  })
+
+  try {
+    const returnValue = applyAction(subtreeRoot, deserializedCall)
+
+    return {
+      returnValue,
+      serializedActionCall: {
+        ...call,
+        modelIdOverrides,
+      },
+    }
+  } finally {
+    patchDisposer()
+  }
+}
+
+function scanPatchesForModelIdChanges(root: object, modelIdOverrides: Patch[], patches: Patch[]) {
+  const len = patches.length
+  for (let i = 0; i < len; i++) {
+    const patch = patches[i]
+    if (patch.op === "replace" || patch.op === "add") {
+      deepScanValueForModelIdChanges(
+        root,
+        modelIdOverrides,
+        patch.value,
+        patch.path as WritablePath
+      )
+    }
+  }
+}
+
+function deepScanValueForModelIdChanges(
+  root: object,
+  modelIdOverrides: Patch[],
+  value: any,
+  path: WritablePath
+) {
+  if (path.length > 0 && typeof value === "string") {
+    // ensure the parent is an actual model
+    const parent = resolvePath(root, path.slice(0, path.length - 1)).value
+
+    if (isModel(parent)) {
+      const propertyName = path[path.length - 1]
+      if (propertyName === getModelIdPropertyName(parent.constructor as any)) {
+        // found one
+        modelIdOverrides.push({
+          op: "replace",
+          path: path.slice(),
+          value: value,
+        })
+      }
+    }
+  } else if (Array.isArray(value)) {
+    const len = value.length
+    for (let i = 0; i < len; i++) {
+      path.push(i)
+      deepScanValueForModelIdChanges(root, modelIdOverrides, value[i], path)
+      path.pop()
+    }
+  } else if (isObject(value)) {
+    // skip frozen values
+    if (!value[frozenKey]) {
+      const keys = Object.keys(value)
+      const len = keys.length
+      for (let i = 0; i < len; i++) {
+        const propName = keys[i]
+        const propValue = value[propName]
+
+        path.push(propName)
+        deepScanValueForModelIdChanges(root, modelIdOverrides, propValue, path)
+        path.pop()
+      }
+    }
+  }
+}
+
+/**
+ * Applies (runs) a serialized action over a target object.
+ * In this mode newly generated / modified model IDs previously tracked
+ * by `applySerializedActionAndTrackNewModelIds` will be synchronized after
+ * the action is applied.
+ * This means this method is usually used on the client side.
+ *
+ * If you intend to apply non-serialized actions check `applyAction` instead.
+ *
+ * @param subtreeRoot Subtree root target object to run the action over.
+ * @param call The serialized action, usually as coming from the server/client.
+ * @returns The return value of the action, if any.
+ */
+export function applySerializedActionAndSyncNewModelIds<TRet = any>(
+  subtreeRoot: object,
+  call: SerializedActionCallWithModelIdOverrides
+): TRet {
+  if (!call.serialized) {
+    throw failure("cannot apply a non-serialized action call, use 'applyAction' instead")
+  }
+
+  assertTweakedObject(subtreeRoot, "subtreeRoot")
+
+  const deserializedCall = deserializeActionCall(call, subtreeRoot)
+
+  let returnValue: any
+  runInAction(() => {
+    returnValue = applyAction(subtreeRoot, deserializedCall)
+
+    // apply model id overrides
+    applyPatches(subtreeRoot, call.modelIdOverrides)
+  })
+
+  return returnValue
+}

package/src/actionMiddlewares/actionSerialization/arraySerializer.ts

@@ -1,20 +1,20 @@
-import type { IObservableArray } from "mobx"
-import { isArray, namespace } from "../../utils"
-import { ActionCallArgumentSerializer, cannotSerialize } from "./core"
-
-export const arraySerializer: ActionCallArgumentSerializer<any[] | IObservableArray<any>, any[]> = {
-  id: `${namespace}/array`,
-
-  serialize(value, serialize) {
-    if (!isArray(value)) {
-      return cannotSerialize
-    }
-
-    // this will also transform observable arrays into non-observable ones
-    return value.map(serialize)
-  },
-
-  deserialize(arr, deserialize) {
-    return arr.map(deserialize)
-  },
-}
+import type { IObservableArray } from "mobx"
+import { isArray, namespace } from "../../utils"
+import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
+
+export const arraySerializer: ActionCallArgumentSerializer<any[] | IObservableArray<any>, any[]> = {
+  id: `${namespace}/array`,
+
+  serialize(value, serialize) {
+    if (!isArray(value)) {
+      return cannotSerialize
+    }
+
+    // this will also transform observable arrays into non-observable ones
+    return value.map(serialize)
+  },
+
+  deserialize(arr, deserialize) {
+    return arr.map(deserialize)
+  },
+}

package/src/actionMiddlewares/actionSerialization/dateSerializer.ts

@@ -1,17 +1,17 @@
-import { namespace } from "../../utils"
-import { ActionCallArgumentSerializer, cannotSerialize } from "./core"
-
-export const dateSerializer: ActionCallArgumentSerializer<Date, number> = {
-  id: `${namespace}/dateAsTimestamp`,
-
-  serialize(date) {
-    if (!(date instanceof Date)) {
-      return cannotSerialize
-    }
-    return +date
-  },
-
-  deserialize(timestamp) {
-    return new Date(timestamp)
-  },
-}
+import { namespace } from "../../utils"
+import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
+
+export const dateSerializer: ActionCallArgumentSerializer<Date, number> = {
+  id: `${namespace}/dateAsTimestamp`,
+
+  serialize(date) {
+    if (!(date instanceof Date)) {
+      return cannotSerialize
+    }
+    return +date
+  },
+
+  deserialize(timestamp) {
+    return new Date(timestamp)
+  },
+}

package/src/actionMiddlewares/actionSerialization/mapSerializer.ts

@@ -1,42 +1,42 @@
-import { isObservableMap, ObservableMap } from "mobx"
-import { namespace } from "../../utils"
-import { ActionCallArgumentSerializer, cannotSerialize } from "./core"
-
-export const mapSerializer: ActionCallArgumentSerializer<
-  Map<any, any> | ObservableMap<any, any>,
-  [any, any][]
-> = {
-  id: `${namespace}/mapAsArray`,
-
-  serialize(map, serialize) {
-    if (!(map instanceof Map || isObservableMap(map))) {
-      return cannotSerialize
-    }
-
-    const arr: [any, any][] = []
-
-    const iter = map.keys()
-    let cur = iter.next()
-    while (!cur.done) {
-      const k = cur.value
-      const v = map.get(k)
-      arr.push([serialize(k), serialize(v)])
-      cur = iter.next()
-    }
-
-    return arr
-  },
-
-  deserialize(arr, deserialize) {
-    const map = new Map()
-
-    const len = arr.length
-    for (let i = 0; i < len; i++) {
-      const k = arr[i][0]
-      const v = arr[i][1]
-      map.set(deserialize(k), deserialize(v))
-    }
-
-    return map
-  },
-}
+import { isObservableMap, type ObservableMap } from "mobx"
+import { namespace } from "../../utils"
+import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
+
+export const mapSerializer: ActionCallArgumentSerializer<
+  Map<any, any> | ObservableMap<any, any>,
+  [any, any][]
+> = {
+  id: `${namespace}/mapAsArray`,
+
+  serialize(map, serialize) {
+    if (!(map instanceof Map || isObservableMap(map))) {
+      return cannotSerialize
+    }
+
+    const arr: [any, any][] = []
+
+    const iter = map.keys()
+    let cur = iter.next()
+    while (!cur.done) {
+      const k = cur.value
+      const v = map.get(k)
+      arr.push([serialize(k), serialize(v)])
+      cur = iter.next()
+    }
+
+    return arr
+  },
+
+  deserialize(arr, deserialize) {
+    const map = new Map()
+
+    const len = arr.length
+    for (let i = 0; i < len; i++) {
+      const k = arr[i][0]
+      const v = arr[i][1]
+      map.set(deserialize(k), deserialize(v))
+    }
+
+    return map
+  },
+}

package/src/actionMiddlewares/actionSerialization/objectPathSerializer.ts

@@ -1,50 +1,50 @@
-import { fastGetRootPath, resolvePathCheckingIds } from "../../parent/path"
-import { Path } from "../../parent/pathTypes"
-import { isTweakedObject } from "../../tweaker/core"
-import { failure, namespace } from "../../utils"
-import { rootPathToTargetPathIds } from "../utils"
-import { ActionCallArgumentSerializer, cannotSerialize } from "./core"
-
-interface ObjectPath {
-  targetPath: Path
-  targetPathIds: (string | null)[]
-}
-
-export const objectPathSerializer: ActionCallArgumentSerializer<object, ObjectPath> = {
-  id: `${namespace}/objectPath`,
-
-  serialize(value, _, targetRoot) {
-    if (typeof value !== "object" || value === null || !isTweakedObject(value, false)) {
-      return cannotSerialize
-    }
-
-    // try to serialize a ref to its path if possible instead
-    if (targetRoot) {
-      const rootPath = fastGetRootPath(value, false)
-      if (rootPath.root === targetRoot) {
-        return {
-          targetPath: rootPath.path,
-          targetPathIds: rootPathToTargetPathIds(rootPath),
-        } as ObjectPath
-      }
-    }
-
-    return cannotSerialize
-  },
-
-  deserialize(ref, _, targetRoot) {
-    // try to resolve the node back
-    if (targetRoot) {
-      const result = resolvePathCheckingIds(targetRoot, ref.targetPath, ref.targetPathIds)
-      if (result.resolved) {
-        return result.value
-      }
-    }
-
-    throw failure(
-      `object at path ${JSON.stringify(ref.targetPath)} with ids ${JSON.stringify(
-        ref.targetPathIds
-      )} could not be resolved`
-    )
-  },
-}
+import { fastGetRootPath, resolvePathCheckingIds } from "../../parent/path"
+import type { Path } from "../../parent/pathTypes"
+import { isTweakedObject } from "../../tweaker/core"
+import { failure, namespace } from "../../utils"
+import { rootPathToTargetPathIds } from "../utils"
+import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
+
+interface ObjectPath {
+  targetPath: Path
+  targetPathIds: (string | null)[]
+}
+
+export const objectPathSerializer: ActionCallArgumentSerializer<object, ObjectPath> = {
+  id: `${namespace}/objectPath`,
+
+  serialize(value, _, targetRoot) {
+    if (typeof value !== "object" || value === null || !isTweakedObject(value, false)) {
+      return cannotSerialize
+    }
+
+    // try to serialize a ref to its path if possible instead
+    if (targetRoot) {
+      const rootPath = fastGetRootPath(value, false)
+      if (rootPath.root === targetRoot) {
+        return {
+          targetPath: rootPath.path,
+          targetPathIds: rootPathToTargetPathIds(rootPath),
+        } as ObjectPath
+      }
+    }
+
+    return cannotSerialize
+  },
+
+  deserialize(ref, _, targetRoot) {
+    // try to resolve the node back
+    if (targetRoot) {
+      const result = resolvePathCheckingIds(targetRoot, ref.targetPath, ref.targetPathIds)
+      if (result.resolved) {
+        return result.value
+      }
+    }
+
+    throw failure(
+      `object at path ${JSON.stringify(ref.targetPath)} with ids ${JSON.stringify(
+        ref.targetPathIds
+      )} could not be resolved`
+    )
+  },
+}

package/src/actionMiddlewares/actionSerialization/objectSnapshotSerializer.ts

@@ -1,21 +1,21 @@
-import { fromSnapshot } from "../../snapshot/fromSnapshot"
-import { getSnapshot } from "../../snapshot/getSnapshot"
-import { isTweakedObject } from "../../tweaker/core"
-import { namespace } from "../../utils"
-import { ActionCallArgumentSerializer, cannotSerialize } from "./core"
-
-export const objectSnapshotSerializer: ActionCallArgumentSerializer<object, object> = {
-  id: `${namespace}/objectSnapshot`,
-
-  serialize(value) {
-    if (typeof value !== "object" || value === null || !isTweakedObject(value, false)) {
-      return cannotSerialize
-    }
-
-    return getSnapshot(value)
-  },
-
-  deserialize(snapshot) {
-    return fromSnapshot(snapshot)
-  },
-}
+import { fromSnapshot } from "../../snapshot/fromSnapshot"
+import { getSnapshot } from "../../snapshot/getSnapshot"
+import { isTweakedObject } from "../../tweaker/core"
+import { namespace } from "../../utils"
+import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
+
+export const objectSnapshotSerializer: ActionCallArgumentSerializer<object, object> = {
+  id: `${namespace}/objectSnapshot`,
+
+  serialize(value) {
+    if (typeof value !== "object" || value === null || !isTweakedObject(value, false)) {
+      return cannotSerialize
+    }
+
+    return getSnapshot(value)
+  },
+
+  deserialize(snapshot) {
+    return fromSnapshot(snapshot)
+  },
+}