seroval 0.6.0 → 0.7.0

package/src/tree/async.ts

@@ -3,7 +3,7 @@
 import assert from '../assert';
 import { Feature } from '../compat';
 import { createIndexedValue, getRootID, ParserContext } from '../context';
-import quote from '../quote';
+import { serializeString } from '../string';
 import {
   BigIntTypedArrayValue,
   TypedArrayValue,
@@ -27,6 +27,8 @@ import {
   TRUE_NODE,
   UNDEFINED_NODE,
   createReferenceNode,
+  createArrayBufferNode,
+  createDataViewNode,
 } from './primitives';
 import { hasReferenceID } from './reference';
 import {
@@ -40,6 +42,8 @@ import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
   SerovalErrorNode,
+  SerovalFormDataNode,
+  SerovalHeadersNode,
   SerovalIterableNode,
   SerovalMapNode,
   SerovalNode,
@@ -50,7 +54,12 @@ import {
   SerovalPromiseNode,
   SerovalSetNode,
 } from './types';
-import { createURLNode, createURLSearchParamsNode } from './web-api';
+import {
+  createBlobNode,
+  createFileNode,
+  createURLNode,
+  createURLSearchParamsNode,
+} from './web-api';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -104,6 +113,7 @@ async function generateArrayNode(
     d: undefined,
     a: await generateNodeList(ctx, current),
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -146,6 +156,7 @@ async function generateMapNode(
     d: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -182,6 +193,7 @@ async function generateSetNode(
     d: undefined,
     a: nodes,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -198,14 +210,16 @@ async function generateProperties(
   let deferredSize = 0;
   let nodesSize = 0;
   let item: unknown;
+  let escaped: string;
   for (const key of keys) {
     item = properties[key];
+    escaped = serializeString(key);
     if (isIterable(item)) {
-      deferredKeys[deferredSize] = key;
+      deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
     } else {
-      keyNodes[nodesSize] = key;
+      keyNodes[nodesSize] = escaped;
       valueNodes[nodesSize] = await parse(ctx, item);
       nodesSize++;
     }
@@ -242,6 +256,7 @@ async function generateIterableNode(
       : undefined,
     a: await generateNodeList(ctx, array),
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -262,6 +277,7 @@ async function generatePromiseNode(
     d: undefined,
     a: undefined,
     f: await parse(ctx, value),
+    b: undefined,
   }));
 }
 
@@ -287,6 +303,7 @@ async function generateObjectNode(
     d: await generateProperties(ctx, current as Record<string, unknown>),
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -303,12 +320,13 @@ async function generateAggregateErrorNode(
     t: SerovalNodeType.AggregateError,
     i: id,
     s: undefined,
-    l: current.errors.length,
+    l: undefined,
     c: undefined,
-    m: quote(current.message),
+    m: serializeString(current.message),
     d: optionsNode,
-    a: await generateNodeList(ctx, current.errors as unknown[]),
+    a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -327,10 +345,59 @@ async function generateErrorNode(
     s: undefined,
     l: undefined,
     c: getErrorConstructorName(current),
-    m: quote(current.message),
+    m: serializeString(current.message),
     d: optionsNode,
     a: undefined,
     f: undefined,
+    b: undefined,
+  };
+}
+
+async function generateHeadersNode(
+  ctx: ParserContext,
+  id: number,
+  current: Headers,
+): Promise<SerovalHeadersNode> {
+  assert(ctx.features & Feature.WebAPI, 'Unsupported type "Headers"');
+  const items: Record<string, string> = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: SerovalNodeType.Headers,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: await generateProperties(ctx, items),
+    a: undefined,
+    f: undefined,
+    b: undefined,
+  };
+}
+
+async function generateFormDataNode(
+  ctx: ParserContext,
+  id: number,
+  current: FormData,
+): Promise<SerovalFormDataNode> {
+  assert(ctx.features & Feature.WebAPI, 'Unsupported type "FormData"');
+  const items: Record<string, FormDataEntryValue> = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: SerovalNodeType.FormData,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: await generateProperties(ctx, items),
+    a: undefined,
+    f: undefined,
+    b: undefined,
   };
 }
 
@@ -384,6 +451,8 @@ async function parse<T>(
           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:
@@ -397,6 +466,8 @@ async function parse<T>(
         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,
@@ -440,6 +511,14 @@ async function parse<T>(
           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;
       }

package/src/tree/deserialize.ts

@@ -1,17 +1,24 @@
+/* eslint-disable prefer-spread */
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import {
   SerializationContext,
 } from '../context';
-import { invQuote } from '../quote';
-import { AsyncServerValue } from '../types';
+import { deserializeString } from '../string';
 import { getReference } from './reference';
 import { getErrorConstructor, getTypedArrayConstructor } from './shared';
 import { SYMBOL_REF } from './symbols';
 import {
   SerovalAggregateErrorNode,
+  SerovalArrayBufferNode,
   SerovalArrayNode,
   SerovalBigIntTypedArrayNode,
+  SerovalBlobNode,
+  SerovalDataViewNode,
+  SerovalDateNode,
   SerovalErrorNode,
+  SerovalFileNode,
+  SerovalFormDataNode,
+  SerovalHeadersNode,
   SerovalIterableNode,
   SerovalMapNode,
   SerovalNode,
@@ -20,8 +27,12 @@ import {
   SerovalObjectNode,
   SerovalObjectRecordNode,
   SerovalPromiseNode,
+  SerovalReferenceNode,
+  SerovalRegExpNode,
   SerovalSetNode,
   SerovalTypedArrayNode,
+  SerovalURLNode,
+  SerovalURLSearchParamsNode,
 } from './types';
 
 function assignIndexedValue<T>(
@@ -29,17 +40,23 @@ function assignIndexedValue<T>(
   index: number,
   value: T,
 ) {
-  ctx.valueMap.set(index, value);
+  if (ctx.markedRefs.has(index)) {
+    ctx.valueMap.set(index, value);
+  }
   return value;
 }
 
-function deserializeNodeList(
+function deserializeArray(
   ctx: SerializationContext,
-  node: SerovalArrayNode | SerovalIterableNode | SerovalAggregateErrorNode,
-  result: unknown[],
+  node: SerovalArrayNode,
 ) {
+  const result: unknown[] = assignIndexedValue(
+    ctx,
+    node.i,
+    new Array<unknown>(node.l),
+  );
   let item: SerovalNode;
-  for (let i = 0, len = node.a.length; i < len; i++) {
+  for (let i = 0, len = node.l; i < len; i++) {
     item = node.a[i];
     if (item) {
       result[i] = deserializeTree(ctx, item);
@@ -48,21 +65,6 @@ function deserializeNodeList(
   return result;
 }
 
-function deserializeArray(
-  ctx: SerializationContext,
-  node: SerovalArrayNode,
-) {
-  const result: AsyncServerValue[] = assignIndexedValue(
-    ctx,
-    node.i,
-    new Array<AsyncServerValue>(node.l),
-  );
-  ctx.stack.push(node.i);
-  deserializeNodeList(ctx, node, result);
-  ctx.stack.pop();
-  return result;
-}
-
 function deserializeProperties(
   ctx: SerializationContext,
   node: SerovalObjectRecordNode,
@@ -72,7 +74,7 @@ function deserializeProperties(
     return {};
   }
   for (let i = 0; i < node.s; i++) {
-    result[node.k[i]] = deserializeTree(ctx, node.v[i]);
+    result[deserializeString(node.k[i])] = deserializeTree(ctx, node.v[i]);
   }
   return result;
 }
@@ -84,11 +86,9 @@ function deserializeNullConstructor(
   const result = assignIndexedValue(
     ctx,
     node.i,
-    Object.create(null) as Record<string, AsyncServerValue>,
+    Object.create(null) as Record<string, unknown>,
   );
-  ctx.stack.push(node.i);
   deserializeProperties(ctx, node.d, result);
-  ctx.stack.pop();
   return result;
 }
 
@@ -96,10 +96,8 @@ function deserializeObject(
   ctx: SerializationContext,
   node: SerovalObjectNode,
 ) {
-  const result = assignIndexedValue(ctx, node.i, {} as Record<string, AsyncServerValue>);
-  ctx.stack.push(node.i);
+  const result = assignIndexedValue(ctx, node.i, {} as Record<string, unknown>);
   deserializeProperties(ctx, node.d, result);
-  ctx.stack.pop();
   return result;
 }
 
@@ -108,11 +106,9 @@ function deserializeSet(
   node: SerovalSetNode,
 ) {
   const result = assignIndexedValue(ctx, node.i, new Set<unknown>());
-  ctx.stack.push(node.i);
-  for (let i = 0, len = node.a.length; i < len; i++) {
+  for (let i = 0, len = node.l; i < len; i++) {
     result.add(deserializeTree(ctx, node.a[i]));
   }
-  ctx.stack.pop();
   return result;
 }
 
@@ -125,18 +121,16 @@ function deserializeMap(
     node.i,
     new Map<unknown, unknown>(),
   );
-  ctx.stack.push(node.i);
-  for (let i = 0; i < node.d.s; i++) {
+  for (let i = 0, len = node.d.s; i < len; i++) {
     result.set(
       deserializeTree(ctx, node.d.k[i]),
       deserializeTree(ctx, node.d.v[i]),
     );
   }
-  ctx.stack.pop();
   return result;
 }
 
-type AssignableValue = AggregateError | Error | Iterable<AsyncServerValue>
+type AssignableValue = AggregateError | Error | Iterable<unknown>
 type AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode | SerovalIterableNode;
 
 function deserializeDictionary<T extends AssignableValue>(
@@ -145,9 +139,7 @@ function deserializeDictionary<T extends AssignableValue>(
   result: T,
 ) {
   if (node.d) {
-    ctx.stack.push(node.i);
     const fields = deserializeProperties(ctx, node.d, {});
-    ctx.stack.pop();
     Object.assign(result, fields);
   }
   return result;
@@ -158,10 +150,11 @@ function deserializeAggregateError(
   node: SerovalAggregateErrorNode,
 ) {
   // Serialize the required arguments
-  const result = assignIndexedValue(ctx, node.i, new AggregateError([], invQuote(node.m)));
-  ctx.stack.push(node.i);
-  result.errors = deserializeNodeList(ctx, node, new Array<AsyncServerValue>(node.l));
-  ctx.stack.pop();
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    new AggregateError([], deserializeString(node.m)),
+  );
   // `AggregateError` might've been extended
   // either through class or custom properties
   // Make sure to assign extra properties
@@ -173,7 +166,7 @@ function deserializeError(
   node: SerovalErrorNode,
 ) {
   const ErrorConstructor = getErrorConstructor(node.c);
-  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(invQuote(node.m)));
+  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(deserializeString(node.m)));
   return deserializeDictionary(ctx, node, result);
 }
 
@@ -204,21 +197,26 @@ function deserializePromise(
   return result;
 }
 
+function deserializeArrayBuffer(
+  ctx: SerializationContext,
+  node: SerovalArrayBufferNode,
+) {
+  const bytes = new Uint8Array(node.s);
+  const result = assignIndexedValue(ctx, node.i, bytes.buffer);
+  return result;
+}
+
 function deserializeTypedArray(
   ctx: SerializationContext,
   node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
 ) {
   const TypedArray = getTypedArrayConstructor(node.c);
-  const dummy = new TypedArray();
+  const source = deserializeTree(ctx, node.f) as ArrayBuffer;
   const result = assignIndexedValue(ctx, node.i, new TypedArray(
-    dummy.buffer,
+    source,
+    node.b,
     node.l,
   ));
-  for (let i = 0, len = node.s.length; i < len; i++) {
-    result[i] = node.t === SerovalNodeType.BigIntTypedArray
-      ? BigInt(node.s[i])
-      : Number(node.s[i]);
-  }
   return result;
 }
 
@@ -226,14 +224,121 @@ function deserializeIterable(
   ctx: SerializationContext,
   node: SerovalIterableNode,
 ) {
-  const values: AsyncServerValue[] = [];
-  deserializeNodeList(ctx, node, values);
-  const result = assignIndexedValue(ctx, node.i, {
+  const values: unknown[] = [];
+  let item: SerovalNode;
+  for (let i = 0, len = node.l; i < len; i++) {
+    item = node.a[i];
+    if (item) {
+      values[i] = deserializeTree(ctx, item);
+    }
+  }
+  const result: Iterable<unknown> = assignIndexedValue(ctx, node.i, {
     [Symbol.iterator]: () => values.values(),
   });
   return deserializeDictionary(ctx, node, result);
 }
 
+function deserializeDate(
+  ctx: SerializationContext,
+  node: SerovalDateNode,
+) {
+  return assignIndexedValue(ctx, node.i, new Date(node.s));
+}
+
+function deserializeRegExp(
+  ctx: SerializationContext,
+  node: SerovalRegExpNode,
+) {
+  return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
+}
+
+function deserializeURL(
+  ctx: SerializationContext,
+  node: SerovalURLNode,
+) {
+  return assignIndexedValue(ctx, node.i, new URL(deserializeString(node.s)));
+}
+
+function deserializeURLSearchParams(
+  ctx: SerializationContext,
+  node: SerovalURLSearchParamsNode,
+) {
+  return assignIndexedValue(ctx, node.i, new URLSearchParams(deserializeString(node.s)));
+}
+
+function deserializeReference(
+  ctx: SerializationContext,
+  node: SerovalReferenceNode,
+) {
+  return assignIndexedValue(ctx, node.i, getReference(deserializeString(node.s)));
+}
+
+function deserializeDataView(
+  ctx: SerializationContext,
+  node: SerovalDataViewNode,
+) {
+  const source = deserializeTree(ctx, node.f) as ArrayBuffer;
+  const result = assignIndexedValue(ctx, node.i, new DataView(
+    source,
+    node.b,
+    node.l,
+  ));
+  return result;
+}
+
+function deserializeBlob(
+  ctx: SerializationContext,
+  node: SerovalBlobNode,
+) {
+  const source = deserializeTree(ctx, node.f) as ArrayBuffer;
+  const result = assignIndexedValue(ctx, node.i, new Blob(
+    [source],
+    { type: deserializeString(node.c) },
+  ));
+  return result;
+}
+
+function deserializeFile(
+  ctx: SerializationContext,
+  node: SerovalFileNode,
+) {
+  const source = deserializeTree(ctx, node.f) as ArrayBuffer;
+  const result = assignIndexedValue(ctx, node.i, new File(
+    [source],
+    deserializeString(node.m),
+    { type: deserializeString(node.c), lastModified: node.b },
+  ));
+  return result;
+}
+
+function deserializeHeaders(
+  ctx: SerializationContext,
+  node: SerovalHeadersNode,
+) {
+  const result = assignIndexedValue(ctx, node.i, new Headers());
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    result.set(
+      deserializeString(node.d.k[i]),
+      deserializeTree(ctx, node.d.v[i]) as string,
+    );
+  }
+  return result;
+}
+
+function deserializeFormData(
+  ctx: SerializationContext,
+  node: SerovalFormDataNode,
+) {
+  const result = assignIndexedValue(ctx, node.i, new FormData());
+  for (let i = 0, len = node.d.s; i < len; i++) {
+    result.set(
+      deserializeString(node.d.k[i]),
+      deserializeTree(ctx, node.d.v[i]) as FormDataEntryValue,
+    );
+  }
+  return result;
+}
+
 export default function deserializeTree(
   ctx: SerializationContext,
   node: SerovalNode,
@@ -243,7 +348,7 @@ export default function deserializeTree(
     case SerovalNodeType.Boolean:
       return node.s;
     case SerovalNodeType.String:
-      return invQuote(node.s);
+      return deserializeString(node.s);
     case SerovalNodeType.Undefined:
       return undefined;
     case SerovalNodeType.Null:
@@ -267,16 +372,20 @@ export default function deserializeTree(
     case SerovalNodeType.NullConstructor:
       return deserializeNullConstructor(ctx, node);
     case SerovalNodeType.Date:
-      return assignIndexedValue(ctx, node.i, new Date(node.s));
+      return deserializeDate(ctx, node);
     case SerovalNodeType.RegExp:
-      return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
+      return deserializeRegExp(ctx, node);
     case SerovalNodeType.Set:
       return deserializeSet(ctx, node);
     case SerovalNodeType.Map:
       return deserializeMap(ctx, node);
+    case SerovalNodeType.ArrayBuffer:
+      return deserializeArrayBuffer(ctx, node);
     case SerovalNodeType.BigIntTypedArray:
     case SerovalNodeType.TypedArray:
       return deserializeTypedArray(ctx, node);
+    case SerovalNodeType.DataView:
+      return deserializeDataView(ctx, node);
     case SerovalNodeType.AggregateError:
       return deserializeAggregateError(ctx, node);
     case SerovalNodeType.Error:
@@ -288,11 +397,19 @@ export default function deserializeTree(
     case SerovalNodeType.WKSymbol:
       return SYMBOL_REF[node.s];
     case SerovalNodeType.URL:
-      return assignIndexedValue(ctx, node.i, new URL(node.s));
+      return deserializeURL(ctx, node);
     case SerovalNodeType.URLSearchParams:
-      return assignIndexedValue(ctx, node.i, new URLSearchParams(node.s));
+      return deserializeURLSearchParams(ctx, node);
     case SerovalNodeType.Reference:
-      return assignIndexedValue(ctx, node.i, getReference(invQuote(node.s)));
+      return deserializeReference(ctx, node);
+    case SerovalNodeType.Blob:
+      return deserializeBlob(ctx, node);
+    case SerovalNodeType.File:
+      return deserializeFile(ctx, node);
+    case SerovalNodeType.Headers:
+      return deserializeHeaders(ctx, node);
+    case SerovalNodeType.FormData:
+      return deserializeFormData(ctx, node);
     default:
       throw new Error('Unsupported type');
   }