@vastblast/capnweb 0.4.2 → 0.5.0

package/dist/index-workers.js

@@ -63,6 +63,12 @@ function typeForRpc(value) {
       return "writable";
     case ReadableStream.prototype:
       return "readable";
+    case Headers.prototype:
+      return "headers";
+    case Request.prototype:
+      return "request";
+    case Response.prototype:
+      return "response";
     // TODO: All other structured clone types.
     case RpcStub.prototype:
       return "stub";
@@ -616,6 +622,22 @@ var RpcPayload = class _RpcPayload {
         this.hooks.push(hook);
         return stream;
       }
+      case "headers":
+        return new Headers(value);
+      case "request": {
+        let req = value;
+        if (req.body) {
+          this.deepCopy(req.body, req, "body", req, dupStubs, owner);
+        }
+        return new Request(req);
+      }
+      case "response": {
+        let resp = value;
+        if (resp.body) {
+          this.deepCopy(resp.body, resp, "body", resp, dupStubs, owner);
+        }
+        return new Response(resp.body, resp);
+      }
       default:
         throw new Error("unreachable");
     }
@@ -795,6 +817,18 @@ var RpcPayload = class _RpcPayload {
       }
       case "rpc-thenable":
         return;
+      case "headers":
+        return;
+      case "request": {
+        let req = value;
+        if (req.body) this.disposeImpl(req.body, req);
+        return;
+      }
+      case "response": {
+        let resp = value;
+        if (resp.body) this.disposeImpl(resp.body, resp);
+        return;
+      }
       case "writable": {
         let stream = value;
         let hook = this.rpcTargets?.get(stream);
@@ -850,6 +884,9 @@ var RpcPayload = class _RpcPayload {
       case "rpc-target":
       case "writable":
       case "readable":
+      case "headers":
+      case "request":
+      case "response":
         return;
       case "array": {
         let array = value;
@@ -933,6 +970,9 @@ function followPath(value, parent, path, owner) {
       case "bytes":
       case "date":
       case "error":
+      case "headers":
+      case "request":
+      case "response":
         value = void 0;
         break;
       case "undefined":
@@ -1354,6 +1394,73 @@ var Devaluator = class _Devaluator {
           ];
         }
       }
+      case "headers":
+        return ["headers", [...value]];
+      case "request": {
+        let req = value;
+        let init = {};
+        if (req.method !== "GET") init.method = req.method;
+        let headers = [...req.headers];
+        if (headers.length > 0) {
+          init.headers = headers;
+        }
+        if (req.body) {
+          init.body = this.devaluateImpl(req.body, req, depth + 1);
+          init.duplex = req.duplex || "half";
+        } else if (req.body === void 0 && !["GET", "HEAD", "OPTIONS", "TRACE", "DELETE"].includes(req.method)) {
+          let bodyPromise = req.arrayBuffer();
+          let readable = new ReadableStream({
+            async start(controller) {
+              try {
+                controller.enqueue(new Uint8Array(await bodyPromise));
+                controller.close();
+              } catch (err) {
+                controller.error(err);
+              }
+            }
+          });
+          let hook = streamImpl.createReadableStreamHook(readable);
+          let importId = this.exporter.createPipe(readable, hook);
+          init.body = ["readable", importId];
+          init.duplex = req.duplex || "half";
+        }
+        if (req.cache && req.cache !== "default") init.cache = req.cache;
+        if (req.redirect !== "follow") init.redirect = req.redirect;
+        if (req.integrity) init.integrity = req.integrity;
+        if (req.mode && req.mode !== "cors") init.mode = req.mode;
+        if (req.credentials && req.credentials !== "same-origin") {
+          init.credentials = req.credentials;
+        }
+        if (req.referrer && req.referrer !== "about:client") init.referrer = req.referrer;
+        if (req.referrerPolicy) init.referrerPolicy = req.referrerPolicy;
+        if (req.keepalive) init.keepalive = req.keepalive;
+        let cfReq = req;
+        if (cfReq.cf) init.cf = cfReq.cf;
+        if (cfReq.encodeResponseBody && cfReq.encodeResponseBody !== "automatic") {
+          init.encodeResponseBody = cfReq.encodeResponseBody;
+        }
+        return ["request", req.url, init];
+      }
+      case "response": {
+        let resp = value;
+        let body = this.devaluateImpl(resp.body, resp, depth + 1);
+        let init = {};
+        if (resp.status !== 200) init.status = resp.status;
+        if (resp.statusText) init.statusText = resp.statusText;
+        let headers = [...resp.headers];
+        if (headers.length > 0) {
+          init.headers = headers;
+        }
+        let cfResp = resp;
+        if (cfResp.cf) init.cf = cfResp.cf;
+        if (cfResp.encodeBody && cfResp.encodeBody !== "automatic") {
+          init.encodeBody = cfResp.encodeBody;
+        }
+        if (cfResp.webSocket) {
+          throw new TypeError("Can't serialize a Response containing a webSocket.");
+        }
+        return ["response", body, init];
+      }
       case "error": {
         let e = value;
         let rewritten = this.exporter.onSendError(e);
@@ -1453,6 +1560,14 @@ var NullImporter = class {
   }
 };
 var NULL_IMPORTER = new NullImporter();
+function fixBrokenRequestBody(request, body) {
+  let promise = new Response(body).arrayBuffer().then((arrayBuffer) => {
+    let bytes = new Uint8Array(arrayBuffer);
+    let result = new Request(request, { body: bytes });
+    return new PayloadStubHook(RpcPayload.fromAppReturn(result));
+  });
+  return new RpcPromise(new PromiseStubHook(promise), []);
+}
 var Evaluator = class _Evaluator {
   constructor(importer) {
     this.importer = importer;
@@ -1530,6 +1645,56 @@ var Evaluator = class _Evaluator {
           return -Infinity;
         case "nan":
           return NaN;
+        case "headers":
+          if (value.length === 2 && value[1] instanceof Array) {
+            return new Headers(value[1]);
+          }
+          break;
+        case "request": {
+          if (value.length !== 3 || typeof value[1] !== "string") break;
+          let url = value[1];
+          let init = value[2];
+          if (typeof init !== "object" || init === null) break;
+          if (init.body) {
+            init.body = this.evaluateImpl(init.body, init, "body");
+            if (init.body === null || typeof init.body === "string" || init.body instanceof Uint8Array || init.body instanceof ReadableStream) ; else {
+              throw new TypeError("Request body must be of type ReadableStream.");
+            }
+          }
+          if (init.signal) {
+            init.signal = this.evaluateImpl(init.signal, init, "signal");
+            if (!(init.signal instanceof AbortSignal)) {
+              throw new TypeError("Request siganl must be of type AbortSignal.");
+            }
+          }
+          if (init.headers && !(init.headers instanceof Array)) {
+            throw new TypeError("Request headers must be serialized as an array of pairs.");
+          }
+          let result = new Request(url, init);
+          if (init.body instanceof ReadableStream && result.body === void 0) {
+            let promise = fixBrokenRequestBody(result, init.body);
+            this.promises.push({ promise, parent, property });
+            return promise;
+          } else {
+            return result;
+          }
+        }
+        case "response": {
+          if (value.length !== 3) break;
+          let body = this.evaluateImpl(value[1], parent, property);
+          if (body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof ReadableStream) ; else {
+            throw new TypeError("Response body must be of type ReadableStream.");
+          }
+          let init = value[2];
+          if (typeof init !== "object" || init === null) break;
+          if (init.webSocket) {
+            throw new TypeError("Can't deserialize a Response containing a webSocket.");
+          }
+          if (init.headers && !(init.headers instanceof Array)) {
+            throw new TypeError("Request headers must be serialized as an array of pairs.");
+          }
+          return new Response(body, init);
+        }
         case "import":
         case "pipeline": {
           if (value.length < 2 || value.length > 4) {