@effect/platform-browser 0.0.0-snapshot-c0ae728e57df2c572ea803e1bb7121088cd67b49

package/src/Error.ts

@@ -0,0 +1,34 @@
+/**
+ * @since 1.0.0
+ */
+
+export {
+  /**
+   * @since 1.0.0
+   * @category error
+   */
+  BadArgument,
+  /**
+   * @since 1.0.0
+   * @category type id
+   */
+  PlatformErrorTypeId,
+  /**
+   * @since 1.0.0
+   * @category error
+   */
+  SystemError
+} from "@effect/platform/Error"
+
+export type {
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  PlatformError,
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  SystemErrorReason
+} from "@effect/platform/Error"

package/src/HttpClient.ts

@@ -0,0 +1,62 @@
+/**
+ * @since 1.0.0
+ */
+import * as body from "@effect/platform/Http/Body"
+import * as client from "@effect/platform/Http/Client"
+import * as error from "@effect/platform/Http/ClientError"
+import * as request from "@effect/platform/Http/ClientRequest"
+import * as response from "@effect/platform/Http/ClientResponse"
+import * as headers from "@effect/platform/Http/Headers"
+import * as urlParams from "@effect/platform/Http/UrlParams"
+
+export {
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Body](https://effect-ts.github.io/effect/platform/Http/Body.ts.html)
+   * - Module: `@effect/platform/Http/Body`
+   */
+  body,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Client](https://effect-ts.github.io/effect/platform/Http/Client.ts.html)
+   * - Module: `@effect/platform/Http/Client`
+   */
+  client,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/ClientError](https://effect-ts.github.io/effect/platform/Http/ClientError.ts.html)
+   * - Module: `@effect/platform/Http/ClientError`
+   */
+  error,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Headers](https://effect-ts.github.io/effect/platform/Http/Headers.ts.html)
+   * - Module: `@effect/platform/Http/Headers`
+   */
+  headers,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/ClientRequest](https://effect-ts.github.io/effect/platform/Http/ClientRequest.ts.html)
+   * - Module: `@effect/platform/Http/ClientRequest`
+   */
+  request,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/ClientResponse](https://effect-ts.github.io/effect/platform/Http/ClientResponse.ts.html)
+   * - Module: `@effect/platform/Http/ClientResponse`
+   */
+  response,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/UrlParams](https://effect-ts.github.io/effect/platform/Http/UrlParams.ts.html)
+   * - Module: `@effect/platform/Http/UrlParams`
+   */
+  urlParams
+}

package/src/KeyValueStore.ts

@@ -0,0 +1,27 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/KeyValueStore`](https://effect-ts.github.io/effect/platform/KeyValueStore.ts.html).
+ */
+import * as internal from "./internal/keyValueStore.js"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/KeyValueStore"
+
+/**
+ * Creates a KeyValueStore layer that uses the browser's localStorage api. Values are stored between sessions.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export const layerLocalStorage = internal.layerLocalStorage
+
+/**
+ * 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
+ */
+export const layerSessionStorage = internal.layerSessionStorage

package/src/Path.ts

@@ -0,0 +1,7 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Path`](https://effect-ts.github.io/effect/platform/Path.ts.html).
+ */
+
+export * from "@effect/platform/Path"

package/src/Runtime.ts

@@ -0,0 +1,11 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Effect from "effect/Effect"
+import * as internal from "./internal/runtime.js"
+
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+export const runMain: <E, A>(effect: Effect.Effect<A, E>) => void = internal.runMain

package/src/Transferable.ts

@@ -0,0 +1,7 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Transferable`](https://effect-ts.github.io/effect/platform/Transferable.ts.html).
+ */
+
+export * from "@effect/platform/Transferable"

package/src/Worker.ts

@@ -0,0 +1,64 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Worker`](https://effect-ts.github.io/effect/platform/Worker.ts.html).
+ */
+import type * as Worker from "@effect/platform/Worker"
+import type * as Schema from "@effect/schema/Schema"
+import type * as Context from "effect/Context"
+import type * as Effect from "effect/Effect"
+import type * as Layer from "effect/Layer"
+import type * as Scope from "effect/Scope"
+import * as internal from "./internal/worker.js"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/Worker"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePool: <I, E, O>(
+  options: Worker.WorkerPool.Options<I, Worker | SharedWorker>
+) => Effect.Effect<Worker.WorkerPool<I, E, O>, never, Worker.WorkerManager | Scope.Scope> = internal.makePool
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePoolLayer: <Tag, I, E, O>(
+  tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
+  options: Worker.WorkerPool.Options<I, Worker | SharedWorker>
+) => Layer.Layer<Tag> = internal.makePoolLayer
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePoolSerialized: <I extends Schema.TaggedRequest.Any>(
+  options: Worker.SerializedWorkerPool.Options<I, Worker | SharedWorker>
+) => Effect.Effect<Worker.SerializedWorkerPool<I>, never, Worker.WorkerManager | Scope.Scope> =
+  internal.makePoolSerialized
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePoolSerializedLayer: <Tag, I extends Schema.TaggedRequest.Any>(
+  tag: Context.Tag<Tag, Worker.SerializedWorkerPool<I>>,
+  options: Worker.SerializedWorkerPool.Options<I, Worker | SharedWorker>
+) => Layer.Layer<Tag> = internal.makePoolSerializedLayer
+
+/**
+ * @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

package/src/WorkerRunner.ts

@@ -0,0 +1,45 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/WorkerRunner`](https://effect-ts.github.io/effect/platform/WorkerRunner.ts.html).
+ */
+import type { WorkerError } from "@effect/platform/WorkerError"
+import type * as Runner from "@effect/platform/WorkerRunner"
+import type * as Schema from "@effect/schema/Schema"
+import type * as Layer from "effect/Layer"
+import type * as Stream from "effect/Stream"
+import * as internal from "./internal/workerRunner.js"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/WorkerRunner"
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerPlatform: Layer.Layer<Runner.PlatformRunner> = internal.layerPlatform
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: <I, R, E, O>(
+  process: (request: I) => Stream.Stream<O, E, R>,
+  options?: Runner.Runner.Options<I, E, O> | undefined
+) => Layer.Layer<never, WorkerError, R> = internal.layer
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerSerialized: <
+  A extends Schema.TaggedRequest.Any,
+  I,
+  R,
+  Handlers extends Runner.SerializedRunner.Handlers<A>
+>(
+  schema: Schema.Schema<A, I, R>,
+  handlers: Handlers
+) => Layer.Layer<never, WorkerError, R | Runner.SerializedRunner.HandlersContext<Handlers>> = internal.layerSerialized

package/src/index.ts

@@ -0,0 +1,59 @@
+/**
+ * @since 1.0.0
+ */
+export * as Clipboard from "./Clipboard.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Effectify from "./Effectify.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Error from "./Error.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpClient from "./HttpClient.js"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/KeyValueStore`](https://effect-ts.github.io/effect/platform/KeyValueStore.ts.html).
+ */
+export * as KeyValueStore from "./KeyValueStore.js"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Path`](https://effect-ts.github.io/effect/platform/Path.ts.html).
+ */
+export * as Path from "./Path.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Runtime from "./Runtime.js"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Transferable`](https://effect-ts.github.io/effect/platform/Transferable.ts.html).
+ */
+export * as Transferable from "./Transferable.js"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Worker`](https://effect-ts.github.io/effect/platform/Worker.ts.html).
+ */
+export * as Worker from "./Worker.js"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/WorkerRunner`](https://effect-ts.github.io/effect/platform/WorkerRunner.ts.html).
+ */
+export * as WorkerRunner from "./WorkerRunner.js"

package/src/internal/clipboard.ts

@@ -0,0 +1,71 @@
+import * as PlatformError from "@effect/platform/Error"
+import { GenericTag } from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type * as Clipboard from "../Clipboard.js"
+
+/** @internal */
+export const tag = GenericTag<Clipboard.Clipboard>("@effect/platform-browser/Clipboard")
+
+/** @internal */
+export const make = (
+  impl: Omit<Clipboard.Clipboard, "clear" | "writeBlob">
+): Clipboard.Clipboard =>
+  tag.of({
+    ...impl,
+    clear: impl.writeString(""),
+    writeBlob: (blob: Blob) => impl.write([new ClipboardItem({ [blob.type]: blob })])
+  })
+
+/** @internal */
+const clipboardError = (props: Omit<Parameters<typeof PlatformError.SystemError>[0], "reason" | "module">) =>
+  PlatformError.SystemError({
+    reason: "PermissionDenied",
+    module: "Clipboard",
+    ...props
+  })
+
+/** @internal */
+export const layer = Layer.succeed(
+  tag,
+  make({
+    read: Effect.tryPromise({
+      try: () => navigator.clipboard.read(),
+      catch: () =>
+        clipboardError({
+          "message": "Unable to read from clipboard",
+          "method": "read",
+          "pathOrDescriptor": "layer"
+        })
+    }),
+    write: (s: Array<ClipboardItem>) =>
+      Effect.tryPromise({
+        try: () => navigator.clipboard.write(s),
+        catch: () =>
+          clipboardError({
+            "message": "Unable to write to clipboard",
+            "method": "write",
+            "pathOrDescriptor": "layer"
+          })
+      }),
+    readString: Effect.tryPromise({
+      try: () => navigator.clipboard.readText(),
+      catch: () =>
+        clipboardError({
+          "message": "Unable to read a string from clipboard",
+          "method": "readString",
+          "pathOrDescriptor": "layer"
+        })
+    }),
+    writeString: (text: string) =>
+      Effect.tryPromise({
+        try: () => navigator.clipboard.writeText(text),
+        catch: () =>
+          clipboardError({
+            "message": "Unable to write a string to clipboard",
+            "method": "writeString",
+            "pathOrDescriptor": "layer"
+          })
+      })
+  })
+)

package/src/internal/keyValueStore.ts

@@ -0,0 +1,130 @@
+import * as PlatformError from "@effect/platform/Error"
+import * as KeyValueStore from "@effect/platform/KeyValueStore"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+
+const storageError = (props: Omit<Parameters<typeof PlatformError.SystemError>[0], "reason" | "module">) =>
+  PlatformError.SystemError({
+    reason: "PermissionDenied",
+    module: "KeyValueStore",
+    ...props
+  })
+
+/** @internal */
+export const layerLocalStorage = Layer.succeed(
+  KeyValueStore.KeyValueStore,
+  KeyValueStore.make({
+    get: (key: string) =>
+      Effect.try({
+        try: () => Option.fromNullable(localStorage.getItem(key)),
+        catch: () =>
+          storageError({
+            pathOrDescriptor: "layerLocalStorage",
+            method: "get",
+            message: `Unable to get item with key ${key}`
+          })
+      }),
+
+    set: (key: string, value: string) =>
+      Effect.try({
+        try: () => localStorage.setItem(key, value),
+        catch: () =>
+          storageError({
+            pathOrDescriptor: "layerLocalStorage",
+            method: "set",
+            message: `Unable to set item with key ${key}`
+          })
+      }),
+
+    remove: (key: string) =>
+      Effect.try({
+        try: () => localStorage.removeItem(key),
+        catch: () =>
+          storageError({
+            pathOrDescriptor: "layerLocalStorage",
+            method: "remove",
+            message: `Unable to remove item with key ${key}`
+          })
+      }),
+
+    clear: Effect.try({
+      try: () => localStorage.clear(),
+      catch: () =>
+        storageError({
+          pathOrDescriptor: "layerLocalStorage",
+          method: "clear",
+          message: `Unable to clear storage`
+        })
+    }),
+
+    size: Effect.try({
+      try: () => localStorage.length,
+      catch: () =>
+        storageError({
+          pathOrDescriptor: "layerLocalStorage",
+          method: "size",
+          message: `Unable to get size`
+        })
+    })
+  })
+)
+
+/** @internal */
+export const layerSessionStorage = Layer.succeed(
+  KeyValueStore.KeyValueStore,
+  KeyValueStore.make({
+    get: (key: string) =>
+      Effect.try({
+        try: () => Option.fromNullable(sessionStorage.getItem(key)),
+        catch: () =>
+          storageError({
+            pathOrDescriptor: "layerSessionStorage",
+            method: "get",
+            message: `Unable to get item with key ${key}`
+          })
+      }),
+
+    set: (key: string, value: string) =>
+      Effect.try({
+        try: () => sessionStorage.setItem(key, value),
+        catch: () =>
+          storageError({
+            pathOrDescriptor: "layerSessionStorage",
+            method: "set",
+            message: `Unable to set item with key ${key}`
+          })
+      }),
+
+    remove: (key: string) =>
+      Effect.try({
+        try: () => sessionStorage.removeItem(key),
+        catch: () =>
+          storageError({
+            pathOrDescriptor: "layerSessionStorage",
+            method: "remove",
+            message: `Unable to remove item with key ${key}`
+          })
+      }),
+
+    clear: Effect.try({
+      try: () => sessionStorage.clear(),
+      catch: () =>
+        storageError({
+          pathOrDescriptor: "layerSessionStorage",
+          method: "clear",
+          message: `Unable to clear storage`
+        })
+    }),
+
+    size: Effect.try({
+      try: () => sessionStorage.length,
+      catch: () =>
+        storageError({
+          pathOrDescriptor: "layerSessionStorage",
+          method: "size",
+          message: `Unable to get size`
+        })
+    })
+  })
+)

package/src/internal/runtime.ts

@@ -0,0 +1,20 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+
+/** @internal */
+export const runMain = <E, A>(
+  effect: Effect.Effect<A, E>
+) => {
+  const fiber = Effect.runFork(
+    Effect.tapErrorCause(effect, (cause) => {
+      if (Cause.isInterruptedOnly(cause)) {
+        return Effect.unit
+      }
+      return Effect.logError(cause)
+    })
+  )
+
+  addEventListener("beforeunload", () => {
+    Effect.runFork(fiber.interruptAsFork(fiber.id()))
+  })
+}

package/src/internal/worker.ts

@@ -0,0 +1,72 @@
+import * as Worker from "@effect/platform/Worker"
+import { WorkerError } from "@effect/platform/WorkerError"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+
+const platformWorkerImpl = Worker.PlatformWorker.of({
+  [Worker.PlatformWorkerTypeId]: Worker.PlatformWorkerTypeId,
+  spawn<I, O>(worker_: unknown) {
+    return Effect.gen(function*(_) {
+      const worker = worker_ as globalThis.SharedWorker | globalThis.Worker
+      let port: globalThis.Worker | MessagePort
+      if ("port" in worker) {
+        port = worker.port
+        port.start()
+      } else {
+        port = worker
+      }
+
+      yield* _(Effect.addFinalizer(() => Effect.sync(() => port.postMessage([1]))))
+
+      const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
+
+      const fiber = yield* _(
+        Effect.async<never, WorkerError, never>((resume) => {
+          function onMessage(event: MessageEvent) {
+            queue.unsafeOffer((event as MessageEvent).data)
+          }
+          function onError(event: ErrorEvent) {
+            resume(Effect.fail(WorkerError("unknown", event.message, event.error?.stack)))
+          }
+          port.addEventListener("message", onMessage as any)
+          port.addEventListener("error", onError as any)
+          return Effect.sync(() => {
+            port.removeEventListener("message", onMessage as any)
+            port.removeEventListener("error", onError as any)
+          })
+        }),
+        Effect.interruptible,
+        Effect.forkScoped
+      )
+
+      const send = (message: I, transfers?: ReadonlyArray<unknown>) =>
+        Effect.try({
+          try: () => port.postMessage([0, message], transfers as any),
+          catch: (error) => WorkerError("send", (error as any).message, (error as any).stack)
+        })
+
+      return { fiber, queue, send }
+    })
+  }
+})
+
+/** @internal */
+export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerImpl)
+
+/** @internal */
+export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
+
+/** @internal */
+export const makePool = Worker.makePool<globalThis.Worker | globalThis.SharedWorker>()
+
+/** @internal */
+export const makePoolLayer = Worker.makePoolLayer<globalThis.Worker | globalThis.SharedWorker>(layerManager)
+
+/** @internal */
+export const makePoolSerialized = Worker.makePoolSerialized<globalThis.Worker | globalThis.SharedWorker>()
+
+/** @internal */
+export const makePoolSerializedLayer = Worker.makePoolSerializedLayer<globalThis.Worker | globalThis.SharedWorker>(
+  layerManager
+)