effect-start 0.17.0 → 0.17.2

package/dist/hyper/HyperHtml.js

@@ -0,0 +1,144 @@
+/**
+ * Renders Hyper JSX nodes to HTML.
+ *
+ * Effect Start comes with {@link Hyper} and {@link JsxRuntime} to enable
+ * JSX support. The advantage of using JSX over HTML strings or templates
+ * is type safety and better editor support.
+ *
+ * JSX nodes are compatible with React's and Solid's.
+
+ * You can enable JSX support by updating `tsconfig.json`:
+ *
+ * {
+ *   compilerOptions: {
+ *     jsx: "react-jsx",
+ *     jsxImportSource: "effect-start" | "react" | "praect" // etc.
+ *   }
+ * }
+ */
+const EMPTY_TAGS = [
+    "area",
+    "base",
+    "br",
+    "col",
+    "command",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "keygen",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+];
+// escape an attribute
+let esc = (str) => String(str).replace(/[&<>"']/g, (s) => `&${map[s]};`);
+let map = {
+    "&": "amp",
+    "<": "lt",
+    ">": "gt",
+    "\"": "quot",
+    "'": "apos",
+};
+export function renderToString(node, hooks) {
+    const stack = [node];
+    let result = "";
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (typeof current === "string") {
+            if (current.startsWith("<") && current.endsWith(">")) {
+                // This is a closing tag, don't escape it
+                result += current;
+            }
+            else {
+                result += esc(current);
+            }
+            continue;
+        }
+        if (typeof current === "number") {
+            result += esc(current);
+            continue;
+        }
+        if (typeof current === "boolean") {
+            // React-like behavior: booleans render nothing
+            continue;
+        }
+        if (current === null || current === undefined) {
+            // React-like behavior: null/undefined render nothing
+            continue;
+        }
+        if (Array.isArray(current)) {
+            // Handle arrays by pushing all items to stack in reverse order
+            for (let i = current.length - 1; i >= 0; i--) {
+                stack.push(current[i]);
+            }
+            continue;
+        }
+        if (current && typeof current === "object" && current.type) {
+            hooks?.onNode?.(current);
+            if (typeof current.type === "function") {
+                const componentResult = current.type(current.props);
+                if (componentResult != null) {
+                    stack.push(componentResult);
+                }
+                continue;
+            }
+            const { type, props } = current;
+            result += `<${type}`;
+            for (const key in props) {
+                if (key !== "children"
+                    && key !== "innerHTML" // Solid-specific
+                    && key !== "dangerouslySetInnerHTML" // React-specific
+                    && props[key] !== false
+                    && props[key] != null) {
+                    if (props[key] === true) {
+                        result += ` ${esc(key)}`;
+                    }
+                    else {
+                        const resolvedKey = key === "className" ? "class" : key;
+                        const value = props[key];
+                        if (key.startsWith("data-") && typeof value === "object") {
+                            result += ` ${esc(resolvedKey)}="${esc(JSON.stringify(value))}"`;
+                        }
+                        else {
+                            result += ` ${esc(resolvedKey)}="${esc(value)}"`;
+                        }
+                    }
+                }
+            }
+            result += ">";
+            if (!EMPTY_TAGS.includes(type)) {
+                stack.push(`</${type}>`);
+                // React-specific
+                const html = props.dangerouslySetInnerHTML?.__html
+                    ?? props.innerHTML;
+                if (html) {
+                    result += html;
+                }
+                else {
+                    const children = props.children;
+                    if (type === "script" && typeof children === "function") {
+                        result += `(${children.toString()})(window)`;
+                    }
+                    else if (Array.isArray(children)) {
+                        for (let i = children.length - 1; i >= 0; i--) {
+                            stack.push(children[i]);
+                        }
+                    }
+                    else if (children != null) {
+                        stack.push(children);
+                    }
+                }
+            }
+        }
+        else if (current && typeof current === "object") {
+            // Handle objects without type property - convert to string or ignore
+            // This prevents [object Object] from appearing
+            continue;
+        }
+    }
+    return result;
+}

package/dist/hyper/HyperNode.d.ts

@@ -0,0 +1,14 @@
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
+type Primitive = string | number | boolean | null | undefined;
+export type Type = string | HyperComponent;
+export type Props = {
+    [key: string]: Primitive | HyperNode | Iterable<Primitive | HyperNode> | Record<string, unknown> | ((window: Window) => void);
+};
+export type HyperComponent = (props: Props) => HyperNode | Primitive;
+export interface HyperNode {
+    type: Type;
+    props: Props;
+}
+export declare function make(type: Type, props: Props): HyperNode;
+export {};

package/dist/hyper/HyperNode.js

@@ -0,0 +1,11 @@
+export const TypeId = Symbol.for("effect-start/HyperNode");
+const NoChildren = Object.freeze([]);
+export function make(type, props) {
+    return {
+        type,
+        props: {
+            ...props,
+            children: props.children ?? NoChildren,
+        },
+    };
+}

package/dist/hyper/HyperRoute.d.ts

@@ -0,0 +1,8 @@
+import * as Route from "../Route.ts";
+import type * as RouteBody from "../RouteBody.ts";
+import type { JSX } from "./jsx.d.ts";
+export declare 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>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<{
+    format: "html";
+}, {}, string, E, R>]>;

package/dist/hyper/HyperRoute.js

@@ -0,0 +1,32 @@
+import * as Effect from "effect/Effect";
+import * as Entity from "../Entity.js";
+import * as Route from "../Route.js";
+import * as HyperHtml from "./HyperHtml.js";
+function renderValue(value) {
+    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(handler, context, next) {
+    if (Effect.isEffect(handler)) {
+        return handler;
+    }
+    if (typeof handler === "function") {
+        const result = handler(context, next);
+        if (Effect.isEffect(result)) {
+            return result;
+        }
+        return Effect.gen(function* () {
+            return yield* result;
+        });
+    }
+    return Effect.succeed(handler);
+}
+export function html(handler) {
+    return Route.html((context, next) => Effect.map(normalizeToEffect(handler, context, next), renderValue));
+}

package/dist/hyper/HyperRoute.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hyper/HyperRoute.test.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "effect-start/jsx-runtime";
+/** @jsxImportSource effect-start */
+import * as test from "bun:test";
+import * as Effect from "effect/Effect";
+import * as Entity from "../Entity.js";
+import * as Http from "../Http.js";
+import * as Route from "../Route.js";
+import * as RouteHttp from "../RouteHttp.js";
+import * as HyperRoute from "./HyperRoute.js";
+test.describe("HyperRoute.html", () => {
+    test.it("renders JSX to HTML string", async () => {
+        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsx("div", { children: "Hello World" }))));
+        const response = await Http.fetch(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(_jsxs("div", { class: "container", children: [_jsx("h1", { children: "Title" }), _jsx("p", { children: "Paragraph" })] }))));
+        const response = await Http.fetch(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(_jsx("span", { children: "From Effect" })))));
+        const response = await Http.fetch(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 (_jsxs("div", { children: ["Hello ", name] }));
+        }))));
+        const response = await Http.fetch(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(_jsx("div", { children: "Request received" })))));
+        const response = await Http.fetch(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(_jsx("ul", { children: items.map((item) => (_jsx("li", { children: item }))) }))));
+        const response = await Http.fetch(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(_jsx("div", { children: "With Entity" }), { status: 201 }))));
+        const response = await Http.fetch(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(_jsx("div", { "data-signals": {
+                draft: "",
+                pendingDraft: "",
+                username: "User123",
+            }, children: "Content" }))));
+        const response = await Http.fetch(handler, { path: "/" });
+        test.expect(await response.text()).toBe("<div data-signals=\"{&quot;draft&quot;:&quot;&quot;,&quot;pendingDraft&quot;:&quot;&quot;,&quot;username&quot;:&quot;User123&quot;}\">Content</div>");
+    });
+    test.it("renders script with function child as IIFE", async () => {
+        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsx("script", { children: (window) => {
+                console.log("Hello from", window.document.title);
+            } }))));
+        const response = await Http.fetch(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/dist/hyper/index.d.ts

@@ -0,0 +1,4 @@
+export * as Hyper from "./Hyper.ts";
+export * as HyperHtml from "./HyperHtml.ts";
+export * as HyperNode from "./HyperNode.ts";
+export * as HyperRoute from "./HyperRoute.ts";

package/dist/hyper/index.js

@@ -0,0 +1,4 @@
+export * as Hyper from "./Hyper.js";
+export * as HyperHtml from "./HyperHtml.js";
+export * as HyperNode from "./HyperNode.js";
+export * as HyperRoute from "./HyperRoute.js";

package/dist/hyper/jsx-runtime.d.ts

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

package/dist/hyper/jsx-runtime.js

@@ -0,0 +1,8 @@
+import * as HyperNode from "./HyperNode.js";
+function Fragment(props) {
+    return props.children;
+}
+function jsx(type, props) {
+    return HyperNode.make(type, props);
+}
+export { Fragment, jsx, jsx as jsxDEV, jsx as jsxs, };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * as Bundle from "./bundler/Bundle.ts";
+export * as Development from "./Development.ts";
+export * as Entity from "./Entity.ts";
+export * as FileRouter from "./FileRouter.ts";
+export * as Route from "./Route.ts";
+export * as Start from "./Start.ts";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * as Bundle from "./bundler/Bundle.js";
+export * as Development from "./Development.js";
+export * as Entity from "./Entity.js";
+export * as FileRouter from "./FileRouter.js";
+export * as Route from "./Route.js";
+export * as Start from "./Start.js";

package/dist/inference_check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/inference_check.js

@@ -0,0 +1,15 @@
+import { Effect, Context } from "effect";
+import * as Route from "./RouteBody";
+const ServiceA = Context.GenericTag("ServiceA");
+const ServiceB = Context.GenericTag("ServiceB");
+const handler = function* () {
+    yield* ServiceA;
+    yield* ServiceB;
+    return "ok";
+};
+// Check 2: What does 'handle' infer?
+const resultHandler = Route.handle(handler);
+// Let's see if we can provide ServiceA and ServiceB and get a runnable effect (R=never)
+const provided = Effect.provideService(Effect.provideService(resultHandler({}, () => null), ServiceA, { status: 200 }), ServiceB, { status: 200 });
+const runnable = (e) => { };
+runnable(provided);

package/dist/middlewares/BasicAuthMiddleware.d.ts

@@ -0,0 +1,8 @@
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Effect from "effect/Effect";
+export interface BasicAuthConfig {
+    readonly username: string;
+    readonly password: string;
+}
+export declare const make: (config: BasicAuthConfig) => <E, R>(app: import("@effect/platform/HttpApp").Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, HttpServerRequest.HttpServerRequest | R>;

package/dist/middlewares/BasicAuthMiddleware.js

@@ -0,0 +1,22 @@
+import * as HttpMiddleware from "@effect/platform/HttpMiddleware";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Effect from "effect/Effect";
+const unauthorizedResponse = HttpServerResponse.empty({
+    status: 401,
+    headers: { "WWW-Authenticate": "Basic" },
+});
+export const make = (config) => HttpMiddleware.make((app) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const authHeader = request.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Basic ")) {
+        return unauthorizedResponse;
+    }
+    const base64Credentials = authHeader.slice(6);
+    const credentials = atob(base64Credentials);
+    const [username, password] = credentials.split(":");
+    if (username !== config.username || password !== config.password) {
+        return unauthorizedResponse;
+    }
+    return yield* app;
+}));

package/dist/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * as BasicAuthMiddleware from "./BasicAuthMiddleware.ts";

package/dist/middlewares/index.js

@@ -0,0 +1 @@
+export * as BasicAuthMiddleware from "./BasicAuthMiddleware.js";

package/dist/node/FileSystem.d.ts

@@ -0,0 +1,9 @@
+import * as Error from "@effect/platform/Error";
+import type { PlatformError } from "@effect/platform/Error";
+import { SystemError } from "@effect/platform/Error";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Layer from "effect/Layer";
+import * as NFS from "node:fs";
+export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
+export { Error, FileSystem, };
+export declare function handleErrnoException(module: SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError;