mobx-keystone 1.21.0 → 1.22.0

package/dist/types/redux/connectReduxDevTools.d.ts

@@ -1,11 +1,24 @@
+export interface ConnectReduxDevToolsOptions {
+    /**
+     * If it should show the arguments near the action name.
+     *
+     * @default true
+     */
+    logArgsNearName?: boolean;
+    /**
+     * If it should log child actions when they run inside another action tracked
+     * by the same target tree.
+     *
+     * @default true
+     */
+    logChildActions?: boolean;
+}
 /**
  * Connects a tree node to a redux dev tools instance.
  *
  * @param remotedevPackage The remotedev package (usually the result of `require("remoteDev")`) (https://www.npmjs.com/package/remotedev).
  * @param remotedevConnection The result of a connect method from the remotedev package (usually the result of `remoteDev.connectViaExtension(...)`).
  * @param target Object to use as root.
- * @param [options] Optional options object. `logArgsNearName` if it should show the arguments near the action name (default is `true`).
+ * @param [options] Optional options object.
  */
-export declare function connectReduxDevTools(remotedevPackage: any, remotedevConnection: any, target: object, options?: {
-    logArgsNearName?: boolean;
-}): void;
+export declare function connectReduxDevTools(remotedevPackage: any, remotedevConnection: any, target: object, options?: ConnectReduxDevToolsOptions): void;

package/dist/types/types/TypeCheckError.d.ts

@@ -19,9 +19,19 @@ export declare class TypeCheckError {
     readonly modelTrail?: readonly string[];
     /**
      * Creates a type check error from an object payload.
-     * Prefer the object form; the positional form is kept for backwards compatibility.
+     * @param data Type check error data.
      */
-    constructor(...args: [data: TypeCheckErrorData] | [path: Path, expectedTypeName: string, actualValue: any, typeCheckedValue?: any]);
+    constructor(data: TypeCheckErrorData);
+    /**
+     * @deprecated Use the object payload constructor instead for better readability and maintainability.
+     *
+     * Creates a type check error from positional parameters.
+     * @param path Sub-path (where the root is the value being type checked) where the error occurred.
+     * @param expectedTypeName Name of the expected type.
+     * @param actualValue Actual value.
+     * @param typeCheckedValue The value where the type check was invoked.
+     */
+    constructor(path: Path, expectedTypeName: string, actualValue: any, typeCheckedValue?: any);
     /**
      * Throws the type check error as an actual error.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -66,25 +66,25 @@
     "mobx": "^6.0.0 || ^5.0.0 || ^4.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.29.0",
-    "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/plugin-proposal-decorators": "^7.29.0",
-    "@babel/preset-env": "^7.29.0",
-    "@babel/preset-typescript": "^7.28.5",
-    "@swc/core": "^1.15.18",
+    "@babel/core": "^8.0.1",
+    "@babel/plugin-proposal-decorators": "^8.0.2",
+    "@babel/plugin-transform-class-properties": "^8.0.1",
+    "@babel/plugin-transform-typescript": "^8.0.1",
+    "@babel/preset-env": "^8.0.2",
+    "@swc/core": "^1.15.43",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^25.5.0",
-    "@vitest/coverage-v8": "^4.1.0",
+    "@types/node": "^26.0.1",
+    "@vitest/coverage-v8": "^4.1.9",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
     "shx": "^0.4.0",
     "spec.ts": "^1.1.3",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.28.18",
-    "typescript": "^6.0.2",
-    "vite": "^8.0.0",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.1.0"
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.0",
+    "vite-plugin-dts": "^5.0.3",
+    "vitest": "^4.1.9"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/redux/connectReduxDevTools.ts

@@ -9,26 +9,42 @@ import { applySnapshot } from "../snapshot/applySnapshot"
 import { getSnapshot } from "../snapshot/getSnapshot"
 import { assertTweakedObject } from "../tweaker/core"
 
+export interface ConnectReduxDevToolsOptions {
+  /**
+   * If it should show the arguments near the action name.
+   *
+   * @default true
+   */
+  logArgsNearName?: boolean
+
+  /**
+   * If it should log child actions when they run inside another action tracked
+   * by the same target tree.
+   *
+   * @default true
+   */
+  logChildActions?: boolean
+}
+
 /**
  * Connects a tree node to a redux dev tools instance.
  *
  * @param remotedevPackage The remotedev package (usually the result of `require("remoteDev")`) (https://www.npmjs.com/package/remotedev).
  * @param remotedevConnection The result of a connect method from the remotedev package (usually the result of `remoteDev.connectViaExtension(...)`).
  * @param target Object to use as root.
- * @param [options] Optional options object. `logArgsNearName` if it should show the arguments near the action name (default is `true`).
+ * @param [options] Optional options object.
  */
 export function connectReduxDevTools(
   remotedevPackage: any,
   remotedevConnection: any,
   target: object,
-  options?: {
-    logArgsNearName?: boolean
-  }
+  options?: ConnectReduxDevToolsOptions
 ) {
   assertTweakedObject(target, "target")
 
   const opts = {
     logArgsNearName: true,
+    logChildActions: true,
     ...options,
   }
 
@@ -48,12 +64,15 @@ export function connectReduxDevTools(
   const actionIdSymbol = Symbol("actionId")
 
   actionTrackingMiddleware(target, {
+    filter(ctx) {
+      return opts.logChildActions || !hasDevToolsTrackedParentContext(ctx)
+    },
     onStart(ctx) {
       ctx.data[actionIdSymbol] = currentActionId++
     },
     onResume(ctx) {
       // give a chance to the parent to log its own changes before the child starts
-      if (ctx.parentContext) {
+      if (opts.logChildActions && ctx.parentContext) {
         log(ctx.parentContext, undefined)
       }
       log(ctx, undefined)
@@ -184,4 +203,17 @@ export function connectReduxDevTools(
 
     return name
   }
+
+  function hasDevToolsTrackedParentContext(ctx: SimpleActionContext) {
+    let parentContext = ctx.parentContext
+
+    while (parentContext) {
+      if (parentContext.data[actionIdSymbol] !== undefined) {
+        return true
+      }
+      parentContext = parentContext.parentContext
+    }
+
+    return false
+  }
 }

package/src/snapshot/fromArraySnapshot.ts

@@ -1,21 +1,15 @@
-import { observable } from "mobx"
 import { tweakArray } from "../tweaker/tweakArray"
 import { isArray } from "../utils"
 import { withErrorPathSegment } from "../utils/errorDiagnostics"
-import {
-  type FromSnapshotContext,
-  internalFromSnapshot,
-  observableOptions,
-  registerSnapshotter,
-} from "./fromSnapshot"
+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 arr = observable.array([] as any[], observableOptions)
   const ln = sn.length
+  const arr: any[] = new Array(ln)
   for (let i = 0; i < ln; i++) {
-    arr.push(withErrorPathSegment(i, () => internalFromSnapshot(sn[i], ctx)))
+    arr[i] = withErrorPathSegment(i, () => internalFromSnapshot(sn[i], ctx))
   }
   return tweakArray(arr, undefined, true)
 }

package/src/snapshot/fromPlainObjectSnapshot.ts

@@ -1,6 +1,6 @@
-import { observable, set } from "mobx"
+import { observable } from "mobx"
 import { tweakPlainObject } from "../tweaker/tweakPlainObject"
-import { isPlainObject } from "../utils"
+import { isPlainObject, setOwnProp } from "../utils"
 import { withErrorPathSegment } from "../utils/errorDiagnostics"
 import {
   type FromSnapshotContext,
@@ -12,21 +12,26 @@ import type { SnapshotInOfObject } from "./SnapshotOf"
 import { SnapshotterAndReconcilerPriority } from "./SnapshotterAndReconcilerPriority"
 
 function fromPlainObjectSnapshot(sn: SnapshotInOfObject<any>, ctx: FromSnapshotContext): object {
-  const plainObj = observable.object({}, undefined, observableOptions)
+  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]
-    // setIfDifferent not required
-    set(
+    setOwnProp(
       plainObj,
       k,
       withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
     )
   }
-  return tweakPlainObject(plainObj, undefined, undefined, true, false)
+  return tweakPlainObject(
+    observable.object(plainObj, undefined, observableOptions),
+    undefined,
+    undefined,
+    true,
+    false
+  )
 }
 
 /**

package/src/snapshot/fromSnapshot.ts

@@ -1,11 +1,11 @@
-import { action, observable, set } from "mobx"
+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 } from "../utils"
+import { isMap, isPrimitive, isSet, setOwnProp } from "../utils"
 import { runWithErrorDiagnosticsContext, withErrorPathSegment } from "../utils/errorDiagnostics"
 import { registerDefaultSnapshotters } from "./registerDefaultSnapshotters"
 import type { SnapshotInOf, SnapshotInOfModel, SnapshotOutOf } from "./SnapshotOf"
@@ -178,7 +178,7 @@ function snapshotToInitialData(
   ctx: FromSnapshotContext,
   processedSn: SnapshotInOfModel<AnyModel>
 ): any {
-  const initialData = observable.object({}, undefined, observableOptions)
+  const initialData: Record<string, unknown> = {}
 
   const processedSnKeys = Object.keys(processedSn)
   const processedSnKeysLen = processedSnKeys.length
@@ -187,11 +187,10 @@ function snapshotToInitialData(
     if (!isReservedModelKey(k)) {
       const v = processedSn[k]
       const snapshotValue = withErrorPathSegment(k, () => internalFromSnapshot(v, ctx))
-      // setIfDifferent not required
-      set(initialData, k, snapshotValue)
+      setOwnProp(initialData, k, snapshotValue)
     }
   }
-  return initialData
+  return observable.object(initialData, undefined, observableOptions)
 }
 
 export const observableOptions = {

package/src/tweaker/tweakArray.ts

@@ -23,7 +23,6 @@ import {
   updateInternalSnapshot,
 } from "../snapshot/internal"
 import { failure, inDevMode, isArray, isPrimitive } from "../utils"
-import { setIfDifferent } from "../utils/setIfDifferent"
 import { runningWithoutSnapshotOrPatches, tweakedObjects } from "./core"
 import { TweakerPriority } from "./TweakerPriority"
 import { registerTweaker, tweak } from "./tweak"
@@ -35,15 +34,25 @@ import { runTypeCheckingAfterChange } from "./typeChecking"
 export function tweakArray<T extends any[]>(
   value: T,
   parentPath: ParentPath<any> | undefined,
-  doNotTweakChildren: boolean
+  childrenAlreadyTweaked: boolean
 ): T {
   const originalArr: ReadonlyArray<any> = value
   const arrLn = originalArr.length
-  const tweakedArr = isObservableArray(originalArr)
-    ? originalArr
-    : observable.array(undefined, observableOptions)
-  if (tweakedArr !== originalArr) {
-    tweakedArr.length = originalArr.length
+  const originalArrIsObservable = isObservableArray(originalArr)
+  let tweakedArr: IObservableArray<any>
+  // Fresh arrays whose children still need tweaking are collected into a plain
+  // buffer and inserted in one bulk replace at the end.
+  let buffer: any[] | undefined
+
+  if (originalArrIsObservable) {
+    tweakedArr = originalArr as IObservableArray<any>
+  } else if (childrenAlreadyTweaked) {
+    // Snapshot arrays already contain tweaked children, so MobX can initialize
+    // the observable array directly from the source values.
+    tweakedArr = observable.array(originalArr as any[], observableOptions)
+  } else {
+    tweakedArr = observable.array(undefined, observableOptions)
+    buffer = new Array(arrLn)
   }
 
   let interceptDisposer: () => void
@@ -67,13 +76,47 @@ export function tweakArray<T extends any[]>(
   const untransformedSn: any[] = []
   untransformedSn.length = arrLn
 
+  // externally provided observable arrays keep unchanged slots untouched, but
+  // consecutive child replacements can still be applied as single splice ranges
+  let replacementRangeStart = -1
+  let replacementRangeItems: any[] | undefined
+
+  const flushReplacementRange = () => {
+    if (replacementRangeStart >= 0) {
+      tweakedArr.spliceWithArray(
+        replacementRangeStart,
+        replacementRangeItems!.length,
+        replacementRangeItems!
+      )
+      replacementRangeStart = -1
+      replacementRangeItems = undefined
+    }
+  }
+
+  const queueReplacementIfDifferent = (index: number, value: unknown) => {
+    if (tweakedArr[index] === value && index in tweakedArr) {
+      flushReplacementRange()
+      return
+    }
+
+    if (replacementRangeStart + (replacementRangeItems?.length ?? 0) === index) {
+      replacementRangeItems!.push(value)
+    } else {
+      flushReplacementRange()
+      replacementRangeStart = index
+      replacementRangeItems = [value]
+    }
+  }
+
   // substitute initial values by proxied values
   for (let i = 0; i < arrLn; i++) {
     const v = originalArr[i]
 
     if (isPrimitive(v)) {
-      if (!doNotTweakChildren) {
-        setIfDifferent(tweakedArr, i, v)
+      if (buffer) {
+        buffer[i] = v
+      } else if (!childrenAlreadyTweaked) {
+        queueReplacementIfDifferent(i, v)
       }
 
       untransformedSn[i] = v
@@ -81,7 +124,7 @@ export function tweakArray<T extends any[]>(
       const path = { parent: tweakedArr, path: i }
 
       let tweakedValue: any
-      if (doNotTweakChildren) {
+      if (childrenAlreadyTweaked) {
         tweakedValue = v
         setParent(
           tweakedValue, // value
@@ -93,7 +136,12 @@ export function tweakArray<T extends any[]>(
         )
       } else {
         tweakedValue = tweak(v, path)
-        setIfDifferent(tweakedArr, i, tweakedValue)
+      }
+
+      if (buffer) {
+        buffer[i] = tweakedValue
+      } else if (!childrenAlreadyTweaked) {
+        queueReplacementIfDifferent(i, tweakedValue)
       }
 
       const valueSn = getInternalSnapshot(tweakedValue)!
@@ -101,6 +149,13 @@ export function tweakArray<T extends any[]>(
     }
   }
 
+  if (buffer) {
+    // done before the intercept/observe handlers are installed, so this
+    // is a single plain mobx bulk insertion
+    tweakedArr.replace(buffer)
+  } else {
+    flushReplacementRange()
+  }
   setNewInternalSnapshot(tweakedArr, untransformedSn, undefined)
 
   interceptDisposer = intercept(tweakedArr, interceptArrayMutation.bind(undefined, tweakedArr))

package/src/types/TypeCheckError.ts

@@ -30,14 +30,32 @@ export class TypeCheckError {
 
   /**
    * Creates a type check error from an object payload.
-   * Prefer the object form; the positional form is kept for backwards compatibility.
+   * @param data Type check error data.
    */
+  constructor(data: TypeCheckErrorData)
+  /**
+   * @deprecated Use the object payload constructor instead for better readability and maintainability.
+   *
+   * Creates a type check error from positional parameters.
+   * @param path Sub-path (where the root is the value being type checked) where the error occurred.
+   * @param expectedTypeName Name of the expected type.
+   * @param actualValue Actual value.
+   * @param typeCheckedValue The value where the type check was invoked.
+   */
+  constructor(path: Path, expectedTypeName: string, actualValue: any, typeCheckedValue?: any)
+
   constructor(
-    ...args:
-      | [data: TypeCheckErrorData]
-      | [path: Path, expectedTypeName: string, actualValue: any, typeCheckedValue?: any]
+    dataOrPath: TypeCheckErrorData | Path,
+    expectedTypeName?: string,
+    actualValue?: any,
+    typeCheckedValue?: any
   ) {
-    const data = normalizeTypeCheckErrorData(args[0], args[1], args[2], args[3])
+    const data = normalizeTypeCheckErrorData(
+      dataOrPath,
+      expectedTypeName,
+      actualValue,
+      typeCheckedValue
+    )
     const resolvedData = resolveTypeCheckErrorData(data)
 
     this.path = data.path