effect-start 0.25.0 → 0.27.0

package/dist/Cookies.js

@@ -1,371 +0,0 @@
-/*
- * Minimal Cookies management adapted from @effect/platform
- * We'll aim for full compatbility when it stabilizes.
- */
-import * as Duration from "effect/Duration"
-import * as Inspectable from "effect/Inspectable"
-import * as Option from "effect/Option"
-import * as Pipeable from "effect/Pipeable"
-import * as Predicate from "effect/Predicate"
-
-export const TypeId = Symbol.for("effect-start/Cookies")
-
-export const isCookies = (u) => Predicate.hasProperty(u, TypeId)
-
-export const CookieTypeId = Symbol.for("effect-start/Cookies/Cookie")
-
-const CookiesProto = {
-  [TypeId]: TypeId,
-  ...Inspectable.BaseProto,
-  toJSON() {
-    return {
-      _id: "effect-start/Cookies",
-      cookies: Object.fromEntries(Object.entries(this.cookies).map(([k, v]) => [k, v.toJSON()])),
-    }
-  },
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments)
-  },
-}
-
-const CookieProto = {
-  [CookieTypeId]: CookieTypeId,
-  ...Inspectable.BaseProto,
-  toJSON() {
-    return {
-      _id: "effect-start/Cookies/Cookie",
-      name: this.name,
-      value: this.value,
-      options: this.options,
-    }
-  },
-}
-
-const makeCookiesFromRecord = (cookies) => {
-  const self = Object.create(CookiesProto)
-  self.cookies = cookies
-  return self
-}
-
-const cookieFromParts = (
-  name,
-  value,
-  valueEncoded,
-  options,
-) =>
-  Object.assign(Object.create(CookieProto), {
-    name,
-    value,
-    valueEncoded,
-    options,
-  })
-
-export const empty = makeCookiesFromRecord({})
-
-export const fromIterable = (cookies) => {
-  const record = {}
-  for (const cookie of cookies) {
-    record[cookie.name] = cookie
-  }
-  return makeCookiesFromRecord(record)
-}
-
-export const fromSetCookie = (headers) => {
-  const arrayHeaders = typeof headers === "string" ? [headers] : headers
-  const cookies = []
-  for (const header of arrayHeaders) {
-    const cookie = parseSetCookie(header.trim())
-    if (Option.isSome(cookie)) {
-      cookies.push(cookie.value)
-    }
-  }
-  return fromIterable(cookies)
-}
-
-export const unsafeMakeCookie = (
-  name,
-  value,
-  options,
-) => cookieFromParts(name, value, encodeURIComponent(value), options)
-
-export const isEmpty = (self) => {
-  for (const _ in self.cookies) return false
-  return true
-}
-
-export const get = (self, name) =>
-  name in self.cookies ? Option.some(self.cookies[name]) : Option.none()
-
-export const getValue = (self, name) =>
-  Option.map(get(self, name), (cookie) => cookie.value)
-
-export const setCookie = (self, cookie) =>
-  makeCookiesFromRecord({ ...self.cookies, [cookie.name]: cookie })
-
-export const unsafeSet = (
-  self,
-  name,
-  value,
-  options,
-) => setCookie(self, unsafeMakeCookie(name, value, options))
-
-export const unsafeSetAll = (
-  self,
-  cookies,
-) => {
-  const record = { ...self.cookies }
-  for (const [name, value, options] of cookies) {
-    record[name] = unsafeMakeCookie(name, value, options)
-  }
-  return makeCookiesFromRecord(record)
-}
-
-export const remove = (self, name) => {
-  const { [name]: _, ...rest } = self.cookies
-  return makeCookiesFromRecord(rest)
-}
-
-export const merge = (self, that) =>
-  makeCookiesFromRecord({ ...self.cookies, ...that.cookies })
-
-export function serializeCookie(self) {
-  let str = self.name + "=" + self.valueEncoded
-
-  if (self.options === undefined) {
-    return str
-  }
-  const options = self.options
-
-  if (options.maxAge !== undefined) {
-    const maxAge = Duration.toSeconds(options.maxAge)
-    str += "; Max-Age=" + Math.trunc(maxAge)
-  }
-
-  if (options.domain !== undefined) {
-    str += "; Domain=" + options.domain
-  }
-
-  if (options.path !== undefined) {
-    str += "; Path=" + options.path
-  }
-
-  if (options.priority !== undefined) {
-    switch (options.priority) {
-      case "low":
-        str += "; Priority=Low"
-        break
-      case "medium":
-        str += "; Priority=Medium"
-        break
-      case "high":
-        str += "; Priority=High"
-        break
-    }
-  }
-
-  if (options.expires !== undefined) {
-    str += "; Expires=" + options.expires.toUTCString()
-  }
-
-  if (options.httpOnly) {
-    str += "; HttpOnly"
-  }
-
-  if (options.secure) {
-    str += "; Secure"
-  }
-
-  if (options.partitioned) {
-    str += "; Partitioned"
-  }
-
-  if (options.sameSite !== undefined) {
-    switch (options.sameSite) {
-      case "lax":
-        str += "; SameSite=Lax"
-        break
-      case "strict":
-        str += "; SameSite=Strict"
-        break
-      case "none":
-        str += "; SameSite=None"
-        break
-    }
-  }
-
-  return str
-}
-
-export const toCookieHeader = (self) =>
-  Object.values(self.cookies)
-    .map((cookie) => `${cookie.name}=${cookie.valueEncoded}`)
-    .join("; ")
-
-export const toRecord = (self) => {
-  const record = {}
-  for (const cookie of Object.values(self.cookies)) {
-    record[cookie.name] = cookie.value
-  }
-  return record
-}
-
-export const toSetCookieHeaders = (self) =>
-  Object.values(self.cookies).map(serializeCookie)
-
-export function parseHeader(header) {
-  const result = {}
-
-  const strLen = header.length
-  let pos = 0
-  let terminatorPos = 0
-
-  while (true) {
-    if (terminatorPos === strLen) break
-    terminatorPos = header.indexOf(";", pos)
-    if (terminatorPos === -1) terminatorPos = strLen
-
-    let eqIdx = header.indexOf("=", pos)
-    if (eqIdx === -1) break
-    if (eqIdx > terminatorPos) {
-      pos = terminatorPos + 1
-      continue
-    }
-
-    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()
-
-      result[key] = !(val.indexOf("%") === -1) ? tryDecodeURIComponent(val) : val
-    }
-
-    pos = terminatorPos + 1
-  }
-
-  return result
-}
-
-// eslint-disable-next-line no-control-regex
-const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/
-
-function parseSetCookie(header) {
-  const parts = header
-    .split(";")
-    .map((_) => _.trim())
-    .filter((_) => _ !== "")
-  if (parts.length === 0) {
-    return Option.none()
-  }
-
-  const firstEqual = parts[0].indexOf("=")
-  if (firstEqual === -1) {
-    return Option.none()
-  }
-  const name = parts[0].slice(0, firstEqual)
-  if (!fieldContentRegExp.test(name)) {
-    return Option.none()
-  }
-
-  const valueEncoded = parts[0].slice(firstEqual + 1)
-  const value = tryDecodeURIComponent(valueEncoded)
-
-  if (parts.length === 1) {
-    return Option.some(cookieFromParts(name, value, valueEncoded))
-  }
-
-  const options = {}
-
-  for (let i = 1; i < parts.length; i++) {
-    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()
-
-    switch (key.toLowerCase()) {
-      case "domain": {
-        if (value === undefined) break
-        const domain = value.trim().replace(/^\./, "")
-        if (domain) options.domain = domain
-        break
-      }
-      case "expires": {
-        if (value === undefined) break
-        const date = new Date(value)
-        if (!isNaN(date.getTime())) options.expires = date
-        break
-      }
-      case "max-age": {
-        if (value === undefined) break
-        const maxAge = parseInt(value, 10)
-        if (!isNaN(maxAge)) options.maxAge = Duration.seconds(maxAge)
-        break
-      }
-      case "path": {
-        if (value === undefined) break
-        if (value[0] === "/") options.path = value
-        break
-      }
-      case "priority": {
-        if (value === undefined) break
-        switch (value.toLowerCase()) {
-          case "low":
-            options.priority = "low"
-            break
-          case "medium":
-            options.priority = "medium"
-            break
-          case "high":
-            options.priority = "high"
-            break
-        }
-        break
-      }
-      case "httponly": {
-        options.httpOnly = true
-        break
-      }
-      case "secure": {
-        options.secure = true
-        break
-      }
-      case "partitioned": {
-        options.partitioned = true
-        break
-      }
-      case "samesite": {
-        if (value === undefined) break
-        switch (value.toLowerCase()) {
-          case "lax":
-            options.sameSite = "lax"
-            break
-          case "strict":
-            options.sameSite = "strict"
-            break
-          case "none":
-            options.sameSite = "none"
-            break
-        }
-        break
-      }
-    }
-  }
-
-  return Option.some(
-    cookieFromParts(
-      name,
-      value,
-      valueEncoded,
-      Object.keys(options).length > 0 ? options : undefined,
-    ),
-  )
-}
-
-const tryDecodeURIComponent = (str) => {
-  try {
-    return decodeURIComponent(str)
-  } catch {
-    return str
-  }
-}

package/dist/Development.js

@@ -1,94 +0,0 @@
-import * as FileSystem from "./FileSystem.js"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as GlobalValue from "effect/GlobalValue"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as PubSub from "effect/PubSub"
-import * as Stream from "effect/Stream"
-
-const devState = GlobalValue.globalValue(Symbol.for("effect-start/Development"), () => ({
-  count: 0,
-  pubsub: null,
-}))
-
-/** @internal */
-export const _resetForTesting = () => {
-  devState.count = 0
-  devState.pubsub = null
-}
-
-export class Development extends Context.Tag("effect-start/Development")() {}
-
-const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/
-
-export const filterSourceFiles = (event) => {
-  return SOURCE_FILENAME.test(event.path)
-}
-
-export const filterDirectory = (event) => {
-  return event.path.endsWith("/")
-}
-
-export const watchSource = (opts) => {
-  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 }),
-      ),
-    ),
-    customFilter ? Stream.filter(customFilter) : Function.identity,
-    Stream.rechunk(1),
-    Stream.throttle({
-      units: 1,
-      cost: () => 1,
-      duration: "400 millis",
-      strategy: "enforce",
-    }),
-  )
-}
-
-export const watch = (opts) =>
-  Effect.gen(function* () {
-    devState.count++
-
-    if (devState.count === 1) {
-      const pubsub = yield* PubSub.unbounded()
-      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 }
-  })
-
-export const layerWatch = (opts) => Layer.scoped(Development, watch(opts))
-
-export const option = Effect.serviceOption(Development)
-
-export const stream = () =>
-  Stream.unwrap(
-    Function.pipe(
-      option,
-      Effect.map(
-        Option.match({
-          onNone: () => Stream.empty,
-          onSome: (dev) => Stream.fromPubSub(dev.events),
-        }),
-      ),
-    ),
-  )

package/dist/Effectify.js

@@ -1,27 +0,0 @@
-/*
- * Adapted from @effect/platform
- */
-import * as Effect from "effect/Effect"
-
-export const effectify = ((
-  fn,
-  onError,
-  onSyncError,
-) =>
-  (...args) =>
-    Effect.async((resume) => {
-      try {
-        fn(
-          ...args,
-          (err, result) => {
-            if (err) {
-              resume(Effect.fail(onError ? onError(err, args) : err))
-            } else {
-              resume(Effect.succeed(result))
-            }
-          },
-        )
-      } catch (err) {
-        resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
-      }
-    }))