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

main
ts 101 lines 3.04 KB
Raw
1 /**
2 * Parent-side browser platform for Effect workers.
3 *
4 * `layerPlatform` provides the `WorkerPlatform` used to communicate with a
5 * browser `Worker`, `SharedWorker`, or `MessagePort` through Effect's worker
6 * protocol. `layer` combines that platform with a `Spawner` built from a
7 * callback that creates or returns the worker endpoint for each worker id.
8 *
9 * @stability unstable
10 * @since 4.0.0
11 */
12 import * as Deferred from "effect/Deferred"
13 import * as Effect from "effect/Effect"
14 import * as Layer from "effect/Layer"
15 import * as Scope from "effect/Scope"
16 import * as Worker from "effect/workers/Worker"
17 import { WorkerError, WorkerReceiveError } from "effect/workers/WorkerError"
18
19 /**
20 * Creates browser worker layers by combining the default `WorkerPlatform` with a spawner for `Worker`, `SharedWorker`, or `MessagePort` instances.
21 *
22 * **When to use**
23 *
24 * Use when you need both the browser `WorkerPlatform` and a `Spawner` from one
25 * layer.
26 *
27 * **Details**
28 *
29 * The `spawn` callback receives the numeric worker id and may return a
30 * `Worker`, `SharedWorker`, or `MessagePort`.
31 *
32 * **Gotchas**
33 *
34 * Scope finalization sends the worker close protocol over the port. Dedicated
35 * workers created by `spawn` are not terminated by this layer.
36 *
37 * @see {@link layerPlatform} for providing only the browser worker platform
38 *
39 * @stability unstable
40 * @category layers
41 * @since 4.0.0
42 */
43 export const layer = (
44 spawn: (id: number) => Worker | SharedWorker | MessagePort
45 ): Layer.Layer<Worker.WorkerPlatform | Worker.Spawner> =>
46 Layer.merge(
47 layerPlatform,
48 Worker.layerSpawner(spawn)
49 )
50
51 /**
52 * Layer that provides the browser `WorkerPlatform` for `Worker`, `SharedWorker`, and `MessagePort` communication.
53 *
54 * @stability unstable
55 * @category layers
56 * @since 4.0.0
57 */
58 export const layerPlatform: Layer.Layer<Worker.WorkerPlatform> = Layer.succeed(Worker.WorkerPlatform)(
59 Worker.makePlatform<globalThis.SharedWorker | globalThis.Worker | MessagePort>()({
60 setup({ scope, worker }) {
61 const port = "port" in worker ? worker.port : worker
62 return Effect.as(
63 Scope.addFinalizer(
64 scope,
65 Effect.sync(() => {
66 port.postMessage([1])
67 })
68 ),
69 port
70 )
71 },
72 listen({ deferred, emit, port, scope }) {
73 function onMessage(event: MessageEvent) {
74 emit(event.data)
75 }
76 function onError(event: ErrorEvent) {
77 Deferred.doneUnsafe(
78 deferred,
79 new WorkerError({
80 reason: new WorkerReceiveError({
81 message: "An error event was emitter",
82 cause: event.error ?? event.message
83 })
84 })
85 )
86 }
87 port.addEventListener("message", onMessage as any)
88 port.addEventListener("error", onError as any)
89 if ("start" in port) {
90 port.start()
91 }
92 return Scope.addFinalizer(
93 scope,
94 Effect.sync(() => {
95 port.removeEventListener("message", onMessage as any)
96 port.removeEventListener("error", onError as any)
97 })
98 )
99 }
100 })
101 )