mobx-keystone 1.20.0 → 1.22.0

package/src/action/applyMethodCall.ts

@@ -1,37 +1,37 @@
-import { AnyFunction } from "../utils/AnyFunction"
-import { assertTweakedObject } from "../tweaker/core"
-import { lazy } from "../utils"
-import { BuiltInAction } from "./builtInActions"
-import { ActionContextActionType } from "./context"
-import { wrapInAction } from "./wrapInAction"
-
-/**
- * Calls an object method wrapped in an action.
- *
- * @param node  Target object.
- * @param methodName Method name.
- */
-export function applyMethodCall<O extends object, K extends keyof O, FN extends O[K]>(
-  node: O,
-  methodName: K,
-  ...args: FN extends AnyFunction ? Parameters<FN> : never
-): FN extends AnyFunction ? ReturnType<FN> : never {
-  assertTweakedObject(node, "node")
-
-  return wrappedInternalApplyMethodCall().call(node, methodName as string | number, args)
-}
-
-/**
- * @internal
- */
-export function internalApplyMethodCall(this: any, methodName: string | number, args: any[]): any {
-  return this[methodName](...args)
-}
-
-const wrappedInternalApplyMethodCall = lazy(() =>
-  wrapInAction({
-    nameOrNameFn: BuiltInAction.ApplyMethodCall,
-    fn: internalApplyMethodCall,
-    actionType: ActionContextActionType.Sync,
-  })
-)
+import { assertTweakedObject } from "../tweaker/core"
+import { lazy } from "../utils"
+import type { AnyFunction } from "../utils/AnyFunction"
+import { BuiltInAction } from "./builtInActions"
+import { ActionContextActionType } from "./context"
+import { wrapInAction } from "./wrapInAction"
+
+/**
+ * Calls an object method wrapped in an action.
+ *
+ * @param node  Target object.
+ * @param methodName Method name.
+ */
+export function applyMethodCall<O extends object, K extends keyof O, FN extends O[K]>(
+  node: O,
+  methodName: K,
+  ...args: FN extends AnyFunction ? Parameters<FN> : never
+): FN extends AnyFunction ? ReturnType<FN> : never {
+  assertTweakedObject(node, "node")
+
+  return wrappedInternalApplyMethodCall().call(node, methodName as string | number, args)
+}
+
+/**
+ * @internal
+ */
+export function internalApplyMethodCall(this: any, methodName: string | number, args: any[]): any {
+  return this[methodName](...args)
+}
+
+const wrappedInternalApplyMethodCall = lazy(() =>
+  wrapInAction({
+    nameOrNameFn: BuiltInAction.ApplyMethodCall,
+    fn: internalApplyMethodCall,
+    actionType: ActionContextActionType.Sync,
+  })
+)

package/src/action/isModelAction.ts

@@ -1,16 +1,16 @@
-import { AnyFunction } from "../utils/AnyFunction"
-
-/**
- * @internal
- */
-export const modelActionSymbol = Symbol("modelAction")
-
-/**
- * Returns if the given function is a model action or not.
- *
- * @param fn Function to check.
- * @returns
- */
-export function isModelAction(fn: AnyFunction): boolean {
-  return typeof fn === "function" && modelActionSymbol in fn
-}
+import type { AnyFunction } from "../utils/AnyFunction"
+
+/**
+ * @internal
+ */
+export const modelActionSymbol = Symbol("modelAction")
+
+/**
+ * Returns if the given function is a model action or not.
+ *
+ * @param fn Function to check.
+ * @returns
+ */
+export function isModelAction(fn: AnyFunction): boolean {
+  return typeof fn === "function" && modelActionSymbol in fn
+}

package/src/action/middleware.ts

@@ -1,137 +1,137 @@
-import { fastGetParent } from "../parent/path"
-import { isChildOfParent } from "../parent/path2"
-import { assertTweakedObject } from "../tweaker/core"
-import { assertIsFunction, assertIsObject, deleteFromArray, failure } from "../utils"
-import type { ActionContext } from "./context"
-
-/**
- * An action middleware.
- */
-export interface ActionMiddleware {
-  /**
-   * Subtree root object (object and child objects) this middleware will run for.
-   * This target "filter" will be run before the custom filter.
-   */
-  readonly subtreeRoot: object
-
-  /**
-   * A filter function to decide if an action middleware function should be run or not.
-   */
-  filter?: (ctx: ActionContext) => boolean
-
-  /**
-   * An action middleware function.
-   * Rember to `return next()` if you want to continue the action or throw if you want to cancel it.
-   */
-  middleware: (ctx: ActionContext, next: () => any) => any
-}
-
-/**
- * The disposer of an action middleware.
- */
-export type ActionMiddlewareDisposer = () => void
-
-type PartialActionMiddleware = Pick<ActionMiddleware, "filter" | "middleware">
-
-const perObjectActionMiddlewares = new WeakMap<object, PartialActionMiddleware[]>()
-
-/**
- * @internal
- *
- * Runs a callback for each action middlewares to be run over a given object.
- *
- * @returns
- */
-export function forEachActionMiddleware(
-  obj: object,
-  callback: (middleware: PartialActionMiddleware) => void
-): void {
-  // when we call a middleware we will call the middlewares of that object plus all parent objects
-  // the parent object middlewares are run last
-
-  // since an array like [a, b, c] will be called like c(b(a())) this means that we need to call
-  // the parent object ones at the end of the array
-
-  let current: unknown = obj
-  while (current) {
-    const objMwares = perObjectActionMiddlewares.get(current)
-    if (objMwares && objMwares.length > 0) {
-      objMwares.forEach(callback)
-    }
-    current = fastGetParent(current, false)
-  }
-}
-/**
- * @internal
- *
- * Returns the action middlewares to be run over a given object.
- *
- * @returns
- */
-export function getPerObjectActionMiddlewares(obj: object): PartialActionMiddleware[][] {
-  const result: PartialActionMiddleware[][] = []
-
-  let current: unknown = obj
-  while (current) {
-    const objMwares = perObjectActionMiddlewares.get(current)
-    if (objMwares && objMwares.length > 0) {
-      result.push(objMwares)
-    }
-    current = fastGetParent(current, false)
-  }
-
-  return result
-}
-
-/**
- * Adds a global action middleware to be run when an action is performed.
- * It is usually preferable to use `onActionMiddleware` instead to limit it to a given tree and only to topmost level actions
- * or `actionTrackingMiddleware` for a simplified middleware.
- *
- * @param mware Action middleware to be run.
- * @returns A disposer to cancel the middleware. Note that if you don't plan to do an early disposal of the middleware
- * calling this function becomes optional.
- */
-export function addActionMiddleware(mware: ActionMiddleware): ActionMiddlewareDisposer {
-  assertIsObject(mware, "middleware")
-
-  const { middleware, subtreeRoot } = mware
-  let { filter } = mware
-
-  assertTweakedObject(subtreeRoot, "middleware.subtreeRoot")
-  assertIsFunction(middleware, "middleware.middleware")
-  if (filter && typeof filter !== "function") {
-    throw failure("middleware.filter must be a function or undefined")
-  }
-
-  // reminder: never turn middlewares into actions or else
-  // reactions will not be picked up by the undo manager
-
-  if (subtreeRoot) {
-    const targetFilter = (ctx: ActionContext) =>
-      ctx.target === subtreeRoot || isChildOfParent(ctx.target, subtreeRoot)
-
-    if (filter) {
-      const customFilter = filter
-      filter = (ctx) => {
-        return targetFilter(ctx) && customFilter(ctx)
-      }
-    } else {
-      filter = targetFilter
-    }
-  }
-
-  const actualMware = { middleware, filter }
-
-  let objMwares = perObjectActionMiddlewares.get(subtreeRoot)
-  if (objMwares) {
-    objMwares.push(actualMware)
-  } else {
-    objMwares = [actualMware]
-    perObjectActionMiddlewares.set(subtreeRoot, objMwares)
-  }
-
-  return () => {
-    deleteFromArray(objMwares, actualMware)
-  }
-}
+import { fastGetParent } from "../parent/path"
+import { isChildOfParent } from "../parent/path2"
+import { assertTweakedObject } from "../tweaker/core"
+import { assertIsFunction, assertIsObject, deleteFromArray, failure } from "../utils"
+import type { ActionContext } from "./context"
+
+/**
+ * An action middleware.
+ */
+export interface ActionMiddleware {
+  /**
+   * Subtree root object (object and child objects) this middleware will run for.
+   * This target "filter" will be run before the custom filter.
+   */
+  readonly subtreeRoot: object
+
+  /**
+   * A filter function to decide if an action middleware function should be run or not.
+   */
+  filter?: (ctx: ActionContext) => boolean
+
+  /**
+   * An action middleware function.
+   * Rember to `return next()` if you want to continue the action or throw if you want to cancel it.
+   */
+  middleware: (ctx: ActionContext, next: () => any) => any
+}
+
+/**
+ * The disposer of an action middleware.
+ */
+export type ActionMiddlewareDisposer = () => void
+
+type PartialActionMiddleware = Pick<ActionMiddleware, "filter" | "middleware">
+
+const perObjectActionMiddlewares = new WeakMap<object, PartialActionMiddleware[]>()
+
+/**
+ * @internal
+ *
+ * Runs a callback for each action middlewares to be run over a given object.
+ *
+ * @returns
+ */
+export function forEachActionMiddleware(
+  obj: object,
+  callback: (middleware: PartialActionMiddleware) => void
+): void {
+  // when we call a middleware we will call the middlewares of that object plus all parent objects
+  // the parent object middlewares are run last
+
+  // since an array like [a, b, c] will be called like c(b(a())) this means that we need to call
+  // the parent object ones at the end of the array
+
+  let current: unknown = obj
+  while (current) {
+    const objMwares = perObjectActionMiddlewares.get(current)
+    if (objMwares && objMwares.length > 0) {
+      objMwares.forEach(callback)
+    }
+    current = fastGetParent(current, false)
+  }
+}
+/**
+ * @internal
+ *
+ * Returns the action middlewares to be run over a given object.
+ *
+ * @returns
+ */
+export function getPerObjectActionMiddlewares(obj: object): PartialActionMiddleware[][] {
+  const result: PartialActionMiddleware[][] = []
+
+  let current: unknown = obj
+  while (current) {
+    const objMwares = perObjectActionMiddlewares.get(current)
+    if (objMwares && objMwares.length > 0) {
+      result.push(objMwares)
+    }
+    current = fastGetParent(current, false)
+  }
+
+  return result
+}
+
+/**
+ * Adds a global action middleware to be run when an action is performed.
+ * It is usually preferable to use `onActionMiddleware` instead to limit it to a given tree and only to topmost level actions
+ * or `actionTrackingMiddleware` for a simplified middleware.
+ *
+ * @param mware Action middleware to be run.
+ * @returns A disposer to cancel the middleware. Note that if you don't plan to do an early disposal of the middleware
+ * calling this function becomes optional.
+ */
+export function addActionMiddleware(mware: ActionMiddleware): ActionMiddlewareDisposer {
+  assertIsObject(mware, "middleware")
+
+  const { middleware, subtreeRoot } = mware
+  let { filter } = mware
+
+  assertTweakedObject(subtreeRoot, "middleware.subtreeRoot")
+  assertIsFunction(middleware, "middleware.middleware")
+  if (filter && typeof filter !== "function") {
+    throw failure("middleware.filter must be a function or undefined")
+  }
+
+  // reminder: never turn middlewares into actions or else
+  // reactions will not be picked up by the undo manager
+
+  if (subtreeRoot) {
+    const targetFilter = (ctx: ActionContext) =>
+      ctx.target === subtreeRoot || isChildOfParent(ctx.target, subtreeRoot)
+
+    if (filter) {
+      const customFilter = filter
+      filter = (ctx) => {
+        return targetFilter(ctx) && customFilter(ctx)
+      }
+    } else {
+      filter = targetFilter
+    }
+  }
+
+  const actualMware = { middleware, filter }
+
+  let objMwares = perObjectActionMiddlewares.get(subtreeRoot)
+  if (objMwares) {
+    objMwares.push(actualMware)
+  } else {
+    objMwares = [actualMware]
+    perObjectActionMiddlewares.set(subtreeRoot, objMwares)
+  }
+
+  return () => {
+    deleteFromArray(objMwares, actualMware)
+  }
+}