effect-start 0.21.0 → 0.22.0

package/src/ContentNegotiation.ts

@@ -3,7 +3,6 @@
  * Based on {@link https://github.com/jshttp/negotiator}
  */
 
-
 interface ParsedSpec {
   value: string
   q: number
@@ -12,7 +11,7 @@ interface ParsedSpec {
   i: number
 }
 
-const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/
+const simpleMediaTypeRegExp = /^\s*([^\s/;]+)\/([^;\s]+)\s*(?:;(.*))?$/
 const simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/
 const simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/
 const simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/
@@ -25,9 +24,10 @@ function parseQuality(params: string | undefined): number {
   return isNaN(q) ? 1 : Math.min(Math.max(q, 0), 1)
 }
 
-function splitMediaTypeParams(
-  params: string,
-): { params: Record<string, string>; q: number } {
+function splitMediaTypeParams(params: string): {
+  params: Record<string, string>
+  q: number
+} {
   const result: Record<string, string> = {}
   let q = 1
 
@@ -40,7 +40,7 @@ function splitMediaTypeParams(
     const key = trimmed.slice(0, eqIndex).trim().toLowerCase()
     let value = trimmed.slice(eqIndex + 1).trim()
 
-    if (value.startsWith("\"") && value.endsWith("\"")) {
+    if (value.startsWith('"') && value.endsWith('"')) {
       value = value.slice(1, -1)
     }
 
@@ -56,17 +56,13 @@ function splitMediaTypeParams(
   return { params: result, q }
 }
 
-function parseAccept(
-  accept: string,
-): Array<
-  {
-    type: string
-    subtype: string
-    params: Record<string, string>
-    q: number
-    o: number
-  }
-> {
+function parseAccept(accept: string): Array<{
+  type: string
+  subtype: string
+  params: Record<string, string>
+  q: number
+  o: number
+}> {
   const specs: Array<{
     type: string
     subtype: string
@@ -85,9 +81,7 @@ function parseAccept(
 
     const type = match[1].toLowerCase()
     const subtype = match[2].toLowerCase()
-    const { params, q } = match[3]
-      ? splitMediaTypeParams(match[3])
-      : { params: {}, q: 1 }
+    const { params, q } = match[3] ? splitMediaTypeParams(match[3]) : { params: {}, q: 1 }
 
     if (q > 0) {
       specs.push({ type, subtype, params, q, o })
@@ -134,8 +128,7 @@ function specifyMediaType(
   if (specParams.length > 0) {
     if (
       specParams.every(
-        (key) =>
-          spec.params[key].toLowerCase() === (params[key] || "").toLowerCase(),
+        (key) => spec.params[key].toLowerCase() === (params[key] || "").toLowerCase(),
       )
     ) {
       s |= 1
@@ -149,15 +142,13 @@ function specifyMediaType(
 
 function getMediaTypePriority(
   mediaType: string,
-  accepted: Array<
-    {
-      type: string
-      subtype: string
-      params: Record<string, string>
-      q: number
-      o: number
-    }
-  >,
+  accepted: Array<{
+    type: string
+    subtype: string
+    params: Record<string, string>
+    q: number
+    o: number
+  }>,
   index: number,
 ): ParsedSpec {
   let best: { q: number; s: number; o: number } | null = null
@@ -169,18 +160,16 @@ function getMediaTypePriority(
 
   const type = match[1].toLowerCase()
   const subtype = match[2].toLowerCase()
-  const { params } = match[3]
-    ? splitMediaTypeParams(match[3])
-    : { params: {} }
+  const { params } = match[3] ? splitMediaTypeParams(match[3]) : { params: {} }
 
   for (const spec of accepted) {
     const result = specifyMediaType(type, subtype, params, spec)
     if (
-      result
-      && (best === null
-        || result.s > best.s
-        || (result.s === best.s && result.q > best.q)
-        || (result.s === best.s && result.q === best.q && result.o < best.o))
+      result &&
+      (best === null ||
+        result.s > best.s ||
+        (result.s === best.s && result.q > best.q) ||
+        (result.s === best.s && result.q === best.q && result.o < best.o))
     ) {
       best = result
     }
@@ -256,9 +245,12 @@ function specifyLanguage(
 
 function getLanguagePriority(
   language: string,
-  accepted: Array<
-    { prefix: string; suffix: string | undefined; q: number; o: number }
-  >,
+  accepted: Array<{
+    prefix: string
+    suffix: string | undefined
+    q: number
+    o: number
+  }>,
   index: number,
 ): ParsedSpec {
   let best: { q: number; s: number; o: number } | null = null
@@ -266,11 +258,11 @@ function getLanguagePriority(
   for (const spec of accepted) {
     const result = specifyLanguage(language, spec)
     if (
-      result
-      && (best === null
-        || result.s > best.s
-        || (result.s === best.s && result.q > best.q)
-        || (result.s === best.s && result.q === best.q && result.o < best.o))
+      result &&
+      (best === null ||
+        result.s > best.s ||
+        (result.s === best.s && result.q > best.q) ||
+        (result.s === best.s && result.q === best.q && result.o < best.o))
     ) {
       best = result
     }
@@ -285,9 +277,7 @@ function getLanguagePriority(
   }
 }
 
-function parseAcceptEncoding(
-  accept: string,
-): Array<{ encoding: string; q: number; o: number }> {
+function parseAcceptEncoding(accept: string): Array<{ encoding: string; q: number; o: number }> {
   const specs: Array<{ encoding: string; q: number; o: number }> = []
   const parts = accept.split(",")
   let hasIdentity = false
@@ -341,11 +331,11 @@ function getEncodingPriority(
   for (const spec of accepted) {
     const result = specifyEncoding(encoding, spec)
     if (
-      result
-      && (best === null
-        || result.s > best.s
-        || (result.s === best.s && result.q > best.q)
-        || (result.s === best.s && result.q === best.q && result.o < best.o))
+      result &&
+      (best === null ||
+        result.s > best.s ||
+        (result.s === best.s && result.q > best.q) ||
+        (result.s === best.s && result.q === best.q && result.o < best.o))
     ) {
       best = result
     }
@@ -360,9 +350,7 @@ function getEncodingPriority(
   }
 }
 
-function parseAcceptCharset(
-  accept: string,
-): Array<{ charset: string; q: number; o: number }> {
+function parseAcceptCharset(accept: string): Array<{ charset: string; q: number; o: number }> {
   const specs: Array<{ charset: string; q: number; o: number }> = []
   const parts = accept.split(",")
 
@@ -408,11 +396,11 @@ function getCharsetPriority(
   for (const spec of accepted) {
     const result = specifyCharset(charset, spec)
     if (
-      result
-      && (best === null
-        || result.s > best.s
-        || (result.s === best.s && result.q > best.q)
-        || (result.s === best.s && result.q === best.q && result.o < best.o))
+      result &&
+      (best === null ||
+        result.s > best.s ||
+        (result.s === best.s && result.q > best.q) ||
+        (result.s === best.s && result.q === best.q && result.o < best.o))
     ) {
       best = result
     }
@@ -428,24 +416,17 @@ function getCharsetPriority(
 }
 
 function compareSpecs(a: ParsedSpec, b: ParsedSpec): number {
-  return (
-    b.q - a.q
-    || b.s - a.s
-    || a.o - b.o
-    || a.i - b.i
-  )
+  return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i
 }
 
-export function media(accept: string, available?: string[]): string[] {
+export function media(accept: string, available?: Array<string>): Array<string> {
   const parsed = parseAccept(accept)
   if (parsed.length === 0) {
     return []
   }
 
   if (!available) {
-    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) =>
-      `${p.type}/${p.subtype}`
-    )
+    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => `${p.type}/${p.subtype}`)
   }
 
   const priorities = available.map((t, i) => getMediaTypePriority(t, parsed, i))
@@ -454,16 +435,16 @@ export function media(accept: string, available?: string[]): string[] {
   return sorted.map((p) => p.value)
 }
 
-export function language(accept: string, available?: string[]): string[] {
+export function language(accept: string, available?: Array<string>): Array<string> {
   const parsed = parseAcceptLanguage(accept)
   if (parsed.length === 0) {
     return []
   }
 
   if (!available) {
-    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) =>
-      p.suffix ? `${p.prefix}-${p.suffix}` : p.prefix
-    )
+    return parsed
+      .sort((a, b) => b.q - a.q || a.o - b.o)
+      .map((p) => (p.suffix ? `${p.prefix}-${p.suffix}` : p.prefix))
   }
 
   const priorities = available.map((l, i) => getLanguagePriority(l, parsed, i))
@@ -472,7 +453,7 @@ export function language(accept: string, available?: string[]): string[] {
   return sorted.map((p) => p.value)
 }
 
-export function encoding(accept: string, available?: string[]): string[] {
+export function encoding(accept: string, available?: Array<string>): Array<string> {
   const parsed = parseAcceptEncoding(accept)
   if (parsed.length === 0) {
     return []
@@ -488,7 +469,7 @@ export function encoding(accept: string, available?: string[]): string[] {
   return sorted.map((p) => p.value)
 }
 
-export function charset(accept: string, available?: string[]): string[] {
+export function charset(accept: string, available?: Array<string>): Array<string> {
   const parsed = parseAcceptCharset(accept)
   if (parsed.length === 0) {
     return []
@@ -504,37 +485,25 @@ export function charset(accept: string, available?: string[]): string[] {
   return sorted.map((p) => p.value)
 }
 
-export function headerMedia(
-  headers: Headers,
-  available?: string[],
-): string[] {
+export function headerMedia(headers: Headers, available?: Array<string>): Array<string> {
   const accept = headers.get("accept")
   if (!accept) return []
   return media(accept, available)
 }
 
-export function headerLanguage(
-  headers: Headers,
-  available?: string[],
-): string[] {
+export function headerLanguage(headers: Headers, available?: Array<string>): Array<string> {
   const accept = headers.get("accept-language")
   if (!accept) return []
   return language(accept, available)
 }
 
-export function headerEncoding(
-  headers: Headers,
-  available?: string[],
-): string[] {
+export function headerEncoding(headers: Headers, available?: Array<string>): Array<string> {
   const accept = headers.get("accept-encoding")
   if (!accept) return []
   return encoding(accept, available)
 }
 
-export function headerCharset(
-  headers: Headers,
-  available?: string[],
-): string[] {
+export function headerCharset(headers: Headers, available?: Array<string>): Array<string> {
   const accept = headers.get("accept-charset")
   if (!accept) return []
   return charset(accept, available)

package/src/Cookies.ts

@@ -9,23 +9,18 @@ import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import type * as Types from "effect/Types"
 
-export const TypeId: unique symbol = Symbol.for(
-  "effect-start/Cookies",
-)
+export const TypeId: unique symbol = Symbol.for("effect-start/Cookies")
 
 export type TypeId = typeof TypeId
 
-export const isCookies = (u: unknown): u is Cookies =>
-  Predicate.hasProperty(u, TypeId)
+export const isCookies = (u: unknown): u is Cookies => Predicate.hasProperty(u, TypeId)
 
 export interface Cookies extends Pipeable.Pipeable, Inspectable.Inspectable {
   readonly [TypeId]: TypeId
   readonly cookies: Record<string, Cookie>
 }
 
-export const CookieTypeId: unique symbol = Symbol.for(
-  "effect-start/Cookies/Cookie",
-)
+export const CookieTypeId: unique symbol = Symbol.for("effect-start/Cookies/Cookie")
 
 export type CookieTypeId = typeof CookieTypeId
 
@@ -34,24 +29,26 @@ export interface Cookie extends Inspectable.Inspectable {
   readonly name: string
   readonly value: string
   readonly valueEncoded: string
-  readonly options?: {
-    readonly domain?: string | undefined
-    readonly expires?: Date | undefined
-    readonly maxAge?: Duration.DurationInput | undefined
-    readonly path?: string | undefined
-    readonly priority?: "low" | "medium" | "high" | undefined
-    readonly httpOnly?: boolean | undefined
-    readonly secure?: boolean | undefined
-    readonly partitioned?: boolean | undefined
-    readonly sameSite?:
-      // send with top-level navigations and GET requests from third-party sites
-      | "lax"
-      // only send with same-site requests
-      | "strict"
-      // send with all requests (requires Secure)
-      | "none"
-      | undefined
-  } | undefined
+  readonly options?:
+    | {
+        readonly domain?: string | undefined
+        readonly expires?: Date | undefined
+        readonly maxAge?: Duration.DurationInput | undefined
+        readonly path?: string | undefined
+        readonly priority?: "low" | "medium" | "high" | undefined
+        readonly httpOnly?: boolean | undefined
+        readonly secure?: boolean | undefined
+        readonly partitioned?: boolean | undefined
+        readonly sameSite?:
+          // send with top-level navigations and GET requests from third-party sites
+          | "lax"
+          // only send with same-site requests
+          | "strict"
+          // send with all requests (requires Secure)
+          | "none"
+          | undefined
+      }
+    | undefined
 }
 
 const CookiesProto: Omit<Cookies, "cookies"> = {
@@ -60,9 +57,7 @@ const CookiesProto: Omit<Cookies, "cookies"> = {
   toJSON(this: Cookies) {
     return {
       _id: "effect-start/Cookies",
-      cookies: Object.fromEntries(
-        Object.entries(this.cookies).map(([k, v]) => [k, v.toJSON()]),
-      ),
+      cookies: Object.fromEntries(Object.entries(this.cookies).map(([k, v]) => [k, v.toJSON()])),
     }
   },
   pipe() {
@@ -83,9 +78,7 @@ const CookieProto = {
   },
 }
 
-const makeCookiesFromRecord = (
-  cookies: Record<string, Cookie>,
-): Cookies => {
+const makeCookiesFromRecord = (cookies: Record<string, Cookie>): Cookies => {
   const self = Object.create(CookiesProto)
   self.cookies = cookies
   return self
@@ -114,9 +107,7 @@ export const fromIterable = (cookies: Iterable<Cookie>): Cookies => {
   return makeCookiesFromRecord(record)
 }
 
-export const fromSetCookie = (
-  headers: Iterable<string> | string,
-): Cookies => {
+export const fromSetCookie = (headers: Iterable<string> | string): Cookies => {
   const arrayHeaders = typeof headers === "string" ? [headers] : headers
   const cookies: Array<Cookie> = []
   for (const header of arrayHeaders) {
@@ -139,16 +130,10 @@ export const isEmpty = (self: Cookies): boolean => {
   return true
 }
 
-export const get = (
-  self: Cookies,
-  name: string,
-): Option.Option<Cookie> =>
+export const get = (self: Cookies, name: string): Option.Option<Cookie> =>
   name in self.cookies ? Option.some(self.cookies[name]) : Option.none()
 
-export const getValue = (
-  self: Cookies,
-  name: string,
-): Option.Option<string> =>
+export const getValue = (self: Cookies, name: string): Option.Option<string> =>
   Option.map(get(self, name), (cookie) => cookie.value)
 
 export const setCookie = (self: Cookies, cookie: Cookie): Cookies =>
@@ -163,9 +148,7 @@ export const unsafeSet = (
 
 export const unsafeSetAll = (
   self: Cookies,
-  cookies: Iterable<
-    readonly [name: string, value: string, options?: Cookie["options"]]
-  >,
+  cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>,
 ): Cookies => {
   const record: Record<string, Cookie> = { ...self.cookies }
   for (const [name, value, options] of cookies) {
@@ -251,8 +234,7 @@ export function serializeCookie(self: Cookie): string {
 }
 
 export const toCookieHeader = (self: Cookies): string =>
-  Object
-    .values(self.cookies)
+  Object.values(self.cookies)
     .map((cookie) => `${cookie.name}=${cookie.valueEncoded}`)
     .join("; ")
 
@@ -288,13 +270,12 @@ export function parseHeader(header: string): Record<string, string> {
 
     const key = header.substring(pos, eqIdx++).trim()
     if (result[key] === undefined) {
-      const val = header.charCodeAt(eqIdx) === 0x22
-        ? header.substring(eqIdx + 1, terminatorPos - 1).trim()
-        : header.substring(eqIdx, terminatorPos).trim()
+      const val =
+        header.charCodeAt(eqIdx) === 0x22
+          ? header.substring(eqIdx + 1, terminatorPos - 1).trim()
+          : header.substring(eqIdx, terminatorPos).trim()
 
-      result[key] = !(val.indexOf("%") === -1)
-        ? tryDecodeURIComponent(val)
-        : val
+      result[key] = !(val.indexOf("%") === -1) ? tryDecodeURIComponent(val) : val
     }
 
     pos = terminatorPos + 1
@@ -337,9 +318,7 @@ function parseSetCookie(header: string): Option.Option<Cookie> {
     const part = parts[i]
     const equalIndex = part.indexOf("=")
     const key = equalIndex === -1 ? part : part.slice(0, equalIndex).trim()
-    const value = equalIndex === -1
-      ? undefined
-      : part.slice(equalIndex + 1).trim()
+    const value = equalIndex === -1 ? undefined : part.slice(equalIndex + 1).trim()
 
     switch (key.toLowerCase()) {
       case "domain": {

package/src/Development.ts

@@ -7,21 +7,18 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as PubSub from "effect/PubSub"
 import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.ts"
+import type * as PlatformError from "./PlatformError.ts"
 
 export type DevelopmentEvent =
   | FileSystem.WatchEvent
   | {
-    readonly _tag: "Reload"
-  }
+      readonly _tag: "Reload"
+    }
 
-const devState = GlobalValue.globalValue(
-  Symbol.for("effect-start/Development"),
-  () => ({
-    count: 0,
-    pubsub: null as PubSub.PubSub<DevelopmentEvent> | null,
-  }),
-)
+const devState = GlobalValue.globalValue(Symbol.for("effect-start/Development"), () => ({
+  count: 0,
+  pubsub: null as PubSub.PubSub<DevelopmentEvent> | null,
+}))
 
 /** @internal */
 export const _resetForTesting = () => {
@@ -48,25 +45,18 @@ export const filterDirectory = (event: FileSystem.WatchEvent): boolean => {
   return event.path.endsWith("/")
 }
 
-export const watchSource = (
-  opts?: {
-    path?: string
-    recursive?: boolean
-    filter?: (event: FileSystem.WatchEvent) => boolean
-  },
-): Stream.Stream<
-  FileSystem.WatchEvent,
-  PlatformError.PlatformError,
-  FileSystem.FileSystem
-> => {
+export const watchSource = (opts?: {
+  path?: string
+  recursive?: boolean
+  filter?: (event: FileSystem.WatchEvent) => boolean
+}): Stream.Stream<FileSystem.WatchEvent, PlatformError.PlatformError, FileSystem.FileSystem> => {
   const baseDir = opts?.path ?? process.cwd()
   const customFilter = opts?.filter
 
   return Function.pipe(
     Stream.unwrap(
-      Effect.map(
-        FileSystem.FileSystem,
-        fs => fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
+      Effect.map(FileSystem.FileSystem, (fs) =>
+        fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
       ),
     ),
     customFilter ? Stream.filter(customFilter) : Function.identity,
@@ -80,44 +70,39 @@ export const watchSource = (
   )
 }
 
-export const watch = (
-  opts?: {
-    path?: string
-    recursive?: boolean
-    filter?: (event: FileSystem.WatchEvent) => boolean
-  },
-) =>
-  Effect
-    .gen(function*() {
-      devState.count++
-
-      if (devState.count === 1) {
-        const pubsub = yield* PubSub.unbounded<DevelopmentEvent>()
-        devState.pubsub = pubsub
-
-        yield* Function.pipe(
-          watchSource({
-            path: opts?.path,
-            recursive: opts?.recursive,
-            filter: opts?.filter ?? filterSourceFiles,
-          }),
-          Stream.runForEach((event) => PubSub.publish(pubsub, event)),
-          Effect.fork,
-        )
-      } else {
-        yield* PubSub.publish(devState.pubsub!, { _tag: "Reload" })
-      }
-
-      return { events: devState.pubsub! } satisfies DevelopmentService
-    })
-
-export const layerWatch = (
-  opts?: {
-    path?: string
-    recursive?: boolean
-    filter?: (event: FileSystem.WatchEvent) => boolean
-  },
-) => Layer.scoped(Development, watch(opts))
+export const watch = (opts?: {
+  path?: string
+  recursive?: boolean
+  filter?: (event: FileSystem.WatchEvent) => boolean
+}) =>
+  Effect.gen(function* () {
+    devState.count++
+
+    if (devState.count === 1) {
+      const pubsub = yield* PubSub.unbounded<DevelopmentEvent>()
+      devState.pubsub = pubsub
+
+      yield* Function.pipe(
+        watchSource({
+          path: opts?.path,
+          recursive: opts?.recursive,
+          filter: opts?.filter ?? filterSourceFiles,
+        }),
+        Stream.runForEach((event) => PubSub.publish(pubsub, event)),
+        Effect.fork,
+      )
+    } else {
+      yield* PubSub.publish(devState.pubsub!, { _tag: "Reload" })
+    }
+
+    return { events: devState.pubsub! } satisfies DevelopmentService
+  })
+
+export const layerWatch = (opts?: {
+  path?: string
+  recursive?: boolean
+  filter?: (event: FileSystem.WatchEvent) => boolean
+}) => Layer.scoped(Development, watch(opts))
 
 export const stream = (): Stream.Stream<DevelopmentEvent> =>
   Stream.unwrap(