seroval 0.4.0-alpha.13 → 0.4.0-alpha.14

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,23 +27,15 @@ 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;
@@ -74,7 +71,17 @@ class SyncParser {
   }
 
   generateArrayNode(id: number, current: ServerValue[]): SerovalArrayNode {
-    return new SerovalArrayNode(id, this.generateNodeList(current));
+    return {
+      t: SerovalNodeType.Array,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: undefined,
+      a: this.generateNodeList(current),
+      n: undefined,
+    };
   }
 
   generateMapNode(
@@ -105,7 +112,17 @@ class SyncParser {
       keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = this.parse(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(
@@ -130,7 +147,17 @@ class SyncParser {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = this.parse(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 {
@@ -172,14 +199,20 @@ class SyncParser {
   ): SerovalIterableNode {
     assert(this.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
+      d: options
         ? this.generateProperties(options as Record<string, ServerValue>)
         : undefined,
-      this.generateNodeList(Array.from(current)),
-    );
+      a: this.generateNodeList(Array.from(current)),
+      n: undefined,
+    };
   }
 
   generateObjectNode(
@@ -190,10 +223,17 @@ class SyncParser {
     if (Symbol.iterator in current) {
       return this.generateIterableNode(id, current);
     }
-    if (empty) {
-      return new SerovalNullConstructorNode(id, this.generateProperties(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(current),
+      a: undefined,
+      n: undefined,
+    };
   }
 
   generateAggregateErrorNode(
@@ -204,12 +244,17 @@ class SyncParser {
     const optionsNode = options
       ? this.generateProperties(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(current.errors),
+    };
   }
 
   generateErrorNode(
@@ -220,7 +265,17 @@ class SyncParser {
     const optionsNode = options
       ? this.generateProperties(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 {
@@ -230,21 +285,20 @@ class SyncParser {
       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(this.ctx, current);
       case 'object': {
         if (!current) {
           return NULL_NODE;
@@ -252,17 +306,17 @@ class SyncParser {
         // 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);
+        if (this.ctx.markedRefs.has(id)) {
+          return createReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(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,15 +326,10 @@ 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(this.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(this.ctx, id, current as BigIntTypedArrayValue);
           case Map:
             return this.generateMapNode(id, current as Map<ServerValue, ServerValue>);
           case Set:

package/src/tree/types.ts

@@ -1,5 +1,4 @@
-/* eslint-disable max-classes-per-file */
-import { BigIntTypedArrayValue, PrimitiveValue, TypedArrayValue } from '../types';
+import { PrimitiveValue } from '../types';
 
 export const enum SerovalNodeType {
   Primitive,
@@ -22,156 +21,81 @@ export const enum SerovalNodeType {
 
 export interface SerovalBaseNode {
   // Type of the node
-  t?: SerovalNodeType;
+  t: SerovalNodeType;
   // Serialized value
-  s?: PrimitiveValue;
+  s: PrimitiveValue | undefined;
   // Reference ID
-  i?: number;
+  i: number | undefined;
   // Size/Byte offset
-  l?: number;
+  l: number | undefined;
   // Constructor name
-  c?: string;
+  c: string | undefined;
   // dictionary
-  d?: SerovalDictionaryNode;
+  d: SerovalDictionaryNode | undefined;
   // message
-  m?: string;
+  m: string | undefined;
   // next node
-  n?: SerovalNode;
+  n: SerovalNode | undefined;
   // array of nodes
-  a?: SerovalNode[];
+  a: SerovalNode[] | undefined;
 }
 
-export class SerovalObjectRecordNode {
+export interface SerovalObjectRecordNode {
   k: string[];
-
   v: SerovalNode[];
-
   s: number;
-
-  constructor(k: string[], v: SerovalNode[], s: number) {
-    this.k = k;
-    this.v = v;
-    this.s = s;
-  }
 }
 
-export class SerovalMapRecordNode {
+export interface SerovalMapRecordNode {
   k: SerovalNode[];
-
   v: SerovalNode[];
-
   s: number;
-
-  constructor(k: SerovalNode[], v: SerovalNode[], s: number) {
-    this.k = k;
-    this.v = v;
-    this.s = s;
-  }
 }
 
 export type SerovalDictionaryNode =
   | SerovalObjectRecordNode
   | SerovalMapRecordNode;
 
-export class SerovalPrimitiveNode implements SerovalBaseNode {
-  t: SerovalNodeType.Primitive = SerovalNodeType.Primitive;
-
-  s: string | number | null;
-
-  constructor(current: string | number | null) {
-    this.s = current;
-  }
+export interface SerovalPrimitiveNode extends SerovalBaseNode {
+  t: SerovalNodeType.Primitive;
 }
 
-export class SerovalReferenceNode implements SerovalBaseNode {
-  t: SerovalNodeType.Reference = SerovalNodeType.Reference;
-
+export interface SerovalReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Reference;
   i: number;
-
-  constructor(id: number) {
-    this.i = id;
-  }
 }
 
-export class SerovalBigIntNode implements SerovalBaseNode {
-  t: SerovalNodeType.BigInt = SerovalNodeType.BigInt;
-
+export interface SerovalBigIntNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigInt;
   s: string;
-
-  constructor(current: bigint) {
-    this.s = `${current}n`;
-  }
 }
 
-export class SerovalDateNode implements SerovalBaseNode {
-  t: SerovalNodeType.Date = SerovalNodeType.Date;
-
+export interface SerovalDateNode extends SerovalBaseNode {
+  t: SerovalNodeType.Date;
   i: number;
-
   s: string;
-
-  constructor(id: number, current: Date) {
-    this.i = id;
-    this.s = current.toISOString();
-  }
 }
 
-export class SerovalRegExpNode implements SerovalBaseNode {
-  t: SerovalNodeType.RegExp = SerovalNodeType.RegExp;
-
+export interface SerovalRegExpNode extends SerovalBaseNode {
+  t: SerovalNodeType.RegExp;
   i: number;
-
   s: string;
-
-  constructor(id: number, current: RegExp) {
-    this.i = id;
-    this.s = String(current);
-  }
 }
 
-export class SerovalTypedArrayNode implements SerovalBaseNode {
-  t: SerovalNodeType.TypedArray = SerovalNodeType.TypedArray;
-
+export interface SerovalTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.TypedArray;
   i: number;
-
   s: string;
-
   l: number;
-
   c: string;
-
-  constructor(id: number, current: TypedArrayValue) {
-    this.i = id;
-    this.s = current.toString();
-    this.l = current.byteOffset;
-    this.c = current.constructor.name;
-  }
 }
 
-export class SerovalBigIntTypedArrayNode implements SerovalBaseNode {
-  t: SerovalNodeType.BigIntTypedArray = SerovalNodeType.BigIntTypedArray;
-
+export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigIntTypedArray;
   i: number;
-
   s: string;
-
   l: number;
-
   c: string;
-
-  constructor(id: number, current: BigIntTypedArrayValue) {
-    let result = '';
-    const cap = current.length - 1;
-    for (let i = 0; i < cap; i++) {
-      result += `${current[i]}n,`;
-    }
-    result += `"${current[cap]}"`;
-
-    this.i = id;
-    this.s = result;
-    this.l = current.byteOffset;
-    this.c = current.constructor.name;
-  }
 }
 
 export type SerovalSemiPrimitiveNode =
@@ -181,136 +105,63 @@ export type SerovalSemiPrimitiveNode =
   | SerovalTypedArrayNode
   | SerovalBigIntTypedArrayNode;
 
-export class SerovalSetNode implements SerovalBaseNode {
-  t: SerovalNodeType.Set = SerovalNodeType.Set;
-
-  i: number;
-
+export interface SerovalSetNode extends SerovalBaseNode {
+  t: SerovalNodeType.Set;
   a: SerovalNode[];
-
-  constructor(id: number, a: SerovalNode[]) {
-    this.i = id;
-    this.a = a;
-  }
-}
-
-export class SerovalMapNode implements SerovalBaseNode {
-  t: SerovalNodeType.Map = SerovalNodeType.Map;
-
   i: number;
-
-  d: SerovalMapRecordNode;
-
-  constructor(id: number, d: SerovalMapRecordNode) {
-    this.i = id;
-    this.d = d;
-  }
 }
 
-export class SerovalArrayNode implements SerovalBaseNode {
-  t: SerovalNodeType.Array = SerovalNodeType.Array;
-
+export interface SerovalMapNode extends SerovalBaseNode {
+  t: SerovalNodeType.Map;
+  d: SerovalMapRecordNode;
   i: number;
-
-  a: SerovalNode[];
-
-  constructor(id: number, a: SerovalNode[]) {
-    this.i = id;
-    this.a = a;
-  }
 }
 
-export class SerovalObjectNode implements SerovalBaseNode {
-  t: SerovalNodeType.Object = SerovalNodeType.Object;
-
+export interface SerovalArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.Array;
+  a: SerovalNode[];
   i: number;
-
-  d: SerovalObjectRecordNode;
-
-  constructor(id: number, d: SerovalObjectRecordNode) {
-    this.i = id;
-    this.d = d;
-  }
 }
 
-export class SerovalNullConstructorNode implements SerovalBaseNode {
-  t: SerovalNodeType.NullConstructor = SerovalNodeType.NullConstructor;
-
-  i: number;
-
+export interface SerovalObjectNode extends SerovalBaseNode {
+  t: SerovalNodeType.Object;
   d: SerovalObjectRecordNode;
-
-  constructor(id: number, d: SerovalObjectRecordNode) {
-    this.i = id;
-    this.d = d;
-  }
+  i: number;
 }
 
-export class SerovalPromiseNode implements SerovalBaseNode {
-  t: SerovalNodeType.Promise = SerovalNodeType.Promise;
-
+export interface SerovalNullConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.NullConstructor;
+  d: SerovalObjectRecordNode;
   i: number;
-
-  n: SerovalNode;
-
-  constructor(id: number, n: SerovalNode) {
-    this.i = id;
-    this.n = n;
-  }
 }
 
-export class SerovalErrorNode implements SerovalBaseNode {
-  t: SerovalNodeType.Error = SerovalNodeType.Error;
-
+export interface SerovalPromiseNode extends SerovalBaseNode {
+  t: SerovalNodeType.Promise;
+  n: SerovalNode;
   i: number;
+}
 
+export interface SerovalErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.Error;
   c: string;
-
   m: string;
-
   d: SerovalObjectRecordNode | undefined;
-
-  constructor(id: number, c: string, m: string, d: SerovalObjectRecordNode | undefined) {
-    this.i = id;
-    this.c = c;
-    this.m = m;
-    this.d = d;
-  }
-}
-
-export class SerovalAggregateErrorNode implements SerovalBaseNode {
-  t: SerovalNodeType.AggregateError = SerovalNodeType.AggregateError;
-
   i: number;
+}
 
+export interface SerovalAggregateErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.AggregateError;
   m: string;
-
   d: SerovalObjectRecordNode | undefined;
-
   n: SerovalNode;
-
-  constructor(id: number, m: string, d: SerovalObjectRecordNode | undefined, n: SerovalNode) {
-    this.i = id;
-    this.m = m;
-    this.d = d;
-    this.n = n;
-  }
-}
-
-export class SerovalIterableNode implements SerovalBaseNode {
-  t: SerovalNodeType.Iterable = SerovalNodeType.Iterable;
-
   i: number;
+}
 
+export interface SerovalIterableNode extends SerovalBaseNode {
+  t: SerovalNodeType.Iterable;
   d: SerovalObjectRecordNode | undefined;
-
   a: SerovalNode[];
-
-  constructor(id: number, d: SerovalObjectRecordNode | undefined, a: SerovalNode[]) {
-    this.i = id;
-    this.d = d;
-    this.a = a;
-  }
+  i: number;
 }
 
 export type SerovalNode =