seroval 0.4.0 → 0.5.0

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.n));
+  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,
+      };
+    },
+  };
+}

package/src/tree/primitives.ts

@@ -1,23 +1,121 @@
 import assert from '../assert';
 import { Feature } from '../compat';
 import { ParserContext } from '../context';
+import quote from '../quote';
 import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import { INV_SYMBOL_REF, WellKnownSymbols } from './symbols';
 import {
   SerovalBigIntNode,
   SerovalBigIntTypedArrayNode,
+  SerovalBooleanNode,
   SerovalDateNode,
+  SerovalInfinityNode,
+  SerovalNaNNode,
+  SerovalNegativeInfinityNode,
+  SerovalNegativeZeroNode,
   SerovalNodeType,
-  SerovalPrimitiveNode,
+  SerovalNullNode,
+  SerovalNumberNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalStringNode,
   SerovalTypedArrayNode,
+  SerovalUndefinedNode,
+  SerovalWKSymbolNode,
 } from './types';
 
-export function createPrimitiveNode(
-  value: string | number | null,
-): SerovalPrimitiveNode {
+export const TRUE_NODE: SerovalBooleanNode = {
+  t: SerovalNodeType.Boolean,
+  i: undefined,
+  s: true,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const FALSE_NODE: SerovalBooleanNode = {
+  t: SerovalNodeType.Boolean,
+  i: undefined,
+  s: false,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const UNDEFINED_NODE: SerovalUndefinedNode = {
+  t: SerovalNodeType.Undefined,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const NULL_NODE: SerovalNullNode = {
+  t: SerovalNodeType.Null,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
+  t: SerovalNodeType.NegativeZero,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const INFINITY_NODE: SerovalInfinityNode = {
+  t: SerovalNodeType.Infinity,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
+  t: SerovalNodeType.NegativeInfinity,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+export const NAN_NODE: SerovalNaNNode = {
+  t: SerovalNodeType.NaN,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  n: undefined,
+};
+
+export function createNumberNode(value: number): SerovalNumberNode {
   return {
-    t: SerovalNodeType.Primitive,
+    t: SerovalNodeType.Number,
     i: undefined,
     s: value,
     l: undefined,
@@ -29,13 +127,19 @@ export function createPrimitiveNode(
   };
 }
 
-export const TRUE_NODE = createPrimitiveNode('!0');
-export const FALSE_NODE = createPrimitiveNode('!1');
-export const UNDEFINED_NODE = createPrimitiveNode('void 0');
-export const NULL_NODE = createPrimitiveNode(null);
-export const NEG_ZERO_NODE = createPrimitiveNode('-0');
-export const INFINITY_NODE = createPrimitiveNode('1/0');
-export const NEG_INFINITY_NODE = createPrimitiveNode('-1/0');
+export function createStringNode(value: string): SerovalStringNode {
+  return {
+    t: SerovalNodeType.String,
+    i: undefined,
+    s: quote(value),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    n: undefined,
+  };
+}
 
 export function createBigIntNode(
   ctx: ParserContext,
@@ -45,7 +149,7 @@ export function createBigIntNode(
   return {
     t: SerovalNodeType.BigInt,
     i: undefined,
-    s: current.toString() + 'n',
+    s: current.toString(),
     l: undefined,
     c: undefined,
     m: undefined,
@@ -87,10 +191,10 @@ export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode
   return {
     t: SerovalNodeType.RegExp,
     i: id,
-    s: String(current),
+    s: undefined,
     l: undefined,
-    c: undefined,
-    m: undefined,
+    c: current.source,
+    m: current.flags,
     d: undefined,
     a: undefined,
     n: undefined,
@@ -104,10 +208,15 @@ export function createTypedArrayNode(
 ): SerovalTypedArrayNode {
   const constructor = current.constructor.name;
   assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
+  const len = current.length;
+  const values = new Array<string>(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = current[i].toString();
+  }
   return {
     t: SerovalNodeType.TypedArray,
     i: id,
-    s: current.toString(),
+    s: values,
     l: current.byteOffset,
     c: constructor,
     m: undefined,
@@ -129,17 +238,15 @@ export function createBigIntTypedArrayNode(
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
     `Unsupported value type "${constructor}"`,
   );
-  let result = '';
-  for (let i = 0, len = current.length; i < len; i++) {
-    if (i !== 0) {
-      result += ',';
-    }
-    result += current[i].toString() + 'n';
+  const len = current.length;
+  const values = new Array<string>(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = current[i].toString();
   }
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,
-    s: result,
+    s: values,
     l: (current as BigInt64Array).byteOffset,
     c: constructor,
     m: undefined,
@@ -148,3 +255,19 @@ export function createBigIntTypedArrayNode(
     n: undefined,
   };
 }
+
+export function createWKSymbolNode(
+  current: WellKnownSymbols,
+): SerovalWKSymbolNode {
+  return {
+    t: SerovalNodeType.WKSymbol,
+    i: undefined,
+    s: INV_SYMBOL_REF[current],
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    n: undefined,
+  };
+}