brustjs 0.1.19-alpha → 0.1.21-alpha

package/runtime/store/signal.ts

@@ -0,0 +1,152 @@
+// Minimal pull-based reactive core: push-on-write, pull-on-read, synchronous notify.
+// Framework-agnostic — no react, no dom. Foundation for defineStore (Spec A) and
+// the Alpine-style client runtime (Spec B).
+
+// Symbol.for (GLOBAL registry), NOT Symbol(): every island is a SEPARATE Bun.build
+// chunk that inlines its own copy of this module, so a plain `Symbol()` brand would
+// be a DIFFERENT value per chunk — `isSignal` from chunk B then fails to recognize a
+// signal created in chunk A. That poisons the shared store snapshot (a cross-chunk
+// reader computes `{}` and caches it), so e.g. the team dock reads empty after a SPA
+// nav loads a new island chunk. A global registry symbol is identical across chunks.
+const SIGNAL = Symbol.for('brust.signal')
+const COMPUTED = Symbol.for('brust.computed')
+
+export interface Signal<T> {
+  (): T
+  set(next: T | ((prev: T) => T)): void
+  readonly [SIGNAL]: true
+}
+export interface Computed<T> {
+  (): T
+  readonly [COMPUTED]: true
+}
+
+export function isSignal(v: unknown): v is Signal<unknown> {
+  return typeof v === 'function' && (v as { [SIGNAL]?: true })[SIGNAL] === true
+}
+export function isComputed(v: unknown): v is Computed<unknown> {
+  return typeof v === 'function' && (v as { [COMPUTED]?: true })[COMPUTED] === true
+}
+
+// A reactive consumer (effect or computed) tracking its dependencies.
+interface Consumer {
+  run(): void
+  deps: Set<Set<Consumer>>
+  running: boolean
+}
+
+let activeConsumer: Consumer | null = null
+let batchDepth = 0
+const pendingNotify = new Set<Consumer>()
+
+function track(subscribers: Set<Consumer>): void {
+  if (activeConsumer) {
+    subscribers.add(activeConsumer)
+    activeConsumer.deps.add(subscribers)
+  }
+}
+
+function notify(subscribers: Set<Consumer>): void {
+  // Snapshot — a consumer re-running mutates the set.
+  for (const c of [...subscribers]) {
+    if (batchDepth > 0) pendingNotify.add(c)
+    else c.run()
+  }
+}
+
+function flush(): void {
+  const queued = [...pendingNotify]
+  pendingNotify.clear()
+  for (const c of queued) c.run()
+}
+
+export function batch(fn: () => void): void {
+  batchDepth++
+  try {
+    fn()
+  } finally {
+    batchDepth--
+    if (batchDepth === 0) flush()
+  }
+}
+
+export function signal<T>(initial: T): Signal<T> {
+  let value = initial
+  const subscribers = new Set<Consumer>()
+  const read = (() => {
+    track(subscribers)
+    return value
+  }) as Signal<T>
+  read.set = (next: T | ((prev: T) => T)) => {
+    const v = typeof next === 'function' ? (next as (p: T) => T)(value) : next
+    if (Object.is(v, value)) return
+    value = v
+    notify(subscribers)
+  }
+  Object.defineProperty(read, SIGNAL, { value: true })
+  return read
+}
+
+function clearDeps(c: Consumer): void {
+  for (const dep of c.deps) dep.delete(c)
+  c.deps.clear()
+}
+
+export function computed<T>(fn: () => T): Computed<T> {
+  let cached: T
+  let dirty = true
+  const subscribers = new Set<Consumer>()
+  const self: Consumer = {
+    deps: new Set(),
+    running: false,
+    run() {
+      if (self.running) return
+      self.running = true
+      try {
+        dirty = true
+        notify(subscribers) // downstream recomputes lazily on next read
+      } finally {
+        self.running = false
+      }
+    },
+  }
+  const read = (() => {
+    track(subscribers)
+    if (dirty) {
+      clearDeps(self)
+      const prev = activeConsumer
+      activeConsumer = self
+      try {
+        cached = fn()
+        dirty = false
+      } finally {
+        activeConsumer = prev
+      }
+    }
+    return cached
+  }) as Computed<T>
+  Object.defineProperty(read, COMPUTED, { value: true })
+  return read
+}
+
+export function effect(fn: () => void): () => void {
+  const self: Consumer = {
+    deps: new Set(),
+    running: false,
+    run() {
+      if (self.running) return
+      self.running = true
+      clearDeps(self)
+      const prev = activeConsumer
+      activeConsumer = self
+      try {
+        fn()
+      } finally {
+        activeConsumer = prev
+        self.running = false
+      }
+    },
+  }
+  self.run()
+  return () => clearDeps(self)
+}

package/example/pokedex/components/team-bus.ts

@@ -1,25 +0,0 @@
-// Cross-island sync bus.
-//
-// GAP S4: brust has no cross-island shared-state primitive. AddToTeamButton and
-// TeamBuilder are two SEPARATE island chunks (each its own Bun.build bundle), so
-// a module-scope store imported by both would be DUPLICATED — two instances that
-// never see each other. The one thing both chunks genuinely share is the
-// `window` object, so we coordinate through a window CustomEvent. This works,
-// but it's a hand-rolled workaround for a pattern (cart / team / selection) that
-// most apps need. See ../FRAMEWORK-GAPS.md S4.
-
-import type { TeamMember } from '../lib/types'
-
-export const TEAM_EVENT = 'brust-pokedex:team'
-
-export function emitTeam(team: TeamMember[]): void {
-  if (typeof window === 'undefined') return
-  window.dispatchEvent(new CustomEvent<TeamMember[]>(TEAM_EVENT, { detail: team }))
-}
-
-export function onTeam(fn: (team: TeamMember[]) => void): () => void {
-  if (typeof window === 'undefined') return () => {}
-  const handler = (e: Event) => fn((e as CustomEvent<TeamMember[]>).detail)
-  window.addEventListener(TEAM_EVENT, handler)
-  return () => window.removeEventListener(TEAM_EVENT, handler)
-}