mobx-keystone 1.20.0 → 1.22.0

package/src/snapshot/reconcileSnapshot.ts

@@ -1,88 +1,88 @@
-import { set } from "mobx"
-import { modelIdKey, modelTypeKey } from "../model/metadata"
-import { isModel } from "../model/utils"
-import { fastGetParentPathIncludingDataObjects } from "../parent"
-import { isMap, isPrimitive, isSet } from "../utils"
-import type { ModelPool } from "../utils/ModelPool"
-import { getSnapshot } from "./getSnapshot"
-import { registerDefaultReconcilers } from "./registerDefaultReconcilers"
-import { SnapshotProcessingError } from "./SnapshotProcessingError"
-
-type Reconciler = (value: any, sn: any, modelPool: ModelPool, parent: any) => any
-
-const reconcilers: { priority: number; reconciler: Reconciler }[] = []
-
-/**
- * @internal
- */
-export function registerReconciler(priority: number, reconciler: Reconciler): void {
-  reconcilers.push({ priority, reconciler })
-  reconcilers.sort((a, b) => a.priority - b.priority)
-}
-
-/**
- * @internal
- */
-export function reconcileSnapshot(value: any, sn: any, modelPool: ModelPool, parent: any): any {
-  if (isPrimitive(sn)) {
-    return sn
-  }
-
-  // if the snapshot passed is exactly the same as the current one
-  // then it is already reconciled
-  if (getSnapshot(value) === sn) {
-    return value
-  }
-
-  registerDefaultReconcilers()
-
-  const reconcilersLen = reconcilers.length
-  for (let i = 0; i < reconcilersLen; i++) {
-    const { reconciler } = reconcilers[i]
-    const ret = reconciler(value, sn, modelPool, parent)
-    if (ret !== undefined) {
-      return ret
-    }
-  }
-
-  if (isMap(sn)) {
-    throw new SnapshotProcessingError({
-      message: "a snapshot must not contain maps",
-      actualSnapshot: sn,
-    })
-  }
-
-  if (isSet(sn)) {
-    throw new SnapshotProcessingError({
-      message: "a snapshot must not contain sets",
-      actualSnapshot: sn,
-    })
-  }
-
-  throw new SnapshotProcessingError({
-    message: "unsupported snapshot",
-    actualSnapshot: sn,
-  })
-}
-
-/**
- * @internal
- */
-export function detachIfNeeded(newValue: any, oldValue: any, modelPool: ModelPool) {
-  // edge case for when we are swapping models around the tree
-
-  if (newValue === oldValue) {
-    // already where it should be
-    return
-  }
-
-  if (
-    isModel(newValue) &&
-    modelPool.findModelByTypeAndId(newValue[modelTypeKey], newValue[modelIdKey])
-  ) {
-    const parentPath = fastGetParentPathIncludingDataObjects(newValue, false)
-    if (parentPath) {
-      set(parentPath.parent, parentPath.path, null)
-    }
-  }
-}
+import { set } from "mobx"
+import { modelIdKey, modelTypeKey } from "../model/metadata"
+import { isModel } from "../model/utils"
+import { fastGetParentPathIncludingDataObjects } from "../parent"
+import { isMap, isPrimitive, isSet } from "../utils"
+import type { ModelPool } from "../utils/ModelPool"
+import { getSnapshot } from "./getSnapshot"
+import { registerDefaultReconcilers } from "./registerDefaultReconcilers"
+import { SnapshotProcessingError } from "./SnapshotProcessingError"
+
+type Reconciler = (value: any, sn: any, modelPool: ModelPool, parent: any) => any
+
+const reconcilers: { priority: number; reconciler: Reconciler }[] = []
+
+/**
+ * @internal
+ */
+export function registerReconciler(priority: number, reconciler: Reconciler): void {
+  reconcilers.push({ priority, reconciler })
+  reconcilers.sort((a, b) => a.priority - b.priority)
+}
+
+/**
+ * @internal
+ */
+export function reconcileSnapshot(value: any, sn: any, modelPool: ModelPool, parent: any): any {
+  if (isPrimitive(sn)) {
+    return sn
+  }
+
+  // if the snapshot passed is exactly the same as the current one
+  // then it is already reconciled
+  if (getSnapshot(value) === sn) {
+    return value
+  }
+
+  registerDefaultReconcilers()
+
+  const reconcilersLen = reconcilers.length
+  for (let i = 0; i < reconcilersLen; i++) {
+    const { reconciler } = reconcilers[i]
+    const ret = reconciler(value, sn, modelPool, parent)
+    if (ret !== undefined) {
+      return ret
+    }
+  }
+
+  if (isMap(sn)) {
+    throw new SnapshotProcessingError({
+      message: "a snapshot must not contain maps",
+      actualSnapshot: sn,
+    })
+  }
+
+  if (isSet(sn)) {
+    throw new SnapshotProcessingError({
+      message: "a snapshot must not contain sets",
+      actualSnapshot: sn,
+    })
+  }
+
+  throw new SnapshotProcessingError({
+    message: "unsupported snapshot",
+    actualSnapshot: sn,
+  })
+}
+
+/**
+ * @internal
+ */
+export function detachIfNeeded(newValue: any, oldValue: any, modelPool: ModelPool) {
+  // edge case for when we are swapping models around the tree
+
+  if (newValue === oldValue) {
+    // already where it should be
+    return
+  }
+
+  if (
+    isModel(newValue) &&
+    modelPool.findModelByTypeAndId(newValue[modelTypeKey], newValue[modelIdKey])
+  ) {
+    const parentPath = fastGetParentPathIncludingDataObjects(newValue, false)
+    if (parentPath) {
+      set(parentPath.parent, parentPath.path, null)
+    }
+  }
+}

package/src/standardActions/actions.ts

@@ -1,64 +1,64 @@
-import { ActionContextActionType } from "../action/context"
-import { isModelAction } from "../action/isModelAction"
-import { flow, isModelFlow } from "../action/modelFlow"
-import { wrapInAction } from "../action/wrapInAction"
-import { assertIsTreeNode } from "../tweaker/core"
-import { assertIsFunction, failure, logWarning } from "../utils"
-import { AnyFunction } from "../utils/AnyFunction"
-import { copyFunctionMetadata } from "../utils/decorators"
-
-/**
- * A function with an object as target.
- */
-type TargetedAction = AnyFunction
-
-const standaloneActionRegistry = new Map<string, TargetedAction>()
-
-/**
- * @internal
- */
-export function getStandaloneAction(actionName: string) {
-  return standaloneActionRegistry.get(actionName)
-}
-
-/**
- * @internal
- */
-export function addStandaloneAction(fullActionName: string, fn: TargetedAction, isFlow: boolean) {
-  assertIsFunction(fn, fullActionName)
-
-  if (standaloneActionRegistry.has(fullActionName)) {
-    logWarning(
-      "warn",
-      `an standalone action with name "${fullActionName}" already exists (if you are using hot-reloading you may safely ignore this warning)`,
-      `duplicateActionName - ${fullActionName}`
-    )
-  }
-
-  if (isModelAction(fn)) {
-    throw failure("the standalone action must not be previously marked as an action")
-  }
-  if (isModelFlow(fn)) {
-    throw failure("the standalone action must not be previously marked as a flow action")
-  }
-
-  const wrappedAction = isFlow
-    ? flow({ nameOrNameFn: fullActionName, generator: fn })
-    : wrapInAction({
-        nameOrNameFn: fullActionName,
-        fn,
-        actionType: ActionContextActionType.Sync,
-      })
-
-  const finalAction = (target: any, ...args: any[]) => {
-    assertIsTreeNode(target, "target")
-
-    // we need to put the target into this
-    return wrappedAction.call(target, target, ...args)
-  }
-  // preserve user-provided metadata without leaking internal action/flow markers.
-  copyFunctionMetadata(fn, finalAction)
-
-  standaloneActionRegistry.set(fullActionName, finalAction)
-  return finalAction
-}
+import { ActionContextActionType } from "../action/context"
+import { isModelAction } from "../action/isModelAction"
+import { flow, isModelFlow } from "../action/modelFlow"
+import { wrapInAction } from "../action/wrapInAction"
+import { assertIsTreeNode } from "../tweaker/core"
+import { assertIsFunction, failure, logWarning } from "../utils"
+import type { AnyFunction } from "../utils/AnyFunction"
+import { copyFunctionMetadata } from "../utils/decorators"
+
+/**
+ * A function with an object as target.
+ */
+type TargetedAction = AnyFunction
+
+const standaloneActionRegistry = new Map<string, TargetedAction>()
+
+/**
+ * @internal
+ */
+export function getStandaloneAction(actionName: string) {
+  return standaloneActionRegistry.get(actionName)
+}
+
+/**
+ * @internal
+ */
+export function addStandaloneAction(fullActionName: string, fn: TargetedAction, isFlow: boolean) {
+  assertIsFunction(fn, fullActionName)
+
+  if (standaloneActionRegistry.has(fullActionName)) {
+    logWarning(
+      "warn",
+      `an standalone action with name "${fullActionName}" already exists (if you are using hot-reloading you may safely ignore this warning)`,
+      `duplicateActionName - ${fullActionName}`
+    )
+  }
+
+  if (isModelAction(fn)) {
+    throw failure("the standalone action must not be previously marked as an action")
+  }
+  if (isModelFlow(fn)) {
+    throw failure("the standalone action must not be previously marked as a flow action")
+  }
+
+  const wrappedAction = isFlow
+    ? flow({ nameOrNameFn: fullActionName, generator: fn })
+    : wrapInAction({
+        nameOrNameFn: fullActionName,
+        fn,
+        actionType: ActionContextActionType.Sync,
+      })
+
+  const finalAction = (target: any, ...args: any[]) => {
+    assertIsTreeNode(target, "target")
+
+    // we need to put the target into this
+    return wrappedAction.call(target, target, ...args)
+  }
+  // preserve user-provided metadata without leaking internal action/flow markers.
+  copyFunctionMetadata(fn, finalAction)
+
+  standaloneActionRegistry.set(fullActionName, finalAction)
+  return finalAction
+}

package/src/standardActions/objectActions.ts

@@ -1,60 +1,60 @@
-import { isObservable, remove } from "mobx"
-import { toTreeNode } from "../tweaker/tweak"
-import { assertIsObject, namespace as ns } from "../utils"
-import { setIfDifferent } from "../utils/setIfDifferent"
-import { standaloneAction } from "./standaloneActions"
-import { AnyFunction } from "../utils/AnyFunction"
-
-const namespace = `${ns}/objectActions`
-
-export const objectActions = {
-  set: standaloneAction(
-    `${namespace}::set`,
-    <T extends object, K extends keyof T>(target: T, key: K, value: T[K]): void => {
-      if (isObservable(target)) {
-        setIfDifferent(target, key, value)
-      } else {
-        target[key] = value
-      }
-    }
-  ),
-
-  assign: standaloneAction(
-    `${namespace}::assign`,
-    <T extends object>(target: T, partialObject: Partial<T>): void => {
-      assertIsObject(partialObject, "partialObject")
-      const keys = Object.keys(partialObject)
-
-      if (isObservable(target)) {
-        for (const key of keys) {
-          const newValue = (partialObject as any)[key]
-          setIfDifferent(target, key, newValue)
-        }
-      } else {
-        for (const key of keys) {
-          ;(target as any)[key] = (partialObject as any)[key]
-        }
-      }
-    }
-  ),
-
-  delete: standaloneAction(
-    `${namespace}::delete`,
-    <T extends object, K extends keyof T>(target: T, key: K): boolean => {
-      return remove(target, key as any)
-    }
-  ),
-
-  call: standaloneAction(
-    `${namespace}::call`,
-    <T extends object, K extends keyof T>(
-      target: T,
-      methodName: K,
-      ...args: T[K] extends AnyFunction ? Parameters<T[K]> : never
-    ): T[K] extends AnyFunction ? ReturnType<T[K]> : never => {
-      return (target as any)[methodName](...args)
-    }
-  ),
-
-  create: <T extends object>(data: T): T => toTreeNode(data),
-}
+import { isObservable, remove } from "mobx"
+import { toTreeNode } from "../tweaker/tweak"
+import { assertIsObject, namespace as ns } from "../utils"
+import type { AnyFunction } from "../utils/AnyFunction"
+import { setIfDifferent } from "../utils/setIfDifferent"
+import { standaloneAction } from "./standaloneActions"
+
+const namespace = `${ns}/objectActions`
+
+export const objectActions = {
+  set: standaloneAction(
+    `${namespace}::set`,
+    <T extends object, K extends keyof T>(target: T, key: K, value: T[K]): void => {
+      if (isObservable(target)) {
+        setIfDifferent(target, key, value)
+      } else {
+        target[key] = value
+      }
+    }
+  ),
+
+  assign: standaloneAction(
+    `${namespace}::assign`,
+    <T extends object>(target: T, partialObject: Partial<T>): void => {
+      assertIsObject(partialObject, "partialObject")
+      const keys = Object.keys(partialObject)
+
+      if (isObservable(target)) {
+        for (const key of keys) {
+          const newValue = (partialObject as any)[key]
+          setIfDifferent(target, key, newValue)
+        }
+      } else {
+        for (const key of keys) {
+          ;(target as any)[key] = (partialObject as any)[key]
+        }
+      }
+    }
+  ),
+
+  delete: standaloneAction(
+    `${namespace}::delete`,
+    <T extends object, K extends keyof T>(target: T, key: K): boolean => {
+      return remove(target, key as any)
+    }
+  ),
+
+  call: standaloneAction(
+    `${namespace}::call`,
+    <T extends object, K extends keyof T>(
+      target: T,
+      methodName: K,
+      ...args: T[K] extends AnyFunction ? Parameters<T[K]> : never
+    ): T[K] extends AnyFunction ? ReturnType<T[K]> : never => {
+      return (target as any)[methodName](...args)
+    }
+  ),
+
+  create: <T extends object>(data: T): T => toTreeNode(data),
+}

package/src/transforms/ImmutableDate.ts

@@ -1,93 +1,93 @@
-import { failure } from "../utils"
-
-/**
- * @internal
- */
-export interface ImmutableDate
-  extends Omit<
-    Date,
-    | "setTime"
-    | "setMilliseconds"
-    | "setUTCMilliseconds"
-    | "setSeconds"
-    | "setUTCSeconds"
-    | "setMinutes"
-    | "setUTCMinutes"
-    | "setHours"
-    | "setUTCHours"
-    | "setDate"
-    | "setUTCDate"
-    | "setMonth"
-    | "setUTCMonth"
-    | "setFullYear"
-    | "setUTCFullYear"
-  > {}
-
-const errMessage = "this Date object is immutable"
-
-/**
- * @internal
- */
-export class ImmutableDate extends Date {
-  // disable mutable methods
-
-  setTime(): any {
-    throw failure(errMessage)
-  }
-
-  setMilliseconds(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCMilliseconds(): any {
-    throw failure(errMessage)
-  }
-
-  setSeconds(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCSeconds(): any {
-    throw failure(errMessage)
-  }
-
-  setMinutes(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCMinutes(): any {
-    throw failure(errMessage)
-  }
-
-  setHours(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCHours(): any {
-    throw failure(errMessage)
-  }
-
-  setDate(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCDate(): any {
-    throw failure(errMessage)
-  }
-
-  setMonth(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCMonth(): any {
-    throw failure(errMessage)
-  }
-
-  setFullYear(): any {
-    throw failure(errMessage)
-  }
-
-  setUTCFullYear(): any {
-    throw failure(errMessage)
-  }
-}
+import { failure } from "../utils"
+
+/**
+ * @internal
+ */
+export interface ImmutableDate
+  extends Omit<
+    Date,
+    | "setTime"
+    | "setMilliseconds"
+    | "setUTCMilliseconds"
+    | "setSeconds"
+    | "setUTCSeconds"
+    | "setMinutes"
+    | "setUTCMinutes"
+    | "setHours"
+    | "setUTCHours"
+    | "setDate"
+    | "setUTCDate"
+    | "setMonth"
+    | "setUTCMonth"
+    | "setFullYear"
+    | "setUTCFullYear"
+  > {}
+
+const errMessage = "this Date object is immutable"
+
+/**
+ * @internal
+ */
+export class ImmutableDate extends Date {
+  // disable mutable methods
+
+  setTime(): any {
+    throw failure(errMessage)
+  }
+
+  setMilliseconds(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCMilliseconds(): any {
+    throw failure(errMessage)
+  }
+
+  setSeconds(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCSeconds(): any {
+    throw failure(errMessage)
+  }
+
+  setMinutes(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCMinutes(): any {
+    throw failure(errMessage)
+  }
+
+  setHours(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCHours(): any {
+    throw failure(errMessage)
+  }
+
+  setDate(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCDate(): any {
+    throw failure(errMessage)
+  }
+
+  setMonth(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCMonth(): any {
+    throw failure(errMessage)
+  }
+
+  setFullYear(): any {
+    throw failure(errMessage)
+  }
+
+  setUTCFullYear(): any {
+    throw failure(errMessage)
+  }
+}