@effect/platform 0.43.11 → 0.44.1

package/src/HttpServer.ts

@@ -3,11 +3,14 @@
  */
 import * as app from "./Http/App.js"
 import * as body from "./Http/Body.js"
+import * as etag from "./Http/Etag.js"
 import * as headers from "./Http/Headers.js"
 import * as middleware from "./Http/Middleware.js"
 import * as multipart from "./Http/Multipart.js"
 import * as multiplex from "./Http/Multiplex.js"
+import * as platform from "./Http/Platform.js"
 import * as router from "./Http/Router.js"
+import * as server from "./Http/Server.js"
 import * as error from "./Http/ServerError.js"
 import * as request from "./Http/ServerRequest.js"
 import * as response from "./Http/ServerResponse.js"
@@ -35,6 +38,13 @@ export {
    * - Module: `@effect/platform/Http/ServerError`
    */
   error,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Etag](https://effect-ts.github.io/effect/platform/Http/Etag.ts.html)
+   * - Module: `@effect/platform/Http/Etag`
+   */
+  etag,
   /**
    * @since 1.0.0
    *
@@ -63,6 +73,13 @@ export {
    * - Module: `@effect/platform/Http/Multiplex`
    */
   multiplex,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Platform](https://effect-ts.github.io/effect/platform/Http/Platform.ts.html)
+   * - Module: `@effect/platform/Http/Platform`
+   */
+  platform,
   /**
    * @since 1.0.0
    *
@@ -84,6 +101,13 @@ export {
    * - Module: `@effect/platform/Http/Router`
    */
   router,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/Server](https://effect-ts.github.io/effect/platform/Http/Server.ts.html)
+   * - Module: `@effect/platform/Http/Server`
+   */
+  server,
   /**
    * @since 1.0.0
    *

package/src/KeyValueStore.ts

@@ -33,27 +33,27 @@ export interface KeyValueStore {
   /**
    * Returns the value of the specified key if it exists.
    */
-  readonly get: (key: string) => Effect.Effect<never, PlatformError.PlatformError, Option.Option<string>>
+  readonly get: (key: string) => Effect.Effect<Option.Option<string>, PlatformError.PlatformError>
 
   /**
    * Sets the value of the specified key.
    */
-  readonly set: (key: string, value: string) => Effect.Effect<never, PlatformError.PlatformError, void>
+  readonly set: (key: string, value: string) => Effect.Effect<void, PlatformError.PlatformError>
 
   /**
    * Removes the specified key.
    */
-  readonly remove: (key: string) => Effect.Effect<never, PlatformError.PlatformError, void>
+  readonly remove: (key: string) => Effect.Effect<void, PlatformError.PlatformError>
 
   /**
    * Removes all entries.
    */
-  readonly clear: Effect.Effect<never, PlatformError.PlatformError, void>
+  readonly clear: Effect.Effect<void, PlatformError.PlatformError>
 
   /**
    * Returns the number of entries.
    */
-  readonly size: Effect.Effect<never, PlatformError.PlatformError, number>
+  readonly size: Effect.Effect<number, PlatformError.PlatformError>
 
   /**
    * Updates the value of the specified key if it exists.
@@ -61,22 +61,22 @@ export interface KeyValueStore {
   readonly modify: (
     key: string,
     f: (value: string) => string
-  ) => Effect.Effect<never, PlatformError.PlatformError, Option.Option<string>>
+  ) => Effect.Effect<Option.Option<string>, PlatformError.PlatformError>
 
   /**
    * Returns true if the KeyValueStore contains the specified key.
    */
-  readonly has: (key: string) => Effect.Effect<never, PlatformError.PlatformError, boolean>
+  readonly has: (key: string) => Effect.Effect<boolean, PlatformError.PlatformError>
 
   /**
    * Checks if the KeyValueStore contains any entries.
    */
-  readonly isEmpty: Effect.Effect<never, PlatformError.PlatformError, boolean>
+  readonly isEmpty: Effect.Effect<boolean, PlatformError.PlatformError>
 
   /**
    * Create a SchemaStore for the specified schema.
    */
-  readonly forSchema: <R, I, A>(schema: Schema.Schema<R, I, A>) => SchemaStore<R, A>
+  readonly forSchema: <A, I, R>(schema: Schema.Schema<A, I, R>) => SchemaStore<R, A>
 }
 
 /**
@@ -116,7 +116,7 @@ export const prefix: {
  * @since 1.0.0
  * @category layers
  */
-export const layerMemory: Layer.Layer<never, never, KeyValueStore> = internal.layerMemory
+export const layerMemory: Layer.Layer<KeyValueStore> = internal.layerMemory
 
 /**
  * @since 1.0.0
@@ -124,7 +124,7 @@ export const layerMemory: Layer.Layer<never, never, KeyValueStore> = internal.la
  */
 export const layerFileSystem: (
   directory: string
-) => Layer.Layer<FileSystem.FileSystem | Path.Path, PlatformError.PlatformError, KeyValueStore> =
+) => Layer.Layer<KeyValueStore, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path> =
   internal.layerFileSystem
 
 /**
@@ -150,7 +150,7 @@ export interface SchemaStore<R, A> {
    */
   readonly get: (
     key: string
-  ) => Effect.Effect<R, PlatformError.PlatformError | ParseResult.ParseError, Option.Option<A>>
+  ) => Effect.Effect<Option.Option<A>, PlatformError.PlatformError | ParseResult.ParseError, R>
 
   /**
    * Sets the value of the specified key.
@@ -158,22 +158,22 @@ export interface SchemaStore<R, A> {
   readonly set: (
     key: string,
     value: A
-  ) => Effect.Effect<R, PlatformError.PlatformError | ParseResult.ParseError, void>
+  ) => Effect.Effect<void, PlatformError.PlatformError | ParseResult.ParseError, R>
 
   /**
    * Removes the specified key.
    */
-  readonly remove: (key: string) => Effect.Effect<never, PlatformError.PlatformError, void>
+  readonly remove: (key: string) => Effect.Effect<void, PlatformError.PlatformError>
 
   /**
    * Removes all entries.
    */
-  readonly clear: Effect.Effect<never, PlatformError.PlatformError, void>
+  readonly clear: Effect.Effect<void, PlatformError.PlatformError>
 
   /**
    * Returns the number of entries.
    */
-  readonly size: Effect.Effect<never, PlatformError.PlatformError, number>
+  readonly size: Effect.Effect<number, PlatformError.PlatformError>
 
   /**
    * Updates the value of the specified key if it exists.
@@ -181,27 +181,27 @@ export interface SchemaStore<R, A> {
   readonly modify: (
     key: string,
     f: (value: A) => A
-  ) => Effect.Effect<R, PlatformError.PlatformError | ParseResult.ParseError, Option.Option<A>>
+  ) => Effect.Effect<Option.Option<A>, PlatformError.PlatformError | ParseResult.ParseError, R>
 
   /**
    * Returns true if the KeyValueStore contains the specified key.
    */
-  readonly has: (key: string) => Effect.Effect<never, PlatformError.PlatformError, boolean>
+  readonly has: (key: string) => Effect.Effect<boolean, PlatformError.PlatformError>
 
   /**
    * Checks if the KeyValueStore contains any entries.
    */
-  readonly isEmpty: Effect.Effect<never, PlatformError.PlatformError, boolean>
+  readonly isEmpty: Effect.Effect<boolean, PlatformError.PlatformError>
 }
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerSchema: <R, I, A>(
-  schema: Schema.Schema<R, I, A>,
-  tagIdentifier?: unknown
+export const layerSchema: <A, I, R>(
+  schema: Schema.Schema<A, I, R>,
+  tagIdentifier: string
 ) => {
   readonly tag: Context.Tag<SchemaStore<R, A>, SchemaStore<R, A>>
-  readonly layer: Layer.Layer<KeyValueStore, never, SchemaStore<R, A>>
+  readonly layer: Layer.Layer<SchemaStore<R, A>, never, KeyValueStore>
 } = internal.layerSchema

package/src/Path.ts

@@ -18,14 +18,14 @@ export interface Path {
   readonly dirname: (path: string) => string
   readonly extname: (path: string) => string
   readonly format: (pathObject: Partial<Path.Parsed>) => string
-  readonly fromFileUrl: (url: URL) => Effect<never, BadArgument, string>
+  readonly fromFileUrl: (url: URL) => Effect<string, BadArgument>
   readonly isAbsolute: (path: string) => boolean
   readonly join: (...paths: ReadonlyArray<string>) => string
   readonly normalize: (path: string) => string
   readonly parse: (path: string) => Path.Parsed
   readonly relative: (from: string, to: string) => string
   readonly resolve: (...pathSegments: ReadonlyArray<string>) => string
-  readonly toFileUrl: (path: string) => Effect<never, BadArgument, URL>
+  readonly toFileUrl: (path: string) => Effect<URL, BadArgument>
   readonly toNamespacedPath: (path: string) => string
 }
 
@@ -61,4 +61,4 @@ export const Path: Tag<Path, Path> = internal.Path
  * @since 1.0.0
  * @category layer
  */
-export const layer: Layer<never, never, Path> = internal.layer
+export const layer: Layer<Path> = internal.layer

package/src/Runtime.ts

@@ -30,7 +30,7 @@ export const defaultTeardown: Teardown = <E, A>(
  */
 export interface RunMain {
   <E, A>(
-    effect: Effect.Effect<never, E, A>,
+    effect: Effect.Effect<A, E>,
     teardown?: Teardown
   ): void
 }

package/src/Terminal.ts

@@ -19,19 +19,19 @@ export interface Terminal {
   /**
    * The number of columns available on the platform's terminal interface.
    */
-  readonly columns: Effect<never, never, number>
+  readonly columns: Effect<number>
   /**
    * Reads a single input event from the default standard input.
    */
-  readonly readInput: Effect<never, QuitException, UserInput>
+  readonly readInput: Effect<UserInput, QuitException>
   /**
    * Reads a single line from the default standard input.
    */
-  readonly readLine: Effect<never, QuitException, string>
+  readonly readLine: Effect<string, QuitException>
   /**
    * Displays text to the the default standard output.
    */
-  readonly display: (text: string) => Effect<never, PlatformError, void>
+  readonly display: (text: string) => Effect<void, PlatformError>
 }
 
 /**

package/src/Transferable.ts

@@ -1,107 +1,125 @@
 /**
  * @since 1.0.0
  */
-
 import * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
-import { dual, identity } from "effect/Function"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import * as Option from "effect/Option"
 
 /**
  * @since 1.0.0
- * @category symbols
+ * @category models
  */
-export const symbol = Symbol.for("@effect/platform/Transferable")
+export interface CollectorService {
+  readonly addAll: (_: Iterable<globalThis.Transferable>) => Effect.Effect<void>
+  readonly unsafeAddAll: (_: Iterable<globalThis.Transferable>) => void
+  readonly read: Effect.Effect<ReadonlyArray<globalThis.Transferable>>
+  readonly unsafeRead: () => ReadonlyArray<globalThis.Transferable>
+  readonly unsafeClear: () => void
+  readonly clear: Effect.Effect<void>
+}
 
 /**
  * @since 1.0.0
- * @category models
+ * @category tags
+ */
+export class Collector extends Context.Tag("@effect/platform/Transferable/Collector")<
+  Collector,
+  CollectorService
+>() {}
+
+/**
+ * @since 1.0.0
+ * @category constructors
  */
-export interface Transferable {
-  readonly [symbol]: () => ReadonlyArray<globalThis.Transferable>
+export const unsafeMakeCollector = (): CollectorService => {
+  const tranferables: Array<globalThis.Transferable> = []
+  const unsafeAddAll = (transfers: Iterable<globalThis.Transferable>): void => {
+    for (const transfer of transfers) {
+      tranferables.push(transfer)
+    }
+  }
+  const unsafeRead = (): ReadonlyArray<globalThis.Transferable> => tranferables
+  const unsafeClear = (): void => {
+    tranferables.length = 0
+  }
+  return Collector.of({
+    unsafeAddAll,
+    addAll: (transferables) => Effect.sync(() => unsafeAddAll(transferables)),
+    unsafeRead,
+    read: Effect.sync(unsafeRead),
+    unsafeClear,
+    clear: Effect.sync(unsafeClear)
+  })
 }
 
 /**
  * @since 1.0.0
- * @category predicates
+ * @category constructors
  */
-export const isTransferable = (u: unknown): u is Transferable => typeof u === "object" && u !== null && symbol in u
+export const makeCollector: Effect.Effect<CollectorService> = Effect.sync(unsafeMakeCollector)
 
 /**
  * @since 1.0.0
  * @category accessors
  */
-export const get = (u: unknown): ReadonlyArray<globalThis.Transferable> => {
-  if (isTransferable(u)) {
-    return u[symbol]()
-  }
-  return []
-}
+export const addAll = (tranferables: Iterable<globalThis.Transferable>): Effect.Effect<void> =>
+  Effect.flatMap(
+    Effect.serviceOption(Collector),
+    Option.match({
+      onNone: () => Effect.unit,
+      onSome: (_) => _.addAll(tranferables)
+    })
+  )
 
 /**
  * @since 1.0.0
  * @category schema
  */
 export const schema: {
-  <A extends object>(
-    f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ): <R, I>(self: Schema.Schema<R, I, A>) => Schema.Schema<R, I, A>
-  <R, I, A extends object>(
-    self: Schema.Schema<R, I, A>,
-    f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ): Schema.Schema<R, I, A>
-} = dual(2, <R, I, A extends object>(
-  self: Schema.Schema<R, I, A>,
-  f: (_: A) => ReadonlyArray<globalThis.Transferable>
-) => {
-  const fn: Transferable[typeof symbol] = function(this: A) {
-    return f(this)
-  }
-  return Schema.transform(
+  <I>(
+    f: (_: I) => Iterable<globalThis.Transferable>
+  ): <A, R>(self: Schema.Schema<A, I, R>) => Schema.Schema<A, I, R>
+  <R, I, A>(
+    self: Schema.Schema<A, I, R>,
+    f: (_: I) => Iterable<globalThis.Transferable>
+  ): Schema.Schema<A, I, R>
+} = dual(2, <R, I, A>(
+  self: Schema.Schema<A, I, R>,
+  f: (_: I) => Iterable<globalThis.Transferable>
+) =>
+  Schema.transformOrFail(
+    Schema.from(self),
     self,
-    schemaFromSelf(Schema.to(self)),
-    (input) => addProxy(input, fn),
-    identity
-  )
-})
+    ParseResult.succeed,
+    (i) => Effect.as(addAll(f(i)), i)
+  ))
 
-const schemaParse =
-  <R, A extends object>(parse: ParseResult.DecodeUnknown<R, A>): ParseResult.DeclarationDecodeUnknown<R, A> =>
-  (u, options, ast) => {
-    if (!isTransferable(u)) {
-      return ParseResult.fail(ParseResult.type(ast, u))
-    }
-    const f = u[symbol]
-    return ParseResult.map(parse(u, options), (a): A => addProxy(a, f))
-  }
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const ImageData: Schema.Schema<ImageData> = schema(
+  Schema.any,
+  (_) => [(_ as ImageData).data.buffer]
+)
 
 /**
  * @since 1.0.0
  * @category schema
  */
-export const schemaFromSelf = <R, I extends object, A extends object>(
-  item: Schema.Schema<R, I, A>
-): Schema.Schema<R, I, A> => {
-  return Schema.declare(
-    [item],
-    (item) => schemaParse(ParseResult.decodeUnknown(item)),
-    (item) => schemaParse(ParseResult.encodeUnknown(item)),
-    { identifier: "Transferable" }
-  )
-}
+export const MessagePort: Schema.Schema<MessagePort> = schema(
+  Schema.any,
+  (_) => [_ as MessagePort]
+)
 
-const addProxy = <A extends object>(self: A, f: Transferable[typeof symbol]): A & Transferable => {
-  return new Proxy(self, {
-    get(target, key) {
-      if (key === symbol) {
-        return f
-      }
-      return target[key as keyof A]
-    },
-    has(target, p) {
-      if (p === symbol) {
-        return true
-      }
-      return p in target
-    }
-  }) as any
-}
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const Uint8Array: Schema.Schema<Uint8Array> = schema(
+  Schema.Uint8ArrayFromSelf,
+  (_) => [_.buffer]
+)