@effect/platform-browser 0.74.0 → 4.0.0-beta.1

package/src/BrowserWorkerRunner.ts

@@ -1,33 +1,166 @@
 /**
  * @since 1.0.0
  */
-import type * as Runner from "@effect/platform/WorkerRunner"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/workerRunner.js"
-
-export {
-  /**
-   * @since 1.0.0
-   * @category re-exports
-   */
-  launch
-} from "@effect/platform/WorkerRunner"
+import * as Cause from "effect/Cause"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import { identity } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import * as Scope from "effect/Scope"
+import { WorkerError, WorkerReceiveError } from "effect/unstable/workers/WorkerError"
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner"
+
+const cachedPorts = new Set<MessagePort>()
+function globalHandleConnect(event: MessageEvent) {
+  cachedPorts.add((event as MessageEvent).ports[0])
+}
+if (typeof self !== "undefined" && "onconnect" in self) {
+  self.onconnect = globalHandleConnect
+}
 
 /**
  * @since 1.0.0
- * @category constructors
+ * @category Constructors
  */
-export const make: (self: MessagePort | Window) => Runner.PlatformRunner = internal.make
+export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatform["Service"] => ({
+  start: Effect.fnUntraced(function*<O = unknown, I = unknown>() {
+    const disconnects = yield* Queue.make<number>()
+    let currentPortId = 0
+
+    const ports = new Map<number, readonly [MessagePort, Scope.Closeable]>()
+    const sendUnsafe = (portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
+      (ports.get(portId)?.[0] ?? self).postMessage([1, message], {
+        transfer: transfer as any
+      })
+    const send = (portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
+      Effect.sync(() => sendUnsafe(portId, message, transfer))
+
+    const run = <A, E, R>(
+      handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void
+    ) =>
+      Effect.scopedWith(Effect.fnUntraced(function*(scope) {
+        const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
+        const trackFiber = Fiber.runIn(scope)
+        const services = yield* Effect.services<R>()
+        const runFork = Effect.runForkWith(services)
+        const onExit = (exit: Exit.Exit<any, E>) => {
+          if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+            runFork(Effect.logError("unhandled error in worker", exit.cause))
+          }
+        }
+
+        function onMessage(portId: number) {
+          return function(event: MessageEvent) {
+            const message = event.data as WorkerRunner.PlatformMessage<I>
+            if (message[0] === 0) {
+              const result = handler(portId, message[1])
+              if (Effect.isEffect(result)) {
+                const fiber = runFork(result)
+                fiber.addObserver(onExit)
+                trackFiber(fiber)
+              }
+            } else {
+              const port = ports.get(portId)
+              if (!port) {
+                return
+              } else if (ports.size === 1) {
+                // let the last port close with the outer scope
+                return Deferred.doneUnsafe(closeLatch, Exit.void)
+              }
+              ports.delete(portId)
+              Effect.runFork(Scope.close(port[1], Exit.void))
+            }
+          }
+        }
+        function onMessageError(error: MessageEvent) {
+          Deferred.doneUnsafe(
+            closeLatch,
+            new WorkerError({
+              reason: new WorkerReceiveError({
+                message: "An messageerror event was emitted",
+                cause: error.data
+              })
+            }).asEffect()
+          )
+        }
+        function onError(error: any) {
+          Deferred.doneUnsafe(
+            closeLatch,
+            new WorkerError({
+              reason: new WorkerReceiveError({
+                message: "An error event was emitted",
+                cause: error.data
+              })
+            }).asEffect()
+          )
+        }
+        function handlePort(port: MessagePort) {
+          const portScope = Scope.forkUnsafe(scope)
+          const portId = currentPortId++
+          ports.set(portId, [port, portScope])
+          const onMsg = onMessage(portId)
+          port.addEventListener("message", onMsg)
+          port.addEventListener("messageerror", onMessageError)
+          if ("start" in port) {
+            port.start()
+          }
+          port.postMessage([0])
+          Effect.runSync(Scope.addFinalizer(
+            portScope,
+            Effect.sync(() => {
+              port.removeEventListener("message", onMsg)
+              port.removeEventListener("messageerror", onError)
+              port.close()
+            })
+          ))
+        }
+        self.addEventListener("error", onError)
+        let prevOnConnect: unknown | undefined
+        if ("onconnect" in self) {
+          prevOnConnect = self.onconnect
+          self.onconnect = function(event: MessageEvent) {
+            const port = (event as MessageEvent).ports[0]
+            handlePort(port)
+          }
+          for (const port of cachedPorts) {
+            handlePort(port)
+          }
+          cachedPorts.clear()
+        } else {
+          handlePort(self as any)
+        }
+        yield* Scope.addFinalizer(
+          scope,
+          Effect.sync(() => {
+            self.removeEventListener("error", onError)
+            if ("onconnect" in self) {
+              self.close()
+              self.onconnect = prevOnConnect
+            }
+          })
+        )
+
+        yield* Deferred.await(closeLatch)
+      }))
+
+    return identity<WorkerRunner.WorkerRunner<O, I>>({ run, send, sendUnsafe, disconnects })
+  }) as any
+})
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
-export const layer: Layer.Layer<Runner.PlatformRunner> = internal.layer
+export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.sync(WorkerRunner.WorkerRunnerPlatform)(() =>
+  make(self)
+)
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
-export const layerMessagePort: (port: MessagePort | Window) => Layer.Layer<Runner.PlatformRunner> =
-  internal.layerMessagePort
+export const layerMessagePort = (port: MessagePort | Window): Layer.Layer<WorkerRunner.WorkerRunnerPlatform> =>
+  Layer.succeed(WorkerRunner.WorkerRunnerPlatform)(make(port))

package/src/Clipboard.ts

@@ -1,30 +1,20 @@
 /**
  * @since 1.0.0
  */
-import { TypeIdError } from "@effect/platform/Error"
-import * as Context from "effect/Context"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as ServiceMap from "effect/ServiceMap"
 
-/**
- * @since 1.0.0
- * @category type ids
- */
-export const TypeId: unique symbol = Symbol.for("@effect/platform-browser/Clipboard")
+const TypeId = "~@effect/platform-browser/Clipboard"
+const ErrorTypeId = "~@effect/platform-browser/Clipboard/ClipboardError"
 
 /**
  * @since 1.0.0
- * @category type ids
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 1.0.0
- * @category interface
+ * @category Models
  */
 export interface Clipboard {
-  readonly [TypeId]: TypeId
-
+  readonly [TypeId]: typeof TypeId
   readonly read: Effect.Effect<ClipboardItems, ClipboardError>
   readonly readString: Effect.Effect<string, ClipboardError>
   readonly write: (items: ClipboardItems) => Effect.Effect<void, ClipboardError>
@@ -35,39 +25,27 @@ export interface Clipboard {
 
 /**
  * @since 1.0.0
- * @category type ids
- */
-export const ErrorTypeId: unique symbol = Symbol.for("@effect/platform-browser/Clipboard/ClipboardError")
-
-/**
- * @since 1.0.0
- * @category type ids
+ * @category Errors
  */
-export type ErrorTypeId = typeof ErrorTypeId
-
-/**
- * @since 1.0.0
- * @category errors
- */
-export class ClipboardError extends TypeIdError(ErrorTypeId, "ClipboardError")<{
+export class ClipboardError extends Data.TaggedError("ClipboardError")<{
   readonly message: string
   readonly cause: unknown
-}> {}
+}> {
+  readonly [ErrorTypeId] = ErrorTypeId
+}
 
 /**
  * @since 1.0.0
- * @category tag
+ * @category Service
  */
-export const Clipboard: Context.Tag<Clipboard, Clipboard> = Context.GenericTag<Clipboard>(
-  "@effect/platform-browser/Clipboard"
-)
+export const Clipboard: ServiceMap.Service<Clipboard, Clipboard> = ServiceMap.Service<Clipboard>(TypeId)
 
 /**
  * @since 1.0.0
- * @category constructor
+ * @category Constructors
  */
 export const make = (
-  impl: Omit<Clipboard, "clear" | "writeBlob" | TypeId>
+  impl: Omit<Clipboard, "clear" | "writeBlob" | typeof TypeId>
 ): Clipboard =>
   Clipboard.of({
     ...impl,
@@ -80,7 +58,7 @@ export const make = (
  * A layer that directly interfaces with the navigator.clipboard api
  *
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layer: Layer.Layer<Clipboard> = Layer.succeed(
   Clipboard,

package/src/Geolocation.ts

@@ -1,33 +1,23 @@
 /**
  * @since 1.0.0
  */
-import { TypeIdError } from "@effect/platform/Error"
-import * as Context from "effect/Context"
+import * as Cause from "effect/Cause"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import { identity } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
+import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
 
-/**
- * @since 1.0.0
- * @category type ids
- */
-export const TypeId: unique symbol = Symbol.for("@effect/platform-browser/Geolocation")
-
-/**
- * @since 1.0.0
- * @category type ids
- */
-export type TypeId = typeof TypeId
+const TypeId = "~@effect/platform-browser/Geolocation"
+const ErrorTypeId = "~@effect/platform-browser/Geolocation/GeolocationError"
 
 /**
  * @since 1.0.0
- * @category models
+ * @category Models
  */
 export interface Geolocation {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly getCurrentPosition: (
     options?: PositionOptions | undefined
   ) => Effect.Effect<GeolocationPosition, GeolocationError>
@@ -42,37 +32,75 @@ export interface Geolocation {
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Service
  */
-export const Geolocation: Context.Tag<Geolocation, Geolocation> = Context.GenericTag<Geolocation>(
-  "@effect/platform-browser/Geolocation"
-)
+export const Geolocation: ServiceMap.Service<Geolocation, Geolocation> = ServiceMap.Service<Geolocation>(TypeId)
+
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export class GeolocationError extends Data.TaggedError("GeolocationError")<{
+  readonly reason: GeolocationErrorReason
+}> {
+  constructor(props: {
+    readonly reason: GeolocationErrorReason
+  }) {
+    super({
+      ...props,
+      cause: props.reason.cause
+    } as any)
+  }
+
+  readonly [ErrorTypeId] = ErrorTypeId
+
+  override get message(): string {
+    return this.reason.message
+  }
+}
 
 /**
  * @since 1.0.0
- * @category type ids
+ * @category Errors
  */
-export const ErrorTypeId: unique symbol = Symbol.for("@effect/platform-browser/Geolocation/GeolocationError")
+export class PositionUnavailable extends Data.TaggedError("PositionUnavailable")<{
+  readonly cause: unknown
+}> {
+  override get message(): string {
+    return this._tag
+  }
+}
 
 /**
  * @since 1.0.0
- * @category type ids
+ * @category Errors
  */
-export type ErrorTypeId = typeof ErrorTypeId
+export class PermissionDenied extends Data.TaggedError("PermissionDenied")<{
+  readonly cause: unknown
+}> {
+  override get message(): string {
+    return this._tag
+  }
+}
 
 /**
  * @since 1.0.0
- * @category errors
+ * @category Errors
  */
-export class GeolocationError extends TypeIdError(ErrorTypeId, "GeolocationError")<{
-  readonly reason: "PositionUnavailable" | "PermissionDenied" | "Timeout"
+export class Timeout extends Data.TaggedError("Timeout")<{
   readonly cause: unknown
 }> {
-  get message() {
-    return this.reason
+  override get message(): string {
+    return this._tag
   }
 }
 
+/**
+ * @since 1.0.0
+ * @category Errors
+ */
+export type GeolocationErrorReason = PositionUnavailable | PermissionDenied | Timeout
+
 const makeQueue = (
   options:
     | PositionOptions & {
@@ -80,17 +108,28 @@ const makeQueue = (
     }
     | undefined
 ) =>
-  Queue.sliding<Either.Either<GeolocationPosition, GeolocationError>>(options?.bufferSize ?? 16).pipe(
+  Queue.sliding<GeolocationPosition, GeolocationError>(options?.bufferSize ?? 16).pipe(
     Effect.tap((queue) =>
       Effect.acquireRelease(
         Effect.sync(() =>
           navigator.geolocation.watchPosition(
-            (position) => queue.unsafeOffer(Either.right(position)),
+            (position) => Queue.offerUnsafe(queue, position),
             (cause) => {
               if (cause.code === cause.PERMISSION_DENIED) {
-                queue.unsafeOffer(Either.left(new GeolocationError({ reason: "PermissionDenied", cause })))
+                const error = new GeolocationError({
+                  reason: new PermissionDenied({ cause })
+                })
+                Queue.failCauseUnsafe(queue, Cause.fail(error))
               } else if (cause.code === cause.TIMEOUT) {
-                queue.unsafeOffer(Either.left(new GeolocationError({ reason: "Timeout", cause })))
+                const error = new GeolocationError({
+                  reason: new Timeout({ cause })
+                })
+                Queue.failCauseUnsafe(queue, Cause.fail(error))
+              } else if (cause.code === cause.POSITION_UNAVAILABLE) {
+                const error = new GeolocationError({
+                  reason: new PositionUnavailable({ cause })
+                })
+                Queue.failCauseUnsafe(queue, Cause.fail(error))
               }
             },
             options
@@ -103,7 +142,7 @@ const makeQueue = (
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layer: Layer.Layer<Geolocation> = Layer.succeed(
   Geolocation,
@@ -112,21 +151,19 @@ export const layer: Layer.Layer<Geolocation> = Layer.succeed(
     getCurrentPosition: (options) =>
       makeQueue(options).pipe(
         Effect.flatMap(Queue.take),
-        Effect.flatten,
         Effect.scoped
       ),
     watchPosition: (options) =>
       makeQueue(options).pipe(
         Effect.map(Stream.fromQueue),
-        Stream.unwrapScoped,
-        Stream.mapEffect(identity)
+        Stream.unwrap
       )
   })
 )
 
 /**
  * @since 1.0.0
- * @category accessors
+ * @category Accessors
  */
 export const watchPosition = (
   options?:
@@ -135,4 +172,7 @@ export const watchPosition = (
     }
     | undefined
 ): Stream.Stream<GeolocationPosition, GeolocationError, Geolocation> =>
-  Stream.unwrap(Effect.map(Geolocation, (geolocation) => geolocation.watchPosition(options)))
+  Stream.unwrap(Effect.map(
+    Effect.service(Geolocation),
+    (geolocation) => geolocation.watchPosition(options)
+  ))

package/src/Permissions.ts

@@ -1,32 +1,23 @@
 /**
  * @since 1.0.0
  */
-import { TypeIdError } from "@effect/platform/Error"
-import * as Context from "effect/Context"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as ServiceMap from "effect/ServiceMap"
 
-/**
- * @since 1.0.0
- * @category type ids
- */
-export const TypeId: unique symbol = Symbol.for("@effect/platform-browser/Permissions")
-
-/**
- * @since 1.0.0
- * @category type ids
- */
-export type TypeId = typeof TypeId
+const TypeId = "~@effect/platform-browser/Permissions"
+const ErrorTypeId = "~@effect/platform-browser/Permissions/PermissionsError"
 
 /**
- * Wrapper on the Permission API (`navigator.permissions`)
- * with methods for querying status of permissions.
+ * Wrapper on the Permission API (`navigator.permissions`) with methods for
+ * querying status of permissions.
  *
  * @since 1.0.0
- * @category interface
+ * @category Models
  */
 export interface Permissions {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
 
   /**
    * Returns the state of a user permission on the global scope.
@@ -43,43 +34,66 @@ export interface Permissions {
 
 /**
  * @since 1.0.0
- * @category type ids
+ * @category errors
  */
-export const ErrorTypeId: unique symbol = Symbol.for("@effect/platform-browser/Permissions/PermissionsError")
+export class PermissionsInvalidStateError extends Data.TaggedError("InvalidStateError")<{
+  readonly cause: unknown
+}> {
+  override get message(): string {
+    return this._tag
+  }
+}
 
 /**
  * @since 1.0.0
- * @category type ids
+ * @category errors
  */
-export type ErrorTypeId = typeof ErrorTypeId
+export class PermissionsTypeError extends Data.TaggedError("TypeError")<{
+  readonly cause: unknown
+}> {
+  override get message(): string {
+    return this._tag
+  }
+}
 
 /**
  * @since 1.0.0
  * @category errors
  */
-export class PermissionsError extends TypeIdError(ErrorTypeId, "PermissionsError")<{
-  /** https://developer.mozilla.org/en-US/docs/Web/API/Permissions/query#exceptions */
-  readonly reason: "InvalidStateError" | "TypeError"
-  readonly cause: unknown
+export type PermissionsErrorReason = PermissionsInvalidStateError | PermissionsTypeError
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class PermissionsError extends Data.TaggedError("PermissionsError")<{
+  readonly reason: PermissionsErrorReason
 }> {
-  get message() {
-    return this.reason
+  constructor(props: { readonly reason: PermissionsErrorReason }) {
+    super({
+      ...props,
+      cause: props.reason.cause
+    } as any)
+  }
+
+  readonly [ErrorTypeId] = ErrorTypeId
+
+  override get message(): string {
+    return this.reason.message
   }
 }
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Service
  */
-export const Permissions: Context.Tag<Permissions, Permissions> = Context.GenericTag<Permissions>(
-  "@effect/platform-browser/Permissions"
-)
+export const Permissions: ServiceMap.Service<Permissions, Permissions> = ServiceMap.Service<Permissions>(TypeId)
 
 /**
  * A layer that directly interfaces with the `navigator.permissions` api
  *
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layer: Layer.Layer<Permissions> = Layer.succeed(
   Permissions,
@@ -90,8 +104,9 @@ export const layer: Layer.Layer<Permissions> = Layer.succeed(
         try: () => navigator.permissions.query({ name }) as Promise<any>,
         catch: (cause) =>
           new PermissionsError({
-            reason: cause instanceof DOMException ? "InvalidStateError" : "TypeError",
-            cause
+            reason: cause instanceof DOMException
+              ? new PermissionsInvalidStateError({ cause })
+              : new PermissionsTypeError({ cause })
           })
       })
   })

package/src/index.ts

@@ -1,49 +1,55 @@
 /**
  * @since 1.0.0
  */
-export * as BrowserHttpClient from "./BrowserHttpClient.js"
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @since 1.0.0
+ */
+export * as BrowserHttpClient from "./BrowserHttpClient.ts"
 
 /**
  * @since 1.0.0
  */
-export * as BrowserKeyValueStore from "./BrowserKeyValueStore.js"
+export * as BrowserKeyValueStore from "./BrowserKeyValueStore.ts"
 
 /**
  * @since 1.0.0
  */
-export * as BrowserRuntime from "./BrowserRuntime.js"
+export * as BrowserRuntime from "./BrowserRuntime.ts"
 
 /**
  * @since 1.0.0
  */
-export * as BrowserSocket from "./BrowserSocket.js"
+export * as BrowserSocket from "./BrowserSocket.ts"
 
 /**
  * @since 1.0.0
  */
-export * as BrowserStream from "./BrowserStream.js"
+export * as BrowserStream from "./BrowserStream.ts"
 
 /**
  * @since 1.0.0
  */
-export * as BrowserWorker from "./BrowserWorker.js"
+export * as BrowserWorker from "./BrowserWorker.ts"
 
 /**
  * @since 1.0.0
  */
-export * as BrowserWorkerRunner from "./BrowserWorkerRunner.js"
+export * as BrowserWorkerRunner from "./BrowserWorkerRunner.ts"
 
 /**
  * @since 1.0.0
  */
-export * as Clipboard from "./Clipboard.js"
+export * as Clipboard from "./Clipboard.ts"
 
 /**
  * @since 1.0.0
  */
-export * as Geolocation from "./Geolocation.js"
+export * as Geolocation from "./Geolocation.ts"
 
 /**
  * @since 1.0.0
  */
-export * as Permissions from "./Permissions.js"
+export * as Permissions from "./Permissions.ts"

package/BrowserHttpClient/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/BrowserHttpClient.js",
-  "module": "../dist/esm/BrowserHttpClient.js",
-  "types": "../dist/dts/BrowserHttpClient.d.ts"
-}