effect-start 0.29.0 → 0.30.0

package/src/hyper/HyperRoute.test.tsx

@@ -1,166 +0,0 @@
-/** @jsxImportSource effect-start */
-import * as test from "bun:test"
-import type * as Engine from "../datastar/engine.ts"
-import * as Effect from "effect/Effect"
-import * as Entity from "../Entity.ts"
-import * as Fetch from "../Fetch.ts"
-import * as Route from "../Route.ts"
-import * as RouteHttp from "../RouteHttp.ts"
-import * as HyperRoute from "./HyperRoute.ts"
-
-test.describe("HyperRoute.html", () => {
-  test.it("renders JSX to HTML string", async () => {
-    const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(<div>Hello World</div>)))
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test.expect(response.status).toBe(200)
-    test.expect(response.headers.get("Content-Type")).toBe("text/html; charset=utf-8")
-    test.expect(await response.text()).toBe("<div>Hello World</div>")
-  })
-
-  test.it("renders nested JSX elements", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <div class="container">
-            <h1>Title</h1>
-            <p>Paragraph</p>
-          </div>,
-        ),
-      ),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test
-      .expect(await response.text())
-      .toBe('<div class="container"><h1>Title</h1><p>Paragraph</p></div>')
-  })
-
-  test.it("renders JSX from Effect", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(HyperRoute.html(Effect.succeed(<span>From Effect</span>))),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<span>From Effect</span>")
-  })
-
-  test.it("renders JSX from generator function", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          Effect.gen(function* () {
-            const name = yield* Effect.succeed("World")
-            return <div>Hello {name}</div>
-          }),
-        ),
-      ),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<div>Hello World</div>")
-  })
-
-  test.it("renders JSX from handler function", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(HyperRoute.html((context) => Effect.succeed(<div>Request received</div>))),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<div>Request received</div>")
-  })
-
-  test.it("renders JSX with dynamic content", async () => {
-    const items = ["Apple", "Banana", "Cherry"]
-
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <ul>
-            {items.map((item) => (
-              <li>{item}</li>
-            ))}
-          </ul>,
-        ),
-      ),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test.expect(await response.text()).toBe("<ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul>")
-  })
-
-  test.it("handles Entity with JSX body", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(HyperRoute.html(Entity.make(<div>With Entity</div>, { status: 201 }))),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test.expect(response.status).toBe(201)
-    test.expect(await response.text()).toBe("<div>With Entity</div>")
-  })
-
-  test.it("renders data-* attributes with object values as JSON", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <div
-            data-signals={{
-              draft: "",
-              pendingDraft: "",
-              username: "User123",
-            }}
-          >
-            Content
-          </div>,
-        ),
-      ),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-
-    test
-      .expect(await response.text())
-      .toBe(`<div data-signals='{"draft":"","pendingDraft":"","username":"User123"}'>Content</div>`)
-  })
-
-  test.it("data-on-click function argument is typed as DataEvent", () => {
-    const node = (
-      <button
-        data-on:click={(e) => {
-          test.expectTypeOf(e).toMatchTypeOf<Engine.DataEvent>()
-          test.expectTypeOf(e.window).toMatchTypeOf<Window & typeof globalThis>()
-        }}
-      />
-    )
-
-    test.expect(node).toBeDefined()
-  })
-
-  test.it("renders script with function child as IIFE", async () => {
-    const handler = RouteHttp.toWebHandler(
-      Route.get(
-        HyperRoute.html(
-          <script>
-            {(window) => {
-              console.log("Hello from", window.document.title)
-            }}
-          </script>,
-        ),
-      ),
-    )
-
-    const response = await Fetch.fromHandler(handler, { path: "/" })
-    const text = await response.text()
-
-    test.expect(text).toContain("<script>(")
-    test.expect(text).toContain(")(window)</script>")
-    test.expect(text).toContain("window.document.title")
-  })
-})

package/src/hyper/HyperRoute.ts

@@ -1,59 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Entity from "../Entity.ts"
-import * as Route from "../Route.ts"
-import type * as RouteBody from "../RouteBody.ts"
-import type * as Values from "../_Values.ts"
-import * as HyperHtml from "./HyperHtml.ts"
-import type { JSX } from "./jsx.d.ts"
-
-function renderValue(
-  value: JSX.Children | Entity.Entity<JSX.Children>,
-): string | Entity.Entity<string> {
-  if (Entity.isEntity(value)) {
-    return Entity.make(HyperHtml.renderToString(value.body), {
-      status: value.status,
-      url: value.url,
-      headers: value.headers,
-    })
-  }
-  return HyperHtml.renderToString(value)
-}
-
-function normalizeToEffect<B, A, E, R>(
-  handler: RouteBody.HandlerInput<B, A, E, R>,
-  context: Values.Simplify<B>,
-  next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<A>,
-): Effect.Effect<A | Entity.Entity<A>, E, R> {
-  if (Effect.isEffect(handler)) {
-    return handler
-  }
-  if (typeof handler === "function") {
-    const result = (handler as Function)(context, next)
-    if (Effect.isEffect(result)) {
-      return result as Effect.Effect<A | Entity.Entity<A>, E, R>
-    }
-    return Effect.gen(function* () {
-      return yield* result
-    }) as Effect.Effect<A | Entity.Entity<A>, E, R>
-  }
-  return Effect.succeed(handler as A | Entity.Entity<A>)
-}
-
-export function html<
-  D extends Route.RouteDescriptor.Any,
-  B extends {},
-  I extends Route.Route.Tuple,
-  E = never,
-  R = never,
->(
-  handler: RouteBody.HandlerInput<
-    NoInfer<D & B & Route.ExtractBindings<I> & { format: "html" }>,
-    JSX.Children,
-    E,
-    R
-  >,
-) {
-  return Route.html<D, B, I, string, E, R>((context, next) =>
-    Effect.map(normalizeToEffect(handler, context, next as never), renderValue),
-  )
-}

package/src/hyper/html.ts

@@ -1,47 +0,0 @@
-const HtmlStringSymbol = Symbol.for("HtmlString")
-
-export interface HtmlString {
-  readonly [HtmlStringSymbol]: true
-  readonly value: string
-}
-
-const makeHtmlString = (value: string): HtmlString => ({
-  [HtmlStringSymbol]: true,
-  value,
-})
-
-const isHtmlString = (value: unknown): value is HtmlString =>
-  typeof value === "object" && value !== null && HtmlStringSymbol in value
-
-export type HtmlValue =
-  | string
-  | number
-  | bigint
-  | boolean
-  | null
-  | undefined
-  | HtmlString
-  | Function
-  | Record<string, unknown>
-  | ReadonlyArray<HtmlValue>
-
-const resolveValue = (value: HtmlValue): string => {
-  if (value === null || value === undefined || value === false || value === true) return ""
-  if (isHtmlString(value)) return value.value
-  if (Array.isArray(value)) return (value as Array<HtmlValue>).map(resolveValue).join("")
-  if (typeof value === "function") return value.toString()
-  if (typeof value === "object") return JSON.stringify(value)
-  if (typeof value === "string") return value
-  return String(value)
-}
-
-export const html = (strings: TemplateStringsArray, ...values: Array<HtmlValue>): HtmlString => {
-  let result = strings[0]
-  for (let i = 0; i < values.length; i++) {
-    result += resolveValue(values[i])
-    result += strings[i + 1]
-  }
-  return makeHtmlString(result)
-}
-
-html.raw = (value: string): HtmlString => makeHtmlString(value)

package/src/hyper/index.ts

@@ -1,6 +0,0 @@
-export * as Hyper from "./Hyper.ts"
-export { html } from "./html.ts"
-export type { HtmlString, HtmlValue } from "./html.ts"
-export * as HyperHtml from "./HyperHtml.ts"
-export * as HyperNode from "./HyperNode.ts"
-export * as HyperRoute from "./HyperRoute.ts"

package/src/hyper/jsx-runtime.ts

@@ -1,15 +0,0 @@
-import * as HyperNode from "./HyperNode.ts"
-import type { JSX } from "./jsx.d.ts"
-
-function Fragment(props: { children: JSX.Element }) {
-  return props.children
-}
-
-function jsx<T extends HyperNode.Type>(
-  type: T,
-  props: T extends string ? HyperNode.Props : T extends (props: infer P) => any ? P : never,
-): HyperNode.HyperNode {
-  return HyperNode.make(type, props)
-}
-
-export { Fragment, type JSX, jsx, jsx as jsxDEV, jsx as jsxs }