effect-start 0.25.0 → 0.26.0

package/dist/bundler/BundleFiles.js

@@ -1,154 +0,0 @@
-import * as FileSystem from "../FileSystem.js"
-import * as Array from "effect/Array"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as Iterable from "effect/Iterable"
-import * as Record from "effect/Record"
-import * as S from "effect/Schema"
-import * as Bundle from "./Bundle.js"
-
-/**
- * Exports a bundle to a file system under specified directory.
- */
-export const toFiles = (context, outDir) => {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const manifest = {
-      entrypoints: context.entrypoints,
-      artifacts: context.artifacts,
-    }
-
-    const normalizedOutDir = outDir.replace(/\/$/, "")
-
-    const bundleArtifacts = Function.pipe(
-      manifest.artifacts,
-      Array.map((artifact) => /** @type {const} */ [artifact.path, context.getArtifact(artifact.path)]),
-      Record.fromEntries,
-    )
-    const extraArtifacts = {
-      "manifest.json": new Blob([JSON.stringify(manifest, undefined, 2)], {
-        type: "application/json",
-      }),
-    }
-
-    const allArtifacts = {
-      ...bundleArtifacts,
-      ...extraArtifacts,
-    }
-
-    const existingOutDirFiles = yield* fs
-      .readDirectory(normalizedOutDir)
-      .pipe(Effect.catchAll(() => Effect.succeed(null)))
-
-    // check if the output directory is empty. if it contains previous build,
-    // remove it. Otherwise fail.
-    if (existingOutDirFiles && existingOutDirFiles.length > 0) {
-      if (existingOutDirFiles.includes("manifest.json")) {
-        yield* Effect.logWarning("Output directory seems to contain previous build. Overwriting...")
-
-        yield* fs.remove(normalizedOutDir, {
-          recursive: true,
-        })
-      } else {
-        return yield* Effect.fail(
-          new Bundle.BundleError({
-            message: "Output directory is not empty",
-          }),
-        )
-      }
-    }
-
-    yield* fs.makeDirectory(normalizedOutDir, {
-      recursive: true,
-    })
-
-    // write all artifacts to files
-    yield* Effect.all(
-      Function.pipe(
-        allArtifacts,
-        Record.toEntries,
-        Array.map(([p, b]) =>
-          Function.pipe(
-            Effect.tryPromise({
-              try: () => b.arrayBuffer(),
-              catch: (e) =>
-                new Bundle.BundleError({
-                  message: "Failed to read an artifact as a buffer",
-                  cause: e,
-                }),
-            }),
-            Effect.andThen((b) => fs.writeFile(`${normalizedOutDir}/${p}`, new Uint8Array(b))),
-          ),
-        ),
-      ),
-      { concurrency: 16 },
-    )
-  })
-}
-
-/**
- * Loads a bundle from a directory and returns a Bundle.BundleContext.
- * Expects the directory to contain a manifest.json file and all the artifacts
- * referenced in the manifest.
- */
-export const fromFiles = (
-  directory,
-) => {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const normalizedDir = directory.replace(/\/$/, "")
-    const manifest = yield* Function.pipe(
-      fs.readFileString(`${normalizedDir}/manifest.json`),
-      Effect.andThen((v) => JSON.parse(v)),
-      Effect.andThen(S.decodeUnknownSync(Bundle.BundleManifestSchema)),
-      Effect.catchAll((e) =>
-        Effect.fail(
-          new Bundle.BundleError({
-            message: `Failed to read manifest.json from ${normalizedDir}`,
-            cause: e,
-          }),
-        ),
-      ),
-    )
-    const artifactPaths = Array.map(manifest.artifacts, (a) => a.path)
-    const artifactBlobs = yield* Function.pipe(
-      artifactPaths,
-      Iterable.map((path) => fs.readFile(`${normalizedDir}/${path}`)),
-      Effect.all,
-      Effect.catchAll(
-        (e) =>
-          new Bundle.BundleError({
-            message: `Failed to read an artifact from ${normalizedDir}`,
-            cause: e,
-          }),
-      ),
-      Effect.andThen(
-        Iterable.map(
-          (v, i) =>
-            new Blob([v.slice(0)], {
-              type: manifest.artifacts[i].type,
-            }),
-        ),
-      ),
-    )
-    const artifactsRecord = Function.pipe(
-      Iterable.zip(artifactPaths, artifactBlobs),
-      Record.fromEntries,
-    )
-
-    const bundleContext = {
-      ...manifest,
-      // TODO: support fullpath file:// urls
-      // this will require having an access to base path of a build
-      // and maybe problematic because bundlers transform urls on build
-      resolve: (url) => {
-        return manifest.entrypoints[url] ?? null
-      },
-      getArtifact: (path) => {
-        return artifactsRecord[path] ?? null
-      },
-    }
-
-    return bundleContext
-  })
-}

package/dist/bundler/BundleRoute.js

@@ -1,62 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Entity from "../Entity.js"
-import * as PathPattern from "../PathPattern.js"
-import * as Route from "../Route.js"
-import * as RouteTree from "../RouteTree.js"
-import * as Values from "../Values.js"
-import * as Bundle from "./Bundle.js"
-
-/**
- * Creates a GET route that serves bundle artifacts.
- * Mount at a path with a wildcard param (any name works).
- *
- * ```ts
- * RouteTree.make({
- *   "/_bundle/:path+": BundleRoute.make(Bundle.ClientBundle),
- * })
- * ```
- */
-export const make = (tag) =>
-  Route.get(
-    Route.render(function* (ctx) {
-      const bundle = yield* tag
-      const url = new URL(ctx.request.url)
-      const mountPath = (ctx).path ?? "/"
-      const params = PathPattern.match(mountPath, url.pathname)
-      const artifactPath = params ? Values.firstValue(params) : undefined
-      if (!artifactPath) {
-        return Entity.make(new Uint8Array(0), { status: 404 })
-      }
-      const blob = bundle.getArtifact(artifactPath)
-      if (!blob) {
-        return Entity.make(new Uint8Array(0), { status: 404 })
-      }
-      const bytes = new Uint8Array(yield* Effect.promise(() => blob.arrayBuffer()))
-      return Entity.make(bytes, {
-        headers: {
-          "content-type": blob.type || "application/octet-stream",
-          "cache-control": "public, max-age=31536000, immutable",
-        },
-      })
-    }),
-  )
-
-export const client = () => make(Bundle.ClientBundle)
-
-export const layer = (options) =>
-  Layer.effect(
-    Route.Routes,
-    Effect.gen(function* () {
-      const existing = yield* Effect.serviceOption(Route.Routes).pipe(
-        Effect.andThen(Option.getOrUndefined),
-      )
-      const path = options?.path ?? "/_bundle/:path+"
-      const bundleTree = Route.tree({
-        [path]: make(options?.bundle ?? Bundle.ClientBundle),
-      })
-      if (!existing) return bundleTree
-      return RouteTree.merge(existing, bundleTree)
-    }),
-  )

package/dist/client/Overlay.js

@@ -1,33 +0,0 @@
-const OVERLAY_ID = "_bundler_error_overlay"
-
-export function getOverlay() {
-  let overlay = document.getElementById(OVERLAY_ID)
-  if (!overlay) {
-    overlay = document.createElement("pre")
-    overlay.id = OVERLAY_ID
-    Object.assign(overlay.style, {
-      position: "fixed",
-      top: "0",
-      left: "0",
-      right: "0",
-      maxHeight: "40%",
-      overflowY: "auto",
-      margin: "0",
-      padding: "4px",
-      background: "black",
-      color: "red",
-      fontFamily: "monospace",
-      zIndex: "2147483647",
-      whiteSpace: "pre-wrap",
-    })
-    document.body.appendChild(overlay)
-  }
-  return overlay
-}
-
-export function showBuildError(message) {
-  const overlay = getOverlay()
-  const atBottom = overlay.scrollTop + overlay.clientHeight >= overlay.scrollHeight - 1
-  overlay.textContent += message + "\n"
-  if (atBottom) overlay.scrollTop = overlay.scrollHeight
-}

package/dist/client/ScrollState.js

@@ -1,106 +0,0 @@
-const ScrollKey = "_BUNDLER_SCROLL"
-
-/**
- * Persist current scroll state to session storage.
- * Scroll state is saved relatively to visible elements.
- */
-export function persist() {
-  const anchors = []
-  const step = window.innerHeight / 4
-
-  for (let i = 1; i <= 3; i++) {
-    const y = step * i
-    const element = document.elementFromPoint(0, y)
-    if (!element) continue
-    const target = element.id ? element : (element.closest("[id]") ?? element)
-
-    anchors.push({
-      selector: selectorFromElement(target),
-      offset: target.getBoundingClientRect().top,
-    })
-  }
-
-  const state = {
-    anchors,
-    scrollY: window.scrollY,
-  }
-
-  sessionStorage.setItem(ScrollKey, JSON.stringify(state))
-}
-
-export function restore() {
-  const timeout = 3000
-  const tick = 50
-  const raw = sessionStorage.getItem(ScrollKey)
-  if (!raw) return
-
-  sessionStorage.removeItem(ScrollKey)
-
-  const state = JSON.parse(raw)
-
-  const apply = () => {
-    for (const anchor of state.anchors) {
-      const element = document.querySelector(anchor.selector)
-      if (element) {
-        const rect = element.getBoundingClientRect()
-        const top = window.scrollY + rect.top - anchor.offset
-        window.scrollTo({
-          top,
-        })
-        return
-      }
-    }
-
-    window.scrollTo({
-      top: state.scrollY,
-    })
-  }
-
-  let observer
-  let stableTimer
-  const deadline = setTimeout(() => {
-    observer.disconnect()
-    if (stableTimer) clearTimeout(stableTimer)
-    apply()
-  }, timeout)
-
-  observer = new MutationObserver(() => {
-    if (stableTimer) clearTimeout(stableTimer)
-    stableTimer = setTimeout(() => {
-      observer.disconnect()
-      clearTimeout(deadline)
-      apply()
-    }, tick)
-  })
-
-  observer.observe(document.body, {
-    subtree: true,
-    childList: true,
-    attributes: true,
-    characterData: true,
-  })
-
-  stableTimer = setTimeout(() => {
-    observer.disconnect()
-    clearTimeout(deadline)
-    apply()
-  }, tick)
-}
-
-function selectorFromElement(element) {
-  if (element.id) {
-    return `#${CSS.escape(element.id)}`
-  }
-  const parts = []
-  let current = element
-
-  while (current && current !== document.body) {
-    const parent = current.parentElement
-    if (!parent) break
-    const index = Array.from(parent.children).indexOf(current) + 1
-    parts.unshift(`${current.tagName.toLowerCase()}:nth-child(${index})`)
-    current = parent
-  }
-
-  return parts.join(" > ")
-}

package/dist/client/index.js

@@ -1,97 +0,0 @@
-/**
- * This module is intended to be imported in a browser bundle in a development.
- * It is responsible for live reloading the page when bundle changes.
- * When NODE_ENV=production, it does nothing.
- */
-
-/// <reference lib="dom" />
-/// <reference lib="dom.iterable" />
-
-import * as Overlay from "./Overlay.js"
-import * as ScrollState from "./ScrollState.js"
-
-const BUNDLE_URL = globalThis._BUNDLE_URL ?? "/_bundle"
-
-function reload() {
-  ScrollState.persist()
-  window.location.reload()
-}
-
-async function loadAllEntrypoints() {
-  const manifest = await fetch(`/${BUNDLE_URL}/manifest.json`).then((v) =>
-    v.json(),
-  )
-
-  manifest.artifacts
-    .filter((v) => v.path.endsWith(".js"))
-    .forEach((artifact) => {
-      console.log(artifact.path)
-      const script = document.createElement("script")
-      script.src = `${BUNDLE_URL}/${artifact.path}`
-      script.type = "module"
-      script.onload = () => {
-        console.debug("Bundle reloaded")
-      }
-      document.body.appendChild(script)
-    })
-}
-
-function handleBundleEvent(event) {
-  switch (event._tag) {
-    case "Change":
-      console.debug("Bundle change detected...")
-      reload()
-      break
-    case "BuildError":
-      Overlay.showBuildError(event.error)
-      break
-  }
-}
-
-function listen() {
-  const eventSource = new EventSource(`${BUNDLE_URL}/events`)
-
-  eventSource.addEventListener("message", (event) => {
-    try {
-      reloadAllMetaLinks()
-      const data = JSON.parse(event.data)
-
-      handleBundleEvent(data)
-    } catch (error) {
-      console.error("Error parsing SSE event", {
-        error,
-        event,
-      })
-    }
-  })
-
-  eventSource.addEventListener("error", (error) => {
-    console.error("SSE connection error:", error)
-  })
-
-  return () => {
-    eventSource.close()
-  }
-}
-
-function reloadAllMetaLinks() {
-  for (const link of document.getElementsByTagName("link")) {
-    const url = new URL(link.href)
-
-    if (url.host === window.location.host) {
-      const next = link.cloneNode()
-      // TODO: this won't work when link already has query params
-      next.href = next.href + "?" + Math.random().toString(36).slice(2)
-      next.onload = () => link.remove()
-      link.parentNode.insertBefore(next, link.nextSibling)
-      return
-    }
-  }
-}
-
-if (process.env.NODE_ENV !== "production") {
-  window.addEventListener("load", () => {
-    ScrollState.restore()
-    listen()
-  })
-}

package/dist/console/Console.js

@@ -1,42 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Route from "../Route.js"
-import * as RouteTree from "../RouteTree.js"
-import * as ConsoleErrors from "./ConsoleErrors.js"
-import * as ConsoleLogger from "./ConsoleLogger.js"
-import * as ConsoleMetrics from "./ConsoleMetrics.js"
-import * as ConsoleProcess from "./ConsoleProcess.js"
-import * as ConsoleStore from "./ConsoleStore.js"
-import * as ConsoleTracer from "./ConsoleTracer.js"
-import consoleRoutes from "./routes/tree.js"
-
-export { ConsoleStore } from "./ConsoleStore.js"
-
-export function layer(
-  options,
-) {
-  const store = ConsoleStore.layer(options)
-  return Layer.mergeAll(
-    ConsoleTracer.layer,
-    ConsoleLogger.layer,
-    ConsoleMetrics.layer,
-    ConsoleErrors.layer,
-    ConsoleProcess.layer,
-  ).pipe(Layer.provideMerge(store))
-}
-
-export function routeLayer(
-  prefix,
-) {
-  return Layer.effect(
-    Route.Routes,
-    Effect.gen(function* () {
-      const existing = yield* Route.Routes
-      ConsoleStore.store.prefix = prefix
-      const tree = Route.tree({
-        [prefix as "/"]: consoleRoutes,
-      })
-      return RouteTree.merge(existing, tree)
-    }),
-  )
-}

package/dist/console/ConsoleErrors.js

@@ -1,211 +0,0 @@
-import * as Cause from "effect/Cause"
-import * as Chunk from "effect/Chunk"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FiberId from "effect/FiberId"
-import * as FiberRef from "effect/FiberRef"
-import * as HashMap from "effect/HashMap"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as PubSub from "effect/PubSub"
-import * as Supervisor from "effect/Supervisor"
-import * as ConsoleStore from "./ConsoleStore.js"
-
-let errorId = 0
-
-function safeSerialize(value, depth = 0) {
-  if (depth > 4) return "<deep>"
-  if (value === null || value === undefined) return value
-  if (typeof value === "bigint") return `${value}n`
-  if (typeof value === "function") return undefined
-  if (typeof value === "symbol") return value.toString()
-  if (typeof value !== "object") return value
-  if (value instanceof Date) return value.toISOString()
-  if (value instanceof Error) return value.message
-  if (Array.isArray(value)) return value.slice(0, 20).map((v) => safeSerialize(v, depth + 1))
-  const proto = Object.getPrototypeOf(value)
-  if (proto !== null && proto !== Object.prototype) {
-    if (typeof (value)._tag === "string") {
-      return serializeTaggedObject(value, depth)
-    }
-    return `<${proto.constructor?.name ?? "object"}>`
-  }
-  return serializePlainObject(value, depth)
-}
-
-function serializePlainObject(
-  obj,
-  depth,
-) {
-  const out = {}
-  let count = 0
-  for (const [k, v] of Object.entries(obj)) {
-    if (count >= 20) break
-    if (typeof v === "function") continue
-    const serialized = safeSerialize(v, depth + 1)
-    if (serialized !== undefined) {
-      out[k] = serialized
-      count++
-    }
-  }
-  return out
-}
-
-function serializeTaggedObject(
-  obj,
-  depth,
-) {
-  const out = { _tag: obj._tag }
-  let count = 0
-  for (const [k, v] of Object.entries(obj)) {
-    if (count >= 20) break
-    if (k === "_tag") continue
-    if (typeof v === "function") continue
-    if (k === "stack" || k === "name") continue
-    const serialized = safeSerialize(v, depth + 1)
-    if (serialized !== undefined) {
-      out[k] = serialized
-      count++
-    }
-  }
-  return out
-}
-
-function extractTag(error) {
-  if (
-    error !== null &&
-    typeof error === "object" &&
-    "_tag" in error &&
-    typeof (error)._tag === "string"
-  ) {
-    return (error)._tag
-  }
-  return undefined
-}
-
-function extractMessage(error) {
-  if (error instanceof Error) return error.message
-  if (typeof error === "string") return error
-  const tag = extractTag(error)
-  if (tag) return tag
-  try {
-    return String(error)
-  } catch {
-    return "<unknown>"
-  }
-}
-
-function extractProperties(error) {
-  if (error === null || error === undefined || typeof error !== "object") return {}
-  const out = {}
-  let count = 0
-  for (const [k, v] of Object.entries(error)) {
-    if (count >= 20) break
-    if (k === "_tag" || k === "stack" || k === "name") continue
-    if (typeof v === "function") continue
-    const serialized = safeSerialize(v, 0)
-    if (serialized !== undefined) {
-      out[k] = serialized
-      count++
-    }
-  }
-  return out
-}
-
-const spanSymbol = Symbol.for("effect/SpanAnnotation")
-
-function extractSpanName(error) {
-  if (error !== null && typeof error === "object" && spanSymbol in error) {
-    const span = (error)[spanSymbol]
-    return typeof span?.name === "string" ? span.name : undefined
-  }
-  return undefined
-}
-
-function extractDetails(cause) {
-  const details = []
-
-  const failures = Chunk.toArray(Cause.failures(cause))
-  for (const error of failures) {
-    details.push({
-      kind: "fail",
-      tag: extractTag(error),
-      message: extractMessage(error),
-      properties: extractProperties(error),
-      span: extractSpanName(error),
-    })
-  }
-
-  const defects = Chunk.toArray(Cause.defects(cause))
-  for (const defect of defects) {
-    details.push({
-      kind: "die",
-      tag: extractTag(defect),
-      message: extractMessage(defect),
-      properties: extractProperties(defect),
-      span: extractSpanName(defect),
-    })
-  }
-
-  return details
-}
-
-function make(store) {
-  return new (class extends Supervisor.AbstractSupervisor<void> {
-    value = Effect.void
-
-    onStart<A, E, R>(
-      _context: Context.Context<R>,
-      _effect: Effect.Effect<A, E, R>,
-      parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-      fiber: Fiber.RuntimeFiber<A, E>,
-    ) {
-      const childId = FiberId.threadName(fiber.id())
-      if (Option.isSome(parent)) {
-        const parentId = FiberId.threadName(parent.value.id())
-        if (childId !== parentId) {
-          store.fiberParents.set(childId, parentId)
-        }
-      }
-
-      const span = fiber.currentSpan
-      const annotations: Record<string, unknown> = {}
-      const spanAnnotations = fiber.getFiberRef(FiberRef.currentTracerSpanAnnotations)
-      HashMap.forEach(spanAnnotations, (value, key) => {
-        annotations[key] = value
-      })
-      const logAnnotations = fiber.getFiberRef(FiberRef.currentLogAnnotations)
-      HashMap.forEach(logAnnotations, (value, key) => {
-        annotations[key] = value
-      })
-
-      store.fiberContexts.set(childId, {
-        spanName: span?._tag === "Span" ? span.name : undefined,
-        traceId: span ? span.traceId : undefined,
-        annotations,
-      })
-    }
-
-    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>) {
-      if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
-        const error: ConsoleStore.ConsoleError = {
-          id: String(++errorId),
-          date: new Date(),
-          fiberId: FiberId.threadName(fiber.id()),
-          interrupted: Cause.isInterrupted(exit.cause),
-          prettyPrint: Cause.pretty(exit.cause, { renderErrorCause: true }),
-          details: extractDetails(exit.cause),
-        }
-        store.errors.push(error)
-        Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }))
-      }
-    }
-  })()
-}
-
-export const layer = Layer.unwrapEffect(
-  Effect.gen(function* () {
-    const store = yield* ConsoleStore.ConsoleStore
-    return Supervisor.addSupervisor(make(store))
-  }),
-)