feat: serialize RegExp objects over RPC

.changeset/serialize-regexp.md

@@ -0,0 +1,5 @@
+---
+"capnweb": minor
+---
+
+Support serializing `RegExp` objects over RPC.

README.md

@@ -203,11 +203,11 @@ The following types can be passed over RPC (in arguments or return values), and
 * `Error` and its well-known subclasses
 * `Blob`
 * `ReadableStream` and `WritableStream`, with automatic flow control.
+* `RegExp`
 * `Headers`, `Request`, and `Response` from the Fetch API.
 
 The following types are not supported as of this writing, but may be added in the future:
 * `Map` and `Set`
-* `RegExp`
 
 The following are intentionally NOT supported:
 * Application-defined classes that do not extend `RpcTarget`.

__tests__/index.test.ts

@@ -39,6 +39,9 @@ let SERIALIZE_TEST_CASES: Record<string, unknown> = {
   '["-inf"]': -Infinity,
   '["nan"]': NaN,
 
+  '["regexp","foo\\\\d+","gi"]': /foo\d+/gi,
+  '["regexp","^bar$",""]': /^bar$/,
+
   '["headers",[]]': new Headers(),
   '["headers",[["content-type","text/plain"],["x-custom","hello"]]]':
       new Headers({"Content-Type": "text/plain", "X-Custom": "hello"}),

protocol.md

@@ -191,6 +191,10 @@ bound parsing cost.
 
 A JavaScript `Date` value. The number represents milliseconds since the Unix epoch.
 
+`["regexp", source, flags]`
+
+A JavaScript `RegExp` value. `source` and `flags` are the strings from the regular expression's `source` and `flags` properties. The receiver reconstructs the value via `new RegExp(source, flags)`. `flags` is always present, and is an empty string when the expression has no flags. For example, `/foo\d+/gi` is encoded as `["regexp", "foo\\d+", "gi"]`.
+
 `["error", type, message, stack?, props?]`
 
 A JavaScript `Error` value. `type` is the name of the specific well-known `Error` subclass, e.g. "TypeError". `message` is a string containing the error message. `stack` may optionally contain the stack trace, though by default stacks will be redacted for security reasons.

src/core.ts

@@ -39,7 +39,7 @@ export type PropertyPath = (string | number)[];
 
 type TypeForRpc = "unsupported" | "primitive" | "object" | "function" | "array" | "date" |
     "bigint" | "bytes" | "blob" | "stub" | "rpc-promise" | "rpc-target" | "rpc-thenable" |
-    "error" | "undefined" | "writable" | "readable" | "headers" | "request" | "response";
+    "error" | "undefined" | "writable" | "readable" | "regexp" | "headers" | "request" | "response";
 
 const AsyncFunction = (async function () {}).constructor;
 
@@ -93,6 +93,9 @@ export function typeForRpc(value: unknown): TypeForRpc {
     case Date.prototype:
       return "date";
 
+    case RegExp.prototype:
+      return "regexp";
+
     case Uint8Array.prototype:
     case BUFFER_PROTOTYPE:
     case ArrayBuffer.prototype:
@@ -963,6 +966,7 @@ export class RpcPayload {
       case "date":
       case "bytes":
       case "blob":
+      case "regexp":
       case "error":
       case "undefined":
         // immutable, no need to copy
@@ -1344,6 +1348,7 @@ export class RpcPayload {
       case "bytes":
       case "blob":
       case "date":
+      case "regexp":
       case "error":
       case "undefined":
         return;
@@ -1489,6 +1494,7 @@ export class RpcPayload {
       case "rpc-target":
       case "writable":
       case "readable":
+      case "regexp":
       case "headers":
       case "request":
       case "response":
@@ -1642,6 +1648,7 @@ function followPath(value: unknown, parent: object | undefined,
       case "blob":
       case "date":
       case "error":
+      case "regexp":
       case "headers":
       case "request":
       case "response":

src/serialize.ts

@@ -335,6 +335,15 @@ export class Devaluator {
         return ["date", Number.isNaN(time) ? null : time];
       }
 
+      case "regexp": {
+        // At structuredClonable level, keep RegExp as native value.
+        if (this.encodingLevel === "structuredClonable") {
+          return value;
+        }
+        let re = <RegExp>value;
+        return ["regexp", re.source, re.flags];
+      }
+
       case "bytes": {
         let alternateTypeName = BYTE_CONTAINER_TYPE_BY_PROTOTYPE.get(Object.getPrototypeOf(value));
         let bytes: Uint8Array;
@@ -841,6 +850,12 @@ export class Evaluator {
             return new Date(value[1]);
           }
           break;
+        case "regexp":
+          if (value.length === 3 && typeof value[1] === "string" &&
+              typeof value[2] === "string") {
+            return new RegExp(value[1], value[2]);
+          }
+          break;
         case "bytes": {
           let bytes: Uint8Array;
           // At jsonCompatibleWithBytes/structuredClonable level, bytes may already be raw.