mobx-keystone 1.23.0 → 1.24.1

package/src/treeUtils/draft.ts

@@ -1,4 +1,3 @@
-import { action, computed } from "mobx"
 import { pathToTargetPathIds } from "../actionMiddlewares/utils"
 import { resolvePath, resolvePathCheckingIds, skipIdChecking } from "../parent/path"
 import type { Path } from "../parent/pathTypes"
@@ -7,7 +6,7 @@ import { applySnapshot } from "../snapshot/applySnapshot"
 import { fromSnapshot } from "../snapshot/fromSnapshot"
 import { getSnapshot } from "../snapshot/getSnapshot"
 import { assertTweakedObject } from "../tweaker/core"
-import { failure } from "../utils"
+import { failure, mobxAction, mobxComputed } from "../utils"
 import { deepEquals } from "./deepEquals"
 
 /**
@@ -25,7 +24,7 @@ export class Draft<T extends object> {
   /**
    * Commits current draft changes to the original object.
    */
-  @action
+  @mobxAction
   commit(): void {
     applySnapshot(this.originalData, getSnapshot(this.data))
   }
@@ -37,7 +36,7 @@ export class Draft<T extends object> {
    *
    * @param path Path to commit.
    */
-  @action
+  @mobxAction
   commitByPath(path: Path): void {
     const draftTarget = resolvePath(this.data, path)
     if (!draftTarget.resolved) {
@@ -63,7 +62,7 @@ export class Draft<T extends object> {
   /**
    * Resets the draft to be an exact copy of the current state of the original object.
    */
-  @action
+  @mobxAction
   reset(): void {
     applySnapshot(this.data, this.originalSnapshot)
   }
@@ -75,7 +74,7 @@ export class Draft<T extends object> {
    *
    * @param path Path to reset.
    */
-  @action
+  @mobxAction
   resetByPath(path: Path): void {
     const originalTarget = resolvePath(this.originalData, path)
     if (!originalTarget.resolved) {
@@ -101,7 +100,7 @@ export class Draft<T extends object> {
   /**
    * Returns `true` if the draft has changed compared to the original object, `false` otherwise.
    */
-  @computed
+  @mobxComputed
   get isDirty(): boolean {
     return !deepEquals(getSnapshot(this.data), this.originalSnapshot)
   }
@@ -135,7 +134,7 @@ export class Draft<T extends object> {
    */
   readonly originalData: T
 
-  @computed
+  @mobxComputed
   private get originalSnapshot() {
     return getSnapshot(this.originalData)
   }

package/src/tweaker/tweakPlainObject.ts

@@ -48,7 +48,8 @@ export function tweakPlainObject<T extends Record<string, any>>(
   isDataObject: boolean
 ): T {
   const originalObj: Record<string, any> = value
-  const tweakedObj = isObservableObject(originalObj)
+  const originalIsObservableObject = isObservableObject(originalObj)
+  const tweakedObj = originalIsObservableObject
     ? originalObj
     : observable.object({}, undefined, observableOptions)
 
@@ -78,7 +79,7 @@ export function tweakPlainObject<T extends Record<string, any>>(
     const v = originalObj[k]
 
     if (isPrimitive(v)) {
-      if (!doNotTweakChildren) {
+      if (!doNotTweakChildren && !originalIsObservableObject) {
         setIfDifferent(tweakedObj, k, v)
       }
       if (k === "__proto__") {

package/src/types/TypeChecker.ts

@@ -6,7 +6,7 @@ import type { TypeCheckError } from "./TypeCheckError"
 
 type CheckFunction = (value: any, path: Path, typeCheckedValue: any) => TypeCheckError | null
 
-/** @internal */
+/** @ignore */
 export type SnapshotProcessor = (snapshot: any) => unknown
 
 /**
@@ -14,7 +14,7 @@ export type SnapshotProcessor = (snapshot: any) => unknown
  * TypeCheckers rather than processors so recursive graphs can be discovered
  * before any processor body is compiled.
  *
- * @internal
+ * @ignore
  */
 export interface SnapshotProcessorPlan {
   readonly intrinsic?: boolean
@@ -36,7 +36,7 @@ export function snapshotProcessorPlan(
 type SnapshotProcessorSource = SnapshotProcessor | SnapshotProcessorPlan | undefined
 type SnapshotProcessorDirection = "from" | "to"
 
-/** @internal */
+/** @ignore */
 export class SnapshotProcessorPlanNode {
   private readonly owner: TypeChecker | undefined
   private readonly direction: SnapshotProcessorDirection
@@ -196,7 +196,7 @@ export class SnapshotProcessorPlanNode {
 const absentSnapshotProcessorPlanNode = new SnapshotProcessorPlanNode(undefined, "from", undefined)
 
 /**
- * @internal
+ * @ignore
  */
 export enum TypeCheckerBaseType {
   Object = "object",
@@ -243,7 +243,7 @@ export function invalidateCachedToSnapshotProcessorResult(obj: object) {
 }
 
 /**
- * @internal
+ * @ignore
  */
 export class TypeChecker {
   unchecked: boolean
@@ -443,6 +443,6 @@ export class TypeInfo {
 }
 
 /**
- * @internal
+ * @ignore
  */
 export type TypeInfoGen = (t: AnyStandardType) => TypeInfo

package/src/types/schemas.ts

@@ -64,7 +64,7 @@ export interface ObjectOfTypes {
 
 /**
  * Name of the properties of an object that can be set to undefined, any or unknown.
- * @internal
+ * @ignore
  */
 export type UndefinablePropsNames<T> = {
   [K in keyof T]: IsOptionalValue<T[K], K, never>
@@ -72,7 +72,7 @@ export type UndefinablePropsNames<T> = {
 
 /**
  * Computes the optional keys for an object type schema.
- * @internal
+ * @ignore
  */
 export type ObjectOptionalKeys<S> = UndefinablePropsNames<{
   [k in keyof S]: TypeToDataOpt<S[k]> extends infer R ? R : never

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 import * as mobx from "mobx"
 import {
+  type IComputedValue,
   type IObservableArray,
   isObservableArray,
   isObservableMap,
@@ -419,6 +420,127 @@ export const mobx6 = {
   ],
 }
 
+/**
+ * MobX method action decorator compatible with both legacy decorators and
+ * MobX 7's standard decorator API.
+ *
+ * This is a decorator compatibility helper, not a replacement for other
+ * `action` overloads such as `action(fn)`. Field decorators are not supported.
+ *
+ * @hidden
+ */
+export function mobxAction<This, Args extends unknown[], Return>(
+  value: (this: This, ...args: Args) => Return,
+  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>
+): (this: This, ...args: Args) => Return
+export function mobxAction<This, Args extends unknown[], Return>(
+  target: object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Return>
+): TypedPropertyDescriptor<(this: This, ...args: Args) => Return> | void
+export function mobxAction(...args: any[]): any {
+  if (isStandardDecoratorContext(args[1])) {
+    return (mobx.action as any)(args[0], args[1])
+  }
+
+  if (getMobxVersion() < 7) {
+    return (mobx.action as any)(...args)
+  }
+
+  const descriptor = args[2] as PropertyDescriptor | undefined
+  if (!descriptor?.value) {
+    return descriptor
+  }
+
+  if (mobx.isAction(descriptor.value)) {
+    return descriptor
+  }
+
+  return {
+    ...descriptor,
+    value: mobx.action(String(args[1]), descriptor.value),
+  }
+}
+
+/**
+ * MobX getter computed decorator compatible with both legacy decorators and
+ * MobX 7's standard decorator API.
+ *
+ * This is a decorator compatibility helper, not a replacement for other
+ * `computed` overloads. Field decorators and decorator options are not supported.
+ * Under MobX 7's legacy decorator transform the getter is backed by a computed
+ * value, but is not registered as a computed property for MobX introspection.
+ *
+ * @hidden
+ */
+export function mobxComputed<This, Value>(
+  value: (this: This) => Value,
+  context: ClassGetterDecoratorContext<This, Value>
+): ((this: This) => Value) | void
+export function mobxComputed<Value>(
+  target: object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<Value>
+): TypedPropertyDescriptor<Value> | void
+export function mobxComputed(...args: any[]): any {
+  if (isStandardDecoratorContext(args[1])) {
+    return (mobx.computed as any)(args[0], args[1])
+  }
+
+  if (getMobxVersion() < 7) {
+    return (mobx.computed as any)(...args)
+  }
+
+  const descriptor = args[2] as PropertyDescriptor | undefined
+  if (!descriptor?.get) {
+    return descriptor
+  }
+
+  const getter = descriptor.get
+  const computedValues = new WeakMap<object, IComputedValue<unknown>>()
+
+  return {
+    ...descriptor,
+    get(this: object) {
+      let computedValue = computedValues.get(this)
+      if (!computedValue) {
+        const newComputedValue = mobx.computed(() => getter.call(this), {
+          name: String(args[1]),
+        })
+        computedValues.set(this, newComputedValue)
+        computedValue = newComputedValue
+      }
+      return computedValue.get()
+    },
+  }
+}
+
+// Mirrors MobX's standard-decorator call detection. Legacy decorator calls use
+// a string or symbol property key as their second argument, so checking `kind`
+// distinguishes the call shapes without claiming to validate the full context.
+function isStandardDecoratorContext(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { kind?: unknown }).kind === "string"
+  )
+}
+
+/**
+ * Calls `makeObservable` across MobX versions. MobX 7 requires an annotations
+ * object, while MobX 6 and older versions use decorator metadata when no
+ * annotations are passed.
+ *
+ * @internal
+ */
+export function makeObservableCompat(target: object, annotations?: object): void {
+  if (getMobxVersion() >= 7) {
+    mobx6.makeObservable(target, annotations ?? {})
+  } else {
+    mobx6.makeObservable(target)
+  }
+}
+
 /**
  * @internal
  */
@@ -426,17 +548,26 @@ export function propNameToSetterName(propName: string): string {
   return `set${propName[0].toUpperCase()}${propName.slice(1)}`
 }
 
+let cachedMobxVersion: number | undefined
+
 /**
  * @internal
  */
 export function getMobxVersion(): number {
+  if (cachedMobxVersion !== undefined) {
+    return cachedMobxVersion
+  }
+
   if (mobx6.makeObservable!) {
-    return 6
+    const version = (mobx as any)._getGlobalState?.().version
+    cachedMobxVersion = typeof version === "number" && version >= 7 ? version : 6
   } else if ("extendShallowObservable" in mobx) {
-    return 4
+    cachedMobxVersion = 4
   } else {
-    return 5
+    cachedMobxVersion = 5
   }
+
+  return cachedMobxVersion
 }
 
 /**