@playfast/reform-proof 1.1.1 → 1.2.0

package/src/treeBindings.ts

@@ -1,121 +0,0 @@
-import { Effect, Match, Option, Record as Rec } from 'effect'
-import {
-  type CompositionClass,
-  isFeatureBinding,
-  type SlotChild,
-  type SlotClass,
-  type SlotFill,
-  type Structure,
-  type UiContract,
-} from '@playfast/reform'
-import { eventsOf, type Sink, uiNameOf } from './sink'
-
-export interface Mounted {
-  readonly comp: CompositionClass<unknown>
-  readonly props: unknown
-  readonly key: Option.Option<string>
-}
-
-export interface NodeRef {
-  readonly name: string
-  readonly index: number
-}
-
-export interface SettleProgress {
-  readonly previous: string
-  readonly remaining: number
-  readonly stable: boolean
-}
-
-export interface PumpStep {
-  readonly input: unknown
-  readonly index: number
-}
-
-export const childComposition = (child: SlotChild): CompositionClass<unknown> =>
-  isFeatureBinding(child) ? child.composition : child
-
-export const slotsOf = (comp: CompositionClass<unknown>): Record<string, SlotClass> =>
-  Option.getOrElse(Option.fromNullable(comp.manifest.slots), () => ({}))
-
-const isSlotFill = (candidate: unknown): candidate is SlotFill<unknown> =>
-  typeof candidate === 'object' &&
-  candidate !== null &&
-  '_tag' in candidate &&
-  (candidate._tag === 'Each' || candidate._tag === 'One' || candidate._tag === 'Absent')
-
-export const structureFills = (
-  structure: Structure<UiContract>,
-): Record<string, SlotFill<unknown>> =>
-  Rec.fromEntries(
-    Rec.toEntries(structure.slots).flatMap(([slotName, fillValue]) =>
-      isSlotFill(fillValue) ? [[slotName, fillValue] as const] : [],
-    ),
-  )
-
-export const collectBindings: (
-  root: CompositionClass<unknown>,
-) => Effect.Effect<Map<SlotClass, CompositionClass<unknown>>, never, SlotChild> = Effect.fn(
-  'collectBindings',
-)(function* (
-  root: CompositionClass<unknown>,
-): Effect.fn.Return<Map<SlotClass, CompositionClass<unknown>>, never, SlotChild> {
-  const bindings = new Map<SlotClass, CompositionClass<unknown>>()
-  const walk: (comp: CompositionClass<unknown>) => Effect.Effect<void, never, SlotChild> = Effect.fn(
-    'collectBindings.walk',
-  )(function* (comp: CompositionClass<unknown>): Effect.fn.Return<void, never, SlotChild> {
-    yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
-      Effect.gen(function* () {
-        if (bindings.has(slotClass)) {
-          return
-        }
-        const child = childComposition(yield* slotClass.tag)
-        bindings.set(slotClass, child)
-        yield* walk(child)
-      }),
-    )
-  })
-  yield* walk(root)
-  return bindings
-})
-
-const enqueueFill = (
-  slotName: string,
-  fill: SlotFill<unknown>,
-  child: CompositionClass<unknown>,
-): ReadonlyArray<Mounted> =>
-  Match.value(fill).pipe(
-    Match.when({ _tag: 'Each' }, (each) =>
-      each.items.map((entry) => ({
-        comp: child,
-        props: entry.props,
-        key: Option.some(entry.key),
-      })),
-    ),
-    Match.when({ _tag: 'One' }, (oneFill) => [
-      { comp: child, props: oneFill.props, key: Option.some(`${slotName}.0`) },
-    ]),
-    Match.when({ _tag: 'Absent' }, () => []),
-    Match.exhaustive,
-  )
-
-export const driveStructure = (
-  comp: CompositionClass<unknown>,
-  structure: Structure<UiContract>,
-  key: Option.Option<string>,
-  sink: Sink,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-): ReadonlyArray<Mounted> => {
-  sink.api.record({
-    name: uiNameOf(comp),
-    props: structure.props,
-    events: eventsOf(structure),
-    ...(Option.isSome(key) ? { key: key.value } : {}),
-  })
-  const fills = structureFills(structure)
-  return Rec.toEntries(slotsOf(comp)).flatMap(([slotName, slotClass]) => {
-    const child = bindings.get(slotClass)
-    const fill = fills[slotName]
-    return child === undefined || fill === undefined ? [] : enqueueFill(slotName, fill, child)
-  })
-}