@playfast/reform 1.1.1 → 1.2.0

package/src/boundary/boundary.ts

@@ -1,12 +1,11 @@
-import { Context, Data, Effect, Layer, MutableRef, Predicate } from 'effect'
+import { Context, Data, Effect, Equal, Layer, MutableRef, Option, Predicate } from 'effect'
 import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import { resolveScheduler } from '../internal/scheduler'
-import { type InputStores, sameKey, wireSources } from '../internal/sources'
+import { type InputStores, wireSources } from '../internal/sources'
 import { makeDerivedStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import { type Source } from '../state/token'
-import type { AnyValue } from '../internal/variance'
+import { type AnySource, type SourceCapture, type SourceValue } from '../state/token'
 
 export interface BoundaryPending {
   readonly _tag: 'Pending'
@@ -23,29 +22,73 @@ export interface BoundaryReady {
 
 export type BoundaryState = BoundaryPending | BoundaryErrored | BoundaryReady
 
+export const BoundaryStoreTypeId: unique symbol = Symbol.for('reform/BoundaryStore')
+export type BoundaryStoreTypeId = typeof BoundaryStoreTypeId
+
+export interface BoundaryStore<N extends string> {
+  readonly [BoundaryStoreTypeId]: N
+}
+
 const pendingArm: BoundaryState = { _tag: 'Pending' }
 const readyArm: BoundaryState = { _tag: 'Ready' }
 const erroredArm = (errors: ReadonlyArray<unknown>): BoundaryState =>
   Data.struct({ _tag: 'Errored' as const, errors: Data.array(errors) })
 
-export type AnyLifecycleSource = Source<string, AnyValue>
+export type AnyLifecycleSource = AnySource
+
+declare const BoundaryLifecycleMismatchTypeId: unique symbol
+
+interface BoundaryLifecycleMismatch<Value> {
+  readonly [BoundaryLifecycleMismatchTypeId]: Value
+}
+
+type CheckedLifecycleValue<Value> = Value extends { readonly _tag: 'Idle' | 'Loading' }
+  ? Value
+  : Value extends {
+        readonly _tag: 'Success'
+        readonly value: infer _Success
+        readonly refetching: boolean
+      }
+    ? Value
+    : Value extends {
+          readonly _tag: 'Error'
+          readonly error: infer _Failure
+          readonly refetching: boolean
+        }
+      ? Value
+      : BoundaryLifecycleMismatch<Value>
+
+type CheckedLifecycleSource<Source extends AnySource> = [SourceValue<Source>] extends [never]
+  ? BoundaryLifecycleMismatch<Source>
+  : SourceValue<Source> extends CheckedLifecycleValue<SourceValue<Source>>
+    ? Source
+    : BoundaryLifecycleMismatch<SourceValue<Source>>
+
+type CheckedLifecycleSources<Over extends ReadonlyArray<AnyLifecycleSource>> = {
+  readonly [Index in keyof Over]: Over[Index] extends AnySource
+    ? CheckedLifecycleSource<Over[Index]>
+    : BoundaryLifecycleMismatch<Over[Index]>
+}
 
 export interface BoundaryManifest<N extends string> extends Manifest {
   readonly kind: 'Boundary'
   readonly name: N
 }
 
-export interface BoundaryClass<out N extends string, out Over extends ReadonlyArray<AnyLifecycleSource>>
-  extends EffectType<BoundaryState, never, Store<BoundaryState>> {
+export interface BoundaryClass<
+  N extends string,
+  out Over extends ReadonlyArray<AnyLifecycleSource>,
+> extends EffectType<BoundaryState, never, BoundaryStore<N>> {
   new (): {}
   readonly manifest: BoundaryManifest<N>
-  readonly store: Context.Tag<Store<BoundaryState>, Store<BoundaryState>>
+  readonly store: Context.Tag<BoundaryStore<N>, Store<BoundaryState>>
   readonly name: N
   readonly over: Over
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
 }
 
 export interface BoundaryConfig<Over extends ReadonlyArray<AnyLifecycleSource>> {
-  readonly over: Over
+  readonly over: Over & CheckedLifecycleSources<Over>
 }
 
 export interface BoundaryOptions {
@@ -57,54 +100,120 @@ export const make = <const N extends string, const Over extends ReadonlyArray<An
   name: N,
   config: BoundaryConfig<Over>,
 ): BoundaryClass<N, Over> => {
-  const store = Context.GenericTag<Store<BoundaryState>, Store<BoundaryState>>(
+  const store = Context.GenericTag<BoundaryStore<N>, Store<BoundaryState>>(
     `reform/boundary/${name}`,
   )
   const manifest: BoundaryManifest<N> = { kind: 'Boundary', name }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name, over: config.over })
+  const boundary: BoundaryClass<N, Over> = yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    over: config.over,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(boundary),
+  })
+  return boundary
 }
 
 const tagOf = (arm: unknown): string =>
   Predicate.hasProperty(arm, '_tag') && Predicate.isString(arm._tag) ? arm._tag : ''
-const errorOf = (arm: unknown): ReadonlyArray<unknown> =>
-  Predicate.hasProperty(arm, 'error') && tagOf(arm) === 'Error' ? [arm.error] : []
+const errorOf = (arm: unknown): Option.Option<unknown> =>
+  Predicate.hasProperty(arm, 'error') && tagOf(arm) === 'Error'
+    ? Option.some(arm.error)
+    : Option.none()
+
+interface SlotUpdate {
+  readonly slot: number
+  readonly arm: unknown
+}
 
 export const live = <N extends string, Over extends ReadonlyArray<AnyLifecycleSource>>(
   boundary: BoundaryClass<N, Over>,
   options: BoundaryOptions = {},
-): Layer.Layer<Store<BoundaryState>, never, InputStores<Over>> =>
+): Layer.Layer<BoundaryStore<N>, never, InputStores<Over>> =>
   Layer.scoped(
     boundary.store,
     Effect.gen(function* () {
       const scheduler = yield* resolveScheduler
-      const sources = yield* wireSources(boundary.over)
+      const sourceWires = yield* Effect.forEach(boundary.over, (source) => wireSources([source]))
+      const readSource = (source: (typeof sourceWires)[number]): unknown =>
+        source.keyOf(source.snapshot())[0]
+      const arms = sourceWires.map((source) => MutableRef.make(readSource(source)))
+      const loadingCount = MutableRef.make(
+        arms.reduce((count, arm) => count + (tagOf(MutableRef.get(arm)) === 'Loading' ? 1 : 0), 0),
+      )
+      const errorCount = MutableRef.make(
+        arms.reduce(
+          (count, arm) => count + (Option.isSome(errorOf(MutableRef.get(arm))) ? 1 : 0),
+          0,
+        ),
+      )
+      const collectErrors = (): ReadonlyArray<unknown> =>
+        arms.flatMap((arm) => Option.toArray(errorOf(MutableRef.get(arm))))
+      const errorArm = MutableRef.make(erroredArm(collectErrors()))
+      const updateSlot = (update: SlotUpdate): void => {
+        const armRef = arms[update.slot]
+        if (armRef === undefined) {
+          return
+        }
+        const previous = MutableRef.get(armRef)
+        if (Equal.equals(previous, update.arm)) {
+          return
+        }
+        MutableRef.set(armRef, update.arm)
+        MutableRef.update(
+          loadingCount,
+          (count) =>
+            count +
+            (tagOf(update.arm) === 'Loading' ? 1 : 0) -
+            (tagOf(previous) === 'Loading' ? 1 : 0),
+        )
+        const previousError = errorOf(previous)
+        const nextError = errorOf(update.arm)
+        if (!Equal.equals(previousError, nextError)) {
+          MutableRef.update(
+            errorCount,
+            (count) =>
+              count + (Option.isSome(nextError) ? 1 : 0) - (Option.isSome(previousError) ? 1 : 0),
+          )
+          MutableRef.set(errorArm, erroredArm(collectErrors()))
+        }
+      }
+      const synchronize = (): void =>
+        sourceWires.forEach((source, slot) => updateSlot({ slot, arm: readSource(source) }))
 
       const latched = MutableRef.make(false)
-      const memo = MutableRef.make<
-        { readonly key: ReadonlyArray<unknown>; readonly value: BoundaryState } | undefined
-      >(undefined)
+      const incremental = MutableRef.make(false)
       const recompute = (): BoundaryState => {
         if (options.once === true && MutableRef.get(latched)) {
           return readyArm
         }
-        const arms = sources.keyOf(sources.snapshot())
-        const prev = MutableRef.get(memo)
-        if (prev !== undefined && sameKey(arms, prev.key)) {
-          return prev.value
+        if (!MutableRef.get(incremental)) {
+          synchronize()
         }
-        const errors = arms.flatMap(errorOf)
-        const mergedArm =
-          errors.length > 0
-            ? erroredArm(errors)
-            : arms.some((arm) => tagOf(arm) === 'Loading')
-              ? pendingArm
-              : readyArm
-        MutableRef.set(memo, { key: arms, value: mergedArm })
-        return mergedArm
+        return MutableRef.get(errorCount) > 0
+          ? MutableRef.get(errorArm)
+          : MutableRef.get(loadingCount) > 0
+            ? pendingArm
+            : readyArm
       }
 
-      const derived = makeDerivedStore(recompute, sources.subscribe, scheduler)
+      const subscribe = (onChange: () => void): (() => void) => {
+        const publish = (): void => {
+          MutableRef.set(incremental, true)
+          onChange()
+          MutableRef.set(incremental, false)
+        }
+        const settle = (): void => scheduler.schedule([publish])
+        const unsubscribes = sourceWires.map((source, sourceIndex) =>
+          source.subscribe(() => {
+            updateSlot({ slot: sourceIndex, arm: readSource(source) })
+            scheduler.schedule([settle])
+          }),
+        )
+        return () => unsubscribes.forEach((unsubscribe) => unsubscribe())
+      }
+      const derived = makeDerivedStore(recompute, subscribe, scheduler)
       yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
 
       if (options.once === true) {