seroval 0.4.1 → 0.5.1

package/src/tree/async.ts

@@ -2,8 +2,7 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import { createRef, ParserContext } from '../context';
-import quote from '../quote';
+import { createRef, getRootID, ParserContext } from '../context';
 import {
   AsyncServerValue,
   BigIntTypedArrayValue,
@@ -13,22 +12,28 @@ import {
   createBigIntNode,
   createBigIntTypedArrayNode,
   createDateNode,
-  createPrimitiveNode,
+  createNumberNode,
   createReferenceNode,
   createRegExpNode,
+  createStringNode,
   createTypedArrayNode,
+  createWKSymbolNode,
   FALSE_NODE,
+  INFINITY_NODE,
+  NAN_NODE,
+  NEG_INFINITY_NODE,
   NEG_ZERO_NODE,
   NULL_NODE,
   TRUE_NODE,
   UNDEFINED_NODE,
 } from './primitives';
 import {
-  getErrorConstructor,
+  getErrorConstructorName,
   getErrorOptions,
   getIterableOptions,
   isIterable,
 } from './shared';
+import { INV_SYMBOL_REF } from './symbols';
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -90,12 +95,12 @@ async function generateArrayNode(
     t: SerovalNodeType.Array,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.length,
     c: undefined,
     m: undefined,
     d: undefined,
     a: await generateNodeList(ctx, current),
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -137,7 +142,7 @@ async function generateMapNode(
     m: undefined,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -168,12 +173,12 @@ async function generateSetNode(
     t: SerovalNodeType.Set,
     i: id,
     s: undefined,
-    l: undefined,
+    l: len,
     c: undefined,
     m: undefined,
     d: undefined,
     a: nodes,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -218,21 +223,22 @@ async function generateIterableNode(
   id: number,
   current: Iterable<AsyncServerValue>,
 ): Promise<SerovalIterableNode> {
-  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+  assert(ctx.features & Feature.Symbol, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
+  const array = Array.from(current);
   return {
     t: SerovalNodeType.Iterable,
     i: id,
     s: undefined,
-    l: undefined,
+    l: array.length,
     c: undefined,
     m: undefined,
     // Parse options first before the items
     d: options
       ? await generateProperties(ctx, options as Record<string, AsyncServerValue>)
       : undefined,
-    a: await generateNodeList(ctx, Array.from(current)),
-    n: undefined,
+    a: await generateNodeList(ctx, array),
+    f: undefined,
   };
 }
 
@@ -252,7 +258,7 @@ async function generatePromiseNode(
     // Parse options first before the items
     d: undefined,
     a: undefined,
-    n: await parse(ctx, value),
+    f: await parse(ctx, value),
   }));
 }
 
@@ -277,7 +283,7 @@ async function generateObjectNode(
     m: undefined,
     d: await generateProperties(ctx, current as Record<string, AsyncServerValue>),
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -294,12 +300,12 @@ async function generateAggregateErrorNode(
     t: SerovalNodeType.AggregateError,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.errors.length,
     c: undefined,
     m: current.message,
     d: optionsNode,
-    a: undefined,
-    n: await parse(ctx, current.errors),
+    a: await generateNodeList(ctx, current.errors as AsyncServerValue[]),
+    f: undefined,
   };
 }
 
@@ -317,11 +323,11 @@ async function generateErrorNode(
     i: id,
     s: undefined,
     l: undefined,
-    c: getErrorConstructor(current),
+    c: getErrorConstructorName(current),
     m: current.message,
     d: optionsNode,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -335,18 +341,21 @@ async function parse(
     case 'undefined':
       return UNDEFINED_NODE;
     case 'string':
-      return createPrimitiveNode(quote(current));
+      return createStringNode(current);
     case 'number':
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+      switch (current) {
+        case Infinity: return INFINITY_NODE;
+        case -Infinity: return NEG_INFINITY_NODE;
+        default: break;
       }
-      if (Object.is(current, Infinity)) {
-        return createPrimitiveNode('1/0');
+      // eslint-disable-next-line no-self-compare
+      if (current !== current) {
+        return NAN_NODE;
       }
-      if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode('-1/0');
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
       }
-      return createPrimitiveNode(current);
+      return createNumberNode(current);
     case 'bigint':
       return createBigIntNode(ctx, current);
     case 'object': {
@@ -355,7 +364,7 @@ async function parse(
       }
       // Non-primitive values needs a reference ID
       // mostly because the values themselves are stateful
-      const id = createRef(ctx, current, true);
+      const id = createRef(ctx, current);
       if (ctx.markedRefs.has(id)) {
         return createReferenceNode(id);
       }
@@ -424,8 +433,11 @@ async function parse(
         default:
           break;
       }
-      if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
-        return generateAggregateErrorNode(ctx, id, current);
+      if (current instanceof AggregateError) {
+        if (ctx.features & Feature.AggregateError) {
+          return generateAggregateErrorNode(ctx, id, current);
+        }
+        return generateErrorNode(ctx, id, current);
       }
       if (current instanceof Error) {
         return generateErrorNode(ctx, id, current);
@@ -443,6 +455,10 @@ async function parse(
       }
       throw new Error('Unsupported type');
     }
+    case 'symbol':
+      assert(ctx.features & Feature.Symbol, 'Unsupported type "symbol"');
+      assert(current in INV_SYMBOL_REF, 'seroval only supports well-known symbols');
+      return createWKSymbolNode(current);
     default:
       throw new Error('Unsupported type');
   }
@@ -455,5 +471,5 @@ export default async function parseAsync(
   const result = await parse(ctx, current);
   const isObject = result.t === SerovalNodeType.Object
     || result.t === SerovalNodeType.Iterable;
-  return [result, createRef(ctx, current, false), isObject] as const;
+  return [result, getRootID(ctx, current), isObject] as const;
 }

package/src/tree/deserialize.ts

@@ -0,0 +1,288 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import {
+  SerializationContext,
+} from '../context';
+import { invQuote } from '../quote';
+import { AsyncServerValue } from '../types';
+import { getErrorConstructor, getTypedArrayConstructor } from './shared';
+import { SYMBOL_REF } from './symbols';
+import {
+  SerovalAggregateErrorNode,
+  SerovalArrayNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalErrorNode,
+  SerovalIterableNode,
+  SerovalMapNode,
+  SerovalNode,
+  SerovalNodeType,
+  SerovalNullConstructorNode,
+  SerovalObjectNode,
+  SerovalObjectRecordNode,
+  SerovalPromiseNode,
+  SerovalSetNode,
+  SerovalTypedArrayNode,
+} from './types';
+
+function assignRef<T extends AsyncServerValue>(
+  ctx: SerializationContext,
+  index: number,
+  value: T,
+) {
+  ctx.valueMap.set(index, value);
+  return value;
+}
+
+function deserializeNodeList(
+  ctx: SerializationContext,
+  node: SerovalArrayNode | SerovalIterableNode | SerovalAggregateErrorNode,
+  result: AsyncServerValue[],
+) {
+  let item: SerovalNode;
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    item = node.a[i];
+    if (item) {
+      result[i] = deserializeTree(ctx, item);
+    }
+  }
+  return result;
+}
+
+function deserializeArray(
+  ctx: SerializationContext,
+  node: SerovalArrayNode,
+) {
+  const result: AsyncServerValue[] = assignRef(
+    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,
+  result: Record<string, AsyncServerValue>,
+) {
+  if (node.s === 0) {
+    return {};
+  }
+  for (let i = 0; i < node.s; i++) {
+    result[node.k[i]] = deserializeTree(ctx, node.v[i]);
+  }
+  return result;
+}
+
+function deserializeNullConstructor(
+  ctx: SerializationContext,
+  node: SerovalNullConstructorNode,
+) {
+  const result = assignRef(ctx, node.i, Object.create(null) as Record<string, AsyncServerValue>);
+  ctx.stack.push(node.i);
+  deserializeProperties(ctx, node.d, result);
+  ctx.stack.pop();
+  return result;
+}
+
+function deserializeObject(
+  ctx: SerializationContext,
+  node: SerovalObjectNode,
+) {
+  const result = assignRef(ctx, node.i, {} as Record<string, AsyncServerValue>);
+  ctx.stack.push(node.i);
+  deserializeProperties(ctx, node.d, result);
+  ctx.stack.pop();
+  return result;
+}
+
+function deserializeSet(
+  ctx: SerializationContext,
+  node: SerovalSetNode,
+) {
+  const result = assignRef(ctx, node.i, new Set<AsyncServerValue>());
+  ctx.stack.push(node.i);
+  for (let i = 0, len = node.a.length; i < len; i++) {
+    result.add(deserializeTree(ctx, node.a[i]));
+  }
+  ctx.stack.pop();
+  return result;
+}
+
+function deserializeMap(
+  ctx: SerializationContext,
+  node: SerovalMapNode,
+) {
+  const result = assignRef(
+    ctx,
+    node.i,
+    new Map<AsyncServerValue, AsyncServerValue>(),
+  );
+  ctx.stack.push(node.i);
+  for (let i = 0; i < node.d.s; 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 AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode | SerovalIterableNode;
+
+function deserializeDictionary<T extends AssignableValue>(
+  ctx: SerializationContext,
+  node: AssignableNode,
+  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;
+}
+
+function deserializeAggregateError(
+  ctx: SerializationContext,
+  node: SerovalAggregateErrorNode,
+) {
+  // Serialize the required arguments
+  const result = assignRef(ctx, node.i, new AggregateError([], node.m));
+  ctx.stack.push(node.i);
+  result.errors = deserializeNodeList(ctx, node, new Array<AsyncServerValue>(node.l));
+  ctx.stack.pop();
+  // `AggregateError` might've been extended
+  // either through class or custom properties
+  // Make sure to assign extra properties
+  return deserializeDictionary(ctx, node, result);
+}
+
+function deserializeError(
+  ctx: SerializationContext,
+  node: SerovalErrorNode,
+) {
+  const ErrorConstructor = getErrorConstructor(node.c);
+  const result = assignRef(ctx, node.i, new ErrorConstructor(node.m));
+  return deserializeDictionary(ctx, node, result);
+}
+
+interface Deferred {
+  resolve(value: AsyncServerValue): void;
+  promise: Promise<AsyncServerValue>;
+}
+
+function createDeferred(): Deferred {
+  let resolver: Deferred['resolve'];
+  return {
+    resolve(v) {
+      resolver(v);
+    },
+    promise: new Promise((res) => {
+      resolver = res as Deferred['resolve'];
+    }),
+  };
+}
+
+function deserializePromise(
+  ctx: SerializationContext,
+  node: SerovalPromiseNode,
+) {
+  const deferred = createDeferred();
+  const result = assignRef(ctx, node.i, deferred.promise);
+  deferred.resolve(deserializeTree(ctx, node.f));
+  return result;
+}
+
+function deserializeTypedArray(
+  ctx: SerializationContext,
+  node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
+) {
+  const TypedArray = getTypedArrayConstructor(node.c);
+  const dummy = new TypedArray();
+  const result = assignRef(ctx, node.i, new TypedArray(
+    dummy.buffer,
+    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;
+}
+
+function deserializeIterable(
+  ctx: SerializationContext,
+  node: SerovalIterableNode,
+) {
+  const values: AsyncServerValue[] = [];
+  deserializeNodeList(ctx, node, values);
+  const result = assignRef(ctx, node.i, {
+    [Symbol.iterator]: () => values.values(),
+  });
+  return deserializeDictionary(ctx, node, result);
+}
+
+export default function deserializeTree(
+  ctx: SerializationContext,
+  node: SerovalNode,
+): AsyncServerValue {
+  switch (node.t) {
+    case SerovalNodeType.Number:
+    case SerovalNodeType.Boolean:
+      return node.s;
+    case SerovalNodeType.String:
+      return invQuote(node.s);
+    case SerovalNodeType.Undefined:
+      return undefined;
+    case SerovalNodeType.Null:
+      return null;
+    case SerovalNodeType.NegativeZero:
+      return -0;
+    case SerovalNodeType.Infinity:
+      return Infinity;
+    case SerovalNodeType.NegativeInfinity:
+      return -Infinity;
+    case SerovalNodeType.NaN:
+      return NaN;
+    case SerovalNodeType.BigInt:
+      return BigInt(node.s);
+    case SerovalNodeType.Reference:
+      return ctx.valueMap.get(node.i);
+    case SerovalNodeType.Array:
+      return deserializeArray(ctx, node);
+    case SerovalNodeType.Object:
+      return deserializeObject(ctx, node);
+    case SerovalNodeType.NullConstructor:
+      return deserializeNullConstructor(ctx, node);
+    case SerovalNodeType.Date:
+      return assignRef(ctx, node.i, new Date(node.s));
+    case SerovalNodeType.RegExp:
+      return assignRef(ctx, node.i, new RegExp(node.c, node.m));
+    case SerovalNodeType.Set:
+      return deserializeSet(ctx, node);
+    case SerovalNodeType.Map:
+      return deserializeMap(ctx, node);
+    case SerovalNodeType.BigIntTypedArray:
+    case SerovalNodeType.TypedArray:
+      return deserializeTypedArray(ctx, node);
+    case SerovalNodeType.AggregateError:
+      return deserializeAggregateError(ctx, node);
+    case SerovalNodeType.Error:
+      return deserializeError(ctx, node);
+    case SerovalNodeType.Iterable:
+      return deserializeIterable(ctx, node);
+    case SerovalNodeType.Promise:
+      return deserializePromise(ctx, node);
+    case SerovalNodeType.WKSymbol:
+      return SYMBOL_REF[node.s];
+    default:
+      throw new Error('Unsupported type');
+  }
+}

package/src/tree/iterator.ts

@@ -0,0 +1,14 @@
+export default function createIterator<T>(
+  values: Array<T>,
+): Iterator<T> {
+  let index = 0;
+  const len = values.length;
+  return {
+    next() {
+      return {
+        value: values[index++],
+        done: index >= len,
+      };
+    },
+  };
+}