@effect/platform-bun 0.87.0 → 4.0.0-beta.0

package/src/internal/workerRunner.ts

@@ -1,87 +0,0 @@
-import { WorkerError } from "@effect/platform/WorkerError"
-import * as Runner from "@effect/platform/WorkerRunner"
-import * as Cause from "effect/Cause"
-import * as Context from "effect/Context"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FiberSet from "effect/FiberSet"
-import * as Layer from "effect/Layer"
-import * as Runtime from "effect/Runtime"
-import * as Scope from "effect/Scope"
-
-declare const self: MessagePort
-
-const platformRunnerImpl = Runner.PlatformRunner.of({
-  [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
-  start: Effect.fnUntraced(function*(closeLatch: Deferred.Deferred<void, WorkerError>) {
-    if (!("postMessage" in self)) {
-      return yield* new WorkerError({ reason: "spawn", cause: new Error("not in a Worker context") })
-    }
-    const port = self
-    const run = Effect.fnUntraced(function*<A, E, R>(
-      handler: (portId: number, message: any) => Effect.Effect<A, E, R> | void
-    ) {
-      const scope = yield* Effect.scope
-      const runtime = (yield* Effect.runtime<R | Scope.Scope>().pipe(
-        Effect.interruptible
-      )).pipe(
-        Runtime.updateContext(Context.omit(Scope.Scope))
-      ) as Runtime.Runtime<R>
-      const fiberSet = yield* FiberSet.make<any, WorkerError | E>()
-      const runFork = Runtime.runFork(runtime)
-      const onExit = (exit: Exit.Exit<any, E>) => {
-        if (exit._tag === "Failure" && !Cause.isInterruptedOnly(exit.cause)) {
-          Deferred.unsafeDone(closeLatch, Exit.die(Cause.squash(exit.cause)))
-        }
-      }
-
-      function onMessage(event: MessageEvent) {
-        const message = (event as MessageEvent).data as Runner.BackingRunner.Message<any>
-        if (message[0] === 0) {
-          const result = handler(0, message[1])
-          if (Effect.isEffect(result)) {
-            const fiber = runFork(result)
-            fiber.addObserver(onExit)
-            FiberSet.unsafeAdd(fiberSet, fiber)
-          }
-        } else {
-          port.close()
-          Deferred.unsafeDone(closeLatch, Exit.void)
-        }
-      }
-      function onMessageError(error: MessageEvent) {
-        Deferred.unsafeDone(
-          closeLatch,
-          new WorkerError({ reason: "decode", cause: error.data })
-        )
-      }
-      function onError(error: MessageEvent) {
-        Deferred.unsafeDone(
-          closeLatch,
-          new WorkerError({ reason: "unknown", cause: error.data })
-        )
-      }
-      yield* Scope.addFinalizer(
-        scope,
-        Effect.sync(() => {
-          port.removeEventListener("message", onMessage)
-          port.removeEventListener("messageerror", onError)
-        })
-      )
-      port.addEventListener("message", onMessage)
-      port.addEventListener("messageerror", onMessageError)
-      port.postMessage([0])
-    })
-    const send = (_portId: number, message: any, transfer?: ReadonlyArray<unknown>) =>
-      Effect.sync(() =>
-        port.postMessage([1, message], {
-          transfer: transfer as any
-        })
-      )
-    return { run, send }
-  })
-})
-
-/** @internal */
-export const layer = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)