mobx-keystone 1.20.0 → 1.22.0

package/src/transforms/asMap.ts

@@ -1,50 +1,50 @@
-import type { ModelPropTransform } from "../modelShared/prop"
-import { asMap } from "../wrappers/asMap"
-
-const _objectToMapTransform: ModelPropTransform<Record<string, unknown>, Map<string, unknown>> = {
-  transform({ originalValue: obj, cachedTransformedValue: cachedMap }) {
-    return cachedMap ?? (asMap(obj) as unknown as Map<string, unknown>)
-  },
-
-  untransform({ transformedValue: map }) {
-    // do not cache map <-> obj relationship
-
-    const obj: Record<string, unknown> = {}
-    map.forEach((v, k) => {
-      obj[k] = v
-    })
-
-    return obj
-  },
-}
-
-/**
- * @deprecated Prefer the codec equivalent: `tProp(types.mapFromObject(valueType))`.
- * Use `tProp(types.skipCheck(types.mapFromObject(valueType)))` if you don't need runtime validation.
- */
-export const objectToMapTransform = <T>() =>
-  _objectToMapTransform as ModelPropTransform<Record<string, T>, Map<string, T>>
-
-const _arrayToMapTransform: ModelPropTransform<Array<[unknown, unknown]>, Map<unknown, unknown>> = {
-  transform: ({ originalValue: arr, cachedTransformedValue: cachedMap }) => {
-    return cachedMap ?? (asMap(arr) as unknown as Map<string, unknown>)
-  },
-
-  untransform({ transformedValue: map }) {
-    // do not cache map <-> arr relationship
-
-    const arr: Array<[unknown, unknown]> = []
-    map.forEach((v, k) => {
-      arr.push([k, v])
-    })
-
-    return arr
-  },
-}
-
-/**
- * @deprecated Prefer the codec equivalent: `tProp(types.mapFromArray(keyType, valueType))`.
- * Use `tProp(types.skipCheck(types.mapFromArray(keyType, valueType)))` if you don't need runtime validation.
- */
-export const arrayToMapTransform = <K, V>() =>
-  _arrayToMapTransform as ModelPropTransform<Array<[K, V]>, Map<K, V>>
+import type { ModelPropTransform } from "../modelShared/prop"
+import { asMap } from "../wrappers/asMap"
+
+const _objectToMapTransform: ModelPropTransform<Record<string, unknown>, Map<string, unknown>> = {
+  transform({ originalValue: obj, cachedTransformedValue: cachedMap }) {
+    return cachedMap ?? (asMap(obj) as unknown as Map<string, unknown>)
+  },
+
+  untransform({ transformedValue: map }) {
+    // do not cache map <-> obj relationship
+
+    const obj: Record<string, unknown> = {}
+    map.forEach((v, k) => {
+      obj[k] = v
+    })
+
+    return obj
+  },
+}
+
+/**
+ * @deprecated Prefer the codec equivalent: `tProp(types.mapFromObject(valueType))`.
+ * Use `tProp(types.skipCheck(types.mapFromObject(valueType)))` if you don't need runtime validation.
+ */
+export const objectToMapTransform = <T>() =>
+  _objectToMapTransform as ModelPropTransform<Record<string, T>, Map<string, T>>
+
+const _arrayToMapTransform: ModelPropTransform<Array<[unknown, unknown]>, Map<unknown, unknown>> = {
+  transform: ({ originalValue: arr, cachedTransformedValue: cachedMap }) => {
+    return cachedMap ?? (asMap(arr) as unknown as Map<string, unknown>)
+  },
+
+  untransform({ transformedValue: map }) {
+    // do not cache map <-> arr relationship
+
+    const arr: Array<[unknown, unknown]> = []
+    map.forEach((v, k) => {
+      arr.push([k, v])
+    })
+
+    return arr
+  },
+}
+
+/**
+ * @deprecated Prefer the codec equivalent: `tProp(types.mapFromArray(keyType, valueType))`.
+ * Use `tProp(types.skipCheck(types.mapFromArray(keyType, valueType)))` if you don't need runtime validation.
+ */
+export const arrayToMapTransform = <K, V>() =>
+  _arrayToMapTransform as ModelPropTransform<Array<[K, V]>, Map<K, V>>

package/src/transforms/asSet.ts

@@ -1,22 +1,22 @@
-import { ObservableSet } from "mobx"
-import type { ModelPropTransform } from "../modelShared/prop"
-import { asSet } from "../wrappers/asSet"
-
-const _arrayToSetTransform: ModelPropTransform<Array<unknown>, ObservableSet<unknown>> = {
-  transform({ originalValue: arr, cachedTransformedValue: cachedSet }) {
-    return cachedSet ?? asSet(arr)
-  },
-
-  untransform({ transformedValue: set }) {
-    // do not cache set <-> arr relationship
-
-    return Array.from(set.values())
-  },
-}
-
-/**
- * @deprecated Prefer the codec equivalent: `tProp(types.setFromArray(valueType))`.
- * Use `tProp(types.skipCheck(types.setFromArray(valueType)))` if you don't need runtime validation.
- */
-export const arrayToSetTransform = <T>() =>
-  _arrayToSetTransform as ModelPropTransform<Array<T>, Set<T> | ObservableSet<T>>
+import type { ObservableSet } from "mobx"
+import type { ModelPropTransform } from "../modelShared/prop"
+import { asSet } from "../wrappers/asSet"
+
+const _arrayToSetTransform: ModelPropTransform<Array<unknown>, ObservableSet<unknown>> = {
+  transform({ originalValue: arr, cachedTransformedValue: cachedSet }) {
+    return cachedSet ?? asSet(arr)
+  },
+
+  untransform({ transformedValue: set }) {
+    // do not cache set <-> arr relationship
+
+    return Array.from(set.values())
+  },
+}
+
+/**
+ * @deprecated Prefer the codec equivalent: `tProp(types.setFromArray(valueType))`.
+ * Use `tProp(types.skipCheck(types.setFromArray(valueType)))` if you don't need runtime validation.
+ */
+export const arrayToSetTransform = <T>() =>
+  _arrayToSetTransform as ModelPropTransform<Array<T>, Set<T> | ObservableSet<T>>

package/src/transforms/bigint.ts

@@ -1,20 +1,20 @@
-import type { ModelPropTransform } from "../modelShared/prop"
-
-const _stringToBigIntTransform: ModelPropTransform<string, bigint> = {
-  transform({ originalValue, cachedTransformedValue }) {
-    return cachedTransformedValue ?? BigInt(originalValue)
-  },
-
-  untransform({ transformedValue, cacheTransformedValue }) {
-    if (typeof transformedValue === "bigint") {
-      cacheTransformedValue()
-    }
-    return transformedValue.toString()
-  },
-}
-
-/**
- * @deprecated Prefer the codec equivalent: `tProp(types.bigint)`.
- * Use `tProp(types.skipCheck(types.bigint))` if you don't need runtime validation.
- */
-export const stringToBigIntTransform = () => _stringToBigIntTransform
+import type { ModelPropTransform } from "../modelShared/prop"
+
+const _stringToBigIntTransform: ModelPropTransform<string, bigint> = {
+  transform({ originalValue, cachedTransformedValue }) {
+    return cachedTransformedValue ?? BigInt(originalValue)
+  },
+
+  untransform({ transformedValue, cacheTransformedValue }) {
+    if (typeof transformedValue === "bigint") {
+      cacheTransformedValue()
+    }
+    return transformedValue.toString()
+  },
+}
+
+/**
+ * @deprecated Prefer the codec equivalent: `tProp(types.bigint)`.
+ * Use `tProp(types.skipCheck(types.bigint))` if you don't need runtime validation.
+ */
+export const stringToBigIntTransform = () => _stringToBigIntTransform

package/src/transforms/date.ts

@@ -1,40 +1,40 @@
-import type { ModelPropTransform } from "../modelShared/prop"
-import { ImmutableDate } from "./ImmutableDate"
-
-const _timestampToDateTransform: ModelPropTransform<number, Date> = {
-  transform({ originalValue, cachedTransformedValue }) {
-    return cachedTransformedValue ?? new ImmutableDate(originalValue)
-  },
-
-  untransform({ transformedValue, cacheTransformedValue }) {
-    if (transformedValue instanceof ImmutableDate) {
-      cacheTransformedValue()
-    }
-    return +transformedValue
-  },
-}
-
-/**
- * @deprecated Prefer the codec equivalent: `tProp(types.dateAsTimestamp)`.
- * Use `tProp(types.skipCheck(types.dateAsTimestamp))` if you don't need runtime validation.
- */
-export const timestampToDateTransform = () => _timestampToDateTransform
-
-const _isoStringToDateTransform: ModelPropTransform<string, Date> = {
-  transform({ originalValue, cachedTransformedValue }) {
-    return cachedTransformedValue ?? new ImmutableDate(originalValue)
-  },
-
-  untransform({ transformedValue, cacheTransformedValue }) {
-    if (transformedValue instanceof ImmutableDate) {
-      cacheTransformedValue()
-    }
-    return transformedValue.toISOString()
-  },
-}
-
-/**
- * @deprecated Prefer the codec equivalent: `tProp(types.dateAsIsoString)`.
- * Use `tProp(types.skipCheck(types.dateAsIsoString))` if you don't need runtime validation.
- */
-export const isoStringToDateTransform = () => _isoStringToDateTransform
+import type { ModelPropTransform } from "../modelShared/prop"
+import { ImmutableDate } from "./ImmutableDate"
+
+const _timestampToDateTransform: ModelPropTransform<number, Date> = {
+  transform({ originalValue, cachedTransformedValue }) {
+    return cachedTransformedValue ?? new ImmutableDate(originalValue)
+  },
+
+  untransform({ transformedValue, cacheTransformedValue }) {
+    if (transformedValue instanceof ImmutableDate) {
+      cacheTransformedValue()
+    }
+    return +transformedValue
+  },
+}
+
+/**
+ * @deprecated Prefer the codec equivalent: `tProp(types.dateAsTimestamp)`.
+ * Use `tProp(types.skipCheck(types.dateAsTimestamp))` if you don't need runtime validation.
+ */
+export const timestampToDateTransform = () => _timestampToDateTransform
+
+const _isoStringToDateTransform: ModelPropTransform<string, Date> = {
+  transform({ originalValue, cachedTransformedValue }) {
+    return cachedTransformedValue ?? new ImmutableDate(originalValue)
+  },
+
+  untransform({ transformedValue, cacheTransformedValue }) {
+    if (transformedValue instanceof ImmutableDate) {
+      cacheTransformedValue()
+    }
+    return transformedValue.toISOString()
+  },
+}
+
+/**
+ * @deprecated Prefer the codec equivalent: `tProp(types.dateAsIsoString)`.
+ * Use `tProp(types.skipCheck(types.dateAsIsoString))` if you don't need runtime validation.
+ */
+export const isoStringToDateTransform = () => _isoStringToDateTransform

package/src/treeUtils/deepEquals.ts

@@ -1,55 +1,55 @@
-import fastDeepEqual from "fast-deep-equal/es6"
-import { isObservable, toJS } from "mobx"
-import { getSnapshot } from "../snapshot"
-import { isTreeNode } from "../tweaker"
-import { getMobxVersion } from "../utils"
-
-/**
- * Deeply compares two values.
- *
- * Supported values are:
- * - Primitives
- * - Boxed observables
- * - Objects, observable objects
- * - Arrays, observable arrays
- * - Typed arrays
- * - Maps, observable maps
- * - Sets, observable sets
- * - Tree nodes (optimized by using snapshot comparison internally)
- *
- * Note that in the case of models the result will be false if their model IDs are different.
- *
- * @param a First value to compare.
- * @param b Second value to compare.
- * @returns `true` if they are the equivalent, `false` otherwise.
- */
-export function deepEquals(a: any, b: any): boolean {
-  // quick check for reference
-  if (a === b) {
-    return true
-  }
-
-  // use snapshots to compare if possible
-  // since snapshots use structural sharing it is more likely
-  // to speed up comparisons
-  if (isTreeNode(a)) {
-    a = getSnapshot(a)
-  } else if (isObservable(a)) {
-    a = toJS(a, toJSOptions)
-  }
-  if (isTreeNode(b)) {
-    b = getSnapshot(b)
-  } else if (isObservable(b)) {
-    b = toJS(b, toJSOptions)
-  }
-
-  return fastDeepEqual(a, b)
-}
-
-const toJSOptions =
-  getMobxVersion() >= 6
-    ? undefined
-    : {
-        exportMapsAsObjects: false,
-        recurseEverything: false,
-      }
+import fastDeepEqual from "fast-deep-equal/es6"
+import { isObservable, toJS } from "mobx"
+import { getSnapshot } from "../snapshot"
+import { isTreeNode } from "../tweaker"
+import { getMobxVersion } from "../utils"
+
+/**
+ * Deeply compares two values.
+ *
+ * Supported values are:
+ * - Primitives
+ * - Boxed observables
+ * - Objects, observable objects
+ * - Arrays, observable arrays
+ * - Typed arrays
+ * - Maps, observable maps
+ * - Sets, observable sets
+ * - Tree nodes (optimized by using snapshot comparison internally)
+ *
+ * Note that in the case of models the result will be false if their model IDs are different.
+ *
+ * @param a First value to compare.
+ * @param b Second value to compare.
+ * @returns `true` if they are the equivalent, `false` otherwise.
+ */
+export function deepEquals(a: any, b: any): boolean {
+  // quick check for reference
+  if (a === b) {
+    return true
+  }
+
+  // use snapshots to compare if possible
+  // since snapshots use structural sharing it is more likely
+  // to speed up comparisons
+  if (isTreeNode(a)) {
+    a = getSnapshot(a)
+  } else if (isObservable(a)) {
+    a = toJS(a, toJSOptions)
+  }
+  if (isTreeNode(b)) {
+    b = getSnapshot(b)
+  } else if (isObservable(b)) {
+    b = toJS(b, toJSOptions)
+  }
+
+  return fastDeepEqual(a, b)
+}
+
+const toJSOptions =
+  getMobxVersion() >= 6
+    ? undefined
+    : {
+        exportMapsAsObjects: false,
+        recurseEverything: false,
+      }

package/src/treeUtils/sandbox.ts

@@ -1,14 +1,14 @@
 import { reaction, runInAction } from "mobx"
 import {
+  type ReadonlyMiddlewareReturn,
   readonlyMiddleware,
-  ReadonlyMiddlewareReturn,
 } from "../actionMiddlewares/readonlyMiddleware"
 import { createContext } from "../context"
 import { getParentToChildPath, resolvePath } from "../parent/path"
 import { applyPatches } from "../patch/applyPatches"
 import { onPatches } from "../patch/emitPatch"
 import type { Patch } from "../patch/Patch"
-import { PatchRecorder, patchRecorder } from "../patch/patchRecorder"
+import { type PatchRecorder, patchRecorder } from "../patch/patchRecorder"
 import {
   fastIsRootStoreNoAtom,
   isRootStore,
@@ -83,13 +83,16 @@ export class SandboxManager {
    */
   private isCommitting = false
 
+  private readonly subtreeRoot: object
+
   /**
    * Creates an instance of `SandboxManager`.
    * Do not use directly, use `sandbox` instead.
    *
    * @param subtreeRoot Subtree root target object.
    */
-  constructor(private readonly subtreeRoot: object) {
+  constructor(subtreeRoot: object) {
+    this.subtreeRoot = subtreeRoot
     assertTweakedObject(subtreeRoot, "subtreeRoot")
 
     // we temporarily set the default value of the context manager so that

package/src/tweaker/TweakerPriority.ts

@@ -1,9 +1,9 @@
-/**
- * @internal
- */
-export enum TweakerPriority {
-  Model = 0,
-  Array = 1,
-  PlainObject = 2,
-  Frozen = 3,
-}
+/**
+ * @internal
+ */
+export enum TweakerPriority {
+  Model = 0,
+  Array = 1,
+  PlainObject = 2,
+  Frozen = 3,
+}

package/src/tweaker/tweak.ts

@@ -2,7 +2,7 @@ import { action } from "mobx"
 import { isDataModel } from "../dataModel/utils"
 import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig"
 import { getObjectChildren } from "../parent/coreObjectChildren"
-import { fastGetParent, ParentPath } from "../parent/path"
+import { fastGetParent, type ParentPath } from "../parent/path"
 import { setParent } from "../parent/setParent"
 import { unsetInternalSnapshot } from "../snapshot/internal"
 import type { AnyStandardType, TypeToData } from "../types/schemas"
@@ -38,11 +38,12 @@ export function toTreeNode<TType extends AnyStandardType, V extends TypeToData<T
 export function toTreeNode<T extends object>(value: T): T
 
 // base
-export function toTreeNode(arg1: any, arg2?: any): any {
+export function toTreeNode(...args: [arg1: any] | [arg1: any, arg2: any]): any {
+  const [arg1, arg2] = args
   let value: object
   let type: AnyStandardType | undefined
   let hasType: boolean
-  if (arguments.length === 1) {
+  if (args.length === 1) {
     hasType = false
     value = arg1
   } else {