@playfast/reform-proof 1.1.1 → 1.2.0

package/src/facade.ts

@@ -1,258 +0,0 @@
-import { Array as Arr, Effect, ManagedRuntime, Option, Schema as S } from 'effect'
-import {
-  Composition,
-  type CompositionClass,
-  type CompositionService,
-  isStructure,
-  type RenderEnv,
-  type SlotChild,
-  type SlotClass,
-  type Trigger,
-  type UiCapture,
-  type UiContract,
-} from '@playfast/reform'
-import { AssertionFailed, UnknownAction, UnknownSlot } from './errors'
-import { matchProps } from './assertions'
-import type { Action, Facade, SlotFacade } from './index'
-import {
-  keyed,
-  SETTLE_MAX_RENDERS,
-  SETTLE_STEP,
-  settleDrain,
-  type RuntimeServices,
-  type Sink,
-  uiNameOf,
-} from './sink'
-import {
-  collectBindings,
-  driveStructure,
-  type Mounted,
-  type NodeRef,
-  type SettleProgress,
-  slotsOf,
-} from './treeBindings'
-
-type AnyFacade = Facade<UiContract>
-type AnySlotFacade = SlotFacade<UiContract>
-const encodeUnknown = S.encodeSync(S.parseJson(S.Unknown))
-
-const renderMounted = Effect.fn('renderMounted')(function* (
-  mounted: Mounted,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.fn.Return<ReadonlyArray<Mounted>, never, CompositionService> {
-  const service = yield* mounted.comp.tag
-  const env: RenderEnv = { props: mounted.props, tracker: { add: () => {} } }
-  const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(mounted.comp))
-  const frame = yield* Composition.render(service, env)
-  endRenderSpan()
-  if (!isStructure(frame)) {
-    return yield* Effect.dieMessage(
-      `reform-proof: composition ${uiNameOf(mounted.comp)} did not return a Structure`,
-    )
-  }
-  return driveStructure(mounted.comp, frame, mounted.key, sink, bindings)
-})
-
-const renderLevel: (
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-) => Effect.Effect<void, never, CompositionService> = Effect.fn('renderLevel')(function* (
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.fn.Return<void, never, CompositionService> {
-  if (frontier.length === 0) {
-    return
-  }
-  const levels = yield* Effect.forEach(frontier, (mounted) =>
-    renderMounted(mounted, bindings, sink),
-  )
-  yield* renderLevel(levels.flat(), bindings, sink)
-})
-
-const renderTree = Effect.fn('renderTree')(function* (
-  root: CompositionClass<unknown>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.fn.Return<void, never, CompositionService> {
-  sink.reset()
-  yield* renderLevel([{ comp: root, props: {}, key: Option.none() }], bindings, sink)
-})
-
-export const capturesFor = (sink: Sink, name: string): ReadonlyArray<UiCapture> =>
-  sink.captures.filter((capture) => capture.name === name)
-
-export const fingerprint = (sink: Sink): string =>
-  encodeUnknown(sink.captures.map((capture) => [capture.name, capture.props]))
-
-const settleTree = Effect.fn('settleTree')(function* (
-  root: CompositionClass<unknown>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.fn.Return<void, never, CompositionService> {
-  yield* settleDrain
-  yield* renderTree(root, bindings, sink)
-  yield* Effect.iterate(
-    {
-      previous: fingerprint(sink),
-      remaining: SETTLE_MAX_RENDERS,
-      stable: false,
-    },
-    {
-      while: (progress: SettleProgress) => !progress.stable && progress.remaining > 0,
-      body: (progress) =>
-        Effect.gen(function* () {
-          yield* settleDrain
-          yield* Effect.sleep(SETTLE_STEP)
-          yield* renderTree(root, bindings, sink)
-          const current = fingerprint(sink)
-          return {
-            previous: current,
-            remaining: progress.remaining - 1,
-            stable: current === progress.previous,
-          }
-        }),
-    },
-  )
-})
-
-export const makeFacadeEffect: (
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-) => Effect.Effect<
-  {
-    readonly facade: AnyFacade
-    readonly settle: Effect.Effect<void, never, CompositionService>
-  },
-  never,
-  SlotChild
-> = Effect.fn('makeFacadeEffect')(function* (
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): Effect.fn.Return<
-  {
-    readonly facade: AnyFacade
-    readonly settle: Effect.Effect<void, never, CompositionService>
-  },
-  never,
-  SlotChild
-> {
-  const bindings = yield* collectBindings(root)
-  const settle = settleTree(root, bindings, sink)
-  const rerender = renderTree(root, bindings, sink)
-
-  const triggerOf = (ref: NodeRef, event: string): Effect.Effect<Trigger<unknown>> =>
-    Option.match(Option.fromNullable(capturesFor(sink, ref.name)[ref.index]?.events[event]), {
-      onNone: () =>
-        Effect.dieMessage(
-          new UnknownAction({
-            composition: ref.name,
-            action: event,
-            rendered: capturesFor(sink, ref.name).length,
-          }).message,
-        ),
-      onSome: Effect.succeed,
-    })
-
-  const propsFor = (ref: NodeRef): Effect.Effect<unknown, never, CompositionService> =>
-    Effect.map(rerender, () => capturesFor(sink, ref.name)[ref.index]?.props)
-
-  const nodeFacade = (ref: NodeRef, comp: CompositionClass<unknown>): AnyFacade => ({
-    props: propsFor(ref),
-    expectProps: (partial) =>
-      propsFor(ref).pipe(
-        Effect.flatMap((props) => {
-          const mismatch = matchProps({ actual: props, expected: partial })
-          return mismatch === undefined
-            ? Effect.void
-            : Effect.dieMessage(new AssertionFailed({ detail: mismatch }).message)
-        }),
-      ),
-    actions: keyed(
-      (event): Action =>
-        (payload) =>
-          rerender.pipe(
-            Effect.flatMap(() => triggerOf(ref, event)),
-            Effect.flatMap((trigger) =>
-              Effect.sync(() => {
-                dispatched.add(event)
-                trigger(payload)
-              }),
-            ),
-            Effect.flatMap(() => settle),
-            Effect.flatMap(() => propsFor(ref)),
-          ),
-    ),
-    slots: keyed((slotName) => slotFacade(comp, slotName)),
-    frame: settle,
-  })
-
-  const slotFacade = (parent: CompositionClass<unknown>, slotName: string): AnySlotFacade => {
-    const slotClass = slotsOf(parent)[slotName]
-    const child = slotClass && bindings.get(slotClass)
-    if (child === undefined) {
-      return Effect.runSync(
-        Effect.dieMessage(new UnknownSlot({ parent: uiNameOf(parent), slot: slotName }).message),
-      )
-    }
-    const childName = uiNameOf(child)
-    const atIndex = (index: number): Effect.Effect<AnyFacade, never, CompositionService> =>
-      Effect.as(rerender, nodeFacade({ name: childName, index }, child))
-    const first = nodeFacade({ name: childName, index: 0 }, child)
-    const indexOfKey = (key: string): Option.Option<number> =>
-      Arr.findFirstIndex(capturesFor(sink, childName), (capture) => capture.key === key)
-    return {
-      first: atIndex(0),
-      at: atIndex,
-      all: Effect.map(rerender, () =>
-        capturesFor(sink, childName).map((_capture, index) =>
-          nodeFacade({ name: childName, index }, child),
-        ),
-      ),
-      byKey: (key) =>
-        Effect.flatMap(rerender, () =>
-          Option.match(indexOfKey(key), {
-            onNone: () =>
-              Effect.dieMessage(
-                new UnknownSlot({
-                  parent: uiNameOf(parent),
-                  slot: `${slotName}[key=${key}]`,
-                }).message,
-              ),
-            onSome: (index) => Effect.succeed(nodeFacade({ name: childName, index }, child)),
-          }),
-        ),
-      where: (predicate) =>
-        Effect.map(rerender, () =>
-          capturesFor(sink, childName).flatMap((capture, index) =>
-            predicate(capture.props) ? [nodeFacade({ name: childName, index }, child)] : [],
-          ),
-        ),
-      count: Effect.map(rerender, () => capturesFor(sink, childName).length),
-      props: first.props,
-      expectProps: first.expectProps,
-      actions: first.actions,
-      slots: first.slots,
-      frame: first.frame,
-    }
-  }
-
-  return {
-    facade: nodeFacade({ name: uiNameOf(root), index: 0 }, root),
-    settle,
-  }
-})
-
-export const makeFacade = (
-  runtime: ManagedRuntime.ManagedRuntime<RuntimeServices, never>,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: AnyFacade
-  readonly settle: Effect.Effect<void, never, CompositionService>
-} => runtime.runSync(makeFacadeEffect(root, sink, dispatched))

package/src/product.ts

@@ -1,77 +0,0 @@
-import { Option, type Schema } from 'effect'
-import type { CompositionClass } from '@playfast/reform'
-import type { ContractOf, EventsOf } from './index'
-
-type AnyValue = Schema.Schema.Type<Schema.Schema.Any>
-type AnyComposition = CompositionClass<AnyValue, AnyValue>
-
-export interface RequirementManifest<Comp extends AnyComposition, Statement extends string> {
-  readonly kind: 'ProductRequirement'
-  readonly name: Statement
-  readonly statement: Statement
-  readonly composition: Comp
-  readonly events: Option.Option<ReadonlyArray<keyof EventsOf<ContractOf<Comp>>>>
-}
-
-export interface RequirementClass<Comp extends AnyComposition, Statement extends string> {
-  new (): {}
-  readonly manifest: RequirementManifest<Comp, Statement>
-}
-
-export interface ProductManifest<Comp extends AnyComposition> {
-  readonly kind: 'Product'
-  readonly name: string
-  readonly composition: Comp
-  readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>
-}
-
-export interface ProductClass<Comp extends AnyComposition = AnyComposition> {
-  new (): {}
-  readonly manifest: ProductManifest<Comp>
-}
-
-interface MakeRequirementOptionsExternalApi<Comp extends AnyComposition> {
-  readonly events?: ReadonlyArray<keyof EventsOf<ContractOf<Comp>>>
-}
-
-const makeRequirement = <Comp extends AnyComposition, const Statement extends string>(
-  composition: Comp,
-  statement: Statement,
-  options?: MakeRequirementOptionsExternalApi<Comp>,
-): RequirementClass<Comp, Statement> => {
-  const manifest: RequirementManifest<Comp, Statement> = {
-    kind: 'ProductRequirement',
-    name: statement,
-    statement,
-    composition,
-    events: Option.fromNullable(options?.events),
-  }
-  return class {
-    static readonly manifest = manifest
-  }
-}
-
-export const ProductRequirement: { readonly make: typeof makeRequirement } = {
-  make: makeRequirement,
-}
-
-interface MakeProductConfig<Comp extends AnyComposition> {
-  readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>
-}
-
-const makeProduct = <Comp extends AnyComposition>(
-  composition: Comp,
-  config: MakeProductConfig<Comp>,
-): ProductClass<Comp> => {
-  const manifest: ProductManifest<Comp> = {
-    kind: 'Product',
-    name: composition.manifest.name,
-    composition,
-    requirements: config.requirements,
-  }
-  return class {
-    static readonly manifest = manifest
-  }
-}
-
-export const Product: { readonly make: typeof makeProduct } = { make: makeProduct }

package/src/runtimeFacade.ts

@@ -1,269 +0,0 @@
-import { Array as Arr, Effect, Option, Record as Rec } from 'effect'
-import {
-  Composition,
-  type CompositionClass,
-  isStructure,
-  type RenderEnv,
-  type RuntimeHandle,
-  type SlotClass,
-  type Trigger,
-} from '@playfast/reform'
-import { AssertionFailed, UnknownAction, UnknownSlot } from './errors'
-import { matchProps } from './assertions'
-import { capturesFor, fingerprint } from './facade'
-import {
-  keyed,
-  SETTLE_MAX_RENDERS,
-  SETTLE_STEP,
-  settleDrain,
-  type Sink,
-  uiNameOf,
-} from './sink'
-import {
-  childComposition,
-  driveStructure,
-  type Mounted,
-  type NodeRef,
-  type SettleProgress,
-  slotsOf,
-} from './treeBindings'
-
-export interface MountedFacade {
-  readonly props: Effect.Effect<unknown, never, never>
-  readonly expectProps: (partial: unknown) => Effect.Effect<void, never, never>
-  readonly actions: Record<string, (payload: unknown) => Effect.Effect<unknown, never, never>>
-  readonly slots: Record<string, MountedSlotFacade>
-  readonly frame: Effect.Effect<void, never, never>
-}
-
-export interface MountedSlotFacade extends MountedFacade {
-  readonly first: Effect.Effect<MountedFacade, never, never>
-  readonly at: (index: number) => Effect.Effect<MountedFacade, never, never>
-  readonly all: Effect.Effect<ReadonlyArray<MountedFacade>, never, never>
-  readonly byKey: (key: string) => Effect.Effect<MountedFacade, never, never>
-  readonly where: (
-    predicate: (props: unknown) => boolean,
-  ) => Effect.Effect<ReadonlyArray<MountedFacade>, never, never>
-  readonly count: Effect.Effect<number, never, never>
-}
-
-const collectRuntimeBindings = (
-  root: CompositionClass<unknown>,
-  runtime: RuntimeHandle,
-): Map<SlotClass, CompositionClass<unknown>> => {
-  const bindings = new Map<SlotClass, CompositionClass<unknown>>()
-  const walk = (comp: CompositionClass<unknown>): void => {
-    Rec.values(slotsOf(comp)).forEach((slotClass) => {
-      if (bindings.has(slotClass)) {
-        return
-      }
-      const child = childComposition(runtime.read(slotClass.tag))
-      bindings.set(slotClass, child)
-      walk(child)
-    })
-  }
-  walk(root)
-  return bindings
-}
-
-const renderMountedRuntime = (
-  runtime: RuntimeHandle,
-  mounted: Mounted,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): ReadonlyArray<Mounted> => {
-  const service = runtime.read(mounted.comp.tag)
-  const env: RenderEnv = { props: mounted.props, tracker: { add: () => {} } }
-  const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(mounted.comp))
-  const frame = Effect.runSync(Composition.render(service, env))
-  endRenderSpan()
-  if (!isStructure(frame)) {
-    return Effect.runSync(
-      Effect.dieMessage(
-        `reform-proof: composition ${uiNameOf(mounted.comp)} did not return a Structure`,
-      ),
-    )
-  }
-  return driveStructure(mounted.comp, frame, mounted.key, sink, bindings)
-}
-
-const renderLevelRuntime = (
-  runtime: RuntimeHandle,
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): void => {
-  if (frontier.length === 0) {
-    return
-  }
-  const levels = frontier.map((mounted) => renderMountedRuntime(runtime, mounted, bindings, sink))
-  renderLevelRuntime(runtime, levels.flat(), bindings, sink)
-}
-
-const renderTreeRuntime = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.Effect<void, never, never> =>
-  Effect.sync(() => {
-    sink.reset()
-    renderLevelRuntime(runtime, [{ comp: root, props: {}, key: Option.none() }], bindings, sink)
-  })
-
-const settleTreeRuntime = Effect.fn('settleTreeRuntime')(function* (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.fn.Return<void, never, never> {
-  yield* settleDrain
-  yield* renderTreeRuntime(runtime, root, bindings, sink)
-  yield* Effect.iterate(
-    {
-      previous: fingerprint(sink),
-      remaining: SETTLE_MAX_RENDERS,
-      stable: false,
-    },
-    {
-      while: (progress: SettleProgress) => !progress.stable && progress.remaining > 0,
-      body: (progress) =>
-        Effect.gen(function* () {
-          yield* settleDrain
-          yield* Effect.sleep(SETTLE_STEP)
-          yield* renderTreeRuntime(runtime, root, bindings, sink)
-          const current = fingerprint(sink)
-          return {
-            previous: current,
-            remaining: progress.remaining - 1,
-            stable: current === progress.previous,
-          }
-        }),
-    },
-  )
-})
-
-const makeMountedFacade = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: MountedFacade
-  readonly settle: Effect.Effect<void, never, never>
-} => {
-  const bindings = collectRuntimeBindings(root, runtime)
-  const settle = settleTreeRuntime(runtime, root, bindings, sink)
-  const rerender = renderTreeRuntime(runtime, root, bindings, sink)
-
-  const triggerOf = (ref: NodeRef, event: string): Effect.Effect<Trigger<unknown>, never, never> =>
-    Option.match(Option.fromNullable(capturesFor(sink, ref.name)[ref.index]?.events[event]), {
-      onNone: () =>
-        Effect.dieMessage(
-          new UnknownAction({
-            composition: ref.name,
-            action: event,
-            rendered: capturesFor(sink, ref.name).length,
-          }).message,
-        ),
-      onSome: Effect.succeed,
-    })
-
-  const propsFor = (ref: NodeRef): Effect.Effect<unknown, never, never> =>
-    Effect.map(rerender, () => capturesFor(sink, ref.name)[ref.index]?.props)
-
-  const nodeFacade = (ref: NodeRef, comp: CompositionClass<unknown>): MountedFacade => ({
-    props: propsFor(ref),
-    expectProps: (partial) =>
-      propsFor(ref).pipe(
-        Effect.flatMap((props) => {
-          const mismatch = matchProps({ actual: props, expected: partial })
-          return mismatch === undefined
-            ? Effect.void
-            : Effect.dieMessage(new AssertionFailed({ detail: mismatch }).message)
-        }),
-      ),
-    actions: keyed(
-      (event) => (payload: unknown) =>
-        rerender.pipe(
-          Effect.flatMap(() => triggerOf(ref, event)),
-          Effect.flatMap((trigger) =>
-            Effect.sync(() => {
-              dispatched.add(event)
-              trigger(payload)
-            }),
-          ),
-          Effect.flatMap(() => settle),
-          Effect.flatMap(() => propsFor(ref)),
-        ),
-    ),
-    slots: keyed((slotName) => slotFacade(comp, slotName)),
-    frame: settle,
-  })
-
-  const slotFacade = (parent: CompositionClass<unknown>, slotName: string): MountedSlotFacade => {
-    const slotClass = slotsOf(parent)[slotName]
-    const child = slotClass && bindings.get(slotClass)
-    if (child === undefined) {
-      return Effect.runSync(
-        Effect.dieMessage(new UnknownSlot({ parent: uiNameOf(parent), slot: slotName }).message),
-      )
-    }
-    const childName = uiNameOf(child)
-    const atIndex = (index: number): Effect.Effect<MountedFacade, never, never> =>
-      Effect.as(rerender, nodeFacade({ name: childName, index }, child))
-    const first = nodeFacade({ name: childName, index: 0 }, child)
-    const indexOfKey = (key: string): Option.Option<number> =>
-      Arr.findFirstIndex(capturesFor(sink, childName), (capture) => capture.key === key)
-    return {
-      first: atIndex(0),
-      at: atIndex,
-      all: Effect.map(rerender, () =>
-        capturesFor(sink, childName).map((_capture, index) =>
-          nodeFacade({ name: childName, index }, child),
-        ),
-      ),
-      byKey: (key) =>
-        Effect.flatMap(rerender, () =>
-          Option.match(indexOfKey(key), {
-            onNone: () =>
-              Effect.dieMessage(
-                new UnknownSlot({
-                  parent: uiNameOf(parent),
-                  slot: `${slotName}[key=${key}]`,
-                }).message,
-              ),
-            onSome: (index) => Effect.succeed(nodeFacade({ name: childName, index }, child)),
-          }),
-        ),
-      where: (predicate) =>
-        Effect.map(rerender, () =>
-          capturesFor(sink, childName).flatMap((capture, index) =>
-            predicate(capture.props) ? [nodeFacade({ name: childName, index }, child)] : [],
-          ),
-        ),
-      count: Effect.map(rerender, () => capturesFor(sink, childName).length),
-      props: first.props,
-      expectProps: first.expectProps,
-      actions: first.actions,
-      slots: first.slots,
-      frame: first.frame,
-    }
-  }
-
-  return {
-    facade: nodeFacade({ name: uiNameOf(root), index: 0 }, root),
-    settle,
-  }
-}
-
-export const makeRuntimeHandleFacade = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: MountedFacade
-  readonly settle: Effect.Effect<void, never, never>
-} => makeMountedFacade(runtime, root, sink, dispatched)
-

package/src/runtimeTreeDispose.ts

@@ -1,21 +0,0 @@
-import { Array as Arr, Order } from 'effect'
-import type { TreeFeatureMount } from './runtimeTreeTypes'
-
-interface DisposeTreeMountsOptions {
-  readonly status: { disposed: boolean }
-  readonly mounts: Map<string, TreeFeatureMount>
-}
-
-export const disposeTreeMounts = ({ status, mounts }: DisposeTreeMountsOptions): void => {
-  if (status.disposed) {
-    return
-  }
-  status.disposed = true
-  Arr.sortWith(Array.from(mounts.values()), (record) => -record.depth, Order.number).forEach(
-    (record) => {
-      record.attempt += 1
-      record.dispose()
-    },
-  )
-  mounts.clear()
-}