seroval 0.4.0-alpha.12 → 0.4.0-alpha.13

package/src/tree/async.ts

@@ -10,14 +10,9 @@ import {
   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,
@@ -32,16 +27,24 @@ import {
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
+  SerovalBigIntNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalDateNode,
   SerovalErrorNode,
   SerovalIterableNode,
   SerovalMapNode,
+  SerovalMapRecordNode,
   SerovalNode,
   SerovalNodeType,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordNode,
+  SerovalPrimitiveNode,
   SerovalPromiseNode,
+  SerovalReferenceNode,
+  SerovalRegExpNode,
   SerovalSetNode,
+  SerovalTypedArrayNode,
 } from './types';
 
 type ObjectLikeNode =
@@ -91,17 +94,7 @@ class AsyncParser {
     id: number,
     current: AsyncServerValue[],
   ): Promise<SerovalArrayNode> {
-    return {
-      t: SerovalNodeType.Array,
-      i: id,
-      a: await this.generateNodeList(current),
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: undefined,
-      n: undefined,
-    };
+    return new SerovalArrayNode(id, await this.generateNodeList(current));
   }
 
   async generateMapNode(
@@ -132,17 +125,7 @@ class AsyncParser {
       keyNodes[nodeSize + i] = await this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = await this.parse(deferredValue[i]);
     }
-    return {
-      t: SerovalNodeType.Map,
-      i: id,
-      a: undefined,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: { k: keyNodes, v: valueNodes, s: len },
-      n: undefined,
-    };
+    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
   }
 
   async generateSetNode(
@@ -167,17 +150,7 @@ class AsyncParser {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = await this.parse(deferred[i]);
     }
-    return {
-      t: SerovalNodeType.Set,
-      i: id,
-      a: nodes,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: undefined,
-      n: undefined,
-    };
+    return new SerovalSetNode(id, nodes);
   }
 
   async generateProperties(
@@ -208,11 +181,7 @@ class AsyncParser {
       keyNodes[nodesSize + i] = deferredKeys[i];
       valueNodes[nodesSize + i] = await this.parse(deferredValues[i]);
     }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size,
-    };
+    return new SerovalObjectRecordNode(keyNodes, valueNodes, size);
   }
 
   async generateIterableNode(
@@ -221,20 +190,14 @@ class AsyncParser {
   ): Promise<SerovalIterableNode> {
     assert(this.ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return {
-      t: SerovalNodeType.Iterable,
-      i: id,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
+    return new SerovalIterableNode(
+      id,
       // Parse options first before the items
-      d: options
+      options
         ? await this.generateProperties(options as Record<string, AsyncServerValue>)
         : undefined,
-      a: await this.generateNodeList(Array.from(current)),
-      n: undefined,
-    };
+      await this.generateNodeList(Array.from(current)),
+    );
   }
 
   async generatePromiseNode(
@@ -242,18 +205,7 @@ class AsyncParser {
     current: PromiseLike<AsyncServerValue>,
   ): Promise<SerovalPromiseNode> {
     assert(this.ctx.features & Feature.Promise, 'Unsupported type "Promise"');
-    return current.then(async (value) => ({
-      t: SerovalNodeType.Promise,
-      i: id,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      // Parse options first before the items
-      d: undefined,
-      a: undefined,
-      n: await this.parse(value),
-    }));
+    return current.then(async (value) => new SerovalPromiseNode(id, await this.parse(value)));
   }
 
   async generateObjectNode(
@@ -267,17 +219,11 @@ class AsyncParser {
     if ('then' in current && typeof current.then === 'function') {
       return this.generatePromiseNode(id, current as PromiseLike<AsyncServerValue>);
     }
-    return {
-      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      i: id,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: await this.generateProperties(current as Record<string, AsyncServerValue>),
-      a: undefined,
-      n: undefined,
-    };
+    const properties = await this.generateProperties(current as Record<string, AsyncServerValue>);
+    if (empty) {
+      return new SerovalNullConstructorNode(id, properties);
+    }
+    return new SerovalObjectNode(id, properties);
   }
 
   async generateAggregateErrorNode(
@@ -288,17 +234,12 @@ class AsyncParser {
     const optionsNode = options
       ? await this.generateProperties(options)
       : undefined;
-    return {
-      t: SerovalNodeType.AggregateError,
-      i: id,
-      a: undefined,
-      s: undefined,
-      l: undefined,
-      m: current.message,
-      c: undefined,
-      d: optionsNode,
-      n: await this.parse(current.errors),
-    };
+    return new SerovalAggregateErrorNode(
+      id,
+      current.message,
+      optionsNode,
+      await this.parse(current.errors),
+    );
   }
 
   async generateErrorNode(
@@ -309,17 +250,7 @@ class AsyncParser {
     const optionsNode = options
       ? await this.generateProperties(options)
       : undefined;
-    return {
-      t: SerovalNodeType.Error,
-      i: id,
-      a: undefined,
-      s: undefined,
-      l: undefined,
-      m: current.message,
-      c: getErrorConstructor(current),
-      d: optionsNode,
-      n: undefined,
-    };
+    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
   }
 
   async parse(current: AsyncServerValue): Promise<SerovalNode> {
@@ -329,20 +260,21 @@ class AsyncParser {
       case 'undefined':
         return UNDEFINED_NODE;
       case 'string':
-        return createPrimitiveNode(quote(current));
+        return new SerovalPrimitiveNode(quote(current));
       case 'number':
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return createPrimitiveNode('1/0');
+          return INFINITY_NODE;
         }
         if (Object.is(current, -Infinity)) {
-          return createPrimitiveNode('-1/0');
+          return NEG_INFINITY_NODE;
         }
-        return createPrimitiveNode(current);
+        return new SerovalPrimitiveNode(current);
       case 'bigint':
-        return createBigIntNode(this.ctx, current);
+        assert(this.ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
+        return new SerovalBigIntNode(current);
       case 'object': {
         if (!current) {
           return NULL_NODE;
@@ -351,16 +283,16 @@ class AsyncParser {
         // mostly because the values themselves are stateful
         const id = createRef(this.ctx, current, true);
         if (this.ctx.markedRefs[id]) {
-          return createReferenceNode(id);
+          return new SerovalReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(id, current);
         }
         switch (current.constructor) {
           case Date:
-            return createDateNode(id, current as Date);
+            return new SerovalDateNode(id, current as Date);
           case RegExp:
-            return createRegExpNode(id, current as RegExp);
+            return new SerovalRegExpNode(id, current as RegExp);
           case Promise:
             return this.generatePromiseNode(id, current as Promise<AsyncServerValue>);
           case Int8Array:
@@ -372,10 +304,15 @@ class AsyncParser {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            return createTypedArrayNode(this.ctx, id, current as TypedArrayValue);
+            assert(this.ctx.features & Feature.TypedArray, `Unsupported value type "${current.constructor.name}"`);
+            return new SerovalTypedArrayNode(id, current as TypedArrayValue);
           case BigInt64Array:
           case BigUint64Array:
-            return createBigIntTypedArrayNode(this.ctx, id, current as BigIntTypedArrayValue);
+            assert(
+              this.ctx.features & (Feature.BigIntTypedArray),
+              `Unsupported value type "${current.constructor.name}"`,
+            );
+            return new SerovalBigIntTypedArrayNode(id, current as BigIntTypedArrayValue);
           case Map:
             return this.generateMapNode(id, current as Map<AsyncServerValue, AsyncServerValue>);
           case Set:

package/src/tree/primitives.ts

@@ -1,147 +1,11 @@
-import assert from '../assert';
-import { Feature } from '../compat';
-import { ParserContext } from '../context';
-import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
 import {
-  SerovalBigIntNode,
-  SerovalBigIntTypedArrayNode,
-  SerovalDateNode,
-  SerovalNodeType,
   SerovalPrimitiveNode,
-  SerovalReferenceNode,
-  SerovalRegExpNode,
-  SerovalTypedArrayNode,
 } from './types';
 
-export function createPrimitiveNode(
-  value: string | number | null,
-): SerovalPrimitiveNode {
-  return {
-    t: SerovalNodeType.Primitive,
-    i: undefined,
-    s: value,
-    l: undefined,
-    m: undefined,
-    c: undefined,
-    d: undefined,
-    a: undefined,
-    n: undefined,
-  };
-}
-
-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 createBigIntNode(
-  ctx: ParserContext,
-  current: bigint,
-): SerovalBigIntNode {
-  assert(ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
-  return {
-    t: SerovalNodeType.BigInt,
-    i: undefined,
-    a: undefined,
-    s: `${current}n`,
-    l: undefined,
-    m: undefined,
-    c: undefined,
-    d: undefined,
-    n: undefined,
-  };
-}
-
-export function createReferenceNode(id: number): SerovalReferenceNode {
-  return {
-    t: SerovalNodeType.Reference,
-    i: id,
-    a: undefined,
-    s: undefined,
-    l: undefined,
-    m: undefined,
-    c: undefined,
-    d: undefined,
-    n: undefined,
-  };
-}
-
-export function createDateNode(id: number, current: Date): SerovalDateNode {
-  return {
-    t: SerovalNodeType.Date,
-    i: id,
-    a: undefined,
-    s: current.toISOString(),
-    l: undefined,
-    m: undefined,
-    c: undefined,
-    d: undefined,
-    n: undefined,
-  };
-}
-
-export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode {
-  return {
-    t: SerovalNodeType.RegExp,
-    i: id,
-    a: undefined,
-    s: String(current),
-    l: undefined,
-    m: undefined,
-    c: undefined,
-    d: undefined,
-    n: undefined,
-  };
-}
-
-export function createTypedArrayNode(
-  ctx: ParserContext,
-  id: number,
-  current: TypedArrayValue,
-): SerovalTypedArrayNode {
-  const constructor = current.constructor.name;
-  assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
-  return {
-    t: SerovalNodeType.TypedArray,
-    i: id,
-    a: undefined,
-    s: current.toString(),
-    l: current.byteOffset,
-    m: undefined,
-    c: constructor,
-    d: undefined,
-    n: undefined,
-  };
-}
-
-export function createBigIntTypedArrayNode(
-  ctx: ParserContext,
-  id: number,
-  current: BigIntTypedArrayValue,
-): SerovalBigIntTypedArrayNode {
-  const constructor = current.constructor.name;
-  assert(
-    ctx.features & (Feature.BigIntTypedArray),
-    `Unsupported value type "${constructor}"`,
-  );
-  let result = '';
-  const cap = current.length - 1;
-  for (let i = 0; i < cap; i++) {
-    result += `${current[i]}n,`;
-  }
-  result += `"${current[cap]}"`;
-  return {
-    t: SerovalNodeType.BigIntTypedArray,
-    i: id,
-    a: undefined,
-    s: result,
-    l: (current as BigInt64Array).byteOffset,
-    m: undefined,
-    c: constructor,
-    d: undefined,
-    n: undefined,
-  };
-}
+export const TRUE_NODE = new SerovalPrimitiveNode('!0');
+export const FALSE_NODE = new SerovalPrimitiveNode('!1');
+export const UNDEFINED_NODE = new SerovalPrimitiveNode('void 0');
+export const NULL_NODE = new SerovalPrimitiveNode(null);
+export const NEG_ZERO_NODE = new SerovalPrimitiveNode('-0');
+export const INFINITY_NODE = new SerovalPrimitiveNode('1/0');
+export const NEG_INFINITY_NODE = new SerovalPrimitiveNode('-1/0');

package/src/tree/sync.ts

@@ -5,14 +5,9 @@ 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,
@@ -27,15 +22,23 @@ 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;
@@ -71,17 +74,7 @@ class SyncParser {
   }
 
   generateArrayNode(id: number, current: ServerValue[]): SerovalArrayNode {
-    return {
-      t: SerovalNodeType.Array,
-      i: id,
-      a: this.generateNodeList(current),
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: undefined,
-      n: undefined,
-    };
+    return new SerovalArrayNode(id, this.generateNodeList(current));
   }
 
   generateMapNode(
@@ -112,17 +105,7 @@ class SyncParser {
       keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = this.parse(deferredValue[i]);
     }
-    return {
-      t: SerovalNodeType.Map,
-      i: id,
-      a: undefined,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: { k: keyNodes, v: valueNodes, s: len },
-      n: undefined,
-    };
+    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
   }
 
   generateSetNode(
@@ -147,17 +130,7 @@ class SyncParser {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = this.parse(deferred[i]);
     }
-    return {
-      t: SerovalNodeType.Set,
-      i: id,
-      a: nodes,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: undefined,
-      n: undefined,
-    };
+    return new SerovalSetNode(id, nodes);
   }
 
   generateProperties(properties: Record<string, ServerValue>): SerovalObjectRecordNode {
@@ -199,20 +172,14 @@ class SyncParser {
   ): SerovalIterableNode {
     assert(this.ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return {
-      t: SerovalNodeType.Iterable,
-      i: id,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
+    return new SerovalIterableNode(
+      id,
       // Parse options first before the items
-      d: options
+      options
         ? this.generateProperties(options as Record<string, ServerValue>)
         : undefined,
-      a: this.generateNodeList(Array.from(current)),
-      n: undefined,
-    };
+      this.generateNodeList(Array.from(current)),
+    );
   }
 
   generateObjectNode(
@@ -223,17 +190,10 @@ class SyncParser {
     if (Symbol.iterator in current) {
       return this.generateIterableNode(id, current);
     }
-    return {
-      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      i: id,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      d: this.generateProperties(current),
-      a: undefined,
-      n: undefined,
-    };
+    if (empty) {
+      return new SerovalNullConstructorNode(id, this.generateProperties(current));
+    }
+    return new SerovalObjectNode(id, this.generateProperties(current));
   }
 
   generateAggregateErrorNode(
@@ -244,17 +204,12 @@ class SyncParser {
     const optionsNode = options
       ? this.generateProperties(options)
       : undefined;
-    return {
-      t: SerovalNodeType.AggregateError,
-      i: id,
-      a: undefined,
-      s: undefined,
-      l: undefined,
-      m: current.message,
-      c: undefined,
-      d: optionsNode,
-      n: this.parse(current.errors),
-    };
+    return new SerovalAggregateErrorNode(
+      id,
+      current.message,
+      optionsNode,
+      this.parse(current.errors),
+    );
   }
 
   generateErrorNode(
@@ -265,17 +220,7 @@ class SyncParser {
     const optionsNode = options
       ? this.generateProperties(options)
       : undefined;
-    return {
-      t: SerovalNodeType.Error,
-      i: id,
-      a: undefined,
-      s: undefined,
-      l: undefined,
-      m: current.message,
-      c: getErrorConstructor(current),
-      d: optionsNode,
-      n: undefined,
-    };
+    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
   }
 
   parse(current: ServerValue): SerovalNode {
@@ -285,20 +230,21 @@ class SyncParser {
       case 'undefined':
         return UNDEFINED_NODE;
       case 'string':
-        return createPrimitiveNode(quote(current));
+        return new SerovalPrimitiveNode(quote(current));
       case 'number':
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return createPrimitiveNode('1/0');
+          return INFINITY_NODE;
         }
         if (Object.is(current, -Infinity)) {
-          return createPrimitiveNode('-1/0');
+          return NEG_INFINITY_NODE;
         }
-        return createPrimitiveNode(current);
+        return new SerovalPrimitiveNode(current);
       case 'bigint':
-        return createBigIntNode(this.ctx, current);
+        assert(this.ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
+        return new SerovalBigIntNode(current);
       case 'object': {
         if (!current) {
           return NULL_NODE;
@@ -307,16 +253,16 @@ class SyncParser {
         // mostly because the values themselves are stateful
         const id = createRef(this.ctx, current, true);
         if (this.ctx.markedRefs[id]) {
-          return createReferenceNode(id);
+          return new SerovalReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(id, current);
         }
         switch (current.constructor) {
           case Date:
-            return createDateNode(id, current as Date);
+            return new SerovalDateNode(id, current as Date);
           case RegExp:
-            return createRegExpNode(id, current as RegExp);
+            return new SerovalRegExpNode(id, current as RegExp);
           case Int8Array:
           case Int16Array:
           case Int32Array:
@@ -326,10 +272,15 @@ class SyncParser {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            return createTypedArrayNode(this.ctx, id, current as TypedArrayValue);
+            assert(this.ctx.features & Feature.TypedArray, `Unsupported value type "${current.constructor.name}"`);
+            return new SerovalTypedArrayNode(id, current as TypedArrayValue);
           case BigInt64Array:
           case BigUint64Array:
-            return createBigIntTypedArrayNode(this.ctx, id, current as BigIntTypedArrayValue);
+            assert(
+              this.ctx.features & (Feature.BigIntTypedArray),
+              `Unsupported value type "${current.constructor.name}"`,
+            );
+            return new SerovalBigIntTypedArrayNode(id, current as BigIntTypedArrayValue);
           case Map:
             return this.generateMapNode(id, current as Map<ServerValue, ServerValue>);
           case Set: