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

package/src/BrowserHttpClient.ts

@@ -1,37 +1,385 @@
 /**
  * @since 1.0.0
  */
-import type * as HttpClient from "@effect/platform/HttpClient"
-import * as Context from "effect/Context"
-import type { Effect } from "effect/Effect"
-import type * as FiberRef from "effect/FiberRef"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
 import type { LazyArg } from "effect/Function"
+import * as Inspectable from "effect/Inspectable"
 import type * as Layer from "effect/Layer"
-import * as internal from "./internal/httpClient.js"
+import * as Queue from "effect/Queue"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Stream from "effect/Stream"
+import * as Cookies from "effect/unstable/http/Cookies"
+import * as Headers from "effect/unstable/http/Headers"
+import * as HttpClient from "effect/unstable/http/HttpClient"
+import * as HttpClientError from "effect/unstable/http/HttpClientError"
+import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
+import * as HttpIncomingMessage from "effect/unstable/http/HttpIncomingMessage"
+import * as UrlParams from "effect/unstable/http/UrlParams"
+import * as HeaderParser from "multipasta/HeadersParser"
+
+// =============================================================================
+// Fetch
+// =============================================================================
+
+export {
+  /**
+   * @since 1.0.0
+   * @category Fetch
+   */
+  Fetch,
+  /**
+   * @since 1.0.0
+   * @category Fetch
+   */
+  layer as layerFetch,
+  /**
+   * @since 1.0.0
+   * @category Fetch
+   */
+  RequestInit
+} from "effect/unstable/http/FetchHttpClient"
+
+// =============================================================================
+// XML Http Request
+// =============================================================================
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Models
  */
-export const layerXMLHttpRequest: Layer.Layer<HttpClient.HttpClient> = internal.layerXMLHttpRequest
+export type XHRResponseType = "arraybuffer" | "text"
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category References
  */
-export class XMLHttpRequest extends Context.Tag(internal.xhrTagKey)<
-  XMLHttpRequest,
-  LazyArg<globalThis.XMLHttpRequest>
->() {}
+export const CurrentXHRResponseType: ServiceMap.Reference<XHRResponseType> = ServiceMap.Reference(
+  "@effect/platform-browser/BrowserHttpClient/CurrentXHRResponseType",
+  { defaultValue: (): XHRResponseType => "text" }
+)
+
+/**
+ * @since 1.0.0
+ * @category References
+ */
+export const withXHRArrayBuffer = <A, E, R>(
+  self: Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R> =>
+  Effect.provideService(
+    self,
+    CurrentXHRResponseType,
+    "arraybuffer"
+  )
 
 /**
  * @since 1.0.0
- * @category fiber refs
+ * @category Services
  */
-export const currentXHRResponseType: FiberRef.FiberRef<"text" | "arraybuffer"> = internal.currentXHRResponseType
+export class XMLHttpRequest extends ServiceMap.Service<
+  XMLHttpRequest,
+  LazyArg<globalThis.XMLHttpRequest>
+>()("@effect/platform-browser/BrowserHttpClient/XMLHttpRequest") {}
+
+const makeXhrRequest = () => new globalThis.XMLHttpRequest()
+
+const makeXmlHttpRequest = HttpClient.make(
+  (request, url, signal, fiber) =>
+    Effect.suspend(() => {
+      const xhr = ServiceMap.getOrElse(
+        fiber.services,
+        XMLHttpRequest,
+        () => makeXhrRequest
+      )()
+      signal.addEventListener("abort", () => {
+        xhr.abort()
+        xhr.onreadystatechange = null
+      }, { once: true })
+      xhr.open(request.method, url.toString(), true)
+      xhr.responseType = fiber.getRef(CurrentXHRResponseType)
+      Object.entries(request.headers).forEach(([k, v]) => {
+        xhr.setRequestHeader(k, v)
+      })
+      return Effect.andThen(
+        sendBody(xhr, request),
+        Effect.callback<ClientResponseImpl, HttpClientError.HttpClientError>((resume) => {
+          let sent = false
+          const onChange = () => {
+            if (!sent && xhr.readyState >= 2) {
+              sent = true
+              resume(Effect.succeed(new ClientResponseImpl(request, xhr)))
+            }
+          }
+          xhr.onreadystatechange = onChange
+          xhr.onerror = (_event) => {
+            resume(Effect.fail(
+              new HttpClientError.HttpClientError({
+                reason: new HttpClientError.TransportError({
+                  request,
+                  cause: xhr.statusText
+                })
+              })
+            ))
+          }
+          onChange()
+          return Effect.void
+        })
+      )
+    })
+)
+
+const sendBody = (
+  xhr: globalThis.XMLHttpRequest,
+  request: HttpClientRequest.HttpClientRequest
+): Effect.Effect<void, HttpClientError.HttpClientError> => {
+  const body = request.body
+  switch (body._tag) {
+    case "Empty":
+      return Effect.sync(() => xhr.send())
+    case "Raw":
+      return Effect.sync(() => xhr.send(body.body as any))
+    case "Uint8Array":
+      return Effect.sync(() => xhr.send(body.body as any))
+    case "FormData":
+      return Effect.sync(() => xhr.send(body.formData))
+    case "Stream":
+      return Effect.matchEffect(
+        Stream.runFold(body.stream, () => new Uint8Array(0), (acc, chunk) => {
+          const next = new Uint8Array(acc.length + chunk.length)
+          next.set(acc, 0)
+          next.set(chunk, acc.length)
+          return next
+        }),
+        {
+          onFailure: (cause) =>
+            Effect.fail(
+              new HttpClientError.HttpClientError({
+                reason: new HttpClientError.EncodeError({
+                  request,
+                  cause
+                })
+              })
+            ),
+          onSuccess: (body) => Effect.sync(() => xhr.send(body))
+        }
+      )
+  }
+}
+
+const encoder = new TextEncoder()
+
+abstract class IncomingMessageImpl<E> extends Inspectable.Class implements HttpIncomingMessage.HttpIncomingMessage<E> {
+  readonly [HttpIncomingMessage.TypeId]: typeof HttpIncomingMessage.TypeId
+  readonly source: globalThis.XMLHttpRequest
+  readonly onError: (error: unknown) => E
+
+  constructor(source: globalThis.XMLHttpRequest, onError: (error: unknown) => E) {
+    super()
+    this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+    this.source = source
+    this.onError = onError
+    this._rawHeaderString = source.getAllResponseHeaders()
+  }
+
+  private _rawHeaderString: string
+  private _rawHeaders: Record<string, string | Array<string>> | undefined
+  private _headers: Headers.Headers | undefined
+  get headers() {
+    if (this._headers) {
+      return this._headers
+    }
+    if (this._rawHeaderString === "") {
+      return this._headers = Headers.empty
+    }
+    const parser = HeaderParser.make()
+    const result = parser(encoder.encode(this._rawHeaderString + "\r\n"), 0)
+    this._rawHeaders = result._tag === "Headers" ? result.headers : undefined
+    const parsed = result._tag === "Headers" ? Headers.fromInput(result.headers) : Headers.empty
+    return this._headers = parsed
+  }
+
+  cachedCookies: Cookies.Cookies | undefined
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies
+    }
+    if (this._rawHeaders === undefined) {
+      return Cookies.empty
+    } else if (this._rawHeaders["set-cookie"] === undefined) {
+      return this.cachedCookies = Cookies.empty
+    }
+    return this.cachedCookies = Cookies.fromSetCookie(this._rawHeaders["set-cookie"])
+  }
+
+  get remoteAddress() {
+    return undefined
+  }
+
+  _textEffect: Effect.Effect<string, E> | undefined
+  get text(): Effect.Effect<string, E> {
+    if (this._textEffect) {
+      return this._textEffect
+    }
+    return this._textEffect = Effect.callback<string, E>((resume) => {
+      if (this.source.readyState === 4) {
+        resume(Effect.succeed(this.source.responseText))
+        return
+      }
+
+      const onReadyStateChange = () => {
+        if (this.source.readyState === 4) {
+          resume(Effect.succeed(this.source.responseText))
+        }
+      }
+      const onError = () => {
+        resume(Effect.fail(this.onError(this.source.statusText)))
+      }
+      this.source.addEventListener("readystatechange", onReadyStateChange)
+      this.source.addEventListener("error", onError)
+      return Effect.sync(() => {
+        this.source.removeEventListener("readystatechange", onReadyStateChange)
+        this.source.removeEventListener("error", onError)
+      })
+    }).pipe(
+      Effect.cached,
+      Effect.runSync
+    )
+  }
+
+  get json(): Effect.Effect<unknown, E> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => text === "" ? null : JSON.parse(text) as unknown,
+        catch: this.onError
+      }))
+  }
+
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, E> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(text)),
+        catch: this.onError
+      }))
+  }
+
+  get stream(): Stream.Stream<Uint8Array, E> {
+    return Stream.callback<Uint8Array, E>((queue) => {
+      let offset = 0
+      const onReadyStateChange = () => {
+        if (this.source.readyState === 3) {
+          const encoded = encoder.encode(this.source.responseText.slice(offset))
+          Queue.offerUnsafe(queue, encoded)
+          offset = this.source.responseText.length
+        } else if (this.source.readyState === 4) {
+          const encoded = encoder.encode(this.source.responseText.slice(offset))
+          if (offset < this.source.responseText.length) {
+            Queue.offerUnsafe(queue, encoded)
+          }
+          Queue.endUnsafe(queue)
+        }
+      }
+      const onError = () => {
+        Queue.failCauseUnsafe(queue, Cause.fail(this.onError(this.source.statusText)))
+      }
+      this.source.addEventListener("readystatechange", onReadyStateChange)
+      this.source.addEventListener("error", onError)
+      onReadyStateChange()
+      return Effect.sync(() => {
+        this.source.removeEventListener("readystatechange", onReadyStateChange)
+        this.source.removeEventListener("error", onError)
+      })
+    })
+  }
+
+  _arrayBufferEffect: Effect.Effect<ArrayBuffer, E> | undefined
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, E> {
+    if (this._arrayBufferEffect) {
+      return this._arrayBufferEffect
+    }
+    return this._arrayBufferEffect = Effect.callback<ArrayBuffer, E>((resume) => {
+      if (this.source.readyState === 4) {
+        resume(Effect.succeed(this.source.response))
+        return
+      }
+
+      const onReadyStateChange = () => {
+        if (this.source.readyState === 4) {
+          resume(Effect.succeed(this.source.response))
+        }
+      }
+      const onError = () => {
+        resume(Effect.fail(this.onError(this.source.statusText)))
+      }
+      this.source.addEventListener("readystatechange", onReadyStateChange)
+      this.source.addEventListener("error", onError)
+      return Effect.sync(() => {
+        this.source.removeEventListener("readystatechange", onReadyStateChange)
+        this.source.removeEventListener("error", onError)
+      })
+    }).pipe(
+      Effect.map((response) => {
+        if (typeof response === "string") {
+          const arr = encoder.encode(response)
+          return arr.byteLength !== arr.buffer.byteLength
+            ? arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength)
+            : arr.buffer
+        }
+        return response
+      }),
+      Effect.cached,
+      Effect.runSync
+    )
+  }
+}
+
+class ClientResponseImpl extends IncomingMessageImpl<HttpClientError.HttpClientError>
+  implements HttpClientResponse.HttpClientResponse
+{
+  readonly [HttpClientResponse.TypeId]: typeof HttpClientResponse.TypeId
+  readonly request: HttpClientRequest.HttpClientRequest
+
+  constructor(
+    request: HttpClientRequest.HttpClientRequest,
+    source: globalThis.XMLHttpRequest
+  ) {
+    super(source, (cause) =>
+      new HttpClientError.HttpClientError({
+        reason: new HttpClientError.DecodeError({
+          request,
+          response: this,
+          cause
+        })
+      }))
+    this.request = request
+    this[HttpClientResponse.TypeId] = HttpClientResponse.TypeId
+  }
+
+  get status() {
+    return this.source.status
+  }
+
+  get formData(): Effect.Effect<FormData, HttpClientError.HttpClientError> {
+    return Effect.die("Not implemented")
+  }
+
+  override toString(): string {
+    return `ClientResponse(${this.status})`
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "@effect/platform/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    })
+  }
+}
 
 /**
  * @since 1.0.0
- * @category fiber refs
+ * @category Layers
  */
-export const withXHRArrayBuffer: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R> = internal.withXHRArrayBuffer
+export const layerXMLHttpRequest: Layer.Layer<HttpClient.HttpClient> = HttpClient.layerMergedServices(
+  Effect.succeed(makeXmlHttpRequest)
+)

package/src/BrowserKeyValueStore.ts

@@ -1,22 +1,29 @@
 /**
  * @since 1.0.0
  */
-import type * as KeyValueStore from "@effect/platform/KeyValueStore"
 import type * as Layer from "effect/Layer"
-import * as internal from "./internal/keyValueStore.js"
+import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore"
 
 /**
- * Creates a KeyValueStore layer that uses the browser's localStorage api. Values are stored between sessions.
+ * Creates a `KeyValueStore` layer that uses the browser's `localStorage` api.
+ *
+ * Values are stored between sessions.
  *
  * @since 1.0.0
- * @category models
+ * @category Layers
  */
-export const layerLocalStorage: Layer.Layer<KeyValueStore.KeyValueStore> = internal.layerLocalStorage
+export const layerLocalStorage: Layer.Layer<KeyValueStore.KeyValueStore> = KeyValueStore.layerStorage(() =>
+  globalThis.localStorage
+)
 
 /**
- * Creates a KeyValueStore layer that uses the browser's sessionStorage api. Values are stored only for the current session.
+ * Creates a `KeyValueStore` layer that uses the browser's `sessionStorage` api.
+ *
+ * Values are stored only for the current session.
  *
  * @since 1.0.0
- * @category models
+ * @category Layers
  */
-export const layerSessionStorage: Layer.Layer<KeyValueStore.KeyValueStore> = internal.layerSessionStorage
+export const layerSessionStorage: Layer.Layer<KeyValueStore.KeyValueStore> = KeyValueStore.layerStorage(() =>
+  globalThis.sessionStorage
+)

package/src/BrowserRuntime.ts

@@ -1,11 +1,37 @@
 /**
  * @since 1.0.0
  */
-import type { RunMain } from "@effect/platform/Runtime"
-import * as internal from "./internal/runtime.js"
+import type * as Effect from "effect/Effect"
+import { makeRunMain, type Teardown } from "effect/Runtime"
 
 /**
  * @since 1.0.0
- * @category runtime
+ * @category Runtime
  */
-export const runMain: RunMain = internal.runMain
+export const runMain: {
+  /**
+   * @since 1.0.0
+   * @category Runtime
+   */
+  (
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    }
+  ): <E, A>(effect: Effect.Effect<A, E>) => void
+  /**
+   * @since 1.0.0
+   * @category Runtime
+   */
+  <E, A>(
+    effect: Effect.Effect<A, E>,
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    }
+  ): void
+} = makeRunMain(({ fiber }) => {
+  globalThis.addEventListener("beforeunload", () => {
+    fiber.interruptUnsafe(fiber.id)
+  })
+})

package/src/BrowserSocket.ts

@@ -1,25 +1,25 @@
 /**
  * @since 1.0.0
  */
-import * as Socket from "@effect/platform/Socket"
 import * as Layer from "effect/Layer"
+import * as Socket from "effect/unstable/socket/Socket"
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layerWebSocket = (url: string, options?: {
   readonly closeCodeIsError?: (code: number) => boolean
 }): Layer.Layer<Socket.Socket> =>
-  Layer.scoped(Socket.Socket, Socket.makeWebSocket(url, options)).pipe(
+  Layer.effect(Socket.Socket, Socket.makeWebSocket(url, options)).pipe(
     Layer.provide(layerWebSocketConstructor)
   )
 
 /**
- * A WebSocket constructor that uses globalThis.WebSocket.
+ * A WebSocket constructor that uses `globalThis.WebSocket`.
  *
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layerWebSocketConstructor: Layer.Layer<Socket.WebSocketConstructor> =
   Socket.layerWebSocketConstructorGlobal

package/src/BrowserStream.ts

@@ -2,33 +2,43 @@
  * @since 1.0.0
  */
 
-import type * as Stream from "effect/Stream"
-import * as internal from "./internal/stream.js"
+import * as Stream from "effect/Stream"
 
 /**
- * Creates a `Stream` from window.addEventListener.
+ * Creates a `Stream` from `window.addEventListener`.
+ *
+ * By default, the underlying buffer is unbounded in size. You can customize the
+ * buffer size an object as the second argument with the `bufferSize` field.
+ *
  * @since 1.0.0
+ * @category Streams
  */
-export const fromEventListenerWindow: <K extends keyof WindowEventMap>(
+export const fromEventListenerWindow = <K extends keyof WindowEventMap>(
   type: K,
   options?: boolean | {
     readonly capture?: boolean
     readonly passive?: boolean
     readonly once?: boolean
-    readonly bufferSize?: number | "unbounded" | undefined
+    readonly bufferSize?: number | undefined
   } | undefined
-) => Stream.Stream<WindowEventMap[K], never, never> = internal.fromEventListenerWindow
+): Stream.Stream<WindowEventMap[K], never, never> => Stream.fromEventListener<WindowEventMap[K]>(window, type, options)
 
 /**
- * Creates a `Stream` from document.addEventListener.
+ * Creates a `Stream` from `document.addEventListener`.
+ *
+ * By default, the underlying buffer is unbounded in size. You can customize the
+ * buffer size an object as the second argument with the `bufferSize` field.
+ *
  * @since 1.0.0
+ * @category Streams
  */
-export const fromEventListenerDocument: <K extends keyof DocumentEventMap>(
+export const fromEventListenerDocument = <K extends keyof DocumentEventMap>(
   type: K,
   options?: boolean | {
     readonly capture?: boolean
     readonly passive?: boolean
     readonly once?: boolean
-    readonly bufferSize?: number | "unbounded" | undefined
+    readonly bufferSize?: number | undefined
   } | undefined
-) => Stream.Stream<DocumentEventMap[K], never, never> = internal.fromEventListenerDocument
+): Stream.Stream<DocumentEventMap[K], never, never> =>
+  Stream.fromEventListener<DocumentEventMap[K]>(document, type, options)

package/src/BrowserWorker.ts

@@ -1,33 +1,70 @@
 /**
  * @since 1.0.0
  */
-import type * as Worker from "@effect/platform/Worker"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/worker.js"
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerManager: Layer.Layer<Worker.WorkerManager> = internal.layerManager
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerWorker: Layer.Layer<Worker.PlatformWorker> = internal.layerWorker
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import * as Worker from "effect/unstable/workers/Worker"
+import { WorkerError, WorkerReceiveError } from "effect/unstable/workers/WorkerError"
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
-export const layer: (
+export const layer = (
   spawn: (id: number) => Worker | SharedWorker | MessagePort
-) => Layer.Layer<Worker.WorkerManager | Worker.Spawner> = internal.layer
+): Layer.Layer<Worker.WorkerPlatform | Worker.Spawner> =>
+  Layer.merge(
+    layerPlatform,
+    Worker.layerSpawner(spawn)
+  )
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
-export const layerPlatform: (
-  spawn: (id: number) => globalThis.Worker | globalThis.SharedWorker | MessagePort
-) => Layer.Layer<Worker.PlatformWorker | Worker.Spawner> = internal.layerPlatform
+export const layerPlatform: Layer.Layer<Worker.WorkerPlatform> = Layer.succeed(Worker.WorkerPlatform)(
+  Worker.makePlatform<globalThis.SharedWorker | globalThis.Worker | MessagePort>()({
+    setup({ scope, worker }) {
+      const port = "port" in worker ? worker.port : worker
+      return Effect.as(
+        Scope.addFinalizer(
+          scope,
+          Effect.sync(() => {
+            port.postMessage([1])
+          })
+        ),
+        port
+      )
+    },
+    listen({ deferred, emit, port, scope }) {
+      function onMessage(event: MessageEvent) {
+        emit(event.data)
+      }
+      function onError(event: ErrorEvent) {
+        Deferred.doneUnsafe(
+          deferred,
+          new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "An error event was emitter",
+              cause: event.error ?? event.message
+            })
+          }).asEffect()
+        )
+      }
+      port.addEventListener("message", onMessage as any)
+      port.addEventListener("error", onError as any)
+      if ("start" in port) {
+        port.start()
+      }
+      return Scope.addFinalizer(
+        scope,
+        Effect.sync(() => {
+          port.removeEventListener("message", onMessage as any)
+          port.removeEventListener("error", onError as any)
+        })
+      )
+    }
+  })
+)