@playfast/reform-remote 1.1.0 → 1.3.0

package/src/wireRender.ts

@@ -0,0 +1,249 @@
+import { Context, Effect, Match, Option, type ParseResult, Record as Rec } from 'effect'
+import {
+  Composition,
+  type CompositionClass,
+  isStructure,
+  type SlotFill,
+  type Structure,
+  type UiContract,
+} from '@playfast/reform'
+import {
+  type AnyComposition,
+  type AnyScene,
+  type AnySlot,
+  type AnySlotChild,
+  type TriggerRegistryApi,
+  type WireNode,
+  type WireTree,
+} from '@playfast/reform/internal'
+import {
+  childComposition,
+  type Mounted,
+  noRegister,
+  slotsOf,
+  structureFills,
+  toWireNodeFromStructure,
+} from './wireNode'
+
+export interface RenderSceneToWireOptions {
+  readonly register: TriggerRegistryApi['register']
+}
+
+export const serviceFromContext = <Services, Identifier, Service>(
+  context: Context.Context<Services>,
+  tag: Context.Tag<Identifier, Service>,
+  missing: string,
+): Effect.Effect<Service, never, never> =>
+  Option.match(Context.getOption(context, tag), {
+    onNone: () => Effect.dieMessage(missing),
+    onSome: Effect.succeed,
+  })
+
+export const capturedSlotProvider = <Services>(
+  context: Context.Context<Services>,
+  slotDefinition: AnySlot,
+): Effect.Effect<AnySlotChild, never, never> =>
+  slotDefinition.capture((exact) =>
+    serviceFromContext(
+      context,
+      exact.provider,
+      'reform-remote: scene does not provide a declared slot',
+    ),
+  )
+
+export const renderCapturedComposition = <Services>(
+  context: Context.Context<Services>,
+  composition: AnyComposition,
+  props: unknown,
+): Effect.Effect<Structure<UiContract>, never, never> =>
+  composition.capture<Effect.Effect<Structure<UiContract>, never, never>>(
+    <P, C extends UiContract, S extends ReadonlyArray<unknown>, N extends string, Identity>(
+      exact: CompositionClass<P, C, S, N, Identity>,
+    ): Effect.Effect<Structure<UiContract>, never, never> =>
+      Option.match(exact.parseProps(props), {
+        onNone: () =>
+          Effect.dieMessage(
+            `reform-remote: invalid props for composition ${composition.manifest.name}`,
+          ),
+        onSome: (parsed) =>
+          serviceFromContext(
+            context,
+            exact.tag,
+            `reform-remote: scene does not provide composition ${composition.manifest.name}`,
+          ).pipe(
+            Effect.flatMap((service) =>
+              Composition.render<P, C>(service, {
+                props: parsed,
+                tracker: { add: () => {} },
+              }),
+            ),
+            Effect.flatMap((frame) => {
+              if (isStructure(frame)) {
+                return Effect.succeed(frame)
+              }
+              return Effect.dieMessage(
+                `reform-remote: composition ${composition.manifest.name} did not return a Structure`,
+              )
+            }),
+          ),
+      }),
+  )
+
+export const enqueueStructureSlot = (
+  parent: Mounted,
+  slotName: string,
+  child: AnyComposition,
+  fill: SlotFill<unknown>,
+): ReadonlyArray<Mounted> =>
+  Match.value(fill).pipe(
+    Match.tag('Each', (each) => {
+      // Keyed, not positional: a trigger handle embeds the node id, so an id built from
+      // the index silently re-points a handle the client already holds at whatever row
+      // slid into that slot. An accidental duplicate key falls back to the index rather
+      // than minting two nodes with one id.
+      const used = new Set<string>()
+      // The disambiguator is retried rather than assumed free: a key that literally ends
+      // in `#<n>` can already hold the string a later repeat would mint, and two nodes
+      // sharing an id costs a whole row on the wire.
+      const unusedId = (base: string): string => {
+        const attempt = (round: number): string => {
+          const candidate = round === 0 ? base : `${base}#${round}`
+          return used.has(candidate) ? attempt(round + 1) : candidate
+        }
+        return attempt(0)
+      }
+      return each.items.map((entry, index): Mounted => {
+        const id = unusedId(`${parent.id}.${slotName}.${entry.key ?? index}`)
+        used.add(id)
+        return {
+          comp: child,
+          props: entry.props,
+          id,
+          parentId: Option.some(parent.id),
+          slot: Option.some(slotName),
+          childIndex: index,
+          key: Option.fromNullable(entry.key),
+        }
+      })
+    }),
+    Match.tag('One', (single) => [
+      {
+        comp: child,
+        props: single.props,
+        id: `${parent.id}.${slotName}.0`,
+        parentId: Option.some(parent.id),
+        slot: Option.some(slotName),
+        childIndex: 0,
+        key: Option.none(),
+      } satisfies Mounted,
+    ]),
+    Match.tag('Absent', () => []),
+    Match.exhaustive,
+  )
+
+export type SlotProvider<Services> = (
+  slotDefinition: AnySlot,
+) => Effect.Effect<AnySlotChild, never, Services>
+
+export const collect: <Services>(
+  root: AnyComposition,
+  provideSlot: SlotProvider<Services>,
+) => Effect.Effect<Map<AnySlot, AnyComposition>, never, Services> = Effect.fn('collect')(function* <
+  Services,
+>(
+  root: AnyComposition,
+  provideSlot: SlotProvider<Services>,
+): Effect.fn.Return<Map<AnySlot, AnyComposition>, never, Services> {
+  const bindings = new Map<AnySlot, AnyComposition>()
+  // Explicit type keeps the recursive reference cast-free.
+  const walk: (comp: AnyComposition) => Effect.Effect<void, never, Services> = Effect.fn('walk')(
+    function* (comp: AnyComposition): Effect.fn.Return<void, never, Services> {
+      yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
+        Effect.gen(function* () {
+          if (bindings.has(slotClass)) {
+            return
+          }
+          const child = childComposition(yield* provideSlot(slotClass))
+          bindings.set(slotClass, child)
+          yield* walk(child)
+        }),
+      )
+    },
+  )
+  yield* walk(root)
+  return bindings
+})
+
+export type CompositionRenderer<Services> = (
+  composition: AnyComposition,
+  props: unknown,
+) => Effect.Effect<Structure<UiContract>, never, Services>
+
+export interface RenderLevel {
+  <Services>(
+    frontier: ReadonlyArray<Mounted>,
+    bindings: ReadonlyMap<AnySlot, AnyComposition>,
+    register: TriggerRegistryApi['register'],
+    render: CompositionRenderer<Services>,
+  ): Effect.Effect<ReadonlyArray<WireNode>, ParseResult.ParseError, Services>
+}
+
+export const renderLevel: RenderLevel = Effect.fn('renderLevel')(function* <Services>(
+  frontier: ReadonlyArray<Mounted>,
+  bindings: ReadonlyMap<AnySlot, AnyComposition>,
+  register: TriggerRegistryApi['register'],
+  render: CompositionRenderer<Services>,
+): Effect.fn.Return<ReadonlyArray<WireNode>, ParseResult.ParseError, Services> {
+  if (frontier.length === 0) {
+    return []
+  }
+  const rendered = yield* Effect.forEach(frontier, (mounted) =>
+    Effect.gen(function* () {
+      const frame = yield* render(mounted.comp, mounted.props)
+      const node = yield* toWireNodeFromStructure(mounted, frame, register)
+      const fills = structureFills(frame)
+      const children = Rec.toEntries(slotsOf(mounted.comp)).flatMap(([slotName, slotClass]) => {
+        const child = bindings.get(slotClass)
+        if (child === undefined) {
+          return []
+        }
+        const fill = fills[slotName]
+        if (fill === undefined) {
+          return []
+        }
+        return enqueueStructureSlot(mounted, slotName, child, fill)
+      })
+      return { node, children }
+    }),
+  )
+  const nodes = rendered.map((entry) => entry.node)
+  const next = rendered.flatMap((entry) => entry.children)
+  const rest = yield* renderLevel(next, bindings, register, render)
+  return [...nodes, ...rest]
+})
+
+export const renderSceneWith: <SlotServices, CompositionServices>(
+  scene: AnyScene,
+  options: RenderSceneToWireOptions | undefined,
+  provideSlot: SlotProvider<SlotServices>,
+  render: CompositionRenderer<CompositionServices>,
+) => Effect.Effect<WireTree, ParseResult.ParseError, SlotServices | CompositionServices> =
+  Effect.fn('renderSceneWith')(function* <SlotServices, CompositionServices>(
+    scene: AnyScene,
+    options: RenderSceneToWireOptions | undefined,
+    provideSlot: SlotProvider<SlotServices>,
+    render: CompositionRenderer<CompositionServices>,
+  ): Effect.fn.Return<WireTree, ParseResult.ParseError, SlotServices | CompositionServices> {
+    const register = options?.register ?? noRegister
+    const bindings = yield* collect(scene.composition, provideSlot)
+    const root: Mounted = {
+      comp: scene.composition,
+      props: {},
+      id: '0',
+      parentId: Option.none(),
+      slot: Option.none(),
+      childIndex: 0,
+      key: Option.none(),
+    }
+    return yield* renderLevel([root], bindings, register, render)
+  })