hadars 0.1.10 → 0.1.11

package/dist/cli.js

@@ -956,6 +956,74 @@ var makePrecontentHtmlGetter = (htmlFilePromise) => {
     return [preHead + headHtml + postHead, postContent];
   };
 };
+async function transformStream(data, stream) {
+  const writer = stream.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+var gzipCompress = (d) => transformStream(d, new globalThis.CompressionStream("gzip"));
+var gzipDecompress = (d) => transformStream(d, new globalThis.DecompressionStream("gzip"));
+function createRenderCache(opts, handler) {
+  const store = /* @__PURE__ */ new Map();
+  return async (req, ctx) => {
+    const hadarsReq = parseRequest(req);
+    const cacheOpts = await opts(hadarsReq);
+    const key = cacheOpts?.key ?? null;
+    if (key != null) {
+      const entry = store.get(key);
+      if (entry) {
+        if (entry.expiresAt == null || Date.now() < entry.expiresAt) {
+          const accept = req.headers.get("Accept-Encoding") ?? "";
+          if (accept.includes("gzip")) {
+            return new Response(entry.body.buffer, { status: entry.status, headers: entry.headers });
+          }
+          const plain = await gzipDecompress(entry.body);
+          const headers = entry.headers.filter(([k]) => k.toLowerCase() !== "content-encoding");
+          return new Response(plain.buffer, { status: entry.status, headers });
+        }
+        store.delete(key);
+      }
+    }
+    const res = await handler(req, ctx);
+    if (key != null && res) {
+      const ttl = cacheOpts?.ttl;
+      res.clone().arrayBuffer().then(async (buf) => {
+        const body = await gzipCompress(new Uint8Array(buf));
+        const headers = [];
+        res.headers.forEach((v, k) => {
+          if (k.toLowerCase() !== "content-encoding" && k.toLowerCase() !== "content-length") {
+            headers.push([k, v]);
+          }
+        });
+        headers.push(["content-encoding", "gzip"]);
+        store.set(key, {
+          body,
+          status: res.status,
+          headers,
+          expiresAt: ttl != null ? Date.now() + ttl : null
+        });
+      }).catch(() => {
+      });
+    }
+    return res;
+  };
+}
 var SSR_FILENAME = "index.ssr.js";
 var __dirname2 = process.cwd();
 var getSuffix = (mode) => mode === "development" ? `?v=${Date.now()}` : "";
@@ -1295,7 +1363,7 @@ var run = async (options) => {
   const getPrecontentHtml = makePrecontentHtmlGetter(
     fs.readFile(pathMod3.join(__dirname2, StaticPath, "out.html"), "utf-8")
   );
-  await serve(port, async (req, ctx) => {
+  const runHandler = async (req, ctx) => {
     const request = parseRequest(req);
     if (handler) {
       const res = await handler(request);
@@ -1363,7 +1431,12 @@ var run = async (options) => {
       console.error("[hadars] SSR render error:", err);
       return new Response("Internal Server Error", { status: 500 });
     }
-  }, options.websocket);
+  };
+  await serve(
+    port,
+    options.cache ? createRenderCache(options.cache, runHandler) : runHandler,
+    options.websocket
+  );
 };
 
 // cli-lib.ts

package/dist/index.d.ts

@@ -92,6 +92,29 @@ interface HadarsOptions {
      * Has no effect on the SSR bundle or dev mode.
      */
     optimization?: Record<string, unknown>;
+    /**
+     * SSR response cache for `run()` mode. Has no effect in `dev()` mode.
+     *
+     * Receives the incoming request and should return `{ key, ttl? }` to cache
+     * the response, or `null`/`undefined` to skip caching for that request.
+     * `ttl` is the time-to-live in milliseconds; omit for entries that never expire.
+     * The function may be async.
+     *
+     * @example
+     * // Cache every page by pathname (no per-user personalisation):
+     * cache: (req) => ({ key: req.pathname })
+     *
+     * @example
+     * // Cache with a per-route TTL, skip authenticated requests:
+     * cache: (req) => req.cookies.session ? null : { key: req.pathname, ttl: 60_000 }
+     */
+    cache?: (req: HadarsRequest) => {
+        key: string;
+        ttl?: number;
+    } | null | undefined | Promise<{
+        key: string;
+        ttl?: number;
+    } | null | undefined>;
 }
 type SwcPluginItem = string | [string, Record<string, unknown>] | {
     path: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
@@ -52,8 +52,8 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
     "typescript": "^5"
   },
   "peerDependenciesMeta": {
@@ -63,28 +63,28 @@
   },
   "optionalDependencies": {
     "@rspack/core": "1.4.9",
-    "@rspack/dev-server": "^1.1.4",
-    "@rspack/plugin-react-refresh": "^1.5.0",
-    "@swc/core": "^1.4.0",
+    "@rspack/dev-server": "^1.2.1",
+    "@rspack/plugin-react-refresh": "^1.6.1",
+    "@swc/core": "^1.15.18",
     "@types/bun": "latest",
-    "@types/react-dom": "^19.1.9",
+    "@types/react-dom": "^19.2.3",
     "react-refresh": "^0.17.0",
-    "typescript": "^5"
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.0.0",
-    "esbuild": "^0.19.0",
-    "tsup": "^6.6.0"
+    "esbuild": "^0.19.12",
+    "tsup": "^6.7.0"
   },
   "dependencies": {
     "@mdx-js/loader": "^3.1.1",
     "@mdx-js/react": "^3.1.1",
     "@svgr/webpack": "^8.1.0",
-    "@tailwindcss/postcss": "^4.1.12",
-    "postcss": "^8.5.6",
-    "postcss-loader": "^8.2.0",
-    "tailwindcss": "^4.1.12"
+    "@tailwindcss/postcss": "^4.2.1",
+    "postcss": "^8.5.8",
+    "postcss-loader": "^8.2.1",
+    "tailwindcss": "^4.2.1"
   },
   "license": "MIT",
   "repository": {

package/src/build.ts

@@ -230,6 +230,96 @@ const makePrecontentHtmlGetter = (htmlFilePromise: Promise<string>) => {
     };
 };
 
+// ── SSR response cache ────────────────────────────────────────────────────────
+
+interface CacheEntry {
+    /** Gzip-compressed response body — much cheaper to keep in RAM than raw HTML. */
+    body: Uint8Array;
+    status: number;
+    /** Headers with Content-Encoding: gzip already set. */
+    headers: [string, string][];
+    expiresAt: number | null;
+}
+
+type CacheFetchHandler = (req: Request, ctx: any) => Promise<Response | undefined>;
+
+async function transformStream(data: Uint8Array, stream: { writable: WritableStream; readable: ReadableStream<Uint8Array> }): Promise<Uint8Array> {
+    const writer = stream.writable.getWriter();
+    writer.write(data);
+    writer.close();
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+    }
+    const total = chunks.reduce((n, c) => n + c.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) { out.set(c, offset); offset += c.length; }
+    return out;
+}
+
+const gzipCompress   = (d: Uint8Array) => transformStream(d, new (globalThis as any).CompressionStream('gzip'));
+const gzipDecompress = (d: Uint8Array) => transformStream(d, new (globalThis as any).DecompressionStream('gzip'));
+
+function createRenderCache(
+    opts: NonNullable<HadarsOptions['cache']>,
+    handler: CacheFetchHandler,
+): CacheFetchHandler {
+    const store = new Map<string, CacheEntry>();
+
+    return async (req, ctx) => {
+        const hadarsReq = parseRequest(req);
+        const cacheOpts = await opts(hadarsReq);
+        const key = cacheOpts?.key ?? null;
+
+        if (key != null) {
+            const entry = store.get(key);
+            if (entry) {
+                if (entry.expiresAt == null || Date.now() < entry.expiresAt) {
+                    const accept = req.headers.get('Accept-Encoding') ?? '';
+                    if (accept.includes('gzip')) {
+                        return new Response(entry.body.buffer as ArrayBuffer, { status: entry.status, headers: entry.headers });
+                    }
+                    // Client doesn't support gzip — decompress before serving
+                    const plain = await gzipDecompress(entry.body);
+                    const headers = entry.headers.filter(([k]) => k.toLowerCase() !== 'content-encoding');
+                    return new Response(plain.buffer as ArrayBuffer, { status: entry.status, headers });
+                }
+                store.delete(key);
+            }
+        }
+
+        const res = await handler(req, ctx);
+
+        // Compress and cache in the background via clone() so the original
+        // stream is returned to the client immediately.
+        if (key != null && res) {
+            const ttl = cacheOpts?.ttl;
+            res.clone().arrayBuffer().then(async (buf) => {
+                const body = await gzipCompress(new Uint8Array(buf));
+                const headers: [string, string][] = [];
+                res.headers.forEach((v, k) => {
+                    if (k.toLowerCase() !== 'content-encoding' && k.toLowerCase() !== 'content-length') {
+                        headers.push([k, v]);
+                    }
+                });
+                headers.push(['content-encoding', 'gzip']);
+                store.set(key, {
+                    body,
+                    status: res.status,
+                    headers,
+                    expiresAt: ttl != null ? Date.now() + ttl : null,
+                });
+            }).catch(() => { /* ignore read errors on clone */ });
+        }
+
+        return res;
+    };
+}
+
 interface HadarsRuntimeOptions extends HadarsOptions {
     mode: "development" | "production";
 }
@@ -639,7 +729,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
         fs.readFile(pathMod.join(__dirname, StaticPath, 'out.html'), 'utf-8')
     );
 
-    await serve(port, async (req, ctx) => {
+    const runHandler: CacheFetchHandler = async (req, ctx) => {
         const request = parseRequest(req);
         if (handler) {
             const res = await handler(request);
@@ -715,5 +805,11 @@ export const run = async (options: HadarsRuntimeOptions) => {
             console.error('[hadars] SSR render error:', err);
             return new Response('Internal Server Error', { status: 500 });
         }
-    }, options.websocket);
+    };
+
+    await serve(
+        port,
+        options.cache ? createRenderCache(options.cache, runHandler) : runHandler,
+        options.websocket,
+    );
 };

package/src/types/ninety.ts

@@ -93,6 +93,24 @@ export interface HadarsOptions {
      * Has no effect on the SSR bundle or dev mode.
      */
     optimization?: Record<string, unknown>;
+    /**
+     * SSR response cache for `run()` mode. Has no effect in `dev()` mode.
+     *
+     * Receives the incoming request and should return `{ key, ttl? }` to cache
+     * the response, or `null`/`undefined` to skip caching for that request.
+     * `ttl` is the time-to-live in milliseconds; omit for entries that never expire.
+     * The function may be async.
+     *
+     * @example
+     * // Cache every page by pathname (no per-user personalisation):
+     * cache: (req) => ({ key: req.pathname })
+     *
+     * @example
+     * // Cache with a per-route TTL, skip authenticated requests:
+     * cache: (req) => req.cookies.session ? null : { key: req.pathname, ttl: 60_000 }
+     */
+    cache?: (req: HadarsRequest) => { key: string; ttl?: number } | null | undefined
+                                  | Promise<{ key: string; ttl?: number } | null | undefined>;
 }