@effect/platform 0.48.29 → 0.49.0

package/src/Http/UrlParams.ts

@@ -4,10 +4,10 @@
 import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
+import * as Array from "effect/Array"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
-import * as ReadonlyArray from "effect/ReadonlyArray"
 
 /**
  * @since 1.0.0
@@ -27,9 +27,9 @@ export type Input = Readonly<Record<string, string>> | Iterable<readonly [string
  */
 export const fromInput = (input: Input): UrlParams => {
   if (Symbol.iterator in input) {
-    return ReadonlyArray.fromIterable(input)
+    return Array.fromIterable(input)
   }
-  return ReadonlyArray.fromIterable(Object.entries(input))
+  return Array.fromIterable(Object.entries(input))
 }
 
 /**
@@ -59,7 +59,7 @@ export const getAll: {
   (key: string) => (self: UrlParams) => ReadonlyArray<string>,
   (self: UrlParams, key: string) => ReadonlyArray<string>
 >(2, (self, key) =>
-  ReadonlyArray.reduce(self, [] as Array<string>, (acc, [k, value]) => {
+  Array.reduce(self, [] as Array<string>, (acc, [k, value]) => {
     if (k === key) {
       acc.push(value)
     }
@@ -78,7 +78,7 @@ export const getFirst: {
   (self: UrlParams, key: string) => Option.Option<string>
 >(2, (self, key) =>
   Option.map(
-    ReadonlyArray.findFirst(
+    Array.findFirst(
       self,
       ([k]) => k === key
     ),
@@ -97,7 +97,7 @@ export const getLast: {
   (self: UrlParams, key: string) => Option.Option<string>
 >(2, (self, key) =>
   Option.map(
-    ReadonlyArray.findLast(
+    Array.findLast(
       self,
       ([k]) => k === key
     ),
@@ -115,8 +115,8 @@ export const set: {
   (key: string, value: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string, value: string) => UrlParams
 >(3, (self, key, value) =>
-  ReadonlyArray.append(
-    ReadonlyArray.filter(self, ([k]) => k !== key),
+  Array.append(
+    Array.filter(self, ([k]) => k !== key),
     [key, value]
   ))
 
@@ -133,8 +133,8 @@ export const setAll: {
 >(2, (self, input) => {
   const toSet = fromInput(input)
   const keys = toSet.map(([k]) => k)
-  return ReadonlyArray.appendAll(
-    ReadonlyArray.filter(self, ([k]) => keys.includes(k)),
+  return Array.appendAll(
+    Array.filter(self, ([k]) => keys.includes(k)),
     toSet
   )
 })
@@ -150,7 +150,7 @@ export const append: {
   (key: string, value: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string, value: string) => UrlParams
 >(3, (self, key, value) =>
-  ReadonlyArray.append(
+  Array.append(
     self,
     [key, value]
   ))
@@ -166,7 +166,7 @@ export const appendAll: {
   (input: Input) => (self: UrlParams) => UrlParams,
   (self: UrlParams, input: Input) => UrlParams
 >(2, (self, input) =>
-  ReadonlyArray.appendAll(
+  Array.appendAll(
     self,
     fromInput(input)
   ))
@@ -181,7 +181,7 @@ export const remove: {
 } = dual<
   (key: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string) => UrlParams
->(2, (self, key) => ReadonlyArray.filter(self, ([k]) => k !== key))
+>(2, (self, key) => Array.filter(self, ([k]) => k !== key))
 
 /**
  * @since 1.0.0
@@ -197,7 +197,7 @@ export const makeUrl = <E>(url: string, params: UrlParams, onError: (e: unknown)
   Effect.try({
     try: () => {
       const urlInstance = new URL(url, baseUrl())
-      ReadonlyArray.forEach(params, ([key, value]) => {
+      Array.forEach(params, ([key, value]) => {
         if (value !== undefined) {
           urlInstance.searchParams.append(key, value)
         }
@@ -208,7 +208,7 @@ export const makeUrl = <E>(url: string, params: UrlParams, onError: (e: unknown)
   })
 
 const baseUrl = (): string | undefined => {
-  if ("location" in globalThis) {
+  if ("location" in globalThis && globalThis.location !== undefined) {
     return location.origin + location.pathname
   }
   return undefined

package/src/PlatformConfigProvider.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import * as Array from "effect/Array"
 import * as Cause from "effect/Cause"
 import type * as Config from "effect/Config"
 import * as ConfigError from "effect/ConfigError"
@@ -12,7 +13,6 @@ import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
-import * as ReadonlyArray from "effect/ReadonlyArray"
 import { isPlatformError, type PlatformError } from "./Error.js"
 import * as FileSystem from "./FileSystem.js"
 import * as Path from "./Path.js"
@@ -31,7 +31,7 @@ export const fromFileTree = (options?: {
       const rootDirectory = options?.rootDirectory ?? "/"
 
       const parseConfig = <A>(primitive: Config.Config.Primitive<A>) => (value: string) =>
-        Either.map(primitive.parse(value.trim()), ReadonlyArray.of)
+        Either.map(primitive.parse(value.trim()), Array.of)
 
       const readConfig = <A>(filePath: string, primitive: Config.Config.Primitive<A>) =>
         Effect.flatMap(

package/src/Socket.ts

@@ -181,7 +181,7 @@ export const toChannel = <IE>(
       const exitQueue = yield* _(Queue.unbounded<Exit.Exit<Chunk.Chunk<Uint8Array>, SocketError | IE>>())
 
       const input: AsyncProducer.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array | string | CloseEvent>, unknown> = {
-        awaitRead: () => Effect.unit,
+        awaitRead: () => Effect.void,
         emit(chunk) {
           return Effect.catchAllCause(
             Effect.forEach(chunk, write, { discard: true }),
@@ -190,12 +190,12 @@ export const toChannel = <IE>(
         },
         error(error) {
           return Effect.zipRight(
-            Scope.close(writeScope, Exit.unit),
+            Scope.close(writeScope, Exit.void),
             Queue.offer(exitQueue, Exit.failCause(error))
           )
         },
         done() {
-          return Scope.close(writeScope, Exit.unit)
+          return Scope.close(writeScope, Exit.void)
         }
       }
 
@@ -212,7 +212,7 @@ export const toChannel = <IE>(
         .flatMap(
           Queue.take(exitQueue),
           Exit.match({
-            onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.unit : Channel.failCause(cause),
+            onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.void : Channel.failCause(cause),
             onSuccess: (chunk) => Channel.zipRight(Channel.write(chunk), loop)
           })
         )
@@ -350,7 +350,7 @@ export const fromWebSocket = (
           yield* _(
             Effect.async<void, SocketError, never>((resume) => {
               ws.onopen = () => {
-                resume(Effect.unit)
+                resume(Effect.void)
               }
             }),
             Effect.timeoutFail({
@@ -388,7 +388,7 @@ export const fromWebSocket = (
           FiberSet.join(fiberSet),
           Effect.catchIf(
             SocketCloseError.isClean((_) => !closeCodeIsError(_)),
-            (_) => Effect.unit
+            (_) => Effect.void
           )
         )
       }).pipe(

package/src/Transferable.ts

@@ -69,7 +69,7 @@ export const addAll = (tranferables: Iterable<globalThis.Transferable>): Effect.
   Effect.flatMap(
     Effect.serviceOption(Collector),
     Option.match({
-      onNone: () => Effect.unit,
+      onNone: () => Effect.void,
       onSome: (_) => _.addAll(tranferables)
     })
   )

package/src/Worker.ts

@@ -72,7 +72,7 @@ export const PlatformWorker: Context.Tag<PlatformWorker, PlatformWorker> = inter
  * @since 1.0.0
  * @category models
  */
-export interface Worker<I, E, O> {
+export interface Worker<I, O, E = never> {
   readonly id: number
   readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
   readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
@@ -141,8 +141,8 @@ export declare namespace Worker {
  * @since 1.0.0
  * @category models
  */
-export interface WorkerPool<I, E, O> {
-  readonly backing: Pool.Pool<Worker<I, E, O>, WorkerError>
+export interface WorkerPool<I, O, E = never> {
+  readonly backing: Pool.Pool<Worker<I, O, E>, WorkerError>
   readonly broadcast: (message: I) => Effect.Effect<void, E | WorkerError>
   readonly execute: (message: I) => Stream.Stream<O, E | WorkerError>
   readonly executeEffect: (message: I) => Effect.Effect<O, E | WorkerError>
@@ -198,9 +198,9 @@ export type WorkerManagerTypeId = typeof WorkerManagerTypeId
  */
 export interface WorkerManager {
   readonly [WorkerManagerTypeId]: WorkerManagerTypeId
-  readonly spawn: <I, E, O>(
+  readonly spawn: <I, O, E>(
     options: Worker.Options<I>
-  ) => Effect.Effect<Worker<I, E, O>, WorkerError, Scope.Scope | Spawner>
+  ) => Effect.Effect<Worker<I, O, E>, WorkerError, Scope.Scope | Spawner>
 }
 
 /**
@@ -225,16 +225,16 @@ export const layerManager: Layer.Layer<WorkerManager, never, PlatformWorker> = i
  * @since 1.0.0
  * @category constructors
  */
-export const makePool: <I, E, O>(
+export const makePool: <I, O, E>(
   options: WorkerPool.Options<I>
-) => Effect.Effect<WorkerPool<I, E, O>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePool
+) => Effect.Effect<WorkerPool<I, O, E>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePool
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const makePoolLayer: <Tag, I, E, O>(
-  tag: Context.Tag<Tag, WorkerPool<I, E, O>>,
+export const makePoolLayer: <Tag, I, O, E>(
+  tag: Context.Tag<Tag, WorkerPool<I, O, E>>,
   options: WorkerPool.Options<I>
 ) => Layer.Layer<Tag, never, WorkerManager | Spawner> = internal.makePoolLayer
 

package/src/WorkerRunner.ts

@@ -17,8 +17,9 @@ import type { WorkerError } from "./WorkerError.js"
  * @category models
  */
 export interface BackingRunner<I, O> {
-  readonly queue: Queue.Dequeue<I>
+  readonly queue: Queue.Dequeue<readonly [portId: number, message: I]>
   readonly send: (
+    portId: number,
     message: O,
     transfers?: ReadonlyArray<unknown>
   ) => Effect.Effect<void>
@@ -74,7 +75,7 @@ export declare namespace Runner {
    * @since 1.0.0
    * @category models
    */
-  export interface Options<I, E, O> {
+  export interface Options<I, O, E> {
     readonly decode?: (
       message: unknown
     ) => Effect.Effect<I, WorkerError>
@@ -96,7 +97,7 @@ export declare namespace Runner {
  */
 export const make: <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: Runner.Options<I, E, O> | undefined
+  options?: Runner.Options<I, O, E> | undefined
 ) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
 
 /**
@@ -105,7 +106,7 @@ export const make: <I, R, E, O>(
  */
 export const layer: <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: Runner.Options<I, E, O> | undefined
+  options?: Runner.Options<I, O, E> | undefined
 ) => Layer.Layer<never, WorkerError, R | PlatformRunner> = internal.layer
 
 /**

package/src/internal/command.ts

@@ -1,3 +1,4 @@
+import type * as ReadonlyArray from "effect/Array"
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
@@ -5,7 +6,6 @@ import * as HashMap from "effect/HashMap"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
-import type * as ReadonlyArray from "effect/ReadonlyArray"
 import type { Scope } from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as Command from "../Command.js"
@@ -21,15 +21,21 @@ export const isCommand = (u: unknown): u is Command.Command => typeof u === "obj
 
 /** @internal */
 export const env: {
-  (environment: Record<string, string>): (self: Command.Command) => Command.Command
-  (self: Command.Command, environment: Record<string, string>): Command.Command
+  (environment: Record<string, string | undefined>): (self: Command.Command) => Command.Command
+  (self: Command.Command, environment: Record<string, string | undefined>): Command.Command
 } = dual<
-  (environment: Record<string, string>) => (self: Command.Command) => Command.Command,
-  (self: Command.Command, environment: Record<string, string>) => Command.Command
+  (environment: Record<string, string | undefined>) => (self: Command.Command) => Command.Command,
+  (self: Command.Command, environment: Record<string, string | undefined>) => Command.Command
 >(2, (self, environment) => {
   switch (self._tag) {
     case "StandardCommand": {
-      return makeStandard({ ...self, env: HashMap.union(self.env, HashMap.fromIterable(Object.entries(environment))) })
+      return makeStandard({
+        ...self,
+        env: HashMap.union(
+          self.env,
+          HashMap.fromIterable(Object.entries(environment).filter(([v]) => v !== undefined))
+        ) as HashMap.HashMap<string, string>
+      })
     }
     case "PipedCommand": {
       return pipeTo(env(self.left, environment), env(self.right, environment))

package/src/internal/fileSystem.ts

@@ -99,7 +99,7 @@ const stream = (file: File, {
     totalBytesRead: bigint
   ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, Error.PlatformError, unknown, void, unknown> {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
-      return Channel.unit
+      return Channel.void
     }
 
     const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
@@ -109,7 +109,7 @@ const stream = (file: File, {
     return Channel.flatMap(
       file.readAlloc(toRead),
       Option.match({
-        onNone: () => Channel.unit,
+        onNone: () => Channel.void,
         onSome: (buf) =>
           Channel.flatMap(
             Channel.write(Chunk.of(buf)),