effect-start 0.25.0 → 0.26.0

package/dist/console/index.js

@@ -1,3 +0,0 @@
-export * as Console from "./Console.js"
-export * as ConsoleStore from "./ConsoleStore.js"
-export * as Simulation from "./Simulation.js"

package/dist/console/routes/tree.js

@@ -1,30 +0,0 @@
-import * as Route from "../../Route.js"
-import errorsRoute from "./errors/route.tsx"
-import fiberDetailRoute from "./fiberDetail.tsx"
-import fibersRoute from "./fibers/route.tsx"
-import gitRoute from "./git/route.tsx"
-import layout from "./layout.tsx"
-import logsRoute from "./logs/route.tsx"
-import metricsRoute from "./metrics/route.tsx"
-import systemRoute from "./system/route.tsx"
-import rootRoute from "./route.tsx"
-import routesRoute from "./routes/route.tsx"
-import servicesRoute from "./services/route.tsx"
-import traceDetailRoute from "./traceDetail.tsx"
-import tracesRoute from "./traces/route.tsx"
-
-export default Route.tree({
-  "*": layout,
-  "/": rootRoute,
-  "/traces": tracesRoute,
-  "/traces/:id": traceDetailRoute,
-  "/metrics": metricsRoute,
-  "/logs": logsRoute,
-  "/errors": errorsRoute,
-  "/fibers": fibersRoute,
-  "/fibers/:id": fiberDetailRoute,
-  "/routes": routesRoute,
-  "/system": systemRoute,
-  "/services": servicesRoute,
-  "/git": gitRoute,
-})

package/dist/datastar/actions/fetch.js

@@ -1,536 +0,0 @@
-import {
-  action,
-  DATASTAR_FETCH_EVENT,
-  filtered,
-  startPeeking,
-  stopPeeking,
-} from "../engine.js"
-import { kebab } from "../utils.js"
-
-const createHttpMethod = (
-  name,
-  method,
-  openWhenHiddenDefault = true,
-) =>
-  action({
-    name,
-    apply: async (
-      { el, evt, error, cleanups },
-      url,
-      {
-        selector,
-        headers: userHeaders,
-        contentType = "json",
-        filterSignals: { include = /.*/, exclude = /(^|\.)_/ } = {},
-        openWhenHidden = openWhenHiddenDefault,
-        payload,
-        requestCancellation = "auto",
-        retry = "auto",
-        retryInterval = 1_000,
-        retryScaler = 2,
-        retryMaxWaitMs = 30_000,
-        retryMaxCount = 10,
-      } = {},
-    ) => {
-      const controller =
-        requestCancellation instanceof AbortController ? requestCancellation : new AbortController()
-      if (requestCancellation === "auto") {
-        cleanups.get(`@${name}`)?.()
-        cleanups.set(`@${name}`, async () => {
-          controller.abort()
-          await Promise.resolve()
-        })
-      }
-
-      let cleanupFn = null
-
-      try {
-        if (!url?.length) {
-          throw error("FetchNoUrlProvided", { action })
-        }
-
-        const initialHeaders = {
-          Accept: "text/event-stream, text/html, application/json",
-          "Datastar-Request": true,
-        }
-        if (contentType === "json") {
-          initialHeaders["Content-Type"] = "application/json"
-        }
-        const headers = Object.assign({}, initialHeaders, userHeaders)
-
-        const req = {
-          method,
-          headers,
-          openWhenHidden,
-          retry,
-          retryInterval,
-          retryScaler,
-          retryMaxWaitMs,
-          retryMaxCount,
-          signal: controller.signal,
-          onopen: async (response) => {
-            if (response.status >= 400) {
-              dispatchFetch(ERROR, el, { status: response.status.toString() })
-            }
-          },
-          onmessage: (evt) => {
-            if (!evt.event.startsWith("datastar")) return
-            const type = evt.event
-            const argsRawLines = {}
-
-            for (const line of evt.data.split("\n")) {
-              const i = line.indexOf(" ")
-              const k = line.slice(0, i)
-              const v = line.slice(i + 1)
-              ;(argsRawLines[k] ||= []).push(v)
-            }
-
-            const argsRaw = Object.fromEntries(
-              Object.entries(argsRawLines).map(([k, v]) => [k, v.join("\n")]),
-            )
-
-            dispatchFetch(type, el, argsRaw)
-          },
-          onerror: (error) => {
-            if (isWrongContent(error)) {
-              throw error("FetchExpectedTextEventStream", { url })
-            }
-            if (error) {
-              console.error(error.message)
-              dispatchFetch(RETRYING, el, { message: error.message })
-            }
-          },
-        }
-
-        const urlInstance = new URL(url, document.baseURI)
-        const queryParams = new URLSearchParams(urlInstance.search)
-
-        if (contentType === "json") {
-          startPeeking()
-          payload = payload !== undefined ? payload : filtered({ include, exclude })
-          stopPeeking()
-          const body = JSON.stringify(payload)
-          if (method === "GET") {
-            queryParams.set("datastar", body)
-          } else {
-            req.body = body
-          }
-        } else if (contentType === "form") {
-          const formEl = (
-            selector ? document.querySelector(selector) : el.closest("form")
-          )
-          if (!formEl) {
-            throw error("FetchFormNotFound", { action, selector })
-          }
-
-          if (!formEl.noValidate && !formEl.checkValidity()) {
-            formEl.reportValidity()
-            return
-          }
-
-          const formData = new FormData(formEl)
-          let submitter = el
-
-          if (el === formEl && evt instanceof SubmitEvent) {
-            submitter = evt.submitter
-          } else {
-            const preventDefault = (evt) => evt.preventDefault()
-            formEl.addEventListener("submit", preventDefault)
-            cleanupFn = () => {
-              formEl.removeEventListener("submit", preventDefault)
-            }
-          }
-
-          if (submitter instanceof HTMLButtonElement) {
-            const name = submitter.getAttribute("name")
-            if (name) formData.append(name, submitter.value)
-          }
-
-          const multipart = formEl.getAttribute("enctype") === "multipart/form-data"
-          if (!multipart) {
-            headers["Content-Type"] = "application/x-www-form-urlencoded"
-          }
-
-          const formParams = new URLSearchParams(formData)
-          if (method === "GET") {
-            for (const [key, value] of formParams) {
-              queryParams.append(key, value)
-            }
-          } else if (multipart) {
-            req.body = formData
-          } else {
-            req.body = formParams
-          }
-        } else {
-          throw error("FetchInvalidContentType", { action, contentType })
-        }
-
-        dispatchFetch(STARTED, el, {})
-        urlInstance.search = queryParams.toString()
-
-        try {
-          await fetchEventSource(urlInstance.toString(), el, req)
-        } catch (e) {
-          if (!isWrongContent(e)) {
-            throw error("FetchFailed", { method, url, error: e.message })
-          }
-        }
-      } finally {
-        dispatchFetch(FINISHED, el, {})
-        cleanupFn?.()
-        cleanups.delete(`@${name}`)
-      }
-    },
-  })
-
-createHttpMethod("get", "GET", false)
-createHttpMethod("patch", "PATCH")
-createHttpMethod("post", "POST")
-createHttpMethod("put", "PUT")
-createHttpMethod("delete", "DELETE")
-
-export const STARTED = "started"
-export const FINISHED = "finished"
-export const ERROR = "error"
-export const RETRYING = "retrying"
-export const RETRIES_FAILED = "retries-failed"
-
-const dispatchFetch = (type, el, argsRaw) =>
-  document.dispatchEvent(
-    new CustomEvent(DATASTAR_FETCH_EVENT, {
-      detail: { type, el, argsRaw },
-    }),
-  )
-
-const isWrongContent = (err) => `${err}`.includes("text/event-stream")
-
-const getBytes = async (
-  stream,
-  onChunk,
-) => {
-  const reader = stream.getReader()
-  let result = await reader.read()
-  while (!result.done) {
-    onChunk(result.value)
-    result = await reader.read()
-  }
-}
-
-const getLines = (onLine) => {
-  let buffer
-  let position
-  let fieldLength
-  let discardTrailingNewline = false
-
-  return (arr) => {
-    if (!buffer) {
-      buffer = arr
-      position = 0
-      fieldLength = -1
-    } else {
-      buffer = concat(buffer, arr)
-    }
-
-    const bufLength = buffer.length
-    let lineStart = 0
-    while (position < bufLength) {
-      if (discardTrailingNewline) {
-        if (buffer[position] === 10) lineStart = ++position
-        discardTrailingNewline = false
-      }
-
-      let lineEnd = -1
-      for (; position < bufLength && lineEnd === -1; ++position) {
-        switch (buffer[position]) {
-          case 58:
-            if (fieldLength === -1) {
-              fieldLength = position - lineStart
-            }
-            break
-          // @ts-expect-error:7029
-          case 13:
-            discardTrailingNewline = true
-          case 10:
-            lineEnd = position
-            break
-        }
-      }
-
-      if (lineEnd === -1) break
-
-      onLine(buffer.subarray(lineStart, lineEnd), fieldLength)
-      lineStart = position
-      fieldLength = -1
-    }
-
-    if (lineStart === bufLength) buffer = undefined
-    else if (lineStart) {
-      buffer = buffer.subarray(lineStart)
-      position -= lineStart
-    }
-  }
-}
-
-const getMessages = (
-  onId,
-  onRetry,
-  onMessage,
-) => {
-  let message = newMessage()
-  const decoder = new TextDecoder()
-
-  return (line, fieldLength) => {
-    if (!line.length) {
-      onMessage?.(message)
-      message = newMessage()
-    } else if (fieldLength > 0) {
-      const field = decoder.decode(line.subarray(0, fieldLength))
-      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1)
-      const value = decoder.decode(line.subarray(valueOffset))
-
-      switch (field) {
-        case "data":
-          message.data = message.data ? `${message.data}\n${value}` : value
-          break
-        case "event":
-          message.event = value
-          break
-        case "id":
-          onId((message.id = value))
-          break
-        case "retry": {
-          const retry = +value
-          if (!Number.isNaN(retry)) {
-            onRetry((message.retry = retry))
-          }
-          break
-        }
-      }
-    }
-  }
-}
-
-const concat = (a, b) => {
-  const res = new Uint8Array(a.length + b.length)
-  res.set(a)
-  res.set(b, a.length)
-  return res
-}
-
-const newMessage = () => ({
-  data: "",
-  event: "",
-  id: "",
-  retry: undefined,
-})
-
-const fetchEventSource = (
-  input,
-  el,
-  {
-    signal: inputSignal,
-    headers: inputHeaders,
-    onopen: inputOnOpen,
-    onmessage,
-    onclose,
-    onerror,
-    openWhenHidden,
-    fetch: inputFetch,
-    retry = "auto",
-    retryInterval = 1_000,
-    retryScaler = 2,
-    retryMaxWaitMs = 30_000,
-    retryMaxCount = 10,
-    responseOverrides,
-    ...rest
-  },
-) => {
-  return new Promise((resolve, reject) => {
-    const headers = {
-      ...inputHeaders,
-    }
-
-    let curRequestController
-    const onVisibilityChange = () => {
-      curRequestController.abort()
-      if (!document.hidden) create()
-    }
-
-    if (!openWhenHidden) {
-      document.addEventListener("visibilitychange", onVisibilityChange)
-    }
-
-    let retryTimer
-    const dispose = () => {
-      document.removeEventListener("visibilitychange", onVisibilityChange)
-      clearTimeout(retryTimer)
-      curRequestController.abort()
-    }
-
-    inputSignal?.addEventListener("abort", () => {
-      dispose()
-      resolve()
-    })
-
-    const fetch = inputFetch || window.fetch
-    const onopen = inputOnOpen || (() => {})
-
-    let retries = 0
-    let baseRetryInterval = retryInterval
-    const create = async () => {
-      curRequestController = new AbortController()
-      const curRequestSignal = curRequestController.signal
-      try {
-        const response = await fetch(input, {
-          ...rest,
-          headers,
-          signal: curRequestSignal,
-        })
-
-        await onopen(response)
-
-        const dispatchNonSSE = async (
-          dispatchType,
-          response,
-          name,
-          responseOverrides,
-          ...argNames
-        ) => {
-          const argsRaw = {
-            [name]: await response.text(),
-          }
-          for (const n of argNames) {
-            let v = response.headers.get(`datastar-${kebab(n)}`)
-            if (responseOverrides) {
-              const o = (responseOverrides)[n]
-              if (o) v = typeof o === "string" ? o : JSON.stringify(o)
-            }
-            if (v) argsRaw[n] = v
-          }
-
-          dispatchFetch(dispatchType, el, argsRaw)
-          dispose()
-          resolve()
-        }
-
-        const status = response.status
-        const isNoContentStatus = status === 204
-        const isRedirectStatus = status >= 300 && status < 400
-        const isErrorStatus = status >= 400 && status < 600
-
-        if (status !== 200) {
-          onclose?.()
-          if (
-            retry !== "never" &&
-            !isNoContentStatus &&
-            !isRedirectStatus &&
-            (retry === "always" || (retry === "error" && isErrorStatus))
-          ) {
-            clearTimeout(retryTimer)
-            retryTimer = setTimeout(create, retryInterval)
-            return
-          }
-          dispose()
-          resolve()
-          return
-        }
-
-        retries = 0
-        retryInterval = baseRetryInterval
-
-        const ct = response.headers.get("Content-Type")
-        if (ct?.includes("text/html")) {
-          return await dispatchNonSSE(
-            "datastar-patch-elements",
-            response,
-            "elements",
-            responseOverrides,
-            "selector",
-            "mode",
-            "namespace",
-            "useViewTransition",
-            "namespace",
-          )
-        }
-
-        if (ct?.includes("application/json")) {
-          return await dispatchNonSSE(
-            "datastar-patch-signals",
-            response,
-            "signals",
-            responseOverrides,
-            "onlyIfMissing",
-          )
-        }
-
-        if (ct?.includes("text/javascript")) {
-          const script = document.createElement("script")
-          const scriptAttributesHeader = response.headers.get("datastar-script-attributes")
-
-          if (scriptAttributesHeader) {
-            for (const [name, value] of Object.entries(JSON.parse(scriptAttributesHeader))) {
-              script.setAttribute(name, value)
-            }
-          }
-          script.textContent = await response.text()
-          document.head.appendChild(script)
-          dispose()
-          return
-        }
-
-        await getBytes(
-          response.body,
-          getLines(
-            getMessages(
-              (id) => {
-                if (id) {
-                  headers["last-event-id"] = id
-                } else {
-                  delete headers["last-event-id"]
-                }
-              },
-              (retry) => {
-                baseRetryInterval = retryInterval = retry
-              },
-              onmessage,
-            ),
-          ),
-        )
-
-        onclose?.()
-
-        if (retry === "always" && !isRedirectStatus) {
-          clearTimeout(retryTimer)
-          retryTimer = setTimeout(create, retryInterval)
-          return
-        }
-
-        dispose()
-        resolve()
-      } catch (err) {
-        if (!curRequestSignal.aborted) {
-          try {
-            const interval = onerror?.(err) || retryInterval
-            clearTimeout(retryTimer)
-            retryTimer = setTimeout(create, interval)
-            retryInterval = Math.min(retryInterval * retryScaler, retryMaxWaitMs)
-            if (++retries >= retryMaxCount) {
-              dispatchFetch(RETRIES_FAILED, el, {})
-              dispose()
-              reject("Max retries reached.")
-            } else {
-              console.error(
-                `Datastar failed to reach ${input.toString()} retrying in ${interval}ms.`,
-              )
-            }
-          } catch (innerErr) {
-            dispose()
-            reject(innerErr)
-          }
-        }
-      }
-    }
-
-    create()
-  })
-}

package/dist/datastar/actions/peek.js

@@ -1,13 +0,0 @@
-import { action, startPeeking, stopPeeking } from "../engine.js"
-
-action({
-  name: "peek",
-  apply(_, fn) {
-    startPeeking()
-    try {
-      return fn()
-    } finally {
-      stopPeeking()
-    }
-  },
-})

package/dist/datastar/actions/setAll.js

@@ -1,19 +0,0 @@
-import {
-  action,
-  filtered,
-  mergePatch,
-  startPeeking,
-  stopPeeking,
-} from "../engine.js"
-import { updateLeaves } from "../utils.js"
-
-action({
-  name: "setAll",
-  apply(_, value, filter) {
-    startPeeking()
-    const masked = filtered(filter)
-    updateLeaves(masked, () => value)
-    mergePatch(masked)
-    stopPeeking()
-  },
-})

package/dist/datastar/actions/toggleAll.js

@@ -1,19 +0,0 @@
-import {
-  action,
-  filtered,
-  mergePatch,
-  startPeeking,
-  stopPeeking,
-} from "../engine.js"
-import { updateLeaves } from "../utils.js"
-
-action({
-  name: "toggleAll",
-  apply(_, filter) {
-    startPeeking()
-    const masked = filtered(filter)
-    updateLeaves(masked, (oldValue) => !oldValue)
-    mergePatch(masked)
-    stopPeeking()
-  },
-})

package/dist/datastar/attributes/attr.js

@@ -1,49 +0,0 @@
-import { attribute, effect } from "../engine.js"
-
-attribute({
-  name: "attr",
-  requirement: { value: "must" },
-  returnsValue: true,
-  apply({ el, key, rx }) {
-    const syncAttr = (key, val) => {
-      if (val === "" || val === true) {
-        el.setAttribute(key, "")
-      } else if (val === false || val == null) {
-        el.removeAttribute(key)
-      } else if (typeof val === "string") {
-        el.setAttribute(key, val)
-      } else {
-        el.setAttribute(key, JSON.stringify(val))
-      }
-    }
-
-    const update = key
-      ? () => {
-          observer.disconnect()
-          const val = rx()
-          syncAttr(key, val)
-          observer.observe(el, {
-            attributeFilter: [key],
-          })
-        }
-      : () => {
-          observer.disconnect()
-          const obj = rx()
-          const attributeFilter = Object.keys(obj)
-          for (const key of attributeFilter) {
-            syncAttr(key, obj[key])
-          }
-          observer.observe(el, {
-            attributeFilter,
-          })
-        }
-
-    const observer = new MutationObserver(update)
-    const cleanup = effect(update)
-
-    return () => {
-      observer.disconnect()
-      cleanup()
-    }
-  },
-})