effect-start 0.34.0 → 0.35.0

package/src/StaticFiles.ts

@@ -1,15 +1,12 @@
 import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import * as Entity from "./Entity.ts"
 import * as FileSystem from "./FileSystem.ts"
-import * as PathPattern from "./_PathPattern.ts"
+import type * as PathPattern from "./_PathPattern.ts"
 import * as Mime from "./_Mime.ts"
 import * as Route from "./Route.ts"
 import * as RouteSchema from "./RouteSchema.ts"
-import * as RouteTree from "./RouteTree.ts"
-import * as System from "./System.ts"
 
 const defaultMountPath = "/assets"
 const PathParamsSchema = Schema.Struct({
@@ -55,26 +52,15 @@ export const make = (directory: string) =>
 export const layer = (options: {
   directory: string
   path?: string
-}) =>
-  Layer.effect(
-    Route.Routes,
-    Effect.gen(function* () {
-      const existing = yield* Effect.serviceOption(Route.Routes).pipe(
-        Effect.andThen(Option.getOrUndefined),
-      )
-      const trimmedMountPath = (options.path ?? defaultMountPath).trim().replace(/^\/+|\/+$/g, "")
-      const mountPattern = (
-        trimmedMountPath.length > 0 ? `/${trimmedMountPath}/:path+` : "/:path+"
-      ) as PathPattern.PathPattern
-      const staticFilesTree = Route.tree({
-        [mountPattern]: make(options.directory),
-      })
-      if (!existing) {
-        return staticFilesTree
-      }
-      return RouteTree.merge(existing, staticFilesTree)
-    }),
-  )
+}) => {
+  const trimmedMountPath = (options.path ?? defaultMountPath).trim().replace(/^\/+|\/+$/g, "")
+  const mountPattern = (
+    trimmedMountPath.length > 0 ? `/${trimmedMountPath}/:path+` : "/:path+"
+  ) as PathPattern.PathPattern
+  return Route.layerMerge({
+    [mountPattern]: make(options.directory),
+  })
+}
 
 function normalizeRelativePath(path: string): string | null {
   if (path.length === 0 || path.startsWith("/") || path.startsWith("\\")) {

package/src/_HtmlScanner.ts

@@ -0,0 +1,415 @@
+const TEXT = 0
+const TAG_OPEN = 1
+const TAG_NAME = 2
+const BEFORE_ATTR_NAME = 3
+const ATTR_NAME = 4
+const AFTER_ATTR_NAME = 5
+const BEFORE_ATTR_VALUE = 6
+const ATTR_VALUE_DOUBLE_QUOTED = 7
+const ATTR_VALUE_SINGLE_QUOTED = 8
+const ATTR_VALUE_UNQUOTED = 9
+const SELF_CLOSING = 10
+const BOGUS_COMMENT = 11
+
+const RAW_TEXT_TAGS = ["script", "style", "textarea", "title"]
+
+interface Span {
+  start: number
+  end: number
+}
+
+interface AttrInternal {
+  value: string
+  nameSpan: Span
+  valueSpan: Span | undefined
+}
+
+interface TokenizedElement {
+  tag: string
+  attrs: Map<string, AttrInternal>
+  end: number
+}
+
+function* tokenize(html: string): Generator<TokenizedElement> {
+  const len = html.length
+  let i = 0
+  let state = TEXT
+  let tag = ""
+  let attrName = ""
+  let attrNameStart = 0
+  let attrValue = ""
+  let attrValueStart = 0
+  let attrs = new Map<string, AttrInternal>()
+
+  let pending: TokenizedElement | undefined
+
+  const emit = (): string | undefined => {
+    const lower = tag.toLowerCase()
+    pending = { tag, attrs, end: i }
+    tag = ""
+    attrs = new Map()
+    return RAW_TEXT_TAGS.includes(lower) ? lower : undefined
+  }
+
+  const emitAndContinue = () => {
+    const rawTag = emit()
+    state = TEXT
+    if (rawTag) {
+      const needle = `</${rawTag}`
+      const idx = html.toLowerCase().indexOf(needle, i)
+      if (idx === -1) {
+        i = len
+      } else {
+        const end = html.indexOf(">", idx + needle.length)
+        i = end === -1 ? len : end + 1
+      }
+    }
+  }
+
+  const commitAttr = () => {
+    if (attrName) {
+      attrs.set(attrName.toLowerCase(), {
+        value: attrValue,
+        nameSpan: { start: attrNameStart, end: attrNameStart + attrName.length },
+        valueSpan: attrValueStart > 0
+          ? { start: attrValueStart, end: attrValueStart + attrValue.length }
+          : undefined,
+      })
+      attrName = ""
+      attrValue = ""
+      attrValueStart = 0
+    }
+  }
+
+  while (i < len) {
+    const ch = html[i]
+
+    switch (state) {
+      case TEXT:
+        if (ch === "<") {
+          const next = html[i + 1]
+          if (next === "!" && html[i + 2] === "-" && html[i + 3] === "-") {
+            const end = html.indexOf("-->", i + 4)
+            i = end === -1 ? len : end + 3
+          } else if (next === "!" || next === "?") {
+            state = BOGUS_COMMENT
+            i++
+          } else {
+            state = TAG_OPEN
+            i++
+          }
+        } else {
+          i++
+        }
+        break
+
+      case BOGUS_COMMENT: {
+        const end = html.indexOf(">", i)
+        i = end === -1 ? len : end + 1
+        state = TEXT
+        break
+      }
+
+      case TAG_OPEN:
+        if (ch === "/") {
+          const end = html.indexOf(">", i)
+          i = end === -1 ? len : end + 1
+          state = TEXT
+        } else if ((ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z")) {
+          tag = ch
+          state = TAG_NAME
+          i++
+        } else {
+          state = TEXT
+        }
+        break
+
+      case TAG_NAME:
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f") {
+          state = BEFORE_ATTR_NAME
+          i++
+        } else if (ch === "/") {
+          state = SELF_CLOSING
+          i++
+        } else if (ch === ">") {
+          i++
+          emitAndContinue()
+        } else {
+          tag += ch
+          i++
+        }
+        break
+
+      case BEFORE_ATTR_NAME:
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f") {
+          i++
+        } else if (ch === "/") {
+          state = SELF_CLOSING
+          i++
+        } else if (ch === ">") {
+          i++
+          emitAndContinue()
+        } else {
+          attrName = ch
+          attrNameStart = i
+          state = ATTR_NAME
+          i++
+        }
+        break
+
+      case ATTR_NAME:
+        if (ch === "=") {
+          state = BEFORE_ATTR_VALUE
+          i++
+        } else if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f") {
+          state = AFTER_ATTR_NAME
+          i++
+        } else if (ch === "/" || ch === ">") {
+          commitAttr()
+          if (ch === "/") {
+            state = SELF_CLOSING
+            i++
+          } else {
+            i++
+            emitAndContinue()
+          }
+        } else {
+          attrName += ch
+          i++
+        }
+        break
+
+      case AFTER_ATTR_NAME:
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f") {
+          i++
+        } else if (ch === "=") {
+          state = BEFORE_ATTR_VALUE
+          i++
+        } else if (ch === "/") {
+          commitAttr()
+          state = SELF_CLOSING
+          i++
+        } else if (ch === ">") {
+          commitAttr()
+          i++
+          emitAndContinue()
+        } else {
+          commitAttr()
+          attrName = ch
+          attrNameStart = i
+          state = ATTR_NAME
+          i++
+        }
+        break
+
+      case BEFORE_ATTR_VALUE:
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f") {
+          i++
+        } else if (ch === '"') {
+          attrValueStart = i + 1
+          state = ATTR_VALUE_DOUBLE_QUOTED
+          i++
+        } else if (ch === "'") {
+          attrValueStart = i + 1
+          state = ATTR_VALUE_SINGLE_QUOTED
+          i++
+        } else if (ch === ">") {
+          commitAttr()
+          i++
+          emitAndContinue()
+        } else {
+          attrValue = ch
+          attrValueStart = i
+          state = ATTR_VALUE_UNQUOTED
+          i++
+        }
+        break
+
+      case ATTR_VALUE_DOUBLE_QUOTED:
+        if (ch === '"') {
+          commitAttr()
+          state = BEFORE_ATTR_NAME
+          i++
+        } else {
+          attrValue += ch
+          i++
+        }
+        break
+
+      case ATTR_VALUE_SINGLE_QUOTED:
+        if (ch === "'") {
+          commitAttr()
+          state = BEFORE_ATTR_NAME
+          i++
+        } else {
+          attrValue += ch
+          i++
+        }
+        break
+
+      case ATTR_VALUE_UNQUOTED:
+        if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r" || ch === "\f") {
+          commitAttr()
+          state = BEFORE_ATTR_NAME
+          i++
+        } else if (ch === ">") {
+          commitAttr()
+          i++
+          emitAndContinue()
+        } else {
+          attrValue += ch
+          i++
+        }
+        break
+
+      case SELF_CLOSING:
+        if (ch === ">") {
+          i++
+          emitAndContinue()
+        } else {
+          state = BEFORE_ATTR_NAME
+        }
+        break
+    }
+
+    if (pending) {
+      yield pending
+      pending = undefined
+    }
+  }
+}
+
+interface ParsedElement {
+  readonly tagName: string
+  readonly attributes: ReadonlyMap<string, string>
+}
+
+export function* parse(html: string): Generator<ParsedElement> {
+  for (const tok of tokenize(html)) {
+    const attributes = new Map<string, string>()
+    for (const [name, attr] of tok.attrs) {
+      attributes.set(name, attr.value)
+    }
+    yield { tagName: tok.tag.toLowerCase(), attributes }
+  }
+}
+
+class MutableElement {
+  readonly tagName: string
+  private _attrs: Map<string, AttrInternal>
+  private _edits: Array<{ offset: number; deleteCount: number; insert: string }>
+  private _html: string
+  private _end: number
+
+  constructor(
+    tok: TokenizedElement,
+    edits: Array<{ offset: number; deleteCount: number; insert: string }>,
+    html: string,
+  ) {
+    this.tagName = tok.tag.toLowerCase()
+    this._attrs = tok.attrs
+    this._edits = edits
+    this._html = html
+    this._end = tok.end
+  }
+
+  getAttribute(name: string): string | null {
+    const attr = this._attrs.get(name.toLowerCase())
+    return attr ? attr.value : null
+  }
+
+  hasAttribute(name: string): boolean {
+    return this._attrs.has(name.toLowerCase())
+  }
+
+  setAttribute(name: string, value: string): this {
+    const lower = name.toLowerCase()
+    const attr = this._attrs.get(lower)
+    if (attr && attr.valueSpan) {
+      this._edits.push({
+        offset: attr.valueSpan.start,
+        deleteCount: attr.valueSpan.end - attr.valueSpan.start,
+        insert: value,
+      })
+      attr.value = value
+    } else if (attr) {
+      this._edits.push({
+        offset: attr.nameSpan.start,
+        deleteCount: attr.nameSpan.end - attr.nameSpan.start,
+        insert: `${name}="${value}"`,
+      })
+      attr.value = value
+      attr.valueSpan = { start: -1, end: -1 }
+    } else {
+      const insertAt = this._end - 1
+      this._edits.push({
+        offset: insertAt,
+        deleteCount: 0,
+        insert: ` ${name}="${value}"`,
+      })
+      this._attrs.set(lower, {
+        value,
+        nameSpan: { start: -1, end: -1 },
+        valueSpan: { start: -1, end: -1 },
+      })
+    }
+    return this
+  }
+
+  removeAttribute(name: string): this {
+    const lower = name.toLowerCase()
+    const attr = this._attrs.get(lower)
+    if (!attr || attr.nameSpan.start === -1) return this
+
+    let start = attr.nameSpan.start
+    const end = attr.valueSpan
+      ? attr.valueSpan.end + 1
+      : attr.nameSpan.end
+
+    while (start > 0 && " \t\n\r\f".includes(this._html[start - 1])) {
+      start--
+    }
+
+    this._edits.push({ offset: start, deleteCount: end - start, insert: "" })
+    this._attrs.delete(lower)
+    return this
+  }
+
+  get attributes(): IterableIterator<[string, string]> {
+    const entries = this._attrs.entries()
+    return (function* () {
+      for (const [name, attr] of entries) {
+        yield [name, attr.value] as [string, string]
+      }
+    })()
+  }
+}
+
+interface RewriteResult extends Iterable<MutableElement> {
+  toString(): string
+}
+
+export const rewrite = (html: string): RewriteResult => {
+  const edits: Array<{ offset: number; deleteCount: number; insert: string }> = []
+
+  return {
+    *[Symbol.iterator]() {
+      for (const tok of tokenize(html)) {
+        yield new MutableElement(tok, edits, html)
+      }
+    },
+    toString() {
+      if (edits.length === 0) return html
+
+      edits.sort((a, b) => b.offset - a.offset)
+      let result = html
+      for (const edit of edits) {
+        result =
+          result.slice(0, edit.offset) +
+          edit.insert +
+          result.slice(edit.offset + edit.deleteCount)
+      }
+      return result
+    },
+  }
+}

package/src/bun/BunRoute.ts

@@ -25,7 +25,7 @@ export type BunDescriptors = {
 }
 
 export function descriptors(
-  route: Route.Route.Route<any, any, any, any, any>,
+  route: Route.Route<any, any, any, any, any>,
 ): BunDescriptors | undefined {
   const descriptor = Route.descriptor(route) as Partial<BunDescriptors>
   if (typeof descriptor.bunPrefix === "string" && typeof descriptor.bunLoad === "function") {
@@ -45,29 +45,29 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
   const descriptors = { bunPrefix, bunLoad, format: "html" as const }
 
   return function <D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple>(
-    self: Route.RouteSet.RouteSet<D, B, I>,
-  ): Route.RouteSet.RouteSet<
+    self: Route.RouteSet<D, B, I>,
+  ): Route.RouteSet<
     D,
     B,
     [
       ...I,
-      Route.Route.Route<
+      Route.Route<
         BunDescriptors & { format: "html" },
-        { request: Request },
+        {},
         string,
         BunRouteError,
-        BunServer.BunServer
+        BunServer.BunServer | Route.Request
       >,
     ]
   > {
     const handler: Route.Route.Handler<
-      BunDescriptors & { format: "html" } & { request: Request },
+      BunDescriptors & { format: "html" },
       string,
       BunRouteError,
-      BunServer.BunServer
+      BunServer.BunServer | Route.Request
     > = (context, next) =>
       Effect.gen(function* () {
-        const originalRequest = context.request
+        const originalRequest = yield* Route.Request
         const bundleDepth = yield* FiberRef.get(bundleDepthRef)
 
         if (originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true") {
@@ -142,10 +142,10 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
 
     const route = Route.make<
       BunDescriptors & { format: "html" },
-      { request: Request },
+      {},
       string,
       BunRouteError,
-      BunServer.BunServer
+      BunServer.BunServer | Route.Request
     >(handler, descriptors)
 
     return Route.set([...Route.items(self), route] as any, Route.descriptor(self))

package/src/bundler/BundleRoute.ts

@@ -1,11 +1,8 @@
 import type * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
 import * as Entity from "../Entity.ts"
 import * as PathPattern from "../_PathPattern.ts"
 import * as Route from "../Route.ts"
-import * as RouteTree from "../RouteTree.ts"
 import * as Values from "../_Values.ts"
 import * as Bundle from "./Bundle.ts"
 
@@ -23,7 +20,8 @@ export const make = <Tag extends Context.Tag<any, Bundle.BundleContext>>(tag: Ta
   Route.get(
     Route.render(function* (ctx) {
       const bundle = yield* tag
-      const url = new URL(ctx.request.url)
+      const request = yield* Route.Request
+      const url = new URL(request.url)
       const mountPath = (ctx as unknown as { path?: string }).path ?? "/"
       const params = PathPattern.match(mountPath, url.pathname)
       const artifactPath = params ? Values.firstValue(params) : undefined
@@ -49,18 +47,9 @@ export const client = () => make(Bundle.ClientBundle)
 export const layer = (options?: {
   bundle?: Context.Tag<any, Bundle.BundleContext>
   path?: PathPattern.PathPattern
-}) =>
-  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)
-    }),
-  )
+}) => {
+  const path = options?.path ?? "/_bundle/:path+"
+  return Route.layerMerge({
+    [path]: make(options?.bundle ?? Bundle.ClientBundle),
+  })
+}

package/src/datastar/watchers/patchElements.ts

@@ -403,7 +403,7 @@ const removeNode = (node: Node): void => {
 }
 
 const moveBefore: (parentNode: Node, node: Node, after: Node | null) => void = removeNode.call.bind(
-  // @ts-expect-error
+  // @ts-ignore
   ctxPantry.moveBefore ?? ctxPantry.insertBefore,
 )
 

package/src/dev.d.ts

@@ -0,0 +1,3 @@
+declare module "effect-start/dev" {
+  export interface Routes {}
+}