@playfast/reform 1.2.0 → 1.2.1

package/src/channel/procedures.ts

@@ -0,0 +1,108 @@
+import { Context, type Effect, Layer, Option } from 'effect'
+import { makeBucketCache } from '../internal/bucketCache'
+import type { Tagged } from '../runtime/bus'
+
+export interface ProcedureEntry {
+  readonly name: string
+  readonly channelName: string
+  readonly handles: ReadonlySet<string>
+  readonly run: (event: Tagged) => Effect.Effect<unknown, unknown, never>
+}
+
+export interface ProcedureRegistry {
+  readonly entries: Array<ProcedureEntry>
+  readonly byName: Map<string, Set<ProcedureEntry>>
+  readonly byTag: Map<string, Set<ProcedureEntry>>
+  readonly channelsByTag: Map<string, Set<string>>
+  readonly channelsFor: (tag: string) => ReadonlyArray<string>
+  readonly byChannelTag: Map<string, Map<string, Set<ProcedureEntry>>>
+  readonly register: (entry: ProcedureEntry) => void
+  readonly unregister: (entry: ProcedureEntry) => void
+}
+
+const ProceduresBase: Context.TagClass<Procedures, 'reform/Procedures', ProcedureRegistry> =
+  Context.Tag('reform/Procedures')<Procedures, ProcedureRegistry>()
+export class Procedures extends ProceduresBase {}
+
+const getOrCreate = <K, V>(map: Map<K, V>, key: K, make: () => V): V => {
+  const existing = map.get(key)
+  if (existing !== undefined) {
+    return existing
+  }
+  const created = make()
+  map.set(key, created)
+  return created
+}
+
+const dropFrom = <K, T>(map: Map<K, Set<T>>, key: K, target: T): void => {
+  const bucket = map.get(key)
+  if (bucket === undefined) {
+    return
+  }
+  bucket.delete(target)
+  if (bucket.size === 0) {
+    map.delete(key)
+  }
+}
+
+const makeProcedureRegistry = (): ProcedureRegistry => {
+  const entries = new Set<ProcedureEntry>()
+  const byName = new Map<string, Set<ProcedureEntry>>()
+  const byTag = new Map<string, Set<ProcedureEntry>>()
+  const channelsByTag = new Map<string, Set<string>>()
+  const channelsFor = makeBucketCache(channelsByTag)
+  const byChannelTag = new Map<string, Map<string, Set<ProcedureEntry>>>()
+  const snapshot: { value: Option.Option<Array<ProcedureEntry>> } = {
+    value: Option.some([]),
+  }
+  return {
+    get entries() {
+      return Option.getOrElse(snapshot.value, () => {
+        const current = Array.from(entries)
+        snapshot.value = Option.some(current)
+        return current
+      })
+    },
+    byName,
+    byTag,
+    channelsByTag,
+    channelsFor: channelsFor.read,
+    byChannelTag,
+    register: (entry) => {
+      entries.add(entry)
+      snapshot.value = Option.none()
+      getOrCreate(byName, entry.name, () => new Set()).add(entry)
+      entry.handles.forEach((tag) => {
+        getOrCreate(byTag, tag, () => new Set()).add(entry)
+        getOrCreate(channelsByTag, tag, () => new Set()).add(entry.channelName)
+        channelsFor.invalidate(tag)
+        const channelMap = getOrCreate(byChannelTag, entry.channelName, () => new Map())
+        getOrCreate(channelMap, tag, () => new Set()).add(entry)
+      })
+    },
+    unregister: (entry) => {
+      entries.delete(entry)
+      snapshot.value = Option.none()
+      dropFrom(byName, entry.name, entry)
+      entry.handles.forEach((tag) => {
+        dropFrom(byTag, tag, entry)
+        const channelMap = byChannelTag.get(entry.channelName)
+        if (channelMap !== undefined) {
+          dropFrom(channelMap, tag, entry)
+          if (channelMap.get(tag) === undefined) {
+            dropFrom(channelsByTag, tag, entry.channelName)
+            channelsFor.invalidate(tag)
+          }
+          if (channelMap.size === 0) {
+            byChannelTag.delete(entry.channelName)
+          }
+        }
+      })
+    },
+  }
+}
+
+export const proceduresLayer: Layer.Layer<Procedures> = Layer.sync(
+  Procedures,
+  makeProcedureRegistry,
+)

package/src/compose/composition.ts

@@ -1,237 +1,55 @@
-import { Context, Effect, GlobalValue, Layer, MutableRef, Option, Schema, Scope } from 'effect'
-import type { AST } from 'effect/SchemaAST'
+import { Context, Effect, GlobalValue, Layer, MutableRef, Option, Schema } from 'effect'
 import type { YieldWrap } from 'effect/Utils'
-import { type Manifest, definitionClass } from '../definition/definition'
-import type { Tracker } from '../internal/track'
+import { definitionClass } from '../definition/definition'
 import { CurrentTracker } from '../internal/track'
-import { type PropsId, type PropsTag, propsTag } from './props'
-import type { AnySlot, AnySlotInstance, SlotClass, SlotInstance } from './slot'
-import type { Structure } from './structure'
-import type { UiClass, UiContract, UiReflection } from './ui'
+import { propsTag } from './props'
+import type { UiContract } from './ui'
+import type {
+  CompositionActivation,
+  CompositionActivationLayerInput,
+  CompositionCapture,
+  CompositionClass,
+  CompositionConfig,
+  CompositionDefinitionStatics,
+  CompositionId,
+  CompositionLayerInput,
+  CompositionManifest,
+  CompositionService,
+  ContextFreeProps,
+  ContractSlots,
+  EncodedPropsOf,
+  Frame,
+  GeneratorContext,
+  PropsOf,
+  RenderEnv,
+  RequiredSlotIdentities,
+  ScopedCompositionLiveConfig,
+  StatesOf,
+  UiCarrier,
+} from './compositionTypes'
+
+export { CompositionIdTypeId } from './compositionTypes'
+export type {
+  AnyComposition,
+  CompositionActivation,
+  CompositionCapture,
+  CompositionClass,
+  CompositionConfig,
+  CompositionId,
+  CompositionInstance,
+  CompositionManifest,
+  CompositionPropsReceiver,
+  CompositionReflection,
+  CompositionService,
+  CompositionTag,
+  Frame,
+  HasExactCompositionId,
+  RenderEnv,
+  RequiredSlotIdentities,
+  ScopedCompositionLiveConfig,
+  SlotClassesOf,
+} from './compositionTypes'
 
-export type Frame<C extends UiContract = UiContract> = Structure<C>
-
-export interface RenderEnv<out P = unknown> {
-  readonly props: P
-  readonly tracker: Tracker
-}
-
-export type CompositionActivation = Layer.Layer<never, never, never>
-
-export interface CompositionService<in out P = unknown, out C extends UiContract = UiContract> {
-  readonly render: (env: RenderEnv<P>) => Effect.Effect<Frame<C>, never, never>
-  readonly activation: (props: P) => Option.Option<CompositionActivation>
-}
-
-export const CompositionIdTypeId: unique symbol = Symbol.for('reform/CompositionId')
-export type CompositionIdTypeId = typeof CompositionIdTypeId
-
-export interface CompositionId<
-  out N extends string,
-  out Identity = unknown,
-  out RequiredSlots = unknown,
-> {
-  readonly [CompositionIdTypeId]: {
-    readonly name: N
-    readonly identity: Identity
-    readonly requiredSlots: RequiredSlots
-  }
-}
-
-type IsExact<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false
-
-type IsExactCompositionId<Service, N extends string, Identity> = Service extends {
-  readonly [CompositionIdTypeId]: {
-    readonly name: infer ServiceName extends string
-    readonly identity: infer ServiceIdentity
-  }
-}
-  ? IsExact<ServiceName, N> extends true
-    ? IsExact<ServiceIdentity, Identity>
-    : false
-  : false
-
-type IsAny<T> = 0 extends 1 & T ? true : false
-
-export type HasExactCompositionId<Services, N extends string, Identity> =
-  IsAny<Services> extends true
-    ? false
-    : true extends IsExactCompositionId<Services, N, Identity>
-      ? true
-      : false
-
-export type CompositionTag<
-  N extends string,
-  P,
-  C extends UiContract,
-  Identity = unknown,
-> = Context.Tag<CompositionId<N, Identity, RequiredSlotIdentities<C>>, CompositionService<P, C>>
-
-export type SlotClassesOf<C extends UiContract> = C extends {
-  readonly slots: infer Slots extends Record<string, AnySlotInstance>
-}
-  ? {
-      readonly [K in keyof Slots]: Slots[K] extends SlotInstance<
-        infer Child,
-        infer SlotName,
-        infer SlotIdentity
-      >
-        ? SlotClass<Child, SlotName, SlotIdentity>
-        : never
-    }
-  : Readonly<Record<PropertyKey, never>>
-
-type RequiredSlotIdentity<Slot> =
-  Slot extends SlotInstance<infer _Target, infer _Name, infer Identity> ? Identity : never
-
-export type RequiredSlotIdentities<C extends UiContract> = C extends {
-  readonly slots: infer Slots extends Record<string, AnySlotInstance>
-}
-  ? RequiredSlotIdentity<Slots[keyof Slots]>
-  : never
-
-type CompositionSlots<C extends UiContract> = C extends {
-  readonly slots: infer Slots extends Record<string, AnySlotInstance>
-}
-  ? [Slots[keyof Slots]] extends [never]
-    ? {}
-    : { readonly slots: SlotClassesOf<C> }
-  : {}
-
-export type CompositionManifest<
-  C extends UiContract = UiContract,
-  N extends string = string,
-> = Manifest &
-  Omit<CompositionConfig, 'slots' | 'ui'> &
-  CompositionSlots<C> & {
-    readonly kind: 'Composition'
-    readonly name: N
-    readonly ui: UiReflection<C>
-  }
-
-export interface CompositionInstance<out Identity = unknown> {
-  readonly _compositionIdentity: Identity
-}
-
-export interface CompositionReflection<
-  out P = unknown,
-  out C extends UiContract = UiContract,
-  out S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
-  out N extends string = string,
-  out Identity = unknown,
-> {
-  new (): CompositionInstance<Identity>
-  readonly manifest: CompositionManifest<C, N>
-  readonly Props: P
-  readonly Contract: C
-  readonly States: S
-  readonly parseProps: (input: unknown) => Option.Option<P>
-}
-
-export interface CompositionPropsReceiver<in P> {
-  readonly acceptsProps: (props: P) => void
-}
-
-export type CompositionCapture<Result> = <
-  P,
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  N extends string,
-  Identity,
->(
-  composition: CompositionClass<P, C, S, N, Identity>,
-) => Result
-
-export interface AnyComposition extends CompositionReflection {
-  readonly capture: <Result>(visit: CompositionCapture<Result>) => Result
-}
-
-interface CompositionSchema {
-  readonly ast: AST
-}
-
-type GeneratorContext<Eff> = [Eff] extends [never]
-  ? never
-  : [Eff] extends [YieldWrap<Effect.Effect<infer _Success, infer _Error, infer R>>]
-    ? R
-    : never
-
-// Property presence drives Config conditional inference; Option would erase it.
-interface CompositionConfigOptionalFields {
-  readonly description: string
-  readonly props: CompositionSchema
-  readonly states: ReadonlyArray<unknown>
-  readonly calcs: ReadonlyArray<unknown>
-  readonly events: ReadonlyArray<unknown>
-  readonly slots: Record<string, AnySlot>
-}
-
-export interface CompositionConfig extends Partial<CompositionConfigOptionalFields> {
-  readonly title: string
-  readonly ui: UiReflection
-}
-
-type PropsOf<Config> = Config extends { props: infer PropsSchema }
-  ? PropsSchema extends Schema.Schema<infer P, infer _Encoded, infer _Context>
-    ? P
-    : unknown
-  : unknown
-
-type EncodedPropsOf<Config> = Config extends { props: infer PropsSchema }
-  ? PropsSchema extends Schema.Schema<infer _Props, infer Encoded, infer _Context>
-    ? Encoded
-    : unknown
-  : unknown
-
-type StatesOf<Config> = Config extends {
-  states: infer S extends ReadonlyArray<unknown>
-}
-  ? S
-  : readonly []
-
-export interface CompositionClass<
-  in out P,
-  in out C extends UiContract = UiContract,
-  out S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
-  in out N extends string = string,
-  in out Identity = unknown,
->
-  extends CompositionReflection<P, C, S, N, Identity>, CompositionPropsReceiver<P> {
-  readonly Props: P
-  readonly Contract: C
-  readonly States: S
-  readonly identity: symbol
-  readonly props: PropsTag<P>
-  readonly tag: CompositionTag<N, P, C, Identity>
-  readonly capture: <Result>(visit: CompositionCapture<Result>) => Result
-}
-
-type CompositionDefinitionStatics<
-  P,
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  N extends string,
-  Identity,
-> = Pick<
-  CompositionClass<P, C, S, N, Identity>,
-  'manifest' | 'identity' | 'props' | 'parseProps' | 'acceptsProps' | 'tag' | 'capture'
->
-
-interface UiCarrier<C extends UiContract, UiName extends string> {
-  readonly ui: UiClass<C, UiName>
-}
-
-type ContractSlots<C extends UiContract> = CompositionSlots<C>
-
-type ContextFreeProps<Config> = Config extends {
-  readonly props: infer PropsSchema
-}
-  ? PropsSchema extends Schema.Schema<infer _P, infer _Encoded, infer Context>
-    ? [Context] extends [never]
-      ? unknown
-      : { readonly propsSchemaMustNotRequireServices: never }
-    : unknown
-  : unknown
 
 const compositionDefinitionSequence: MutableRef.MutableRef<number> = GlobalValue.globalValue(
   Symbol.for('reform/CompositionDefinitionSequence'),
@@ -282,21 +100,6 @@ export const make =
     return composition
   }
 
-type CompositionLayerInput<Eff> = Exclude<Exclude<GeneratorContext<Eff>, PropsId>, CurrentTracker>
-
-type CompositionActivationLayerInput<Eff> = Exclude<
-  Exclude<GeneratorContext<Eff>, PropsId>,
-  Scope.Scope
->
-
-export interface ScopedCompositionLiveConfig<
-  C extends UiContract,
-  RenderEff extends YieldWrap<Effect.Effect<unknown, never, unknown>>,
-  ActivationEff extends YieldWrap<Effect.Effect<unknown, never, unknown>>,
-> {
-  readonly render: () => Generator<RenderEff, Frame<C>, never>
-  readonly activate: () => Generator<ActivationEff, void, never>
-}
 
 export const live = <
   P,

package/src/compose/compositionTypes.ts

@@ -0,0 +1,249 @@
+import type { Context, Effect, Layer, Option, Schema, Scope } from 'effect'
+import type { AST } from 'effect/SchemaAST'
+import type { YieldWrap } from 'effect/Utils'
+import type { Manifest } from '../definition/definition'
+import type { Tracker } from '../internal/track'
+import type { CurrentTracker } from '../internal/track'
+import type { PropsId, PropsTag } from './props'
+import type { AnySlot, AnySlotInstance, SlotClass, SlotInstance } from './slot'
+import type { Structure } from './structure'
+import type { UiClass, UiContract, UiReflection } from './ui'
+
+export type Frame<C extends UiContract = UiContract> = Structure<C>
+
+export interface RenderEnv<out P = unknown> {
+  readonly props: P
+  readonly tracker: Tracker
+}
+
+export type CompositionActivation = Layer.Layer<never, never, never>
+
+export interface CompositionService<in out P = unknown, out C extends UiContract = UiContract> {
+  readonly render: (env: RenderEnv<P>) => Effect.Effect<Frame<C>, never, never>
+  readonly activation: (props: P) => Option.Option<CompositionActivation>
+}
+
+export const CompositionIdTypeId: unique symbol = Symbol.for('reform/CompositionId')
+export type CompositionIdTypeId = typeof CompositionIdTypeId
+
+export interface CompositionId<
+  out N extends string,
+  out Identity = unknown,
+  out RequiredSlots = unknown,
+> {
+  readonly [CompositionIdTypeId]: {
+    readonly name: N
+    readonly identity: Identity
+    readonly requiredSlots: RequiredSlots
+  }
+}
+
+export type IsExact<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false
+
+export type IsExactCompositionId<Service, N extends string, Identity> = Service extends {
+  readonly [CompositionIdTypeId]: {
+    readonly name: infer ServiceName extends string
+    readonly identity: infer ServiceIdentity
+  }
+}
+  ? IsExact<ServiceName, N> extends true
+    ? IsExact<ServiceIdentity, Identity>
+    : false
+  : false
+
+export type IsAny<T> = 0 extends 1 & T ? true : false
+
+export type HasExactCompositionId<Services, N extends string, Identity> =
+  IsAny<Services> extends true
+    ? false
+    : true extends IsExactCompositionId<Services, N, Identity>
+      ? true
+      : false
+
+export type CompositionTag<
+  N extends string,
+  P,
+  C extends UiContract,
+  Identity = unknown,
+> = Context.Tag<CompositionId<N, Identity, RequiredSlotIdentities<C>>, CompositionService<P, C>>
+
+export type SlotClassesOf<C extends UiContract> = C extends {
+  readonly slots: infer Slots extends Record<string, AnySlotInstance>
+}
+  ? {
+      readonly [K in keyof Slots]: Slots[K] extends SlotInstance<
+        infer Child,
+        infer SlotName,
+        infer SlotIdentity
+      >
+        ? SlotClass<Child, SlotName, SlotIdentity>
+        : never
+    }
+  : Readonly<Record<PropertyKey, never>>
+
+export type RequiredSlotIdentity<Slot> =
+  Slot extends SlotInstance<infer _Target, infer _Name, infer Identity> ? Identity : never
+
+export type RequiredSlotIdentities<C extends UiContract> = C extends {
+  readonly slots: infer Slots extends Record<string, AnySlotInstance>
+}
+  ? RequiredSlotIdentity<Slots[keyof Slots]>
+  : never
+
+export type CompositionSlots<C extends UiContract> = C extends {
+  readonly slots: infer Slots extends Record<string, AnySlotInstance>
+}
+  ? [Slots[keyof Slots]] extends [never]
+    ? {}
+    : { readonly slots: SlotClassesOf<C> }
+  : {}
+
+export type CompositionManifest<
+  C extends UiContract = UiContract,
+  N extends string = string,
+> = Manifest &
+  Omit<CompositionConfig, 'slots' | 'ui'> &
+  CompositionSlots<C> & {
+    readonly kind: 'Composition'
+    readonly name: N
+    readonly ui: UiReflection<C>
+  }
+
+export interface CompositionInstance<out Identity = unknown> {
+  readonly _compositionIdentity: Identity
+}
+
+export interface CompositionReflection<
+  out P = unknown,
+  out C extends UiContract = UiContract,
+  out S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
+  out N extends string = string,
+  out Identity = unknown,
+> {
+  new (): CompositionInstance<Identity>
+  readonly manifest: CompositionManifest<C, N>
+  readonly Props: P
+  readonly Contract: C
+  readonly States: S
+  readonly parseProps: (input: unknown) => Option.Option<P>
+}
+
+export interface CompositionPropsReceiver<in P> {
+  readonly acceptsProps: (props: P) => void
+}
+
+export type CompositionCapture<Result> = <
+  P,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+>(
+  composition: CompositionClass<P, C, S, N, Identity>,
+) => Result
+
+export interface AnyComposition extends CompositionReflection {
+  readonly capture: <Result>(visit: CompositionCapture<Result>) => Result
+}
+
+export interface CompositionSchema {
+  readonly ast: AST
+}
+
+export type GeneratorContext<Eff> = [Eff] extends [never]
+  ? never
+  : [Eff] extends [YieldWrap<Effect.Effect<infer _Success, infer _Error, infer R>>]
+    ? R
+    : never
+
+// Property presence drives Config conditional inference; Option would erase it.
+export interface CompositionConfigOptionalFields {
+  readonly description: string
+  readonly props: CompositionSchema
+  readonly states: ReadonlyArray<unknown>
+  readonly calcs: ReadonlyArray<unknown>
+  readonly events: ReadonlyArray<unknown>
+  readonly slots: Record<string, AnySlot>
+}
+
+export interface CompositionConfig extends Partial<CompositionConfigOptionalFields> {
+  readonly title: string
+  readonly ui: UiReflection
+}
+
+export type PropsOf<Config> = Config extends { props: infer PropsSchema }
+  ? PropsSchema extends Schema.Schema<infer P, infer _Encoded, infer _Context>
+    ? P
+    : unknown
+  : unknown
+
+export type EncodedPropsOf<Config> = Config extends { props: infer PropsSchema }
+  ? PropsSchema extends Schema.Schema<infer _Props, infer Encoded, infer _Context>
+    ? Encoded
+    : unknown
+  : unknown
+
+export type StatesOf<Config> = Config extends {
+  states: infer S extends ReadonlyArray<unknown>
+}
+  ? S
+  : readonly []
+
+export interface CompositionClass<
+  in out P,
+  in out C extends UiContract = UiContract,
+  out S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
+  in out N extends string = string,
+  in out Identity = unknown,
+>
+  extends CompositionReflection<P, C, S, N, Identity>, CompositionPropsReceiver<P> {
+  readonly Props: P
+  readonly Contract: C
+  readonly States: S
+  readonly identity: symbol
+  readonly props: PropsTag<P>
+  readonly tag: CompositionTag<N, P, C, Identity>
+  readonly capture: <Result>(visit: CompositionCapture<Result>) => Result
+}
+
+export type CompositionDefinitionStatics<
+  P,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+> = Pick<
+  CompositionClass<P, C, S, N, Identity>,
+  'manifest' | 'identity' | 'props' | 'parseProps' | 'acceptsProps' | 'tag' | 'capture'
+>
+
+export interface UiCarrier<C extends UiContract, UiName extends string> {
+  readonly ui: UiClass<C, UiName>
+}
+
+export type ContractSlots<C extends UiContract> = CompositionSlots<C>
+
+export type ContextFreeProps<Config> = Config extends {
+  readonly props: infer PropsSchema
+}
+  ? PropsSchema extends Schema.Schema<infer _P, infer _Encoded, infer Context>
+    ? [Context] extends [never]
+      ? unknown
+      : { readonly propsSchemaMustNotRequireServices: never }
+    : unknown
+  : unknown
+export type CompositionLayerInput<Eff> = Exclude<Exclude<GeneratorContext<Eff>, PropsId>, CurrentTracker>
+
+export type CompositionActivationLayerInput<Eff> = Exclude<
+  Exclude<GeneratorContext<Eff>, PropsId>,
+  Scope.Scope
+>
+
+export interface ScopedCompositionLiveConfig<
+  C extends UiContract,
+  RenderEff extends YieldWrap<Effect.Effect<unknown, never, unknown>>,
+  ActivationEff extends YieldWrap<Effect.Effect<unknown, never, unknown>>,
+> {
+  readonly render: () => Generator<RenderEff, Frame<C>, never>
+  readonly activate: () => Generator<ActivationEff, void, never>
+}