effect-start 0.17.0 → 0.17.2

package/dist/client/ScrollState.js

@@ -0,0 +1,98 @@
+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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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.
+ */
+export {};

package/dist/client/index.js

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+import { showBuildError } 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":
+            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/experimental/EncryptedCookies.d.ts

@@ -0,0 +1,51 @@
+import { Cookies, HttpApp, HttpServerResponse } from "@effect/platform";
+import { Effect } from "effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+type CookieValue = string | number | boolean | null | undefined | {
+    [key: string]: CookieValue | unknown;
+} | CookieValue[];
+declare const EncryptedCookiesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EncryptedCookiesError";
+} & Readonly<A>;
+export declare class EncryptedCookiesError extends EncryptedCookiesError_base<{
+    cause: unknown;
+    cookie?: Cookies.Cookie;
+}> {
+}
+declare const EncryptedCookies_base: Context.TagClass<EncryptedCookies, "EncryptedCookies", {
+    encrypt: (value: CookieValue) => Effect.Effect<string, EncryptedCookiesError>;
+    decrypt: (encryptedValue: string) => Effect.Effect<CookieValue, EncryptedCookiesError>;
+    encryptCookie: (cookie: Cookies.Cookie) => Effect.Effect<Cookies.Cookie, EncryptedCookiesError>;
+    decryptCookie: (cookie: Cookies.Cookie) => Effect.Effect<Cookies.Cookie, EncryptedCookiesError>;
+}>;
+export declare class EncryptedCookies extends EncryptedCookies_base {
+}
+export declare function layer(options: {
+    secret: string;
+}): Layer.Layer<EncryptedCookies, EncryptedCookiesError, never>;
+export declare function layerConfig(name?: string): Layer.Layer<EncryptedCookies, EncryptedCookiesError, never>;
+export declare function encrypt(value: CookieValue, options: {
+    key: CryptoKey;
+} | {
+    secret: string;
+}): Effect.Effect<string, EncryptedCookiesError>;
+export declare function encryptCookie(cookie: Cookies.Cookie, options: {
+    key: CryptoKey;
+} | {
+    secret: string;
+}): Effect.Effect<Cookies.Cookie, EncryptedCookiesError>;
+export declare function decryptCookie(cookie: Cookies.Cookie, options: {
+    key: CryptoKey;
+} | {
+    secret: string;
+}): Effect.Effect<Cookies.Cookie, EncryptedCookiesError>;
+export declare function decrypt(encryptedValue: string, options: {
+    key: CryptoKey;
+} | {
+    secret: string;
+}): Effect.Effect<CookieValue, EncryptedCookiesError>;
+export declare function handleError<E>(app: HttpApp.Default<E | EncryptedCookiesError>): Effect.Effect<HttpServerResponse.HttpServerResponse, Exclude<E, {
+    _tag: "EncryptedCookiesError";
+}>, import("@effect/platform/HttpServerRequest").HttpServerRequest>;
+export {};

package/dist/experimental/EncryptedCookies.js

@@ -0,0 +1,243 @@
+import { Cookies, HttpServerResponse, } from "@effect/platform";
+import { Effect, pipe, } from "effect";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Layer from "effect/Layer";
+export class EncryptedCookiesError extends Data.TaggedError("EncryptedCookiesError") {
+}
+export class EncryptedCookies extends Context.Tag("EncryptedCookies")() {
+}
+export function layer(options) {
+    return Layer.effect(EncryptedCookies, Effect.gen(function* () {
+        const keyMaterial = yield* deriveKeyMaterial(options.secret);
+        // Pre-derive both keys once
+        const encryptKey = yield* deriveKey(keyMaterial, ["encrypt"]);
+        const decryptKey = yield* deriveKey(keyMaterial, ["decrypt"]);
+        return EncryptedCookies.of({
+            encrypt: (value) => encryptWithDerivedKey(value, encryptKey),
+            decrypt: (encryptedValue) => decryptWithDerivedKey(encryptedValue, decryptKey),
+            encryptCookie: (cookie) => encryptCookieWithDerivedKey(cookie, encryptKey),
+            decryptCookie: (cookie) => decryptCookieWithDerivedKey(cookie, decryptKey),
+        });
+    }));
+}
+export function layerConfig(name = "SECRET_KEY_BASE") {
+    return Effect
+        .gen(function* () {
+        const secret = yield* pipe(Config.nonEmptyString(name), Effect.flatMap((value) => {
+            return (value.length < 40)
+                ? Effect.fail(new Error("ba"))
+                : Effect.succeed(value);
+        }), Effect.catchAll((err) => {
+            return Effect.dieMessage("SECRET_KEY_BASE must be at least 40 characters");
+        }));
+        return layer({ secret });
+    })
+        .pipe(Layer.unwrapEffect);
+}
+function encodeToBase64Segments(ciphertext, iv, authTag) {
+    return [
+        base64urlEncode(ciphertext),
+        base64urlEncode(iv),
+        base64urlEncode(authTag),
+    ]
+        .join(".");
+}
+function base64urlEncode(data) {
+    const base64 = btoa(String.fromCharCode(...data));
+    return base64
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=/g, "");
+}
+function decodeFromBase64Segments(segments) {
+    return Effect.gen(function* () {
+        const [ciphertextB64, ivB64, authTagB64] = segments;
+        const ciphertext = yield* Effect.try({
+            try: () => base64urlDecode(ciphertextB64),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        const iv = yield* Effect.try({
+            try: () => base64urlDecode(ivB64),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        const authTag = yield* Effect.try({
+            try: () => base64urlDecode(authTagB64),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        return { ciphertext, iv, authTag };
+    });
+}
+function base64urlDecode(data) {
+    // Convert base64url back to standard base64
+    let base64 = data
+        .replace(/-/g, "+")
+        .replace(/_/g, "/");
+    // Add padding if needed
+    while (base64.length % 4) {
+        base64 += "=";
+    }
+    return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+}
+/**
+ * Encrypts cookie value using the SECRET_KEY_BASE.
+ */
+function encryptWithDerivedKey(value, derivedKey) {
+    return Effect.gen(function* () {
+        if (value === null || value === undefined) {
+            return yield* Effect.fail(new EncryptedCookiesError({
+                cause: "Cannot encrypt empty value",
+            }));
+        }
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const data = new TextEncoder().encode(JSON.stringify(value));
+        const encrypted = yield* Effect.tryPromise({
+            try: () => crypto.subtle.encrypt({ name: "AES-GCM", iv }, derivedKey, data),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        const encryptedArray = new Uint8Array(encrypted);
+        const authTagLength = 16;
+        const ciphertext = encryptedArray.slice(0, -authTagLength);
+        const authTag = encryptedArray.slice(-authTagLength);
+        return encodeToBase64Segments(ciphertext, iv, authTag);
+    });
+}
+export function encrypt(value, options) {
+    return Effect.gen(function* () {
+        if ("key" in options) {
+            return yield* encryptWithDerivedKey(value, options.key);
+        }
+        const keyMaterial = yield* deriveKeyMaterial(options.secret);
+        const derivedKey = yield* deriveKey(keyMaterial, ["encrypt"]);
+        return yield* encryptWithDerivedKey(value, derivedKey);
+    });
+}
+function decryptWithDerivedKey(encryptedValue, derivedKey) {
+    return Effect.gen(function* () {
+        if (!encryptedValue || encryptedValue === null || encryptedValue === undefined) {
+            return yield* Effect.fail(new EncryptedCookiesError({
+                cause: "Cannot decrypt null, undefined, or empty value",
+            }));
+        }
+        const segments = encryptedValue.split(".");
+        if (segments.length !== 3) {
+            return yield* Effect.fail(new EncryptedCookiesError({
+                cause: "Invalid encrypted cookie format",
+            }));
+        }
+        const { ciphertext, iv, authTag } = yield* decodeFromBase64Segments(segments);
+        const encryptedData = new Uint8Array(ciphertext.length + authTag.length);
+        encryptedData.set(ciphertext);
+        encryptedData.set(authTag, ciphertext.length);
+        const decrypted = yield* Effect.tryPromise({
+            try: () => crypto.subtle.decrypt({ name: "AES-GCM", iv: iv.slice(0) }, derivedKey, encryptedData),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        const jsonString = new TextDecoder().decode(decrypted);
+        return yield* Effect.try({
+            try: () => JSON.parse(jsonString),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+    });
+}
+function encryptCookieWithDerivedKey(cookie, derivedKey) {
+    return Effect.gen(function* () {
+        const encryptedValue = yield* encryptWithDerivedKey(cookie.value, derivedKey)
+            .pipe(Effect.mapError(error => new EncryptedCookiesError({
+            cause: error.cause,
+            cookie,
+        })));
+        return Cookies.unsafeMakeCookie(cookie.name, encryptedValue, cookie.options);
+    });
+}
+function decryptCookieWithDerivedKey(cookie, derivedKey) {
+    return Effect.gen(function* () {
+        const decryptedValue = yield* decryptWithDerivedKey(cookie.value, derivedKey)
+            .pipe(Effect.mapError(error => new EncryptedCookiesError({
+            cause: error.cause,
+            cookie,
+        })));
+        return Cookies.unsafeMakeCookie(cookie.name, JSON.stringify(decryptedValue), cookie.options);
+    });
+}
+export function encryptCookie(cookie, options) {
+    return Effect.gen(function* () {
+        if ("key" in options) {
+            return yield* encryptCookieWithDerivedKey(cookie, options.key);
+        }
+        const encryptedValue = yield* encrypt(cookie.value, {
+            secret: options.secret,
+        })
+            .pipe(Effect.mapError(error => new EncryptedCookiesError({
+            cause: error.cause,
+            cookie,
+        })));
+        return Cookies.unsafeMakeCookie(cookie.name, encryptedValue, cookie.options);
+    });
+}
+export function decryptCookie(cookie, options) {
+    return Effect.gen(function* () {
+        if ("key" in options) {
+            return yield* decryptCookieWithDerivedKey(cookie, options.key);
+        }
+        const decryptedValue = yield* decrypt(cookie.value, {
+            secret: options.secret,
+        })
+            .pipe(Effect.mapError(error => new EncryptedCookiesError({
+            cause: error.cause,
+            cookie,
+        })));
+        return Cookies.unsafeMakeCookie(cookie.name, JSON.stringify(decryptedValue), cookie.options);
+    });
+}
+export function decrypt(encryptedValue, options) {
+    return Effect.gen(function* () {
+        if ("key" in options) {
+            return yield* decryptWithDerivedKey(encryptedValue, options.key);
+        }
+        const keyMaterial = yield* deriveKeyMaterial(options.secret);
+        const derivedKey = yield* deriveKey(keyMaterial, ["decrypt"]);
+        return yield* decryptWithDerivedKey(encryptedValue, derivedKey);
+    });
+}
+function deriveKeyMaterial(secret) {
+    return Effect.gen(function* () {
+        const encoder = new TextEncoder();
+        const keyMaterial = yield* Effect.tryPromise({
+            try: () => crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HKDF" }, false, ["deriveKey"]),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        return keyMaterial;
+    });
+}
+function deriveKey(keyMaterial, usage) {
+    return Effect.gen(function* () {
+        const encoder = new TextEncoder();
+        const key = yield* Effect.tryPromise({
+            try: () => crypto.subtle.deriveKey({
+                name: "HKDF",
+                salt: encoder.encode("cookie-encryption"),
+                info: encoder.encode("aes-256-gcm"),
+                hash: "SHA-256",
+            }, keyMaterial, { name: "AES-GCM", length: 256 }, false, usage),
+            catch: (error) => new EncryptedCookiesError({ cause: error }),
+        });
+        return key;
+    });
+}
+// TODO something si wrong with return type
+export function handleError(app) {
+    return Effect.gen(function* () {
+        const res = yield* app.pipe(Effect.catchTag("EncryptedCookiesError", (error) => {
+            return HttpServerResponse.empty();
+        }));
+        return res;
+    });
+}
+function generateFriendlyKey(bits = 128) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const length = Math.ceil(bits / Math.log2(chars.length));
+    const bytes = crypto.getRandomValues(new Uint8Array(length));
+    return Array.from(bytes, b => chars[b % chars.length]).join("");
+}

package/dist/experimental/SseHttpResponse.d.ts

@@ -0,0 +1,7 @@
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+export declare const make: <T = any>(stream: Stream.Stream<T, any>, options?: {
+    heartbeatInterval?: Duration.DurationInput;
+}) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;

package/dist/experimental/SseHttpResponse.js

@@ -0,0 +1,28 @@
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+import * as StreamExtra from "../StreamExtra.js";
+const DefaultHeartbeatInterval = Duration.seconds(5);
+export const make = (stream, options) => Effect.gen(function* () {
+    const heartbeat = Stream.repeat(Stream.succeed(null), Schedule.spaced(options?.heartbeatInterval ?? DefaultHeartbeatInterval));
+    const encoder = new TextEncoder();
+    const events = Function.pipe(Stream.merge(heartbeat.pipe(Stream.map(() => ":\n\n")), stream.pipe(Stream.map(event => `data: ${JSON.stringify(event)}\n\n`))), 
+    // without Stream.tap, only two events are sent
+    // Effect.fork(Stream.runDrain) doesn't seem to work.
+    // Asked for help here: [2025-04-09]
+    // https://discord.com/channels/795981131316985866/1359523331400929341
+    Stream.tap(v => Effect.gen(function* () { })), Stream.map(str => encoder.encode(str)));
+    const toStream = StreamExtra.toReadableStreamRuntimePatched(yield* Effect.runtime());
+    // see toStream to understand why we're not using
+    // HttpServerResponse.stream here.
+    return HttpServerResponse.raw(toStream(events), {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    });
+});

package/dist/experimental/index.d.ts

@@ -0,0 +1,2 @@
+export * as EncryptedCookies from "./EncryptedCookies.ts";
+export * as SseHttpResponse from "./SseHttpResponse.ts";

package/dist/experimental/index.js

@@ -0,0 +1,2 @@
+export * as EncryptedCookies from "./EncryptedCookies.js";
+export * as SseHttpResponse from "./SseHttpResponse.js";

package/dist/hyper/Hyper.d.ts

@@ -0,0 +1,32 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import { HyperHooks } from "../x/datastar/index.ts";
+import type { JSX } from "./jsx.d.ts";
+type Elements = JSX.IntrinsicElements;
+type Children = JSX.Children;
+export type { Children, Elements, JSX, };
+declare const Hyper_base: Context.TagClass<Hyper, "Hyper", {
+    hooks: typeof HyperHooks | undefined;
+}>;
+export declare class Hyper extends Hyper_base {
+}
+export declare function layer(opts: {
+    hooks: typeof HyperHooks;
+}): Layer.Layer<Hyper, never, never>;
+type Primitive = string | number | boolean | null | undefined;
+export type HyperType = string | HyperComponent;
+export type HyperProps = {
+    [key: string]: Primitive | ReadonlyArray<Primitive> | HyperNode | HyperNode[] | null | undefined;
+};
+export type HyperComponent = (props: HyperProps) => HyperNode | Primitive;
+export interface HyperNode {
+    type: HyperType;
+    props: HyperProps;
+}
+export declare function h(type: HyperType, props: HyperProps): HyperNode;
+export declare function unsafeUse<Value>(tag: Context.Tag<any, Value>): Value;
+export type GenericJsxObject = {
+    type: any;
+    props: any;
+};
+export declare function isGenericJsxObject(value: unknown): value is GenericJsxObject;

package/dist/hyper/Hyper.js

@@ -0,0 +1,34 @@
+import * as Context from "effect/Context";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+export class Hyper extends Context.Tag("Hyper")() {
+}
+export function layer(opts) {
+    return Layer.sync(Hyper, () => {
+        return {
+            hooks: opts.hooks,
+        };
+    });
+}
+const NoChildren = Object.freeze([]);
+export function h(type, props) {
+    return {
+        type,
+        props: {
+            ...props,
+            children: props.children ?? NoChildren,
+        },
+    };
+}
+export function unsafeUse(tag) {
+    const currentFiber = Option.getOrThrow(Fiber.getCurrentFiber());
+    const context = currentFiber.currentContext;
+    return Context.unsafeGet(context, tag);
+}
+export function isGenericJsxObject(value) {
+    return typeof value === "object"
+        && value !== null
+        && "type" in value
+        && "props" in value;
+}

package/dist/hyper/HyperHtml.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *   }
+ * }
+ */
+import * as HyperNode from "./HyperNode.ts";
+import type { JSX } from "./jsx.d.ts";
+export declare function renderToString(node: JSX.Children, hooks?: {
+    onNode?: (node: HyperNode.HyperNode) => void;
+}): string;