mobx-keystone 1.20.0 → 1.22.0

package/src/ref/customRef.ts

@@ -2,9 +2,9 @@ import { action } from "mobx"
 import {
   getModelRefId,
   internalCustomRef,
-  RefIdResolver,
-  RefOnResolvedValueChange,
-  RefResolver,
+  type RefIdResolver,
+  type RefOnResolvedValueChange,
+  type RefResolver,
 } from "./core"
 import type { RefConstructor } from "./Ref"
 

package/src/ref/rootRef.ts

@@ -1,100 +1,100 @@
-import { action } from "mobx"
-import { fastGetRoot } from "../parent/path"
-import {
-  getModelRefId,
-  internalCustomRef,
-  RefIdResolver,
-  RefOnResolvedValueChange,
-  RefResolver,
-  resolveId,
-} from "./core"
-import type { Ref, RefConstructor } from "./Ref"
-
-/**
- * Custom reference options.
- */
-export interface RootRefOptions<T extends object> {
-  /**
-   * Must return the ID associated to the given target object, or `undefined` if it has no ID.
-   * If not provided it will try to get the reference id from the model `getRefId()` method.
-   *
-   * @param target Target object.
-   */
-  getId?: RefIdResolver
-
-  /**
-   * What should happen when the resolved value changes.
-   *
-   * @param ref Reference object.
-   * @param newValue New resolved value.
-   * @param oldValue Old resolved value.
-   */
-  onResolvedValueChange?: RefOnResolvedValueChange<T>
-}
-
-/**
- * Creates a root ref to an object, which in its snapshot form has an id.
- * A root ref will only be able to resolve references as long as both the Ref
- * and the referenced object share a common root.
- *
- * @template T Target object type.
- * @param modelTypeId Unique model type id.
- * @param [options] Root reference options.
- * @returns A function that allows you to construct that type of root reference.
- */
-export const rootRef: <T extends object>(
-  modelTypeId: string,
-  options?: RootRefOptions<T>
-) => RefConstructor<T> = action(
-  "rootRef",
-  <T extends object>(modelTypeId: string, options?: RootRefOptions<T>): RefConstructor<T> => {
-    const getId = options?.getId ?? getModelRefId
-    const onResolvedValueChange = options?.onResolvedValueChange
-
-    const resolverGen = (ref: Ref<T>): RefResolver<T> => {
-      let cachedTarget: T | undefined
-
-      return () => {
-        const refRoot = fastGetRoot(ref, true)
-
-        if (isRefRootCachedTargetOk(ref, refRoot, cachedTarget, getId)) {
-          return cachedTarget
-        }
-
-        // Detached refs cannot resolve a rootRef target until they are attached.
-        // Skipping resolveId here avoids creating one computed id tree per detached ref.
-        if (refRoot === ref) {
-          return undefined
-        }
-
-        // when not found, everytime a child is added/removed or its id changes we will perform another search
-        // this search is only done once for every distinct getId function
-        const newTarget = resolveId<T>(refRoot, ref.id, getId)
-        if (newTarget) {
-          cachedTarget = newTarget
-        }
-        return newTarget
-      }
-    }
-
-    return internalCustomRef(modelTypeId, resolverGen, getId, onResolvedValueChange)
-  }
-)
-
-function isRefRootCachedTargetOk<T extends object>(
-  ref: Ref<T>,
-  refRoot: object,
-  cachedTarget: T | undefined,
-  getId: RefIdResolver
-): cachedTarget is T {
-  if (!cachedTarget) {
-    return false
-  }
-  if (ref.id !== getId(cachedTarget)) {
-    return false
-  }
-  if (refRoot !== fastGetRoot(cachedTarget, true)) {
-    return false
-  }
-  return true
-}
+import { action } from "mobx"
+import { fastGetRoot } from "../parent/path"
+import {
+  getModelRefId,
+  internalCustomRef,
+  type RefIdResolver,
+  type RefOnResolvedValueChange,
+  type RefResolver,
+  resolveId,
+} from "./core"
+import type { Ref, RefConstructor } from "./Ref"
+
+/**
+ * Custom reference options.
+ */
+export interface RootRefOptions<T extends object> {
+  /**
+   * Must return the ID associated to the given target object, or `undefined` if it has no ID.
+   * If not provided it will try to get the reference id from the model `getRefId()` method.
+   *
+   * @param target Target object.
+   */
+  getId?: RefIdResolver
+
+  /**
+   * What should happen when the resolved value changes.
+   *
+   * @param ref Reference object.
+   * @param newValue New resolved value.
+   * @param oldValue Old resolved value.
+   */
+  onResolvedValueChange?: RefOnResolvedValueChange<T>
+}
+
+/**
+ * Creates a root ref to an object, which in its snapshot form has an id.
+ * A root ref will only be able to resolve references as long as both the Ref
+ * and the referenced object share a common root.
+ *
+ * @template T Target object type.
+ * @param modelTypeId Unique model type id.
+ * @param [options] Root reference options.
+ * @returns A function that allows you to construct that type of root reference.
+ */
+export const rootRef: <T extends object>(
+  modelTypeId: string,
+  options?: RootRefOptions<T>
+) => RefConstructor<T> = action(
+  "rootRef",
+  <T extends object>(modelTypeId: string, options?: RootRefOptions<T>): RefConstructor<T> => {
+    const getId = options?.getId ?? getModelRefId
+    const onResolvedValueChange = options?.onResolvedValueChange
+
+    const resolverGen = (ref: Ref<T>): RefResolver<T> => {
+      let cachedTarget: T | undefined
+
+      return () => {
+        const refRoot = fastGetRoot(ref, true)
+
+        if (isRefRootCachedTargetOk(ref, refRoot, cachedTarget, getId)) {
+          return cachedTarget
+        }
+
+        // Detached refs cannot resolve a rootRef target until they are attached.
+        // Skipping resolveId here avoids creating one computed id tree per detached ref.
+        if (refRoot === ref) {
+          return undefined
+        }
+
+        // when not found, everytime a child is added/removed or its id changes we will perform another search
+        // this search is only done once for every distinct getId function
+        const newTarget = resolveId<T>(refRoot, ref.id, getId)
+        if (newTarget) {
+          cachedTarget = newTarget
+        }
+        return newTarget
+      }
+    }
+
+    return internalCustomRef(modelTypeId, resolverGen, getId, onResolvedValueChange)
+  }
+)
+
+function isRefRootCachedTargetOk<T extends object>(
+  ref: Ref<T>,
+  refRoot: object,
+  cachedTarget: T | undefined,
+  getId: RefIdResolver
+): cachedTarget is T {
+  if (!cachedTarget) {
+    return false
+  }
+  if (ref.id !== getId(cachedTarget)) {
+    return false
+  }
+  if (refRoot !== fastGetRoot(cachedTarget, true)) {
+    return false
+  }
+  return true
+}

package/src/rootStore/attachDetach.ts

@@ -1,89 +1,89 @@
-import { action } from "mobx"
-import { ActionContextActionType } from "../action/context"
-import { HookAction } from "../action/hookActions"
-import { wrapInAction, wrapModelMethodInActionIfNeeded } from "../action/wrapInAction"
-import { AnyModel, BaseModel } from "../model/BaseModel"
-import { WalkTreeMode, walkTree } from "../parent/walkTree"
-
-const onAttachedDisposers = new WeakMap<object, () => void>()
-const attachedToRootStore = new WeakSet<object>()
-
-/**
- * @internal
- */
-export const attachToRootStore = action(
-  "attachToRootStore",
-  (rootStore: object, child: object): void => {
-    // we use an array to ensure they will get called even if the actual hook modifies the tree
-    const childrenToCall: AnyModel[] = []
-
-    walkTree(
-      child,
-      (ch) => {
-        // we use this to avoid calling onAttachedToRootStore
-        // twice
-        if (attachedToRootStore.has(ch)) {
-          return
-        }
-        attachedToRootStore.add(ch)
-
-        if (ch instanceof BaseModel && (ch as any).onAttachedToRootStore) {
-          wrapModelMethodInActionIfNeeded(
-            ch as any,
-            "onAttachedToRootStore",
-            HookAction.OnAttachedToRootStore
-          )
-
-          childrenToCall.push(ch as AnyModel)
-        }
-      },
-      WalkTreeMode.ParentFirst
-    )
-
-    const childrenToCallLen = childrenToCall.length
-    for (let i = 0; i < childrenToCallLen; i++) {
-      const ch = childrenToCall[i]
-
-      const disposer = (ch as any).onAttachedToRootStore(rootStore)
-      if (disposer) {
-        onAttachedDisposers.set(ch, disposer)
-      }
-    }
-  }
-)
-
-/**
- * @internal
- */
-export const detachFromRootStore = action("detachFromRootStore", (child: object): void => {
-  // we use an array to ensure they will get called even if the actual hook modifies the tree
-  const disposersToCall: (() => void)[] = []
-
-  walkTree(
-    child,
-    (ch) => {
-      if (!attachedToRootStore.delete(ch)) {
-        return
-      }
-
-      const disposer = onAttachedDisposers.get(ch)
-      if (disposer) {
-        // wrap disposer in action
-        const disposerAction = wrapInAction({
-          nameOrNameFn: HookAction.OnAttachedToRootStoreDisposer,
-          fn: disposer,
-          actionType: ActionContextActionType.Sync,
-        }).bind(ch)
-        onAttachedDisposers.delete(ch)
-
-        disposersToCall.push(disposerAction)
-      }
-    },
-    WalkTreeMode.ChildrenFirst
-  )
-
-  const disposersToCallLen = disposersToCall.length
-  for (let i = 0; i < disposersToCallLen; i++) {
-    disposersToCall[i]()
-  }
-})
+import { action } from "mobx"
+import { ActionContextActionType } from "../action/context"
+import { HookAction } from "../action/hookActions"
+import { wrapInAction, wrapModelMethodInActionIfNeeded } from "../action/wrapInAction"
+import { type AnyModel, BaseModel } from "../model/BaseModel"
+import { WalkTreeMode, walkTree } from "../parent/walkTree"
+
+const onAttachedDisposers = new WeakMap<object, () => void>()
+const attachedToRootStore = new WeakSet<object>()
+
+/**
+ * @internal
+ */
+export const attachToRootStore = action(
+  "attachToRootStore",
+  (rootStore: object, child: object): void => {
+    // we use an array to ensure they will get called even if the actual hook modifies the tree
+    const childrenToCall: AnyModel[] = []
+
+    walkTree(
+      child,
+      (ch) => {
+        // we use this to avoid calling onAttachedToRootStore
+        // twice
+        if (attachedToRootStore.has(ch)) {
+          return
+        }
+        attachedToRootStore.add(ch)
+
+        if (ch instanceof BaseModel && (ch as any).onAttachedToRootStore) {
+          wrapModelMethodInActionIfNeeded(
+            ch as any,
+            "onAttachedToRootStore",
+            HookAction.OnAttachedToRootStore
+          )
+
+          childrenToCall.push(ch as AnyModel)
+        }
+      },
+      WalkTreeMode.ParentFirst
+    )
+
+    const childrenToCallLen = childrenToCall.length
+    for (let i = 0; i < childrenToCallLen; i++) {
+      const ch = childrenToCall[i]
+
+      const disposer = (ch as any).onAttachedToRootStore(rootStore)
+      if (disposer) {
+        onAttachedDisposers.set(ch, disposer)
+      }
+    }
+  }
+)
+
+/**
+ * @internal
+ */
+export const detachFromRootStore = action("detachFromRootStore", (child: object): void => {
+  // we use an array to ensure they will get called even if the actual hook modifies the tree
+  const disposersToCall: (() => void)[] = []
+
+  walkTree(
+    child,
+    (ch) => {
+      if (!attachedToRootStore.delete(ch)) {
+        return
+      }
+
+      const disposer = onAttachedDisposers.get(ch)
+      if (disposer) {
+        // wrap disposer in action
+        const disposerAction = wrapInAction({
+          nameOrNameFn: HookAction.OnAttachedToRootStoreDisposer,
+          fn: disposer,
+          actionType: ActionContextActionType.Sync,
+        }).bind(ch)
+        onAttachedDisposers.delete(ch)
+
+        disposersToCall.push(disposerAction)
+      }
+    },
+    WalkTreeMode.ChildrenFirst
+  )
+
+  const disposersToCallLen = disposersToCall.length
+  for (let i = 0; i < disposersToCallLen; i++) {
+    disposersToCall[i]()
+  }
+})

package/src/rootStore/rootStore.ts

@@ -1,4 +1,4 @@
-import { action, createAtom, IAtom } from "mobx"
+import { action, createAtom, type IAtom } from "mobx"
 import { fastGetRoot, isRoot } from "../parent/path"
 import { assertTweakedObject } from "../tweaker/core"
 import { failure } from "../utils"

package/src/snapshot/SnapshotOf.ts

@@ -1,104 +1,104 @@
-import type { Frozen, frozenKey } from "../frozen/Frozen"
-import type { AnyModel } from "../model/BaseModel"
-import type { modelIdKey, modelTypeKey } from "../model/metadata"
-import type { ModelFromSnapshot, ModelToSnapshot } from "../modelShared/BaseModelShared"
-import type { ArraySet, ObjectMap } from "../wrappers"
-
-// this must be a type rather than an interface to ensure compatibility with index signatures
-// (e.g. PlainObject)
-export type FrozenData<D> = {
-  [frozenKey]: true
-  data: D
-}
-
-// snapshot out
-
-// infer is there just to cache type generation
-
-export type SnapshotOutOfObject<T> = {
-  [k in keyof T]: SnapshotOutOf<T[k]> extends infer R ? R : never
-}
-
-export type SnapshotOutOfModel<M extends AnyModel> = ModelToSnapshot<M>
-
-export interface SnapshotOutOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {}
-
-export interface SnapshotOutOfObjectMap<V> {
-  items: { [k: string]: SnapshotOutOf<V> }
-  [modelTypeKey]?: string
-  [modelIdKey]: string
-}
-
-export interface SnapshotOutOfArraySet<V> {
-  items: SnapshotOutOf<V>[]
-  [modelTypeKey]?: string
-  [modelIdKey]: string
-}
-
-export type SnapshotOutOf<T> =
-  T extends ObjectMap<infer V>
-    ? SnapshotOutOfObjectMap<V> extends infer R
-      ? R
-      : never
-    : T extends ArraySet<infer V>
-      ? SnapshotOutOfArraySet<V> extends infer R
-        ? R
-        : never
-      : T extends AnyModel
-        ? SnapshotOutOfModel<T> extends infer R
-          ? R
-          : never
-        : T extends Frozen<any>
-          ? SnapshotOutOfFrozen<T> extends infer R
-            ? R
-            : never
-          : T extends object
-            ? SnapshotOutOfObject<T> extends infer R
-              ? R
-              : never
-            : T
-
-// snapshot in
-
-export type SnapshotInOfObject<T> = {
-  [k in keyof T]: SnapshotInOf<T[k]> extends infer R ? R : never
-}
-
-export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>
-
-export interface SnapshotInOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {}
-
-export interface SnapshotInOfObjectMap<V> {
-  items?: { [k: string]: SnapshotOutOf<V> }
-  [modelTypeKey]?: string
-  [modelIdKey]: string
-}
-
-export interface SnapshotInOfArraySet<V> {
-  items?: SnapshotOutOf<V>[]
-  [modelTypeKey]?: string
-  [modelIdKey]: string
-}
-
-export type SnapshotInOf<T> =
-  T extends ObjectMap<infer V>
-    ? SnapshotInOfObjectMap<V> extends infer R
-      ? R
-      : never
-    : T extends ArraySet<infer V>
-      ? SnapshotInOfArraySet<V> extends infer R
-        ? R
-        : never
-      : T extends AnyModel
-        ? SnapshotInOfModel<T> extends infer R
-          ? R
-          : never
-        : T extends Frozen<any>
-          ? SnapshotInOfFrozen<T> extends infer R
-            ? R
-            : never
-          : T extends object
-            ? SnapshotInOfObject<T> extends infer R
-              ? R
-              : never
-            : T
+import type { Frozen, frozenKey } from "../frozen/Frozen"
+import type { AnyModel } from "../model/BaseModel"
+import type { modelIdKey, modelTypeKey } from "../model/metadata"
+import type { ModelFromSnapshot, ModelToSnapshot } from "../modelShared/BaseModelShared"
+import type { ArraySet, ObjectMap } from "../wrappers"
+
+// this must be a type rather than an interface to ensure compatibility with index signatures
+// (e.g. PlainObject)
+export type FrozenData<D> = {
+  [frozenKey]: true
+  data: D
+}
+
+// snapshot out
+
+// infer is there just to cache type generation
+
+export type SnapshotOutOfObject<T> = {
+  [k in keyof T]: SnapshotOutOf<T[k]> extends infer R ? R : never
+}
+
+export type SnapshotOutOfModel<M extends AnyModel> = ModelToSnapshot<M>
+
+export interface SnapshotOutOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {}
+
+export interface SnapshotOutOfObjectMap<V> {
+  items: { [k: string]: SnapshotOutOf<V> }
+  [modelTypeKey]?: string
+  [modelIdKey]: string
+}
+
+export interface SnapshotOutOfArraySet<V> {
+  items: SnapshotOutOf<V>[]
+  [modelTypeKey]?: string
+  [modelIdKey]: string
+}
+
+export type SnapshotOutOf<T> =
+  T extends ObjectMap<infer V>
+    ? SnapshotOutOfObjectMap<V> extends infer R
+      ? R
+      : never
+    : T extends ArraySet<infer V>
+      ? SnapshotOutOfArraySet<V> extends infer R
+        ? R
+        : never
+      : T extends AnyModel
+        ? SnapshotOutOfModel<T> extends infer R
+          ? R
+          : never
+        : T extends Frozen<any>
+          ? SnapshotOutOfFrozen<T> extends infer R
+            ? R
+            : never
+          : T extends object
+            ? SnapshotOutOfObject<T> extends infer R
+              ? R
+              : never
+            : T
+
+// snapshot in
+
+export type SnapshotInOfObject<T> = {
+  [k in keyof T]: SnapshotInOf<T[k]> extends infer R ? R : never
+}
+
+export type SnapshotInOfModel<M extends AnyModel> = ModelFromSnapshot<M>
+
+export interface SnapshotInOfFrozen<F extends Frozen<any>> extends FrozenData<F["data"]> {}
+
+export interface SnapshotInOfObjectMap<V> {
+  items?: { [k: string]: SnapshotOutOf<V> }
+  [modelTypeKey]?: string
+  [modelIdKey]: string
+}
+
+export interface SnapshotInOfArraySet<V> {
+  items?: SnapshotOutOf<V>[]
+  [modelTypeKey]?: string
+  [modelIdKey]: string
+}
+
+export type SnapshotInOf<T> =
+  T extends ObjectMap<infer V>
+    ? SnapshotInOfObjectMap<V> extends infer R
+      ? R
+      : never
+    : T extends ArraySet<infer V>
+      ? SnapshotInOfArraySet<V> extends infer R
+        ? R
+        : never
+      : T extends AnyModel
+        ? SnapshotInOfModel<T> extends infer R
+          ? R
+          : never
+        : T extends Frozen<any>
+          ? SnapshotInOfFrozen<T> extends infer R
+            ? R
+            : never
+          : T extends object
+            ? SnapshotInOfObject<T> extends infer R
+              ? R
+              : never
+            : T