mobx-keystone 1.20.0 → 1.22.0

package/src/action/modelFlowPromiseGenerator.ts

@@ -1,125 +1,127 @@
-/*
-function* promiseGenerator<T>(
-  this: Promise<T>
-) {
-  const ret: T = yield this
-  return ret
-}
-*/
-
-// above code but compiled by TS for ES5
-// so we don't include a dependency to regenerator runtime
-
-const __generator = function (thisArg: any, body: any) {
-  let _: any = {
-      label: 0,
-      sent: function () {
-        if (t[0] & 1) throw t[1]
-        return t[1]
-      },
-      trys: [],
-      ops: [],
-    },
-    f: any,
-    y: any,
-    t: any,
-    g: any
-  return (
-    (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-    typeof Symbol === "function" &&
-      (g[Symbol.iterator] = function () {
-        return this
-      }),
-    g
-  )
-  function verb(n: any) {
-    return function (v: any) {
-      return step([n, v])
-    }
-  }
-  function step(op: any) {
-    if (f) throw new TypeError("Generator is already executing.")
-    while (_)
-      try {
-        if (
-          ((f = 1),
-          y &&
-            (t =
-              op[0] & 2
-                ? y["return"]
-                : op[0]
-                  ? y["throw"] || ((t = y["return"]) && t.call(y), 0)
-                  : y.next) &&
-            !(t = t.call(y, op[1])).done)
-        )
-          return t
-        if (((y = 0), t)) op = [op[0] & 2, t.value]
-        switch (op[0]) {
-          case 0:
-          case 1:
-            t = op
-            break
-          case 4:
-            _.label++
-            return { value: op[1], done: false }
-          case 5:
-            _.label++
-            y = op[1]
-            op = [0]
-            continue
-          case 7:
-            op = _.ops.pop()
-            _.trys.pop()
-            continue
-          default:
-            if (
-              !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
-              (op[0] === 6 || op[0] === 2)
-            ) {
-              _ = 0
-              continue
-            }
-            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
-              _.label = op[1]
-              break
-            }
-            if (op[0] === 6 && _.label < t[1]) {
-              _.label = t[1]
-              t = op
-              break
-            }
-            if (t && _.label < t[2]) {
-              _.label = t[2]
-              _.ops.push(op)
-              break
-            }
-            if (t[2]) _.ops.pop()
-            _.trys.pop()
-            continue
-        }
-        op = body.call(thisArg, _)
-      } catch (e) {
-        op = [6, e]
-        y = 0
-      } finally {
-        f = t = 0
-      }
-    if (op[0] & 5) throw op[1]
-    return { value: op[0] ? op[1] : void 0, done: true }
-  }
-}
-
-export function promiseGenerator(this: Promise<any>) {
-  let ret
-  return __generator(this, function (this: any, _a: any) {
-    switch (_a.label) {
-      case 0:
-        return [4 /*yield*/, this]
-      case 1:
-        ret = _a.sent()
-        return [2 /*return*/, ret]
-      default:
-        return
-    }
-  })
-}
+// biome-ignore-all lint: transpiled TypeScript ES5 helper kept verbatim; its generated shape intentionally violates style and complexity rules.
+
+/*
+function* promiseGenerator<T>(
+  this: Promise<T>
+) {
+  const ret: T = yield this
+  return ret
+}
+*/
+
+// above code but compiled by TS for ES5
+// so we don't include a dependency to regenerator runtime
+
+const __generator = function (thisArg: any, body: any) {
+  let _: any = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1]
+        return t[1]
+      },
+      trys: [],
+      ops: [],
+    },
+    f: any,
+    y: any,
+    t: any,
+    g: any
+  return (
+    (g = { next: verb(0), throw: verb(1), return: verb(2) }),
+    typeof Symbol === "function" &&
+      (g[Symbol.iterator] = function () {
+        return this
+      }),
+    g
+  )
+  function verb(n: any) {
+    return function (v: any) {
+      return step([n, v])
+    }
+  }
+  function step(op: any) {
+    if (f) throw new TypeError("Generator is already executing.")
+    while (_)
+      try {
+        if (
+          ((f = 1),
+          y &&
+            (t =
+              op[0] & 2
+                ? y["return"]
+                : op[0]
+                  ? y["throw"] || ((t = y["return"]) && t.call(y), 0)
+                  : y.next) &&
+            !(t = t.call(y, op[1])).done)
+        )
+          return t
+        if (((y = 0), t)) op = [op[0] & 2, t.value]
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op
+            break
+          case 4:
+            _.label++
+            return { value: op[1], done: false }
+          case 5:
+            _.label++
+            y = op[1]
+            op = [0]
+            continue
+          case 7:
+            op = _.ops.pop()
+            _.trys.pop()
+            continue
+          default:
+            if (
+              !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
+              (op[0] === 6 || op[0] === 2)
+            ) {
+              _ = 0
+              continue
+            }
+            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+              _.label = op[1]
+              break
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1]
+              t = op
+              break
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2]
+              _.ops.push(op)
+              break
+            }
+            if (t[2]) _.ops.pop()
+            _.trys.pop()
+            continue
+        }
+        op = body.call(thisArg, _)
+      } catch (e) {
+        op = [6, e]
+        y = 0
+      } finally {
+        f = t = 0
+      }
+    if (op[0] & 5) throw op[1]
+    return { value: op[0] ? op[1] : void 0, done: true }
+  }
+}
+
+export function promiseGenerator(this: Promise<any>) {
+  let ret
+  return __generator(this, function (this: any, _a: any) {
+    switch (_a.label) {
+      case 0:
+        return [4 /*yield*/, this]
+      case 1:
+        ret = _a.sent()
+        return [2 /*return*/, ret]
+      default:
+        return
+    }
+  })
+}

package/src/action/pendingActions.ts

@@ -1,42 +1,42 @@
-import { getCurrentActionContext } from "./context"
-import { getActionProtection } from "./protection"
-
-const pendingActions: (() => void)[] = []
-
-function isActionRunning(): boolean {
-  return !getActionProtection() || !!getCurrentActionContext()
-}
-
-/**
- * @internal
- */
-export function enqueuePendingAction(action: () => void): void {
-  // delay action until all current actions are finished
-  if (isActionRunning()) {
-    pendingActions.push(action)
-  } else {
-    action()
-  }
-}
-
-let pendingActionsRunning = false
-
-/**
- * @internal
- */
-export function tryRunPendingActions(): void {
-  if (isActionRunning() || pendingActionsRunning) {
-    return
-  }
-
-  pendingActionsRunning = true
-
-  try {
-    while (pendingActions.length > 0) {
-      const nextAction = pendingActions.shift()!
-      nextAction()
-    }
-  } finally {
-    pendingActionsRunning = false
-  }
-}
+import { getCurrentActionContext } from "./context"
+import { getActionProtection } from "./protection"
+
+const pendingActions: (() => void)[] = []
+
+function isActionRunning(): boolean {
+  return !getActionProtection() || !!getCurrentActionContext()
+}
+
+/**
+ * @internal
+ */
+export function enqueuePendingAction(action: () => void): void {
+  // delay action until all current actions are finished
+  if (isActionRunning()) {
+    pendingActions.push(action)
+  } else {
+    action()
+  }
+}
+
+let pendingActionsRunning = false
+
+/**
+ * @internal
+ */
+export function tryRunPendingActions(): void {
+  if (isActionRunning() || pendingActionsRunning) {
+    return
+  }
+
+  pendingActionsRunning = true
+
+  try {
+    while (pendingActions.length > 0) {
+      const nextAction = pendingActions.shift()!
+      nextAction()
+    }
+  } finally {
+    pendingActionsRunning = false
+  }
+}

package/src/action/wrapInAction.ts

@@ -1,156 +1,156 @@
-import { action } from "mobx"
-import type { O } from "ts-toolbelt"
-import type { AnyDataModel } from "../dataModel/BaseDataModel"
-import type { AnyModel } from "../model/BaseModel"
-import { AnyFunction } from "../utils/AnyFunction"
-import { copyFunctionMetadata } from "../utils/decorators"
-import {
-  ActionContext,
-  ActionContextActionType,
-  getCurrentActionContext,
-  setCurrentActionContext,
-} from "./context"
-import { isModelAction, modelActionSymbol } from "./isModelAction"
-import { getPerObjectActionMiddlewares } from "./middleware"
-import type { FlowFinisher } from "./modelFlow"
-import { tryRunPendingActions } from "./pendingActions"
-
-/**
- * @internal
- */
-export type WrapInActionOverrideContextFn = (ctx: O.Writable<ActionContext>, self: AnyModel) => void
-
-/**
- * @internal
- */
-export function wrapInAction<T extends Function>({
-  nameOrNameFn,
-  fn,
-  actionType,
-  overrideContext,
-  isFlowFinisher = false,
-}: {
-  nameOrNameFn: string | (() => string)
-  fn: T
-  actionType: ActionContextActionType
-  overrideContext?: WrapInActionOverrideContextFn
-  isFlowFinisher?: boolean
-}): T {
-  let fnInAction = false
-
-  const wrappedAction = function (this: AnyModel, ...args: unknown[]) {
-    const name = typeof nameOrNameFn === "function" ? nameOrNameFn() : nameOrNameFn
-
-    if (!fnInAction) {
-      fnInAction = true
-
-      // we need to make only inner actions actual mobx actions
-      // so reactions (e.g. reference detaching) are picked up in the
-      // right context
-      fn = action(name, fn)
-    }
-
-    const parentContext = getCurrentActionContext()
-
-    const context: O.Writable<ActionContext> = {
-      actionName: name,
-      type: actionType,
-      target: this,
-      args,
-      parentContext,
-      data: {},
-      rootContext: undefined as never, // will be set after the override
-    }
-    if (overrideContext) {
-      overrideContext(context, this)
-    }
-    if (!context.rootContext) {
-      if (context.previousAsyncStepContext) {
-        context.rootContext = context.previousAsyncStepContext.rootContext
-      } else if (context.parentContext) {
-        context.rootContext = context.parentContext.rootContext
-      } else {
-        context.rootContext = context
-      }
-    }
-
-    setCurrentActionContext(context)
-
-    const perObjectMiddlewares = getPerObjectActionMiddlewares(context.target)
-
-    let objectIndex = perObjectMiddlewares.length - 1 // from topmost parent to the object itself
-    let objectMwareIndex = 0
-
-    const runNextMiddleware = (): unknown => {
-      const objectMwares = perObjectMiddlewares[objectIndex]
-      if (!objectMwares) {
-        // no more middlewares, run base action
-        return fn.apply(this, args)
-      }
-      const mwareData = objectMwares[objectMwareIndex]
-
-      // advance to the next middleware
-      objectMwareIndex++
-      if (objectMwareIndex >= objectMwares.length) {
-        objectMwareIndex = 0
-        objectIndex--
-      }
-
-      const filterPassed = mwareData.filter ? mwareData.filter(context) : true
-      return filterPassed ? mwareData.middleware(context, runNextMiddleware) : runNextMiddleware()
-    }
-
-    try {
-      const ret = runNextMiddleware()
-
-      if (isFlowFinisher) {
-        const flowFinisher = ret as FlowFinisher
-        const value = flowFinisher.value
-        if (flowFinisher.resolution === "accept") {
-          flowFinisher.accepter(value)
-        } else {
-          flowFinisher.rejecter(value)
-        }
-        return value // not sure if this is even needed
-      } else {
-        return ret
-      }
-    } finally {
-      setCurrentActionContext(context.parentContext)
-
-      tryRunPendingActions()
-    }
-  }
-  ;(wrappedAction as unknown as { [modelActionSymbol]: true })[modelActionSymbol] = true
-
-  copyFunctionMetadata(fn, wrappedAction)
-
-  return wrappedAction as unknown as T
-}
-
-/**
- * @internal
- */
-export function wrapModelMethodInActionIfNeeded<M extends AnyModel | AnyDataModel>(
-  model: M,
-  propertyKey: keyof M,
-  name: string
-): void {
-  const fn = model[propertyKey] as AnyFunction
-  if (isModelAction(fn)) {
-    return
-  }
-
-  const wrappedFn = wrapInAction({
-    nameOrNameFn: name,
-    fn,
-    actionType: ActionContextActionType.Sync,
-  })
-  const proto = Object.getPrototypeOf(model)
-  const protoFn = proto[propertyKey]
-  if (protoFn === fn) {
-    proto[propertyKey] = wrappedFn
-  } else {
-    model[propertyKey] = wrappedFn as M[typeof propertyKey]
-  }
-}
+import { action } from "mobx"
+import type { O } from "ts-toolbelt"
+import type { AnyDataModel } from "../dataModel/BaseDataModel"
+import type { AnyModel } from "../model/BaseModel"
+import type { AnyFunction } from "../utils/AnyFunction"
+import { copyFunctionMetadata } from "../utils/decorators"
+import {
+  type ActionContext,
+  ActionContextActionType,
+  getCurrentActionContext,
+  setCurrentActionContext,
+} from "./context"
+import { isModelAction, modelActionSymbol } from "./isModelAction"
+import { getPerObjectActionMiddlewares } from "./middleware"
+import type { FlowFinisher } from "./modelFlow"
+import { tryRunPendingActions } from "./pendingActions"
+
+/**
+ * @internal
+ */
+export type WrapInActionOverrideContextFn = (ctx: O.Writable<ActionContext>, self: AnyModel) => void
+
+/**
+ * @internal
+ */
+export function wrapInAction<T extends Function>({
+  nameOrNameFn,
+  fn,
+  actionType,
+  overrideContext,
+  isFlowFinisher = false,
+}: {
+  nameOrNameFn: string | (() => string)
+  fn: T
+  actionType: ActionContextActionType
+  overrideContext?: WrapInActionOverrideContextFn
+  isFlowFinisher?: boolean
+}): T {
+  let fnInAction = false
+
+  const wrappedAction = function (this: AnyModel, ...args: unknown[]) {
+    const name = typeof nameOrNameFn === "function" ? nameOrNameFn() : nameOrNameFn
+
+    if (!fnInAction) {
+      fnInAction = true
+
+      // we need to make only inner actions actual mobx actions
+      // so reactions (e.g. reference detaching) are picked up in the
+      // right context
+      fn = action(name, fn)
+    }
+
+    const parentContext = getCurrentActionContext()
+
+    const context: O.Writable<ActionContext> = {
+      actionName: name,
+      type: actionType,
+      target: this,
+      args,
+      parentContext,
+      data: {},
+      rootContext: undefined as never, // will be set after the override
+    }
+    if (overrideContext) {
+      overrideContext(context, this)
+    }
+    if (!context.rootContext) {
+      if (context.previousAsyncStepContext) {
+        context.rootContext = context.previousAsyncStepContext.rootContext
+      } else if (context.parentContext) {
+        context.rootContext = context.parentContext.rootContext
+      } else {
+        context.rootContext = context
+      }
+    }
+
+    setCurrentActionContext(context)
+
+    const perObjectMiddlewares = getPerObjectActionMiddlewares(context.target)
+
+    let objectIndex = perObjectMiddlewares.length - 1 // from topmost parent to the object itself
+    let objectMwareIndex = 0
+
+    const runNextMiddleware = (): unknown => {
+      const objectMwares = perObjectMiddlewares[objectIndex]
+      if (!objectMwares) {
+        // no more middlewares, run base action
+        return fn.apply(this, args)
+      }
+      const mwareData = objectMwares[objectMwareIndex]
+
+      // advance to the next middleware
+      objectMwareIndex++
+      if (objectMwareIndex >= objectMwares.length) {
+        objectMwareIndex = 0
+        objectIndex--
+      }
+
+      const filterPassed = mwareData.filter ? mwareData.filter(context) : true
+      return filterPassed ? mwareData.middleware(context, runNextMiddleware) : runNextMiddleware()
+    }
+
+    try {
+      const ret = runNextMiddleware()
+
+      if (isFlowFinisher) {
+        const flowFinisher = ret as FlowFinisher
+        const value = flowFinisher.value
+        if (flowFinisher.resolution === "accept") {
+          flowFinisher.accepter(value)
+        } else {
+          flowFinisher.rejecter(value)
+        }
+        return value // not sure if this is even needed
+      } else {
+        return ret
+      }
+    } finally {
+      setCurrentActionContext(context.parentContext)
+
+      tryRunPendingActions()
+    }
+  }
+  ;(wrappedAction as unknown as { [modelActionSymbol]: true })[modelActionSymbol] = true
+
+  copyFunctionMetadata(fn, wrappedAction)
+
+  return wrappedAction as unknown as T
+}
+
+/**
+ * @internal
+ */
+export function wrapModelMethodInActionIfNeeded<M extends AnyModel | AnyDataModel>(
+  model: M,
+  propertyKey: keyof M,
+  name: string
+): void {
+  const fn = model[propertyKey] as AnyFunction
+  if (isModelAction(fn)) {
+    return
+  }
+
+  const wrappedFn = wrapInAction({
+    nameOrNameFn: name,
+    fn,
+    actionType: ActionContextActionType.Sync,
+  })
+  const proto = Object.getPrototypeOf(model)
+  const protoFn = proto[propertyKey]
+  if (protoFn === fn) {
+    proto[propertyKey] = wrappedFn
+  } else {
+    model[propertyKey] = wrappedFn as M[typeof propertyKey]
+  }
+}

package/src/actionMiddlewares/actionSerialization/actionSerialization.ts

@@ -4,7 +4,7 @@ import { assertTweakedObject } from "../../tweaker/core"
 import { failure, isJSONPrimitive, isPlainObject } from "../../utils"
 import type { JSONPrimitiveValue } from "../../utils/types"
 import { arraySerializer } from "./arraySerializer"
-import { ActionCallArgumentSerializer, cannotSerialize } from "./core"
+import { type ActionCallArgumentSerializer, cannotSerialize } from "./core"
 import { dateSerializer } from "./dateSerializer"
 import { mapSerializer } from "./mapSerializer"
 import { objectPathSerializer } from "./objectPathSerializer"