@playfast/reform 1.1.1 → 1.2.0

package/src/calc/calcFamily.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, MutableRef } from 'effect'
+import { Context, Effect, Layer, MutableRef, type Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import {
   type InputsObject,
@@ -9,45 +9,70 @@ import {
 } from '../internal/sources'
 import { resolveScheduler } from '../internal/scheduler'
 import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentation'
+import { reuse } from '../internal/reuse'
 import { makeDerivedStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
 import { type FamilyOptions, type FamilyStore } from '../state/stateFamily'
 import { type AnySource } from '../state/token'
-import type { AnySchema } from '../internal/variance'
 
-export interface CalcFamilyManifest<N extends string, K, Out> extends Manifest {
+export interface CalcFamilySchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface CalcFamilyManifest<N extends string> extends Manifest {
   readonly kind: 'CalcFamily'
   readonly name: N
-  readonly key: AnySchema<K>
-  readonly output: AnySchema<Out>
+  readonly key: CalcFamilySchemaReflection
+  readonly output: CalcFamilySchemaReflection
+}
+
+export const CalcFamilyStoreTypeId: unique symbol = Symbol.for('reform/CalcFamilyStore')
+export type CalcFamilyStoreTypeId = typeof CalcFamilyStoreTypeId
+
+export interface CalcFamilyStore<N extends string, in out K, in out Out> extends FamilyStore<
+  K,
+  Out
+> {
+  readonly [CalcFamilyStoreTypeId]: N
 }
 
 export interface CalcFamilyClass<
-  out N extends string,
-  out Inputs extends ReadonlyArray<AnySource>,
-  in out K,
-  in out Out,
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  K,
+  Out,
 > {
   new (): { readonly Key: K }
-  readonly manifest: CalcFamilyManifest<N, K, Out>
-  readonly store: Context.Tag<FamilyStore<K, Out>, FamilyStore<K, Out>>
+  readonly manifest: CalcFamilyManifest<N>
+  readonly store: Context.Tag<CalcFamilyStore<N, K, Out>, FamilyStore<K, Out>>
   readonly inputs: Inputs
 }
 
-export interface CalcFamilyConfig<Inputs extends ReadonlyArray<AnySource>, K, Out> {
-  readonly key: AnySchema<K>
+export interface CalcFamilyConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  KeySchema extends Schema.Schema.AnyNoContext,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+> {
+  readonly key: KeySchema
   readonly inputs: Inputs
-  readonly output: AnySchema<Out>
+  readonly output: OutputSchema
 }
 
-export const make = <const N extends string, const Inputs extends ReadonlyArray<AnySource>, K, Out>(
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  KeySchema extends Schema.Schema.AnyNoContext,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+>(
   name: N,
-  config: CalcFamilyConfig<Inputs, K, Out>,
-): CalcFamilyClass<N, Inputs, K, Out> => {
-  const store = Context.GenericTag<FamilyStore<K, Out>, FamilyStore<K, Out>>(
+  config: CalcFamilyConfig<Inputs, KeySchema, OutputSchema>,
+): CalcFamilyClass<N, Inputs, Schema.Schema.Type<KeySchema>, Schema.Schema.Type<OutputSchema>> => {
+  type K = Schema.Schema.Type<KeySchema>
+  type Out = Schema.Schema.Type<OutputSchema>
+  const store = Context.GenericTag<CalcFamilyStore<N, K, Out>, FamilyStore<K, Out>>(
     `reform/calcFamily/${name}`,
   )
-  const manifest: CalcFamilyManifest<N, K, Out> = {
+  const manifest: CalcFamilyManifest<N> = {
     kind: 'CalcFamily',
     name,
     key: config.key,
@@ -63,19 +88,21 @@ export const make = <const N extends string, const Inputs extends ReadonlyArray<
 export const read = <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(
   family: CalcFamilyClass<N, Inputs, K, Out>,
   key: K,
-): Effect.Effect<Out, never, FamilyStore<K, Out>> =>
+): Effect.Effect<Out, never, CalcFamilyStore<N, K, Out>> =>
   Effect.flatMap(family.store, (familyStore) => readTracked(familyStore.at(key)))
 
-export interface CalcFamilyLiveOptionsExternalApi<Inputs extends ReadonlyArray<AnySource>>
-  extends FamilyOptions {
+export interface CalcFamilyLiveOptionsExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+> extends FamilyOptions {
   readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly reuse?: boolean
 }
 
 export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>, K, Out>(
   family: CalcFamilyClass<N, Inputs, K, Out>,
   compute: (key: K) => (inputs: InputsObject<Inputs>) => Out,
   options: CalcFamilyLiveOptionsExternalApi<Inputs> = {},
-): Layer.Layer<FamilyStore<K, Out>, never, InputStores<Inputs>> =>
+): Layer.Layer<CalcFamilyStore<N, K, Out>, never, InputStores<Inputs>> =>
   Layer.scoped(
     family.store,
     Effect.gen(function* () {
@@ -96,7 +123,9 @@ export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>,
         subscribers.delete(key)
       }
 
-      const createMember = (key: K): { readonly store: Store<Out>; readonly unsubscribe: () => void } => {
+      const createMember = (
+        key: K,
+      ): { readonly store: Store<Out>; readonly unsubscribe: () => void } => {
         const body = compute(key)
         const memo = MutableRef.make<
           { readonly key: ReadonlyArray<unknown>; readonly output: Out } | undefined
@@ -109,7 +138,9 @@ export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>,
             return prev.output
           }
           const end = instrumentation.calcRecomputed(family.manifest.name)
-          const output = body(args)
+          const fresh = body(args)
+          const output =
+            options.reuse === true && prev !== undefined ? reuse(prev.output, fresh) : fresh
           end()
           MutableRef.set(memo, { key: memoKey, output })
           return output

package/src/calc/compose.ts

@@ -13,20 +13,7 @@ export function composeCalcs<LOut, LErr, LIn, AOut, AErr, AIn, BOut, BErr, BIn>(
   LErr | AErr | BErr,
   BIn | Exclude<AIn | Exclude<LIn, AOut>, BOut>
 >
-export function composeCalcs<
-  LOut,
-  LErr,
-  LIn,
-  AOut,
-  AErr,
-  AIn,
-  BOut,
-  BErr,
-  BIn,
-  COut,
-  CErr,
-  CIn,
->(
+export function composeCalcs<LOut, LErr, LIn, AOut, AErr, AIn, BOut, BErr, BIn, COut, CErr, CIn>(
   leaf: Layer.Layer<LOut, LErr, LIn>,
   upstream1: Layer.Layer<AOut, AErr, AIn>,
   upstream2: Layer.Layer<BOut, BErr, BIn>,

package/src/channel/channel.ts

@@ -1,14 +1,20 @@
-import { Chunk, Context, Duration, Effect, Exit, Layer, Match, Option, Queue, Scope, Stream } from 'effect'
+import {
+  Chunk,
+  Context,
+  Duration,
+  Effect,
+  Exit,
+  Layer,
+  Match,
+  Option,
+  Queue,
+  Scope,
+  Stream,
+} from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
+import { makeBucketCache } from '../internal/bucketCache'
 import type { Tagged } from '../runtime/bus'
 import { resolveInstrumentation } from '../runtime/instrumentation'
-import { type ProcedureEntry, Procedures } from './procedureRegistry'
-export {
-  type ProcedureEntry,
-  type ProcedureRegistry,
-  Procedures,
-  proceduresLayer,
-} from './procedureRegistry'
 
 export type ChannelPolicy =
   | { readonly _tag: 'merge' }
@@ -38,6 +44,111 @@ export interface ChannelConfig {
   readonly policy: ChannelPolicy
 }
 
+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,
+)
+
 export interface ChannelRuntime {
   readonly name: string
   readonly policy: ChannelPolicy
@@ -53,7 +164,9 @@ const ChannelsBase: Context.TagClass<
 > = Context.Tag('reform/Channels')<Channels, { readonly byName: Map<string, ChannelRuntime> }>()
 export class Channels extends ChannelsBase {}
 
-export const channelsLayer: Layer.Layer<Channels> = Layer.sync(Channels, () => ({ byName: new Map() }))
+export const channelsLayer: Layer.Layer<Channels> = Layer.sync(Channels, () => ({
+  byName: new Map(),
+}))
 
 export const make = (name: string, config: ChannelConfig): ChannelClass =>
   definitionClass<ChannelClass>({
@@ -155,9 +268,13 @@ export const live = (channel: ChannelClass): Layer.Layer<never, never, Channels
 
       const events = Stream.fromQueue(queue)
       const driven: Stream.Stream<unknown> = Match.value(channel.policy).pipe(
-        Match.tag('merge', () => Stream.mapEffect(events, runMatching, { concurrency: 'unbounded' })),
+        Match.tag('merge', () =>
+          Stream.mapEffect(events, runMatching, { concurrency: 'unbounded' }),
+        ),
         Match.tag('latest', () =>
-          Stream.flatMap(events, (event) => Stream.fromEffect(runMatching(event)), { switch: true }),
+          Stream.flatMap(events, (event) => Stream.fromEffect(runMatching(event)), {
+            switch: true,
+          }),
         ),
         Match.tag('debounce', (policy) =>
           events.pipe(

package/src/compose/composition.test.ts

@@ -0,0 +1,19 @@
+import { Option, Schema } from 'effect'
+import { expect, it } from '@effect/vitest'
+import { make } from './composition'
+import { ui } from './ui'
+
+class ItemUi extends ui('composition.parser.ItemUi')<{
+  props: { readonly label: string }
+}>() {}
+
+class Item extends make('composition.parser.Item', {
+  title: 'Item',
+  props: Schema.Struct({ label: Schema.String }),
+  ui: ItemUi,
+})<Item>() {}
+
+it('validates reflected props against the composition schema', () => {
+  expect(Item.parseProps({ label: 'ready' })).toEqual(Option.some({ label: 'ready' }))
+  expect(Option.isNone(Item.parseProps({ label: 1 }))).toBe(true)
+})