effect-start 0.23.0 → 0.25.0

package/dist/datastar/watchers/patchSignals.js

@@ -1,14 +1,14 @@
-import { mergePatch, watcher } from "../engine.js";
-import { jsStrToObject } from "../utils.js";
+import { mergePatch, watcher } from "../engine.js"
+import { jsStrToObject } from "../utils.js"
+
 watcher({
-    name: "datastar-patch-signals",
-    apply({ error }, { signals, onlyIfMissing }) {
-        if (signals) {
-            const ifMissing = onlyIfMissing?.trim() === "true";
-            mergePatch(jsStrToObject(signals), { ifMissing });
-        }
-        else {
-            throw error("PatchSignalsExpectedSignals");
-        }
-    },
-});
+  name: "datastar-patch-signals",
+  apply({ error }, { signals, onlyIfMissing }) {
+    if (signals) {
+      const ifMissing = onlyIfMissing?.trim() === "true"
+      mergePatch(jsStrToObject(signals), { ifMissing })
+    } else {
+      throw error("PatchSignalsExpectedSignals")
+    }
+  },
+})

package/dist/experimental/EncryptedCookies.js

@@ -1,212 +1,328 @@
-import * as Cookies from "../Cookies.js";
-import * as Config from "effect/Config";
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-export class EncryptedCookiesError extends Data.TaggedError("EncryptedCookiesError") {
-}
-export class EncryptedCookies extends Context.Tag("EncryptedCookies")() {
-}
+import * as Cookies from "../Cookies.js"
+import * as Config from "effect/Config"
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+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),
-        });
-    }));
+  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* Config.nonEmptyString(name).pipe(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(".");
+  return Effect.gen(function* () {
+    const secret = yield* Config.nonEmptyString(name).pipe(
+      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 };
-    });
+  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));
+  // 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({
+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);
-    });
+          }),
+      ),
+    )
+    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({
+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({
+          }),
+      ),
+    )
+    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({
+          }),
+      ),
+    )
+    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);
-    });
+          }),
+      ),
+    )
+    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;
-    });
+  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
+  })
 }

package/dist/experimental/index.js

@@ -1 +1 @@
-export * as EncryptedCookies from "./EncryptedCookies.js";
+export * as EncryptedCookies from "./EncryptedCookies.js"

package/dist/hyper/Hyper.js

@@ -1,23 +1,28 @@
-import * as Context from "effect/Context";
-import * as Fiber from "effect/Fiber";
-import * as Option from "effect/Option";
-export class Hyper extends Context.Tag("Hyper")() {
-}
-const NoChildren = Object.freeze([]);
+import * as Context from "effect/Context"
+import * as Fiber from "effect/Fiber"
+import * as Option from "effect/Option"
+
+export class Hyper extends Context.Tag("Hyper")() {}
+
+const NoChildren = Object.freeze([])
+
 export function h(type, props) {
-    return {
-        type,
-        props: {
-            ...props,
-            children: props.children ?? NoChildren,
-        },
-    };
+  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);
+  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;
+  return typeof value === "object" && value !== null && "type" in value && "props" in value
 }