The best way to control Claude Code, Codex and more from any computer or phone

main
ts 115 lines 3.67 KB
Raw
1 import * as BrowserWorkerRunner from "@effect/platform-browser/BrowserWorkerRunner"
2 import { assert, describe, it } from "@effect/vitest"
3 import * as Effect from "effect/Effect"
4 import * as Fiber from "effect/Fiber"
5 import * as Queue from "effect/Queue"
6
7 type Listener = EventListenerOrEventListenerObject
8
9 const makePort = () => {
10 const listeners = new Map<string, Set<Listener>>()
11 const added: Array<readonly [string, Listener]> = []
12 const removed: Array<readonly [string, Listener]> = []
13 const port = {
14 addEventListener(type: string, listener: Listener | null) {
15 if (listener === null) return
16 added.push([type, listener])
17 const eventListeners = listeners.get(type) ?? new Set()
18 eventListeners.add(listener)
19 listeners.set(type, eventListeners)
20 },
21 removeEventListener(type: string, listener: Listener | null) {
22 if (listener === null) return
23 removed.push([type, listener])
24 listeners.get(type)?.delete(listener)
25 },
26 postMessage() {},
27 start() {},
28 close() {}
29 } as unknown as MessagePort
30
31 return {
32 added,
33 removed,
34 port,
35 emit(type: string, data: unknown) {
36 const event = type === "error" ? new ErrorEvent(type, { error: data }) : { data } as MessageEvent
37 for (const listener of listeners.get(type) ?? []) {
38 if (typeof listener === "function") {
39 listener(event)
40 } else {
41 listener.handleEvent(event)
42 }
43 }
44 }
45 }
46 }
47
48 const makeSharedWorker = () => {
49 const worker = {
50 onconnect: null as ((event: MessageEvent) => void) | null,
51 addEventListener() {},
52 removeEventListener() {},
53 close() {}
54 }
55 return {
56 worker: worker as unknown as Window,
57 connect(port: MessagePort) {
58 worker.onconnect?.({ ports: [port] } as unknown as MessageEvent)
59 }
60 }
61 }
62
63 describe("BrowserWorkerRunner", () => {
64 it.effect("preserves the cause from an error event", () =>
65 Effect.gen(function*() {
66 const fake = makePort()
67 const cause = new Error("worker failed")
68 const runner = yield* BrowserWorkerRunner.make(fake.port).start()
69 const fiber = yield* Effect.forkChild(runner.run<void, never, never>(() => {}))
70 yield* Effect.yieldNow
71
72 fake.emit("error", cause)
73 const error = yield* Effect.flip(Fiber.join(fiber))
74
75 assert.strictEqual(error.reason.cause, cause)
76 }))
77
78 it.effect("removes the registered messageerror listener", () =>
79 Effect.gen(function*() {
80 const fake = makePort()
81 const runner = yield* BrowserWorkerRunner.make(fake.port).start()
82 const fiber = yield* Effect.forkChild(runner.run<void, never, never>(() => {}))
83 yield* Effect.yieldNow
84
85 fake.emit("message", [1])
86 yield* Fiber.join(fiber)
87
88 const added = fake.added.find(([type]) => type === "messageerror")
89 const removed = fake.removed.find(([type]) => type === "messageerror")
90 assert.isDefined(added)
91 assert.isDefined(removed)
92 assert.strictEqual(removed[1], added[1])
93 }))
94
95 it.effect("emits disconnects for closed SharedWorker ports", () =>
96 Effect.gen(function*() {
97 const sharedWorker = makeSharedWorker()
98 const first = makePort()
99 const second = makePort()
100 const runner = yield* BrowserWorkerRunner.make(sharedWorker.worker).start()
101 const fiber = yield* Effect.forkChild(runner.run<void, never, never>(() => {}))
102 yield* Effect.yieldNow
103
104 sharedWorker.connect(first.port)
105 sharedWorker.connect(second.port)
106 first.emit("message", [1])
107
108 const disconnects = runner.disconnects
109 assert.isDefined(disconnects)
110 assert.strictEqual(yield* Queue.take(disconnects), 0)
111
112 second.emit("message", [1])
113 yield* Fiber.join(fiber)
114 }))
115 })