@typeonce/effect-machine 0.27.1 → 0.29.0

package/src/internal/machine/atom.ts

@@ -8,6 +8,7 @@ import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Equal from "effect/Equal"
 import * as Fiber from "effect/Fiber"
+import * as MutableHashMap from "effect/MutableHashMap"
 import * as Option from "effect/Option"
 import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
@@ -78,6 +79,47 @@ const preparedByMachineAtom = new WeakMap<
   Atom.Atom<AsyncResult.AsyncResult<Machine.Prepared<any, any, any, any, any, any, any>, any>>
 >()
 
+type WeakFamilyEntry<Value extends object> = {
+  readonly ref: WeakRef<Value>
+}
+
+// This follows Atom.family, but cleanup is generation-aware. A finalizer for a
+// collected value must not remove a newer value installed for the same key.
+const retainedFamily = <Key, Value extends object>(
+  makeValue: (key: Key) => Value
+): (key: Key) => Value => {
+  if (typeof WeakRef === "undefined" || typeof FinalizationRegistry === "undefined") {
+    return Atom.family(makeValue)
+  }
+
+  const values = MutableHashMap.empty<Key, WeakFamilyEntry<Value>>()
+  const registry = new FinalizationRegistry<{
+    readonly key: Key
+    readonly entry: WeakFamilyEntry<Value>
+  }>(({ entry, key }) => {
+    const current = MutableHashMap.get(values, key)
+    if (Option.isSome(current) && current.value === entry) {
+      MutableHashMap.remove(values, key)
+    }
+  })
+
+  return (key) => {
+    const current = MutableHashMap.get(values, key)
+    if (Option.isSome(current)) {
+      const value = current.value.ref.deref()
+      if (value !== undefined) {
+        return value
+      }
+    }
+
+    const value = makeValue(key)
+    const entry = { ref: new WeakRef(value) }
+    MutableHashMap.set(values, key, entry)
+    registry.register(value, { key, entry })
+    return value
+  }
+}
+
 const runMachineAtomEffect = <State, Event, Error, Output, Emitted, StartError, Requirements>(
   get: Atom.AtomContext,
   start: Effect.Effect<Machine.MachineRef<State, Event, Error, Output, Emitted>, StartError, Requirements>
@@ -515,6 +557,41 @@ const selectSnapshotByPath = <
 ): Option.Option<SnapshotByIdentifier<State, Path>> =>
   Topology.getSnapshotByPath(snapshot, path) as Option.Option<SnapshotByIdentifier<State, Path>>
 
+type SelectorKind =
+  | "matches"
+  | "matchesChild"
+  | "select"
+  | "selectChild"
+  | "selectSnapshot"
+  | "selectSnapshotChild"
+
+const selectorsByBridge = new WeakMap<object, Map<SelectorKind, Map<string, Atom.Atom<any>>>>()
+
+const cachedSelector = <A>(
+  bridge: object,
+  kind: SelectorKind,
+  path: string,
+  make: () => Atom.Atom<A>
+): Atom.Atom<A> => {
+  let selectorsByKind = selectorsByBridge.get(bridge)
+  if (selectorsByKind === undefined) {
+    selectorsByKind = new Map()
+    selectorsByBridge.set(bridge, selectorsByKind)
+  }
+  let selectorsByPath = selectorsByKind.get(kind)
+  if (selectorsByPath === undefined) {
+    selectorsByPath = new Map()
+    selectorsByKind.set(kind, selectorsByPath)
+  }
+  const cached = selectorsByPath.get(path)
+  if (cached !== undefined) {
+    return cached as Atom.Atom<A>
+  }
+  const selector = make()
+  selectorsByPath.set(path, selector)
+  return selector
+}
+
 export const select = <
   State extends Machine.Machine.AtomicSnapshot<string, unknown>,
   Event,
@@ -529,8 +606,14 @@ export const select = <
 ): Atom.Atom<
   AsyncResult.AsyncResult<Option.Option<SnapshotValueByIdentifier<State, Path>>, StartError | Error>
 > =>
-  Atom.mapResult(self.result, (snapshot) => selectValueByPath(snapshot, path)).pipe(
-    Atom.withEquality(Equal.equals)
+  cachedSelector(
+    self,
+    "select",
+    path,
+    () =>
+      Atom.mapResult(self.result, (snapshot) => selectValueByPath(snapshot, path)).pipe(
+        Atom.withEquality(Equal.equals)
+      )
   )
 
 export const selectSnapshot = <
@@ -547,8 +630,14 @@ export const selectSnapshot = <
 ): Atom.Atom<
   AsyncResult.AsyncResult<Option.Option<SnapshotByIdentifier<State, Path>>, StartError | Error>
 > =>
-  Atom.mapResult(self.result, (snapshot) => selectSnapshotByPath(snapshot, path)).pipe(
-    Atom.withEquality(Equal.equals)
+  cachedSelector(
+    self,
+    "selectSnapshot",
+    path,
+    () =>
+      Atom.mapResult(self.result, (snapshot) => selectSnapshotByPath(snapshot, path)).pipe(
+        Atom.withEquality(Equal.equals)
+      )
   )
 
 export const selectChild = <
@@ -564,10 +653,11 @@ export const selectChild = <
     StartError | RefError<Machine.ChildMachine.Ref<Child>>
   >
 > =>
-  Atom.mapResult(
-    self.result,
-    Option.flatMap((snapshot) => selectValueByPath(snapshot, path))
-  ).pipe(Atom.withEquality(Equal.equals))
+  cachedSelector(self, "selectChild", path, () =>
+    Atom.mapResult(
+      self.result,
+      Option.flatMap((snapshot) => selectValueByPath(snapshot, path))
+    ).pipe(Atom.withEquality(Equal.equals)))
 
 export const selectSnapshotChild = <
   Child extends Machine.ChildMachine.Any,
@@ -582,10 +672,11 @@ export const selectSnapshotChild = <
     StartError | RefError<Machine.ChildMachine.Ref<Child>>
   >
 > =>
-  Atom.mapResult(
-    self.result,
-    Option.flatMap((snapshot) => selectSnapshotByPath(snapshot, path))
-  ).pipe(Atom.withEquality(Equal.equals))
+  cachedSelector(self, "selectSnapshotChild", path, () =>
+    Atom.mapResult(
+      self.result,
+      Option.flatMap((snapshot) => selectSnapshotByPath(snapshot, path))
+    ).pipe(Atom.withEquality(Equal.equals)))
 
 export const matches = <
   State extends Machine.Machine.AtomicSnapshot<string, unknown>,
@@ -599,8 +690,14 @@ export const matches = <
   self: MachineAtom<State, Event, Error, Output, StartError, Emitted>,
   path: Path
 ): Atom.Atom<AsyncResult.AsyncResult<boolean, StartError | Error>> =>
-  Atom.mapResult(self.result, (snapshot) => Option.isSome(Topology.getSnapshotByPath(snapshot, path))).pipe(
-    Atom.withEquality(Equal.equals)
+  cachedSelector(
+    self,
+    "matches",
+    path,
+    () =>
+      Atom.mapResult(self.result, (snapshot) => Option.isSome(Topology.getSnapshotByPath(snapshot, path))).pipe(
+        Atom.withEquality(Equal.equals)
+      )
   )
 
 export const matchesChild = <
@@ -613,10 +710,11 @@ export const matchesChild = <
 ): Atom.Atom<
   AsyncResult.AsyncResult<boolean, StartError | RefError<Machine.ChildMachine.Ref<Child>>>
 > =>
-  Atom.mapResult(
-    self.result,
-    Option.exists((snapshot) => Option.isSome(Topology.getSnapshotByPath(snapshot, path)))
-  ).pipe(Atom.withEquality(Equal.equals))
+  cachedSelector(self, "matchesChild", path, () =>
+    Atom.mapResult(
+      self.result,
+      Option.exists((snapshot) => Option.isSome(Topology.getSnapshotByPath(snapshot, path)))
+    ).pipe(Atom.withEquality(Equal.equals)))
 
 type MachineResumeRequirementsOf<M extends Machine.Machine.Any> = MachineResumeRequirements<
   Machine.Machine.Services<M>,
@@ -738,6 +836,69 @@ const resumeWithRuntime = (
   return makeFromRefAtom(ref as any)
 }
 
+type FamilyBridge = MachineAtom<any, never, any, any, any, any> | ChildMachineAtom<any, any>
+
+type FamilyOptions = {
+  readonly atoms: Readonly<Record<string, (bridge: FamilyBridge) => Atom.Atom<any>>>
+  readonly label?: (key: any, atomName: string) => string | undefined
+}
+
+const retainFamilyOwner = <Source extends Atom.Atom<any>>(
+  owner: { readonly bridge: FamilyBridge },
+  source: Source,
+  label: string | undefined
+): Atom.WithoutSerializable<Source> => {
+  const retained = { owner, source }
+  let atom: Atom.Atom<any> = Atom.transform(
+    source,
+    (get) => get(retained.source),
+    { initialValueTarget: source }
+  ).pipe(
+    Atom.withEquality((value, next) => retained.source.equals(value, next))
+  )
+  if (label !== undefined) {
+    atom = atom.pipe(Atom.withLabel(label))
+  }
+  return atom as unknown as Atom.WithoutSerializable<Source>
+}
+
+const makeFamily = (
+  makeBridge: (key: any) => FamilyBridge,
+  options: FamilyOptions
+): Readonly<Record<string, (key: any) => Atom.Atom<any>>> => {
+  const owners = retainedFamily((key: any) => ({ bridge: makeBridge(key) }))
+  const atoms: Record<string, (key: any) => Atom.Atom<any>> = {}
+
+  for (const atomName of Object.keys(options.atoms)) {
+    const project = options.atoms[atomName]!
+    atoms[atomName] = retainedFamily((key: any) => {
+      const owner = owners(key)
+      const source = project(owner.bridge)
+      return retainFamilyOwner(owner, source, options.label?.(key, atomName))
+    })
+  }
+
+  return atoms
+}
+
+export const family = (
+  machine: Machine.Machine.Any,
+  options: FamilyOptions
+): Readonly<Record<string, (key: any) => Atom.Atom<any>>> =>
+  makeFamily(
+    (input) => (make as any)(machine, input),
+    options
+  )
+
+export const familyChild = (
+  parent: MachineAtom<any, never, any, any, any, any> | ChildMachineAtom<any, any>,
+  options: FamilyOptions & { readonly child: (key: any) => Machine.ChildMachine.Any }
+): Readonly<Record<string, (key: any) => Atom.Atom<any>>> =>
+  makeFamily(
+    (key) => parent.child(options.child(key)),
+    options
+  )
+
 export const bind = <Services, RuntimeError>(
   runtime: Atom.AtomRuntime<Services, RuntimeError>
 ): Bound<Services, RuntimeError> => ({
@@ -749,5 +910,10 @@ export const bind = <Services, RuntimeError>(
       >["make"],
   resume:
     ((machine: Machine.Machine.Any, snapshot: Machine.Machine.Snapshot<any>) =>
-      resumeWithRuntime(runtime, machine, snapshot)) as Bound<Services, RuntimeError>["resume"]
+      resumeWithRuntime(runtime, machine, snapshot)) as Bound<Services, RuntimeError>["resume"],
+  family: ((machine: Machine.Machine.Any, options: FamilyOptions) =>
+    makeFamily(
+      (input) => makeWithRuntime(runtime, machine, [input]),
+      options
+    )) as Bound<Services, RuntimeError>["family"]
 })