seroval 0.10.3 → 0.11.0

package/src/core/keys.ts

@@ -30,7 +30,7 @@ export const GLOBAL_CONTEXT_API_SCRIPT = `self.${GLOBAL_CONTEXT_API}=self.${GLOB
   + `${GLOBAL_CONTEXT_PROMISE_REJECT}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_REJECT}(d),this.uP(p)},`
   + `uS:function(s){delete s.${LOCAL_CONTEXT_STREAM_CONTROLLER}},`
   + `${GLOBAL_CONTEXT_STREAM_EMIT}:function(s,t,d,c){switch(c=s.${LOCAL_CONTEXT_STREAM_CONTROLLER},t){case 0:return c.enqueue(d);case 1:return(this.uS(s),c.error(d));case 2:return(this.uS(s),c.close())}},`
-  + `${GLOBAL_CONTEXT_STREAM_CONSTRUCTOR}:function(s,c){return(s=new ReadableStream({start:function(x){c=x}})).${LOCAL_CONTEXT_STREAM_CONTROLLER}=c,s},`
+  + `${GLOBAL_CONTEXT_STREAM_CONSTRUCTOR}:function(s,c){return(s=new ReadableStream({start:function(x){c=x}})).${LOCAL_CONTEXT_STREAM_CONTROLLER}=c,s}`
   + '}';
 
 export function getCrossReferenceHeader(id?: string): string {

package/src/core/tree/async.ts

@@ -1,7 +1,6 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable @typescript-eslint/no-use-before-define */
-import assert from '../assert';
-import { Feature } from '../compat';
+import { BIGINT_FLAG, Feature } from '../compat';
 import type { ParserContext } from './context';
 import {
   createIndexedValue,
@@ -24,6 +23,7 @@ import {
   createDataViewNode,
   createSymbolNode,
   createFunctionNode,
+  serializeArrayBuffer,
 } from './primitives';
 import { hasReferenceID } from '../reference';
 import {
@@ -36,7 +36,9 @@ import type {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
   SerovalBoxedNode,
+  SerovalCustomEventNode,
   SerovalErrorNode,
+  SerovalEventNode,
   SerovalFormDataNode,
   SerovalHeadersNode,
   SerovalMapNode,
@@ -47,6 +49,8 @@ import type {
   SerovalObjectRecordNode,
   SerovalPlainRecordNode,
   SerovalPromiseNode,
+  SerovalRequestNode,
+  SerovalResponseNode,
   SerovalSetNode,
 } from '../types';
 import {
@@ -67,8 +71,14 @@ import {
   createRegExpNode,
   createStringNode,
 } from '../base-primitives';
-import { createURLNode, createURLSearchParamsNode } from '../web-api';
+import { createDOMExceptionNode, createURLNode, createURLSearchParamsNode } from '../web-api';
 import promiseToResult from '../promise-to-result';
+import {
+  createCustomEventOptions,
+  createEventOptions,
+  createRequestOptions,
+  createResponseOptions,
+} from '../constructors';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -127,7 +137,6 @@ async function generateMapNode(
   id: number,
   current: Map<unknown, unknown>,
 ): Promise<SerovalMapNode> {
-  assert(ctx.features & Feature.Map, new UnsupportedTypeError(current));
   const len = current.size;
   const keyNodes = new Array<SerovalNode>(len);
   const valueNodes = new Array<SerovalNode>(len);
@@ -172,7 +181,6 @@ async function generateSetNode(
   id: number,
   current: Set<unknown>,
 ): Promise<SerovalSetNode> {
-  assert(ctx.features & Feature.Set, new UnsupportedTypeError(current));
   const len = current.size;
   const nodes = new Array<SerovalNode>(len);
   const deferred = new Array<unknown>(len);
@@ -299,7 +307,6 @@ async function generatePromiseNode(
   id: number,
   current: Promise<unknown>,
 ): Promise<SerovalPromiseNode> {
-  assert(ctx.features & Feature.Promise, new UnsupportedTypeError(current));
   const [status, result] = await promiseToResult(current);
   return {
     t: SerovalNodeType.Promise,
@@ -394,7 +401,6 @@ async function generateHeadersNode(
   id: number,
   current: Headers,
 ): Promise<SerovalHeadersNode> {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
   const items: Record<string, string> = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -420,7 +426,6 @@ async function generateFormDataNode(
   id: number,
   current: FormData,
 ): Promise<SerovalFormDataNode> {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
   const items: Record<string, FormDataEntryValue> = {};
   current.forEach((value, key) => {
     items[key] = value;
@@ -462,6 +467,98 @@ async function generateBoxedNode(
   };
 }
 
+async function generateRequestNode(
+  ctx: ParserContext,
+  id: number,
+  current: Request,
+): Promise<SerovalRequestNode> {
+  return {
+    t: SerovalNodeType.Request,
+    i: id,
+    s: serializeString(current.url),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    f: await parseObject(
+      ctx,
+      createRequestOptions(current, current.body ? await current.clone().arrayBuffer() : null),
+    ),
+    a: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+async function generateResponseNode(
+  ctx: ParserContext,
+  id: number,
+  current: Response,
+): Promise<SerovalResponseNode> {
+  return {
+    t: SerovalNodeType.Response,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    f: undefined,
+    a: [
+      current.body
+        ? serializeArrayBuffer(ctx, await current.clone().arrayBuffer())
+        : NULL_NODE,
+      await parseObject(ctx, createResponseOptions(current)),
+    ],
+    b: undefined,
+    o: undefined,
+  };
+}
+
+async function generateEventNode(
+  ctx: ParserContext,
+  id: number,
+  current: Event,
+): Promise<SerovalEventNode> {
+  return {
+    t: SerovalNodeType.Event,
+    i: id,
+    s: serializeString(current.type),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: await parseObject(ctx, createEventOptions(current)),
+    b: undefined,
+    o: undefined,
+  };
+}
+
+async function generateCustomEventNode(
+  ctx: ParserContext,
+  id: number,
+  current: CustomEvent,
+): Promise<SerovalCustomEventNode> {
+  return {
+    t: SerovalNodeType.CustomEvent,
+    i: id,
+    s: serializeString(current.type),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: await parseObject(ctx, createCustomEventOptions(current)),
+    b: undefined,
+    o: undefined,
+  };
+}
+
 async function parseObject(
   ctx: ParserContext,
   current: object | null,
@@ -481,49 +578,17 @@ async function parseObject(
   if (Array.isArray(current)) {
     return generateArrayNode(ctx, id, current);
   }
-  switch (current.constructor) {
+  const currentClass = current.constructor;
+  switch (currentClass) {
     case Number:
     case Boolean:
     case String:
     case BigInt:
-    case Function:
-    case Symbol:
       return generateBoxedNode(ctx, id, current);
     case Date:
       return createDateNode(id, current as unknown as Date);
     case RegExp:
       return createRegExpNode(id, current as unknown as RegExp);
-    case Promise:
-      return generatePromiseNode(ctx, id, current as unknown as Promise<unknown>);
-    case ArrayBuffer:
-      return createArrayBufferNode(id, current as unknown as ArrayBuffer);
-    case Int8Array:
-    case Int16Array:
-    case Int32Array:
-    case Uint8Array:
-    case Uint16Array:
-    case Uint32Array:
-    case Uint8ClampedArray:
-    case Float32Array:
-    case Float64Array:
-      return createTypedArrayNode(ctx, id, current as unknown as TypedArrayValue);
-    case BigInt64Array:
-    case BigUint64Array:
-      return createBigIntTypedArrayNode(ctx, id, current as unknown as BigIntTypedArrayValue);
-    case DataView:
-      return createDataViewNode(ctx, id, current as unknown as DataView);
-    case Map:
-      return generateMapNode(
-        ctx,
-        id,
-        current as unknown as Map<unknown, unknown>,
-      );
-    case Set:
-      return generateSetNode(
-        ctx,
-        id,
-        current as unknown as Set<unknown>,
-      );
     case Object:
       return generateObjectNode(
         ctx,
@@ -538,11 +603,6 @@ async function parseObject(
         current as Record<string, unknown>,
         true,
       );
-    case AggregateError:
-      if (ctx.features & Feature.AggregateError) {
-        return generateAggregateErrorNode(ctx, id, current as unknown as AggregateError);
-      }
-      return generateErrorNode(ctx, id, current as unknown as AggregateError);
     case Error:
     case EvalError:
     case RangeError:
@@ -551,36 +611,106 @@ async function parseObject(
     case TypeError:
     case URIError:
       return generateErrorNode(ctx, id, current as unknown as Error);
-    case URL:
-      return createURLNode(ctx, id, current as unknown as URL);
-    case URLSearchParams:
-      return createURLSearchParamsNode(ctx, id, current as unknown as URLSearchParams);
-    case Blob:
-      return createBlobNode(ctx, id, current as unknown as Blob);
-    case File:
-      return createFileNode(ctx, id, current as unknown as File);
-    case Headers:
-      return generateHeadersNode(ctx, id, current as unknown as Headers);
-    case FormData:
-      return generateFormDataNode(ctx, id, current as unknown as FormData);
     default:
       break;
   }
-  if (current instanceof AggregateError) {
-    if (ctx.features & Feature.AggregateError) {
-      return generateAggregateErrorNode(ctx, id, current);
+  // Typed Arrays
+  if (ctx.features & Feature.TypedArray) {
+    switch (currentClass) {
+      case ArrayBuffer:
+        return createArrayBufferNode(id, current as unknown as ArrayBuffer);
+      case Int8Array:
+      case Int16Array:
+      case Int32Array:
+      case Uint8Array:
+      case Uint16Array:
+      case Uint32Array:
+      case Uint8ClampedArray:
+      case Float32Array:
+      case Float64Array:
+        return createTypedArrayNode(ctx, id, current as unknown as TypedArrayValue);
+      case DataView:
+        return createDataViewNode(ctx, id, current as unknown as DataView);
+      default:
+        break;
     }
-    return generateErrorNode(ctx, id, current);
   }
+  // BigInt Typed Arrays
+  if ((ctx.features & BIGINT_FLAG) === BIGINT_FLAG) {
+    switch (currentClass) {
+      case BigInt64Array:
+      case BigUint64Array:
+        return createBigIntTypedArrayNode(ctx, id, current as unknown as BigIntTypedArrayValue);
+      default:
+        break;
+    }
+  }
+  // ES Collection
+  if (ctx.features & Feature.Map && currentClass === Map) {
+    return generateMapNode(
+      ctx,
+      id,
+      current as unknown as Map<unknown, unknown>,
+    );
+  }
+  if (ctx.features & Feature.Set && currentClass === Set) {
+    return generateSetNode(
+      ctx,
+      id,
+      current as unknown as Set<unknown>,
+    );
+  }
+  // Web APIs
+  if (ctx.features & Feature.WebAPI) {
+    switch (currentClass) {
+      case URL:
+        return createURLNode(id, current as unknown as URL);
+      case URLSearchParams:
+        return createURLSearchParamsNode(id, current as unknown as URLSearchParams);
+      case Blob:
+        return createBlobNode(ctx, id, current as unknown as Blob);
+      case File:
+        return createFileNode(ctx, id, current as unknown as File);
+      case Headers:
+        return generateHeadersNode(ctx, id, current as unknown as Headers);
+      case FormData:
+        return generateFormDataNode(ctx, id, current as unknown as FormData);
+      case Request:
+        return generateRequestNode(ctx, id, current as unknown as Request);
+      case Response:
+        return generateResponseNode(ctx, id, current as unknown as Response);
+      case Event:
+        return generateEventNode(ctx, id, current as unknown as Event);
+      case CustomEvent:
+        return generateCustomEventNode(ctx, id, current as unknown as CustomEvent);
+      case DOMException:
+        return createDOMExceptionNode(id, current as unknown as DOMException);
+      default:
+        break;
+    }
+  }
+  if (
+    (ctx.features & Feature.AggregateError)
+    && (currentClass === AggregateError || current instanceof AggregateError)
+  ) {
+    return generateAggregateErrorNode(ctx, id, current as unknown as AggregateError);
+  }
+  // Promises
+  if (
+    (ctx.features & Feature.Promise)
+    && (currentClass === Promise || current instanceof Promise)
+  ) {
+    return generatePromiseNode(ctx, id, current as unknown as Promise<unknown>);
+  }
+  // Slow path. We only need to handle Errors and Iterators
+  // since they have very broad implementations.
   if (current instanceof Error) {
     return generateErrorNode(ctx, id, current);
   }
-  if (current instanceof Promise) {
-    return generatePromiseNode(ctx, id, current);
-  }
   // Generator functions don't have a global constructor
-  if (Symbol.iterator in current) {
-    return generateObjectNode(ctx, id, current, !!current.constructor);
+  // despite existing
+  if (ctx.features & Feature.Symbol && Symbol.iterator in current) {
+    return generateObjectNode(ctx, id, current, !!currentClass);
   }
   throw new UnsupportedTypeError(current);
 }
@@ -589,23 +719,26 @@ export default async function parseAsync<T>(
   ctx: ParserContext,
   current: T,
 ): Promise<SerovalNode> {
-  switch (typeof current) {
+  const t = typeof current;
+  if (ctx.features & Feature.BigInt && t === 'bigint') {
+    return createBigIntNode(ctx, current as bigint);
+  }
+  switch (t) {
     case 'boolean':
       return current ? TRUE_NODE : FALSE_NODE;
     case 'undefined':
       return UNDEFINED_NODE;
     case 'string':
-      return createStringNode(current);
+      return createStringNode(current as string);
     case 'number':
-      return createNumberNode(current);
-    case 'bigint':
-      return createBigIntNode(ctx, current);
+      return createNumberNode(current as number);
     case 'object':
-      return parseObject(ctx, current);
+      return parseObject(ctx, current as object);
     case 'symbol':
-      return createSymbolNode(ctx, current);
+      return createSymbolNode(ctx, current as symbol);
     case 'function':
-      return createFunctionNode(ctx, current);
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      return createFunctionNode(ctx, current as Function);
     default:
       throw new UnsupportedTypeError(current);
   }

package/src/core/tree/deserialize.ts

@@ -14,9 +14,12 @@ import type {
   SerovalBigIntTypedArrayNode,
   SerovalBlobNode,
   SerovalBoxedNode,
+  SerovalCustomEventNode,
+  SerovalDOMExceptionNode,
   SerovalDataViewNode,
   SerovalDateNode,
   SerovalErrorNode,
+  SerovalEventNode,
   SerovalFileNode,
   SerovalFormDataNode,
   SerovalHeadersNode,
@@ -29,6 +32,8 @@ import type {
   SerovalPromiseNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalRequestNode,
+  SerovalResponseNode,
   SerovalSetNode,
   SerovalTypedArrayNode,
   SerovalURLNode,
@@ -383,6 +388,73 @@ function deserializeBoxed(
   );
 }
 
+function deserializeRequest(
+  ctx: DeserializerContext,
+  node: SerovalRequestNode,
+): Request {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new Request(deserializeString(node.s), deserializeTree(ctx, node.f) as RequestInit),
+  );
+}
+
+function deserializeResponse(
+  ctx: DeserializerContext,
+  node: SerovalResponseNode,
+): Response {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new Response(
+      deserializeTree(ctx, node.a[0]) as BodyInit,
+      deserializeTree(ctx, node.a[1]) as RequestInit,
+    ),
+  );
+}
+
+function deserializeEvent(
+  ctx: DeserializerContext,
+  node: SerovalEventNode,
+): Event {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new Event(
+      deserializeString(node.s),
+      deserializeTree(ctx, node.f) as EventInit,
+    ),
+  );
+}
+
+function deserializeCustomEvent(
+  ctx: DeserializerContext,
+  node: SerovalCustomEventNode,
+): CustomEvent {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new CustomEvent(
+      deserializeString(node.s),
+      deserializeTree(ctx, node.f) as CustomEventInit,
+    ),
+  );
+}
+
+function deserializeDOMException(
+  ctx: DeserializerContext,
+  node: SerovalDOMExceptionNode,
+): DOMException {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    new DOMException(
+      deserializeString(node.s),
+      deserializeString(node.c),
+    ),
+  );
+}
+
 export default function deserializeTree(
   ctx: DeserializerContext,
   node: SerovalNode,
@@ -442,6 +514,16 @@ export default function deserializeTree(
       return deserializeFormData(ctx, node);
     case SerovalNodeType.Boxed:
       return deserializeBoxed(ctx, node);
+    case SerovalNodeType.Request:
+      return deserializeRequest(ctx, node);
+    case SerovalNodeType.Response:
+      return deserializeResponse(ctx, node);
+    case SerovalNodeType.Event:
+      return deserializeEvent(ctx, node);
+    case SerovalNodeType.CustomEvent:
+      return deserializeCustomEvent(ctx, node);
+    case SerovalNodeType.DOMException:
+      return deserializeDOMException(ctx, node);
     default:
       throw new Error('invariant');
   }

package/src/core/tree/primitives.ts

@@ -1,9 +1,7 @@
 import assert from '../assert';
-import { Feature } from '../compat';
 import type { ParserContext } from './context';
 import { createIndexedValue } from './context';
 import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
-import UnsupportedTypeError from '../UnsupportedTypeError';
 import { hasReferenceID } from '../reference';
 import type {
   SerovalBigIntTypedArrayNode,
@@ -39,7 +37,6 @@ export function createTypedArrayNode(
   id: number,
   current: TypedArrayValue,
 ): SerovalTypedArrayNode {
-  assert(ctx.features & Feature.TypedArray, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.TypedArray,
     i: id,
@@ -56,17 +53,11 @@ export function createTypedArrayNode(
   };
 }
 
-const BIGINT_FLAG = Feature.BigIntTypedArray | Feature.BigInt;
-
 export function createBigIntTypedArrayNode(
   ctx: ParserContext,
   id: number,
   current: BigIntTypedArrayValue,
 ): SerovalBigIntTypedArrayNode {
-  assert(
-    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
-    new UnsupportedTypeError(current),
-  );
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,

package/src/core/tree/serialize.ts

@@ -36,6 +36,11 @@ import type {
   SerovalObjectRecordKey,
   SerovalBoxedNode,
   SerovalWKSymbolNode,
+  SerovalRequestNode,
+  SerovalResponseNode,
+  SerovalEventNode,
+  SerovalCustomEventNode,
+  SerovalDOMExceptionNode,
 } from '../types';
 import {
   SerovalObjectRecordSpecialKey,
@@ -729,6 +734,53 @@ function serializeWKSymbol(
   return assignIndexedValue(ctx, node.i, SYMBOL_STRING[node.s]);
 }
 
+function serializeRequest(
+  ctx: SerializerContext,
+  node: SerovalRequestNode,
+): string {
+  return assignIndexedValue(ctx, node.i, 'new Request("' + node.s + '",' + serializeTree(ctx, node.f) + ')');
+}
+
+function serializeResponse(
+  ctx: SerializerContext,
+  node: SerovalResponseNode,
+): string {
+  return assignIndexedValue(ctx, node.i, 'new Response(' + serializeTree(ctx, node.a[0]) + ',' + serializeTree(ctx, node.a[1]) + ')');
+}
+
+function serializeEvent(
+  ctx: SerializerContext,
+  node: SerovalEventNode,
+): string {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    'new Event("' + node.s + '",' + serializeTree(ctx, node.f) + ')',
+  );
+}
+
+function serializeCustomEvent(
+  ctx: SerializerContext,
+  node: SerovalCustomEventNode,
+): string {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    'new CustomEvent("' + node.s + '",' + serializeTree(ctx, node.f) + ')',
+  );
+}
+
+function serializeDOMException(
+  ctx: SerializerContext,
+  node: SerovalDOMExceptionNode,
+): string {
+  return assignIndexedValue(
+    ctx,
+    node.i,
+    'new DOMException("' + node.s + '","' + node.c + '")',
+  );
+}
+
 export default function serializeTree(
   ctx: SerializerContext,
   node: SerovalNode,
@@ -789,6 +841,16 @@ export default function serializeTree(
       return serializeFormData(ctx, node);
     case SerovalNodeType.Boxed:
       return serializeBoxed(ctx, node);
+    case SerovalNodeType.Request:
+      return serializeRequest(ctx, node);
+    case SerovalNodeType.Response:
+      return serializeResponse(ctx, node);
+    case SerovalNodeType.Event:
+      return serializeEvent(ctx, node);
+    case SerovalNodeType.CustomEvent:
+      return serializeCustomEvent(ctx, node);
+    case SerovalNodeType.DOMException:
+      return serializeDOMException(ctx, node);
     default:
       throw new Error('invariant');
   }