mobx-keystone 1.20.0 → 1.22.0

package/src/snapshot/fromModelSnapshot.ts

@@ -1,70 +1,70 @@
-import { AnyModel } from "../model/BaseModel"
-import { getModelIdPropertyName } from "../model/getModelMetadata"
-import { ModelConstructorOptions } from "../model/ModelConstructorOptions"
-import { modelTypeKey } from "../model/metadata"
-import { getModelOrSnapshotTypeAndId, getSnapshotModelType } from "../model/utils"
-import { ModelClass } from "../modelShared/BaseModelShared"
-import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"
-import { withErrorModelTrailEntry } from "../utils/errorDiagnostics"
-import { FromSnapshotContext, registerSnapshotter } from "./fromSnapshot"
-import { SnapshotInOfModel } from "./SnapshotOf"
-import { SnapshotProcessingError } from "./SnapshotProcessingError"
-import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
-
-function fromModelSnapshot(sn: SnapshotInOfModel<AnyModel>, ctx: FromSnapshotContext): AnyModel {
-  const type = sn[modelTypeKey]
-
-  if (!type) {
-    throw new SnapshotProcessingError({
-      message: `a model snapshot must contain a type key (${modelTypeKey}), but none was found`,
-      actualSnapshot: sn,
-    })
-  }
-
-  const modelInfo = getModelInfoForName(type)
-  if (!modelInfo) {
-    throw new SnapshotProcessingError({
-      message: getModelNotRegisteredErrorMessage(type),
-      actualSnapshot: sn,
-    })
-  }
-
-  const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
-  if (modelIdPropertyName && sn[modelIdPropertyName] === undefined) {
-    throw new SnapshotProcessingError({
-      message: `a model snapshot of type '${type}' must contain an id key (${modelIdPropertyName}), but none was found`,
-      actualSnapshot: sn,
-    })
-  }
-
-  const modelTypeAndId = getModelOrSnapshotTypeAndId(sn)
-  const modelId = modelTypeAndId?.modelId
-
-  return withErrorModelTrailEntry(type, modelId, () => {
-    return new (modelInfo.class as any)(undefined, {
-      snapshotInitialData: {
-        unprocessedSnapshot: sn,
-        unprocessedModelType:
-          typeof ctx.untypedSnapshot === "object" &&
-          ctx.untypedSnapshot &&
-          modelTypeKey in ctx.untypedSnapshot
-            ? ctx.untypedSnapshot[modelTypeKey]
-            : undefined,
-        snapshotToInitialData: ctx.snapshotToInitialData,
-      },
-      generateNewIds: ctx.options.generateNewIds,
-    } satisfies ModelConstructorOptions)
-  })
-}
-
-/**
- * @internal
- */
-export function registerFromModelSnapshotter() {
-  registerSnapshotter(SnapshotterAndReconcilerPriority.Model, (sn, ctx) => {
-    if (getSnapshotModelType(sn) !== undefined) {
-      return fromModelSnapshot(sn, ctx)
-    }
-    return undefined
-  })
-}
+import type { AnyModel } from "../model/BaseModel"
+import { getModelIdPropertyName } from "../model/getModelMetadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
+import { modelTypeKey } from "../model/metadata"
+import { getModelOrSnapshotTypeAndId, getSnapshotModelType } from "../model/utils"
+import type { ModelClass } from "../modelShared/BaseModelShared"
+import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"
+import { withErrorModelTrailEntry } from "../utils/errorDiagnostics"
+import { type FromSnapshotContext, registerSnapshotter } from "./fromSnapshot"
+import type { SnapshotInOfModel } from "./SnapshotOf"
+import { SnapshotProcessingError } from "./SnapshotProcessingError"
+import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
+
+function fromModelSnapshot(sn: SnapshotInOfModel<AnyModel>, ctx: FromSnapshotContext): AnyModel {
+  const type = sn[modelTypeKey]
+
+  if (!type) {
+    throw new SnapshotProcessingError({
+      message: `a model snapshot must contain a type key (${modelTypeKey}), but none was found`,
+      actualSnapshot: sn,
+    })
+  }
+
+  const modelInfo = getModelInfoForName(type)
+  if (!modelInfo) {
+    throw new SnapshotProcessingError({
+      message: getModelNotRegisteredErrorMessage(type),
+      actualSnapshot: sn,
+    })
+  }
+
+  const modelIdPropertyName = getModelIdPropertyName(modelInfo.class as ModelClass<AnyModel>)
+  if (modelIdPropertyName && sn[modelIdPropertyName] === undefined) {
+    throw new SnapshotProcessingError({
+      message: `a model snapshot of type '${type}' must contain an id key (${modelIdPropertyName}), but none was found`,
+      actualSnapshot: sn,
+    })
+  }
+
+  const modelTypeAndId = getModelOrSnapshotTypeAndId(sn)
+  const modelId = modelTypeAndId?.modelId
+
+  return withErrorModelTrailEntry(type, modelId, () => {
+    return new (modelInfo.class as any)(undefined, {
+      snapshotInitialData: {
+        unprocessedSnapshot: sn,
+        unprocessedModelType:
+          typeof ctx.untypedSnapshot === "object" &&
+          ctx.untypedSnapshot &&
+          modelTypeKey in ctx.untypedSnapshot
+            ? ctx.untypedSnapshot[modelTypeKey]
+            : undefined,
+        snapshotToInitialData: ctx.snapshotToInitialData,
+      },
+      generateNewIds: ctx.options.generateNewIds,
+    } satisfies ModelConstructorOptions)
+  })
+}
+
+/**
+ * @internal
+ */
+export function registerFromModelSnapshotter() {
+  registerSnapshotter(SnapshotterAndReconcilerPriority.Model, (sn, ctx) => {
+    if (getSnapshotModelType(sn) !== undefined) {
+      return fromModelSnapshot(sn, ctx)
+    }
+    return undefined
+  })
+}

package/src/snapshot/fromPlainObjectSnapshot.ts

@@ -1,42 +1,47 @@
-import { observable, set } from "mobx"
-import { tweakPlainObject } from "../tweaker/tweakPlainObject"
-import { isPlainObject } from "../utils"
-import { withErrorPathSegment } from "../utils/errorDiagnostics"
-import {
-  FromSnapshotContext,
-  internalFromSnapshot,
-  observableOptions,
-  registerSnapshotter,
-} from "./fromSnapshot"
-import { SnapshotInOfObject } from "./SnapshotOf"
-import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
-
-function fromPlainObjectSnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): object {
-  const plainObj = observable.object({}, undefined, observableOptions)
-
-  const snKeys = Object.keys(sn)
-  const snKeysLen = snKeys.length
-  for (let i = 0; i < snKeysLen; i++) {
-    const k = snKeys[i]
-    const v = sn[k]
-    // setIfDifferent not required
-    set(
-      plainObj,
-      k,
-      withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
-    )
-  }
-  return tweakPlainObject(plainObj, undefined, undefined, true, false)
-}
-
-/**
- * @internal
- */
-export function registerFromPlainObjectSnapshotter() {
-  registerSnapshotter(SnapshotterAndReconcilerPriority.PlainObject, (sn, ctx) => {
-    if (isPlainObject(sn)) {
-      return fromPlainObjectSnapshot(sn, ctx)
-    }
-    return undefined
-  })
-}
+import { observable } from "mobx"
+import { tweakPlainObject } from "../tweaker/tweakPlainObject"
+import { isPlainObject, setOwnProp } from "../utils"
+import { withErrorPathSegment } from "../utils/errorDiagnostics"
+import {
+  type FromSnapshotContext,
+  internalFromSnapshot,
+  observableOptions,
+  registerSnapshotter,
+} from "./fromSnapshot"
+import type { SnapshotInOfObject } from "./SnapshotOf"
+import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
+
+function fromPlainObjectSnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): object {
+  const plainObj: Record<string, unknown> = {}
+
+  const snKeys = Object.keys(sn)
+  const snKeysLen = snKeys.length
+  for (let i = 0; i < snKeysLen; i++) {
+    const k = snKeys[i]
+    const v = sn[k]
+    setOwnProp(
+      plainObj,
+      k,
+      withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
+    )
+  }
+  return tweakPlainObject(
+    observable.object(plainObj, undefined, observableOptions),
+    undefined,
+    undefined,
+    true,
+    false
+  )
+}
+
+/**
+ * @internal
+ */
+export function registerFromPlainObjectSnapshotter() {
+  registerSnapshotter(SnapshotterAndReconcilerPriority.PlainObject, (sn, ctx) => {
+    if (isPlainObject(sn)) {
+      return fromPlainObjectSnapshot(sn, ctx)
+    }
+    return undefined
+  })
+}

package/src/snapshot/fromSnapshot.ts

@@ -1,198 +1,198 @@
-import { action, observable, set } from "mobx"
-import type { AnyModel } from "../model/BaseModel"
-import { isReservedModelKey } from "../model/metadata"
-import { resolveStandardTypeNoThrow, resolveTypeChecker } from "../types/resolveTypeChecker"
-import type { AnyType, TypeToData, TypeToSnapshotIn } from "../types/schemas"
-import { isLateTypeChecker, TypeChecker } from "../types/TypeChecker"
-import { resolveCodecSupport } from "../types/utility/typesCodec"
-import { isMap, isPrimitive, isSet } from "../utils"
-import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
-import { registerDefaultSnapshotters } from "./registerDefaultSnapshotters"
-import type { SnapshotInOf, SnapshotInOfModel, SnapshotOutOf } from "./SnapshotOf"
-import { SnapshotProcessingError } from "./SnapshotProcessingError"
-
-/**
- * @internal
- */
-export type Snapshotter = (sn: any, ctx: FromSnapshotContext) => any
-
-const snapshotters: { priority: number; snapshotter: Snapshotter }[] = []
-
-/**
- * @internal
- */
-export function registerSnapshotter(priority: number, snapshotter: Snapshotter): void {
-  snapshotters.push({ priority, snapshotter })
-  snapshotters.sort((a, b) => a.priority - b.priority)
-}
-
-/**
- * From snapshot options.
- */
-export interface FromSnapshotOptions {
-  /**
-   * Pass `true` to generate new internal ids for models rather than reusing them. (Default is `false`)
-   */
-  generateNewIds: boolean
-}
-
-/**
- * @internal
- */
-export interface FromSnapshotContext {
-  options: FromSnapshotOptions
-  snapshotToInitialData: (processedSn: SnapshotInOfModel<AnyModel>) => any
-  untypedSnapshot: unknown
-}
-
-/**
- * Given a type deserializes a data structure from its snapshot form.
- *
- * @template TType Object type.
- * @param type Type.
- * @param snapshot Snapshot, even if a primitive.
- * @param options Options.
- * @returns The deserialized object.
- */
-export function fromSnapshot<TType extends AnyType>(
-  type: TType,
-  snapshot: TypeToSnapshotIn<TType>,
-  options?: Partial<FromSnapshotOptions>
-): TypeToData<TType>
-
-/**
- * Deserializes a data structure from its snapshot form.
- *
- * @template T Object type.
- * @param snapshot Snapshot, even if a primitive.
- * @param options Options.
- * @returns The deserialized object.
- */
-export function fromSnapshot<T>(
-  snapshot: SnapshotInOf<T> | SnapshotOutOf<T>,
-  options?: Partial<FromSnapshotOptions>
-): T
-
-export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
-  return runWithErrorDiagnosticsContext(() => {
-    let snapshot: any
-    let unprocessedSnapshot: unknown
-    let options: Partial<FromSnapshotOptions> | undefined
-    const standardType = arguments.length >= 2 ? resolveStandardTypeNoThrow(arg1) : undefined
-
-    if (isLateTypeChecker(arg1) || arg1 instanceof TypeChecker || standardType) {
-      const resolvedType = standardType ?? arg1
-      const codecSupport = resolveCodecSupport(resolvedType)
-
-      if (codecSupport.hasCodec) {
-        unprocessedSnapshot = arg2
-        snapshot = resolveTypeChecker(codecSupport.storedType).fromSnapshotProcessor(
-          unprocessedSnapshot
-        )
-        options = arg3
-        const storedValue = fromSnapshotAction(snapshot, unprocessedSnapshot, options)
-        return codecSupport.adapter.toRuntime(storedValue)
-      }
-
-      const typeChecker = resolveTypeChecker(resolvedType)
-      unprocessedSnapshot = arg2
-      snapshot = typeChecker.fromSnapshotProcessor(unprocessedSnapshot)
-      options = arg3
-    } else {
-      snapshot = arg1
-      unprocessedSnapshot = snapshot
-      options = arg2
-    }
-
-    return fromSnapshotAction(snapshot, unprocessedSnapshot, options)
-  })
-}
-
-const fromSnapshotAction = action(
-  "fromSnapshot",
-  <T>(
-    snapshot: SnapshotInOf<T>,
-    unprocessedSnapshot: unknown,
-    options: Partial<FromSnapshotOptions> | undefined
-  ): T => {
-    const opts = {
-      generateNewIds: false,
-      overrideRootModelId: undefined,
-      ...options,
-    }
-
-    const ctx: Partial<FromSnapshotContext> = {
-      options: opts,
-      untypedSnapshot: unprocessedSnapshot,
-    }
-    ctx.snapshotToInitialData = snapshotToInitialData.bind(undefined, ctx as FromSnapshotContext)
-
-    return internalFromSnapshot<T>(snapshot, ctx as FromSnapshotContext)
-  }
-)
-
-/**
- * @internal
- */
-export function internalFromSnapshot<T>(
-  sn: SnapshotInOf<T> | SnapshotOutOf<T>,
-  ctx: FromSnapshotContext
-): T {
-  if (isPrimitive(sn)) {
-    return sn as any
-  }
-
-  registerDefaultSnapshotters()
-
-  const snapshotterLen = snapshotters.length
-  for (let i = 0; i < snapshotterLen; i++) {
-    const { snapshotter } = snapshotters[i]
-    const ret = snapshotter(sn, ctx)
-    if (ret !== undefined) {
-      return ret
-    }
-  }
-
-  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,
-  })
-}
-
-function snapshotToInitialData(
-  ctx: FromSnapshotContext,
-  processedSn: SnapshotInOfModel<AnyModel>
-): any {
-  const initialData = observable.object({}, undefined, observableOptions)
-
-  const processedSnKeys = Object.keys(processedSn)
-  const processedSnKeysLen = processedSnKeys.length
-  for (let i = 0; i < processedSnKeysLen; i++) {
-    const k = processedSnKeys[i]
-    if (!isReservedModelKey(k)) {
-      const v = processedSn[k]
-      const snapshotValue = withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
-      // setIfDifferent not required
-      set(initialData, k, snapshotValue)
-    }
-  }
-  return initialData
-}
-
-export const observableOptions = {
-  deep: false,
-}
+import { action, observable } from "mobx"
+import type { AnyModel } from "../model/BaseModel"
+import { isReservedModelKey } from "../model/metadata"
+import { resolveStandardTypeNoThrow, resolveTypeChecker } from "../types/resolveTypeChecker"
+import type { AnyType, TypeToData, TypeToSnapshotIn } from "../types/schemas"
+import { isLateTypeChecker, TypeChecker } from "../types/TypeChecker"
+import { resolveCodecSupport } from "../types/utility/typesCodec"
+import { isMap, isPrimitive, isSet, setOwnProp } from "../utils"
+import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
+import { registerDefaultSnapshotters } from "./registerDefaultSnapshotters"
+import type { SnapshotInOf, SnapshotInOfModel, SnapshotOutOf } from "./SnapshotOf"
+import { SnapshotProcessingError } from "./SnapshotProcessingError"
+
+/**
+ * @internal
+ */
+export type Snapshotter = (sn: any, ctx: FromSnapshotContext) => any
+
+const snapshotters: { priority: number; snapshotter: Snapshotter }[] = []
+
+/**
+ * @internal
+ */
+export function registerSnapshotter(priority: number, snapshotter: Snapshotter): void {
+  snapshotters.push({ priority, snapshotter })
+  snapshotters.sort((a, b) => a.priority - b.priority)
+}
+
+/**
+ * From snapshot options.
+ */
+export interface FromSnapshotOptions {
+  /**
+   * Pass `true` to generate new internal ids for models rather than reusing them. (Default is `false`)
+   */
+  generateNewIds: boolean
+}
+
+/**
+ * @internal
+ */
+export interface FromSnapshotContext {
+  options: FromSnapshotOptions
+  snapshotToInitialData: (processedSn: SnapshotInOfModel<AnyModel>) => any
+  untypedSnapshot: unknown
+}
+
+/**
+ * Given a type deserializes a data structure from its snapshot form.
+ *
+ * @template TType Object type.
+ * @param type Type.
+ * @param snapshot Snapshot, even if a primitive.
+ * @param options Options.
+ * @returns The deserialized object.
+ */
+export function fromSnapshot<TType extends AnyType>(
+  type: TType,
+  snapshot: TypeToSnapshotIn<TType>,
+  options?: Partial<FromSnapshotOptions>
+): TypeToData<TType>
+
+/**
+ * Deserializes a data structure from its snapshot form.
+ *
+ * @template T Object type.
+ * @param snapshot Snapshot, even if a primitive.
+ * @param options Options.
+ * @returns The deserialized object.
+ */
+export function fromSnapshot<T>(
+  snapshot: SnapshotInOf<T> | SnapshotOutOf<T>,
+  options?: Partial<FromSnapshotOptions>
+): T
+
+export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
+  return runWithErrorDiagnosticsContext(() => {
+    let snapshot: any
+    let unprocessedSnapshot: unknown
+    let options: Partial<FromSnapshotOptions> | undefined
+    // biome-ignore lint/complexity/noArguments: overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
+    const standardType = arguments.length >= 2 ? resolveStandardTypeNoThrow(arg1) : undefined
+
+    if (isLateTypeChecker(arg1) || arg1 instanceof TypeChecker || standardType) {
+      const resolvedType = standardType ?? arg1
+      const codecSupport = resolveCodecSupport(resolvedType)
+
+      if (codecSupport.hasCodec) {
+        unprocessedSnapshot = arg2
+        snapshot = resolveTypeChecker(codecSupport.storedType).fromSnapshotProcessor(
+          unprocessedSnapshot
+        )
+        options = arg3
+        const storedValue = fromSnapshotAction(snapshot, unprocessedSnapshot, options)
+        return codecSupport.adapter.toRuntime(storedValue)
+      }
+
+      const typeChecker = resolveTypeChecker(resolvedType)
+      unprocessedSnapshot = arg2
+      snapshot = typeChecker.fromSnapshotProcessor(unprocessedSnapshot)
+      options = arg3
+    } else {
+      snapshot = arg1
+      unprocessedSnapshot = snapshot
+      options = arg2
+    }
+
+    return fromSnapshotAction(snapshot, unprocessedSnapshot, options)
+  })
+}
+
+const fromSnapshotAction = action(
+  "fromSnapshot",
+  <T>(
+    snapshot: SnapshotInOf<T>,
+    unprocessedSnapshot: unknown,
+    options: Partial<FromSnapshotOptions> | undefined
+  ): T => {
+    const opts = {
+      generateNewIds: false,
+      overrideRootModelId: undefined,
+      ...options,
+    }
+
+    const ctx: Partial<FromSnapshotContext> = {
+      options: opts,
+      untypedSnapshot: unprocessedSnapshot,
+    }
+    ctx.snapshotToInitialData = snapshotToInitialData.bind(undefined, ctx as FromSnapshotContext)
+
+    return internalFromSnapshot<T>(snapshot, ctx as FromSnapshotContext)
+  }
+)
+
+/**
+ * @internal
+ */
+export function internalFromSnapshot<T>(
+  sn: SnapshotInOf<T> | SnapshotOutOf<T>,
+  ctx: FromSnapshotContext
+): T {
+  if (isPrimitive(sn)) {
+    return sn as any
+  }
+
+  registerDefaultSnapshotters()
+
+  const snapshotterLen = snapshotters.length
+  for (let i = 0; i < snapshotterLen; i++) {
+    const { snapshotter } = snapshotters[i]
+    const ret = snapshotter(sn, ctx)
+    if (ret !== undefined) {
+      return ret
+    }
+  }
+
+  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,
+  })
+}
+
+function snapshotToInitialData(
+  ctx: FromSnapshotContext,
+  processedSn: SnapshotInOfModel<AnyModel>
+): any {
+  const initialData: Record<string, unknown> = {}
+
+  const processedSnKeys = Object.keys(processedSn)
+  const processedSnKeysLen = processedSnKeys.length
+  for (let i = 0; i < processedSnKeysLen; i++) {
+    const k = processedSnKeys[i]
+    if (!isReservedModelKey(k)) {
+      const v = processedSn[k]
+      const snapshotValue = withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
+      setOwnProp(initialData, k, snapshotValue)
+    }
+  }
+  return observable.object(initialData, undefined, observableOptions)
+}
+
+export const observableOptions = {
+  deep: false,
+}