seroval 0.4.0-alpha.8 → 0.4.0-alpha.9

package/src/tree/sync.ts

@@ -15,19 +15,19 @@ import {
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
-  SerovalDictionaryNode,
   SerovalErrorNode,
   SerovalIterableNode,
   SerovalMapNode,
   SerovalNode,
   SerovalNodeType,
+  SerovalObjectRecordNode,
   SerovalSetNode,
 } from './types';
 
 function serializePropertiesSync(
   ctx: ParserContext,
   properties: Record<string, unknown>,
-): SerovalDictionaryNode {
+): SerovalObjectRecordNode {
   const keys = Object.keys(properties);
   const size = keys.length;
   const keyNodes = new Array<string>(size);
@@ -51,7 +51,11 @@ function serializePropertiesSync(
     keyNodes[nodesSize + i] = deferredKeys[i];
     valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, size];
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size,
+  };
 }
 
 function generateSetNode(
@@ -77,7 +81,17 @@ function generateSetNode(
   for (let i = 0; i < deferredSize; i++) {
     nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
   }
-  return [SerovalNodeType.Set, nodes, id];
+  return {
+    t: SerovalNodeType.Set,
+    i: id,
+    a: nodes,
+    s: undefined,
+    l: undefined,
+    m: undefined,
+    c: undefined,
+    d: undefined,
+    n: undefined,
+  };
 }
 
 function generateMapNode(
@@ -109,7 +123,17 @@ function generateMapNode(
     keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
     valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
   }
-  return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
+  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,
+  };
 }
 
 function generateNodeList(
@@ -141,7 +165,17 @@ function generateArrayNode(
   current: ServerValue[],
   id: number,
 ): SerovalArrayNode {
-  return [SerovalNodeType.Array, generateNodeList(ctx, current), id];
+  return {
+    t: SerovalNodeType.Array,
+    i: id,
+    a: generateNodeList(ctx, current),
+    s: undefined,
+    l: undefined,
+    m: undefined,
+    c: undefined,
+    d: undefined,
+    n: undefined,
+  };
 }
 
 function generateAggregateErrorNode(
@@ -153,8 +187,17 @@ function generateAggregateErrorNode(
   const optionsNode = options
     ? serializePropertiesSync(ctx, options)
     : undefined;
-  const errorsNode = generateTreeSync(ctx, current.errors as ServerValue);
-  return [SerovalNodeType.AggregateError, [current.message, optionsNode, errorsNode], id];
+  return {
+    t: SerovalNodeType.AggregateError,
+    i: id,
+    a: undefined,
+    s: undefined,
+    l: undefined,
+    m: current.message,
+    c: undefined,
+    d: optionsNode,
+    n: generateTreeSync(ctx, current.errors as ServerValue),
+  };
 }
 
 function generateErrorNode(
@@ -166,11 +209,17 @@ function generateErrorNode(
   const optionsNode = options
     ? serializePropertiesSync(ctx, options)
     : undefined;
-  return [
-    SerovalNodeType.Error,
-    [getErrorConstructor(current), current.message, optionsNode],
-    id,
-  ];
+  return {
+    t: SerovalNodeType.Error,
+    i: id,
+    a: undefined,
+    s: undefined,
+    l: undefined,
+    m: current.message,
+    c: getErrorConstructor(current),
+    d: optionsNode,
+    n: undefined,
+  };
 }
 
 function generateIterableNode(
@@ -180,11 +229,18 @@ function generateIterableNode(
 ): SerovalIterableNode {
   assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
-  return [SerovalNodeType.Iterable, [
+  return {
+    t: SerovalNodeType.Iterable,
+    i: id,
+    s: undefined,
+    l: undefined,
+    m: undefined,
+    c: undefined,
     // Parse options first before the items
-    options ? serializePropertiesSync(ctx, options) : undefined,
-    generateNodeList(ctx, Array.from(current)),
-  ], id];
+    d: options ? serializePropertiesSync(ctx, options) : undefined,
+    a: generateNodeList(ctx, Array.from(current)),
+    n: undefined,
+  };
 }
 
 function generateTreeSync(
@@ -192,12 +248,23 @@ function generateTreeSync(
   current: ServerValue,
 ): SerovalNode {
   if (isPrimitive(current)) {
-    return [SerovalNodeType.Primitive, serializePrimitive(current)];
+    return {
+      t: SerovalNodeType.Primitive,
+      i: undefined,
+      s: serializePrimitive(current),
+      l: undefined,
+      m: undefined,
+      c: undefined,
+      // Parse options first before the items
+      d: undefined,
+      a: undefined,
+      n: undefined,
+    };
   }
   // Non-primitive values needs a reference ID
   // mostly because the values themselves are stateful
   const id = generateRef(ctx, current);
-  if (Array.isArray(id)) {
+  if (typeof id !== 'number') {
     return id;
   }
   const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
@@ -224,11 +291,18 @@ function generateTreeSync(
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
-    return [
-      empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      serializePropertiesSync(ctx, current as Record<string, unknown>),
-      id,
-    ];
+    return {
+      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
+      i: id,
+      s: undefined,
+      l: undefined,
+      m: undefined,
+      c: undefined,
+      // Parse options first before the items
+      d: serializePropertiesSync(ctx, current as Record<string, unknown>),
+      a: undefined,
+      n: undefined,
+    };
   }
   throw new Error('Unsupported value');
 }
@@ -238,5 +312,5 @@ export default function parseSync(
   current: ServerValue,
 ) {
   const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === SerovalNodeType.Object] as const;
+  return [result, createRef(ctx, current), result.t === SerovalNodeType.Object] as const;
 }

package/src/tree/types.ts

@@ -19,72 +19,150 @@ export const enum SerovalNodeType {
   BigIntTypedArray,
 }
 
-export type SerovalPrimitiveNode = [
-  type: SerovalNodeType.Primitive,
-  value: PrimitiveValue,
-];
-export type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
+export interface SerovalBaseNode {
+  // Type of the node
+  t: SerovalNodeType;
+  // Serialized value
+  s: PrimitiveValue | undefined;
+  // Reference ID
+  i: number | undefined;
+  // Size/Byte offset
+  l: number | undefined;
+  // Constructor name
+  c: string | undefined;
+  // dictionary
+  d: SerovalDictionaryNode | undefined;
+  // message
+  m: string | undefined;
+  // next node
+  n: SerovalNode | undefined;
+  // array of nodes
+  a: SerovalNode[] | undefined;
+}
+
+export interface SerovalObjectRecordNode {
+  k: string[];
+  v: SerovalNode[];
+  s: number;
+}
+
+export interface SerovalMapRecordNode {
+  k: SerovalNode[];
+  v: SerovalNode[];
+  s: number;
+}
+
+export type SerovalDictionaryNode =
+  | SerovalObjectRecordNode
+  | SerovalMapRecordNode;
+
+export interface SerovalPrimitiveNode extends SerovalBaseNode {
+  t: SerovalNodeType.Primitive;
+}
+
+export interface SerovalReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Reference;
+  i: number;
+}
+
+export interface SerovalBigIntNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigInt;
+  s: string;
+}
+
+export interface SerovalDateNode extends SerovalBaseNode {
+  t: SerovalNodeType.Date;
+  i: number;
+  s: string;
+}
+
+export interface SerovalRegExpNode extends SerovalBaseNode {
+  t: SerovalNodeType.RegExp;
+  i: number;
+  s: string;
+}
+
+export interface SerovalTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.TypedArray;
+  i: number;
+  s: string;
+  l: number;
+  c: string;
+}
+
+export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.BigIntTypedArray;
+  i: number;
+  s: string;
+  l: number;
+  c: string;
+}
+
 export type SerovalSemiPrimitiveNode =
-  | [type: SerovalNodeType.BigInt, value: string]
-  | [type: SerovalNodeType.Date, value: string, id: number]
-  | [type: SerovalNodeType.RegExp, value: string, id: number]
-  | [
-    type: SerovalNodeType.TypedArray,
-    value: [constructor: string, array: string, byteOffset: number],
-    id: number
-  ]
-  | [
-    type: SerovalNodeType.BigIntTypedArray,
-    value: [constructor: string, array: string, byteOffset: number],
-    id: number
-  ];
-
-export type SerovalDictionaryNode = [key: string[], value: SerovalNode[], size: number];
-export type SerovalSetNode = [type: SerovalNodeType.Set, value: SerovalNode[], id: number];
-export type SerovalMapNode = [
-  type: SerovalNodeType.Map,
-  value: [key: SerovalNode[], value: SerovalNode[], size: number],
-  id: number
-];
-export type SerovalArrayNode = [type: SerovalNodeType.Array, value: SerovalNode[], id: number];
-export type SerovalObjectNode = [
-  type: SerovalNodeType.Object,
-  value: SerovalDictionaryNode,
-  id: number
-];
-export type SerovalNullConstructorNode = [
-  type: SerovalNodeType.NullConstructor,
-  value: SerovalDictionaryNode,
-  id: number,
-];
-export type SerovalPromiseNode = [type: SerovalNodeType.Promise, value: SerovalNode, id: number];
-export type SerovalErrorNode = [
-  type: SerovalNodeType.Error,
-  value: [
-    constructor: string,
-    message: string,
-    options?: SerovalDictionaryNode,
-  ],
-  id: number
-];
-export type SerovalAggregateErrorNode = [
-  type: SerovalNodeType.AggregateError,
-  value: [
-    message: string,
-    options: SerovalDictionaryNode | undefined,
-    errors: SerovalNode,
-  ],
-  id: number
-];
-
-export type SerovalIterableNode = [
-  type: SerovalNodeType.Iterable,
-  value: [
-    options: SerovalDictionaryNode | undefined,
-    items: SerovalNode[],
-  ],
-  id: number,
-];
+  | SerovalBigIntNode
+  | SerovalDateNode
+  | SerovalRegExpNode
+  | SerovalTypedArrayNode
+  | SerovalBigIntTypedArrayNode;
+
+export interface SerovalSetNode extends SerovalBaseNode {
+  t: SerovalNodeType.Set;
+  a: SerovalNode[];
+  i: number;
+}
+
+export interface SerovalMapNode extends SerovalBaseNode {
+  t: SerovalNodeType.Map;
+  d: SerovalMapRecordNode;
+  i: number;
+}
+
+export interface SerovalArrayNode extends SerovalBaseNode {
+  t: SerovalNodeType.Array;
+  a: SerovalNode[];
+  i: number;
+}
+
+export interface SerovalObjectNode extends SerovalBaseNode {
+  t: SerovalNodeType.Object;
+  d: SerovalObjectRecordNode;
+  i: number;
+}
+
+export interface SerovalNullConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.NullConstructor;
+  d: SerovalObjectRecordNode;
+  i: number;
+}
+
+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;
+  i: number;
+}
+
+export interface SerovalAggregateErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.AggregateError;
+  m: string;
+  d: SerovalObjectRecordNode | undefined;
+  n: SerovalNode;
+  i: number;
+}
+
+export interface SerovalIterableNode extends SerovalBaseNode {
+  t: SerovalNodeType.Iterable;
+  d: SerovalObjectRecordNode | undefined;
+  a: SerovalNode[];
+  i: number;
+}
 
 export type SerovalNode =
   | SerovalPrimitiveNode