tw-framework 1.0.4 → 1.0.5

package/dist/adapters/node/server.mjs

@@ -124,6 +124,7 @@ const server = createServer((req, res) => {
   }
 
   const file = resolveFile(pathname);
+  const spaFallback = file === null;
   const finalPath = file ?? ((existsSync(join(ROOT, "index.html")) && pathname !== "/") ? join(ROOT, "index.html") : null);
   if (!finalPath) {
     // Custom 404 page if the build produced one.
@@ -136,6 +137,17 @@ const server = createServer((req, res) => {
     res.writeHead(404, { "content-type": "text/plain", ...SECURITY_HEADERS });
     return res.end("Not Found");
   }
+  // Unknown routes served through the SPA fallback must answer 404 -- a
+  // 200 soft-404 hides broken links from crawlers and uptime checks. The
+  // built 404.html takes priority; otherwise the shell is served WITH the
+  // 404 status so client-side routing still works.
+  if (spaFallback) {
+    const notFoundPage = join(ROOT, "404.html");
+    const spaPath = existsSync(notFoundPage) ? notFoundPage : finalPath;
+    res.writeHead(404, { "content-type": "text/html; charset=utf-8", ...SECURITY_HEADERS });
+    if (req.method === "HEAD") return res.end();
+    return createReadStream(spaPath).pipe(res);
+  }
 
   const stat = statSync(finalPath);
   const ext = extname(finalPath).toLowerCase();

package/dist/hydration-runtime.js

@@ -269,7 +269,24 @@
   }
 
   function navigate(path, push) {
-    fetch(path, { headers: { "X-TW-Navigate": "1" } })
+    // loading.tw skeleton (docs/commands-reference.md): the boundary ships
+    // hidden; show it while the navigation fetch runs, hide it again after.
+    var lb = document.querySelector("[data-loading-boundary]");
+    function hideSkeleton() {
+      if (lb) try { lb.style.display = "none"; } catch (e) { /* gone */ }
+    }
+    if (lb) {
+      // Show via the framework's own display style (empty string would
+      // fall back to the default block and fight the inline display:none).
+      try { lb.style.display = "block"; } catch (e) { /* ignore */ }
+    }
+    fetch(path, {
+      headers: { "X-TW-Navigate": "1" },
+      // Hover-prefetch warms the HTTP cache WITHOUT the navigate header;
+      // a real navigation must bypass that cache so the server can render
+      // `(.)page.tw` interceptors (and other nav-specific output).
+      cache: "reload",
+    })
       .then(function (r) { return r.text(); })
       .then(function (html) {
         swapPage(html, path);
@@ -277,8 +294,9 @@
           try { history.pushState({ tw: 1 }, "", path); } catch (e) { /* ignore */ }
         }
         window.scrollTo(0, 0);
+        hideSkeleton();
       })
-      .catch(function () { window.location.href = path; });
+      .catch(function () { hideSkeleton(); window.location.href = path; });
   }
 
   document.addEventListener("click", function (e) {

package/dist/node-adapter.ts

@@ -72,6 +72,48 @@ if (typeof globalThis.Bun === "undefined") {
       this.params = {};
     }
     async json() { return JSON.parse(this._body ? this._body.toString("utf-8") : "{}"); }
+    /**
+     * multipart/form-data (docs/multipart-forms.md): parse the buffered body
+     * into a FormData-like object. Route handlers expect request.formData()
+     * to exist exactly like the fetch standard on Bun.
+     */
+    async formData(): Promise<any> {
+      const bodyStr = this._body ? this._body.toString("binary") : "";
+      const ct = String(this.headers?.get?.("content-type") ?? "");
+      const bm = /boundary=(?:"([^"]+)"|([^;]+))/i.exec(ct);
+      if (!bm) throw new Error("FormData: no multipart boundary");
+      const boundary = "--" + (bm[1] ?? bm[2]).trim();
+      const out: [string, any][] = [];
+      const parts = bodyStr.split(boundary);
+      for (let i = 1; i < parts.length - 1; i++) {
+        const raw = parts[i];
+        const sep = raw.indexOf("\r\n\r\n");
+        if (sep < 0) continue;
+        const head = raw.slice(0, sep);
+        let data = raw.slice(sep + 4);
+        if (data.endsWith("\r\n")) data = data.slice(0, -2);
+        const nameM = /name="([^"]*)"/.exec(head);
+        if (!nameM) continue;
+        const fileM = /filename="([^"]*)"/.exec(head);
+        const typeM = /content-type:\s*([^\r\n]+)/i.exec(head);
+        if (fileM) {
+          const buf = Buffer.from(data, "binary");
+          out.push([nameM[1], {
+            name: fileM[1],
+            type: typeM ? typeM[1].trim() : "application/octet-stream",
+            size: buf.length,
+            arrayBuffer: async () => buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength),
+          }]);
+        } else {
+          out.push([nameM[1], data]);
+        }
+      }
+      return {
+        entries: () => out[Symbol.iterator](),
+        forEach: (fn: any) => out.forEach(([k, v]) => fn(v, k)),
+        get: (k: string) => (out.find(([kk]) => kk === k) || [, undefined])[1],
+      };
+    }
     async text() { return this._body ? this._body.toString("utf-8") : ""; }
     async arrayBuffer() {
       if (!this._body) return new ArrayBuffer(0);
@@ -98,6 +140,22 @@ if (typeof globalThis.Bun === "undefined") {
       const b: any = this._body;
       // Blob (Bun.file) and other web bodies
       if (b && typeof b.arrayBuffer === "function") return await b.arrayBuffer();
+      // Web ReadableStream (render stream responses): drain into a buffer.
+      if (b && typeof b.getReader === "function") {
+        const reader = b.getReader();
+        const chunks: Uint8Array[] = [];
+        let total = 0;
+        for (;;) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+          total += value.byteLength;
+        }
+        const out = new Uint8Array(total);
+        let off = 0;
+        for (const c of chunks) { out.set(c, off); off += c.byteLength; }
+        return out.buffer;
+      }
       const buf = Buffer.isBuffer(b) ? b : Buffer.from(b);
       return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
     }
@@ -137,11 +195,31 @@ if (typeof globalThis.Bun === "undefined") {
             body: req.method === "GET" || req.method === "HEAD" ? undefined : body,
           });
           const response = await opts.fetch(request);
-          const buf = Buffer.from(await response.arrayBuffer());
           const outHeaders = {};
           for (const [k, v] of response.headers.entries()) outHeaders[k] = v;
-          res.writeHead(response.status, outHeaders);
-          res.end(buf);
+          // Stream ReadableStream bodies chunk-by-chunk. Buffering via
+          // arrayBuffer() would HANG forever for persistent streams
+          // (signal streaming SSE /_tw/stream never closes).
+          const respBody: any = (response as any).body;
+          if (respBody && typeof respBody.getReader === "function") {
+            res.writeHead(response.status, outHeaders);
+            const reader = respBody.getReader();
+            const pump = (): void => {
+              reader
+                .read()
+                .then(({ done, value }: { done: boolean; value?: Uint8Array }) => {
+                  if (done) { try { res.end(); } catch { /* closed */ } return; }
+                  try { res.write(Buffer.from(value ?? [])); } catch { /* client gone */ }
+                  pump();
+                })
+                .catch(() => { try { res.end(); } catch { /* closed */ } });
+            };
+            pump();
+          } else {
+            const buf = Buffer.from(await response.arrayBuffer());
+            res.writeHead(response.status, outHeaders);
+            res.end(buf);
+          }
         } catch (err) {
           try { res.writeHead(500, { "Content-Type": "text/plain" }); res.end("Internal Server Error"); } catch { /* closed */ }
           console.error("[tw:node] request error:", err && err.message);