seroval 0.4.0-alpha.13 → 0.4.0-alpha.15

package/src/tree/shared.ts

@@ -1,13 +1,7 @@
-import { SerializationContext } from '../context';
 import {
   AsyncServerValue,
   ErrorValue,
 } from '../types';
-import {
-  SerovalNode,
-  SerovalReferenceNode,
-  SerovalNodeType,
-} from './types';
 
 export function getErrorConstructor(error: ErrorValue) {
   if (error instanceof EvalError) {
@@ -66,13 +60,6 @@ export function getIterableOptions(obj: Iterable<any>) {
   return undefined;
 }
 
-export function isReferenceInStack(
-  ctx: SerializationContext,
-  node: SerovalNode,
-): node is SerovalReferenceNode {
-  return node.t === SerovalNodeType.Reference && ctx.stack.includes(node.i);
-}
-
 export function isIterable(
   value: unknown,
 ): value is Iterable<AsyncServerValue> {

package/src/tree/sync.ts

@@ -5,9 +5,14 @@ import { createRef, ParserContext } from '../context';
 import quote from '../quote';
 import { BigIntTypedArrayValue, ServerValue, TypedArrayValue } from '../types';
 import {
+  createBigIntNode,
+  createBigIntTypedArrayNode,
+  createDateNode,
+  createPrimitiveNode,
+  createReferenceNode,
+  createRegExpNode,
+  createTypedArrayNode,
   FALSE_NODE,
-  INFINITY_NODE,
-  NEG_INFINITY_NODE,
   NEG_ZERO_NODE,
   NULL_NODE,
   TRUE_NODE,
@@ -22,35 +27,21 @@ import {
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
-  SerovalBigIntNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalDateNode,
   SerovalErrorNode,
   SerovalIterableNode,
   SerovalMapNode,
-  SerovalMapRecordNode,
   SerovalNode,
   SerovalNodeType,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordNode,
-  SerovalPrimitiveNode,
-  SerovalReferenceNode,
-  SerovalRegExpNode,
   SerovalSetNode,
-  SerovalTypedArrayNode,
 } from './types';
 
 type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode | SerovalIterableNode;
 
 class SyncParser {
-  ctx: ParserContext;
-
-  constructor(ctx: ParserContext) {
-    this.ctx = ctx;
-  }
-
-  generateNodeList(current: ServerValue[]) {
+  static generateNodeList(ctx: ParserContext, current: ServerValue[]) {
     const size = current.length;
     const nodes = new Array<SerovalNode>(size);
     const deferred = new Array<ServerValue>(size);
@@ -61,27 +52,42 @@ class SyncParser {
         if (isIterable(item)) {
           deferred[i] = item;
         } else {
-          nodes[i] = this.parse(item);
+          nodes[i] = this.parse(ctx, item);
         }
       }
     }
     for (let i = 0; i < size; i++) {
       if (i in deferred) {
-        nodes[i] = this.parse(deferred[i]);
+        nodes[i] = this.parse(ctx, deferred[i]);
       }
     }
     return nodes;
   }
 
-  generateArrayNode(id: number, current: ServerValue[]): SerovalArrayNode {
-    return new SerovalArrayNode(id, this.generateNodeList(current));
+  static generateArrayNode(
+    ctx: ParserContext,
+    id: number,
+    current: ServerValue[],
+  ): SerovalArrayNode {
+    return {
+      t: SerovalNodeType.Array,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: undefined,
+      a: this.generateNodeList(ctx, current),
+      n: undefined,
+    };
   }
 
-  generateMapNode(
+  static generateMapNode(
+    ctx: ParserContext,
     id: number,
     current: Map<ServerValue, ServerValue>,
   ): SerovalMapNode {
-    assert(this.ctx.features & Feature.Map, 'Unsupported type "Map"');
+    assert(ctx.features & Feature.Map, 'Unsupported type "Map"');
     const len = current.size;
     const keyNodes = new Array<SerovalNode>(len);
     const valueNodes = new Array<SerovalNode>(len);
@@ -96,23 +102,34 @@ class SyncParser {
         deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes[nodeSize] = this.parse(key);
-        valueNodes[nodeSize] = this.parse(value);
+        keyNodes[nodeSize] = this.parse(ctx, key);
+        valueNodes[nodeSize] = this.parse(ctx, value);
         nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
-      valueNodes[nodeSize + i] = this.parse(deferredValue[i]);
+      keyNodes[nodeSize + i] = this.parse(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = this.parse(ctx, deferredValue[i]);
     }
-    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
+    return {
+      t: SerovalNodeType.Map,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: { k: keyNodes, v: valueNodes, s: len },
+      a: undefined,
+      n: undefined,
+    };
   }
 
-  generateSetNode(
+  static generateSetNode(
+    ctx: ParserContext,
     id: number,
     current: Set<ServerValue>,
   ): SerovalSetNode {
-    assert(this.ctx.features & Feature.Set, 'Unsupported type "Set"');
+    assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
     const len = current.size;
     const nodes = new Array<SerovalNode>(len);
     const deferred = new Array<ServerValue>(len);
@@ -123,17 +140,30 @@ class SyncParser {
       if (isIterable(item)) {
         deferred[deferredSize++] = item;
       } else {
-        nodes[nodeSize++] = this.parse(item);
+        nodes[nodeSize++] = this.parse(ctx, item);
       }
     }
     // Parse deferred items
     for (let i = 0; i < deferredSize; i++) {
-      nodes[nodeSize + i] = this.parse(deferred[i]);
+      nodes[nodeSize + i] = this.parse(ctx, deferred[i]);
     }
-    return new SerovalSetNode(id, nodes);
+    return {
+      t: SerovalNodeType.Set,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: undefined,
+      a: nodes,
+      n: undefined,
+    };
   }
 
-  generateProperties(properties: Record<string, ServerValue>): SerovalObjectRecordNode {
+  static generateProperties(
+    ctx: ParserContext,
+    properties: Record<string, ServerValue>,
+  ): SerovalObjectRecordNode {
     const keys = Object.keys(properties);
     const size = keys.length;
     const keyNodes = new Array<string>(size);
@@ -151,13 +181,13 @@ class SyncParser {
         deferredSize++;
       } else {
         keyNodes[nodesSize] = key;
-        valueNodes[nodesSize] = this.parse(item);
+        valueNodes[nodesSize] = this.parse(ctx, item);
         nodesSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
       keyNodes[nodesSize + i] = deferredKeys[i];
-      valueNodes[nodesSize + i] = this.parse(deferredValues[i]);
+      valueNodes[nodesSize + i] = this.parse(ctx, deferredValues[i]);
     }
     return {
       k: keyNodes,
@@ -166,103 +196,137 @@ class SyncParser {
     };
   }
 
-  generateIterableNode(
+  static generateIterableNode(
+    ctx: ParserContext,
     id: number,
     current: Iterable<ServerValue>,
   ): SerovalIterableNode {
-    assert(this.ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+    assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return new SerovalIterableNode(
-      id,
+    return {
+      t: SerovalNodeType.Iterable,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
       // Parse options first before the items
-      options
-        ? this.generateProperties(options as Record<string, ServerValue>)
+      d: options
+        ? this.generateProperties(ctx, options as Record<string, ServerValue>)
         : undefined,
-      this.generateNodeList(Array.from(current)),
-    );
+      a: this.generateNodeList(ctx, Array.from(current)),
+      n: undefined,
+    };
   }
 
-  generateObjectNode(
+  static generateObjectNode(
+    ctx: ParserContext,
     id: number,
     current: Record<string, ServerValue> | Iterable<ServerValue>,
     empty: boolean,
   ): ObjectLikeNode {
     if (Symbol.iterator in current) {
-      return this.generateIterableNode(id, current);
-    }
-    if (empty) {
-      return new SerovalNullConstructorNode(id, this.generateProperties(current));
+      return this.generateIterableNode(ctx, id, current);
     }
-    return new SerovalObjectNode(id, this.generateProperties(current));
+    return {
+      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: this.generateProperties(ctx, current),
+      a: undefined,
+      n: undefined,
+    };
   }
 
-  generateAggregateErrorNode(
+  static generateAggregateErrorNode(
+    ctx: ParserContext,
     id: number,
     current: AggregateError,
   ): SerovalAggregateErrorNode {
     const options = getErrorOptions(current);
     const optionsNode = options
-      ? this.generateProperties(options)
+      ? this.generateProperties(ctx, options)
       : undefined;
-    return new SerovalAggregateErrorNode(
-      id,
-      current.message,
-      optionsNode,
-      this.parse(current.errors),
-    );
+    return {
+      t: SerovalNodeType.AggregateError,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: current.message,
+      d: optionsNode,
+      a: undefined,
+      n: this.parse(ctx, current.errors),
+    };
   }
 
-  generateErrorNode(
+  static generateErrorNode(
+    ctx: ParserContext,
     id: number,
     current: Error,
   ): SerovalErrorNode {
     const options = getErrorOptions(current);
     const optionsNode = options
-      ? this.generateProperties(options)
+      ? this.generateProperties(ctx, options)
       : undefined;
-    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
+    return {
+      t: SerovalNodeType.Error,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: getErrorConstructor(current),
+      m: current.message,
+      d: optionsNode,
+      a: undefined,
+      n: undefined,
+    };
   }
 
-  parse(current: ServerValue): SerovalNode {
+  static parse(
+    ctx: ParserContext,
+    current: ServerValue,
+  ): SerovalNode {
     switch (typeof current) {
       case 'boolean':
         return current ? TRUE_NODE : FALSE_NODE;
       case 'undefined':
         return UNDEFINED_NODE;
       case 'string':
-        return new SerovalPrimitiveNode(quote(current));
+        return createPrimitiveNode(quote(current));
       case 'number':
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return INFINITY_NODE;
+          return createPrimitiveNode('1/0');
         }
         if (Object.is(current, -Infinity)) {
-          return NEG_INFINITY_NODE;
+          return createPrimitiveNode('-1/0');
         }
-        return new SerovalPrimitiveNode(current);
+        return createPrimitiveNode(current);
       case 'bigint':
-        assert(this.ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
-        return new SerovalBigIntNode(current);
+        return createBigIntNode(ctx, current);
       case 'object': {
         if (!current) {
           return NULL_NODE;
         }
         // Non-primitive values needs a reference ID
         // mostly because the values themselves are stateful
-        const id = createRef(this.ctx, current, true);
-        if (this.ctx.markedRefs[id]) {
-          return new SerovalReferenceNode(id);
+        const id = createRef(ctx, current, true);
+        if (ctx.markedRefs.has(id)) {
+          return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
-          return this.generateArrayNode(id, current);
+          return this.generateArrayNode(ctx, id, current);
         }
         switch (current.constructor) {
           case Date:
-            return new SerovalDateNode(id, current as Date);
+            return createDateNode(id, current as Date);
           case RegExp:
-            return new SerovalRegExpNode(id, current as RegExp);
+            return createRegExpNode(id, current as RegExp);
           case Int8Array:
           case Int16Array:
           case Int32Array:
@@ -272,28 +336,23 @@ class SyncParser {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            assert(this.ctx.features & Feature.TypedArray, `Unsupported value type "${current.constructor.name}"`);
-            return new SerovalTypedArrayNode(id, current as TypedArrayValue);
+            return createTypedArrayNode(ctx, id, current as TypedArrayValue);
           case BigInt64Array:
           case BigUint64Array:
-            assert(
-              this.ctx.features & (Feature.BigIntTypedArray),
-              `Unsupported value type "${current.constructor.name}"`,
-            );
-            return new SerovalBigIntTypedArrayNode(id, current as BigIntTypedArrayValue);
+            return createBigIntTypedArrayNode(ctx, id, current as BigIntTypedArrayValue);
           case Map:
-            return this.generateMapNode(id, current as Map<ServerValue, ServerValue>);
+            return this.generateMapNode(ctx, id, current as Map<ServerValue, ServerValue>);
           case Set:
-            return this.generateSetNode(id, current as Set<ServerValue>);
+            return this.generateSetNode(ctx, id, current as Set<ServerValue>);
           case Object:
-            return this.generateObjectNode(id, current as Record<string, ServerValue>, false);
+            return this.generateObjectNode(ctx, id, current as Record<string, ServerValue>, false);
           case undefined:
-            return this.generateObjectNode(id, current as Record<string, ServerValue>, true);
+            return this.generateObjectNode(ctx, id, current as Record<string, ServerValue>, true);
           case AggregateError:
-            if (this.ctx.features & Feature.AggregateError) {
-              return this.generateAggregateErrorNode(id, current as AggregateError);
+            if (ctx.features & Feature.AggregateError) {
+              return this.generateAggregateErrorNode(ctx, id, current as AggregateError);
             }
-            return this.generateErrorNode(id, current as AggregateError);
+            return this.generateErrorNode(ctx, id, current as AggregateError);
           case Error:
           case EvalError:
           case RangeError:
@@ -301,19 +360,19 @@ class SyncParser {
           case SyntaxError:
           case TypeError:
           case URIError:
-            return this.generateErrorNode(id, current as Error);
+            return this.generateErrorNode(ctx, id, current as Error);
           default:
             break;
         }
-        if (current instanceof AggregateError && this.ctx.features & Feature.AggregateError) {
-          return this.generateAggregateErrorNode(id, current);
+        if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
+          return this.generateAggregateErrorNode(ctx, id, current);
         }
         if (current instanceof Error) {
-          return this.generateErrorNode(id, current);
+          return this.generateErrorNode(ctx, id, current);
         }
         // Generator functions don't have a global constructor
         if (Symbol.iterator in current) {
-          return this.generateIterableNode(id, current);
+          return this.generateIterableNode(ctx, id, current);
         }
         throw new Error('Unsupported type');
       }
@@ -327,7 +386,7 @@ export default function parseSync(
   ctx: ParserContext,
   current: ServerValue,
 ) {
-  const result = new SyncParser(ctx).parse(current);
+  const result = SyncParser.parse(ctx, current);
   const isObject = result.t === SerovalNodeType.Object
     || result.t === SerovalNodeType.Iterable;
   return [result, createRef(ctx, current, false), isObject] as const;