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

package/src/index.ts

@@ -4,10 +4,11 @@ import {
   SerializationContext,
   getRefParam,
   Options,
-  ParserContext,
+  createParserContext,
+  createSerializationContext,
 } from './context';
 import parseAsync from './tree/async';
-import serializeTree, { resolvePatches } from './tree/serialize';
+import SerovalSerializer, { resolvePatches } from './tree/serialize';
 import parseSync from './tree/sync';
 import { SerovalNode } from './tree/types';
 import {
@@ -69,10 +70,10 @@ export function serialize<T extends ServerValue>(
   source: T,
   options?: Partial<Options>,
 ) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
-  const serial = new SerializationContext(ctx);
-  const result = serializeTree(serial, tree);
+  const serial = createSerializationContext(ctx);
+  const result = new SerovalSerializer(serial).serialize(tree);
   return finalize(serial, rootID, isObject, result);
 }
 
@@ -80,10 +81,10 @@ export async function serializeAsync<T extends AsyncServerValue>(
   source: T,
   options?: Partial<Options>,
 ) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
-  const serial = new SerializationContext(ctx);
-  const result = serializeTree(serial, tree);
+  const serial = createSerializationContext(ctx);
+  const result = new SerovalSerializer(serial).serialize(tree);
   return finalize(serial, rootID, isObject, result);
 }
 
@@ -92,52 +93,52 @@ export function deserialize<T extends AsyncServerValue>(source: string): T {
   return (0, eval)(source) as T;
 }
 
-type SerovalJSON = [
-  tree: SerovalNode,
-  root: number,
-  isObject: boolean,
-  feature: number,
-  markedRefs: Record<number, number>,
-];
+interface SerovalJSON {
+  t: SerovalNode,
+  r: number,
+  i: boolean,
+  f: number,
+  m: number[],
+}
 
 export function toJSON<T extends ServerValue>(
   source: T,
   options?: Partial<Options>,
 ) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs,
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs),
+  });
 }
 
 export async function toJSONAsync<T extends AsyncServerValue>(
   source: T,
   options?: Partial<Options>,
 ) {
-  const ctx = new ParserContext(options);
+  const ctx = createParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs,
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs),
+  });
 }
 
 export function compileJSON(source: string): string {
   const parsed = JSON.parse(source) as SerovalJSON;
-  const serial = new SerializationContext({
-    features: parsed[3],
-    markedRefs: parsed[4],
+  const serial = createSerializationContext({
+    features: parsed.f,
+    markedRefs: parsed.m,
   });
-  const result = serializeTree(serial, parsed[0]);
-  return finalize(serial, parsed[1], parsed[2], result);
+  const result = new SerovalSerializer(serial).serialize(parsed.t);
+  return finalize(serial, parsed.r, parsed.i, result);
 }
 
 export function fromJSON<T extends AsyncServerValue>(source: string): T {

package/src/tree/async.ts

@@ -10,9 +10,14 @@ 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,
@@ -27,24 +32,16 @@ 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 =
@@ -94,7 +91,17 @@ class AsyncParser {
     id: number,
     current: AsyncServerValue[],
   ): Promise<SerovalArrayNode> {
-    return new SerovalArrayNode(id, await this.generateNodeList(current));
+    return {
+      t: SerovalNodeType.Array,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: undefined,
+      a: await this.generateNodeList(current),
+      n: undefined,
+    };
   }
 
   async generateMapNode(
@@ -125,7 +132,17 @@ class AsyncParser {
       keyNodes[nodeSize + i] = await this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = await 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,
+    };
   }
 
   async generateSetNode(
@@ -150,7 +167,17 @@ class AsyncParser {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = await 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,
+    };
   }
 
   async generateProperties(
@@ -181,7 +208,11 @@ class AsyncParser {
       keyNodes[nodesSize + i] = deferredKeys[i];
       valueNodes[nodesSize + i] = await this.parse(deferredValues[i]);
     }
-    return new SerovalObjectRecordNode(keyNodes, valueNodes, size);
+    return {
+      k: keyNodes,
+      v: valueNodes,
+      s: size,
+    };
   }
 
   async generateIterableNode(
@@ -190,14 +221,20 @@ class AsyncParser {
   ): Promise<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
         ? await this.generateProperties(options as Record<string, AsyncServerValue>)
         : undefined,
-      await this.generateNodeList(Array.from(current)),
-    );
+      a: await this.generateNodeList(Array.from(current)),
+      n: undefined,
+    };
   }
 
   async generatePromiseNode(
@@ -205,7 +242,18 @@ class AsyncParser {
     current: PromiseLike<AsyncServerValue>,
   ): Promise<SerovalPromiseNode> {
     assert(this.ctx.features & Feature.Promise, 'Unsupported type "Promise"');
-    return current.then(async (value) => new SerovalPromiseNode(id, await this.parse(value)));
+    return current.then(async (value) => ({
+      t: SerovalNodeType.Promise,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      // Parse options first before the items
+      d: undefined,
+      a: undefined,
+      n: await this.parse(value),
+    }));
   }
 
   async generateObjectNode(
@@ -219,11 +267,17 @@ class AsyncParser {
     if ('then' in current && typeof current.then === 'function') {
       return this.generatePromiseNode(id, current as PromiseLike<AsyncServerValue>);
     }
-    const properties = await this.generateProperties(current as Record<string, AsyncServerValue>);
-    if (empty) {
-      return new SerovalNullConstructorNode(id, properties);
-    }
-    return new SerovalObjectNode(id, properties);
+    return {
+      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      d: await this.generateProperties(current as Record<string, AsyncServerValue>),
+      a: undefined,
+      n: undefined,
+    };
   }
 
   async generateAggregateErrorNode(
@@ -234,12 +288,17 @@ class AsyncParser {
     const optionsNode = options
       ? await this.generateProperties(options)
       : undefined;
-    return new SerovalAggregateErrorNode(
-      id,
-      current.message,
-      optionsNode,
-      await this.parse(current.errors),
-    );
+    return {
+      t: SerovalNodeType.AggregateError,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: current.message,
+      d: optionsNode,
+      a: undefined,
+      n: await this.parse(current.errors),
+    };
   }
 
   async generateErrorNode(
@@ -250,7 +309,17 @@ class AsyncParser {
     const optionsNode = options
       ? await 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,
+    };
   }
 
   async parse(current: AsyncServerValue): Promise<SerovalNode> {
@@ -260,21 +329,20 @@ class AsyncParser {
       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;
@@ -282,17 +350,17 @@ class AsyncParser {
         // 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 Promise:
             return this.generatePromiseNode(id, current as Promise<AsyncServerValue>);
           case Int8Array:
@@ -304,15 +372,10 @@ class AsyncParser {
           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<AsyncServerValue, AsyncServerValue>);
           case Set:

package/src/tree/primitives.ts

@@ -1,11 +1,147 @@
+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 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');
+export function createPrimitiveNode(
+  value: string | number | null,
+): SerovalPrimitiveNode {
+  return {
+    t: SerovalNodeType.Primitive,
+    i: undefined,
+    s: value,
+    l: undefined,
+    c: undefined,
+    m: 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,
+    s: `${current}n`,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    n: undefined,
+  };
+}
+
+export function createReferenceNode(id: number): SerovalReferenceNode {
+  return {
+    t: SerovalNodeType.Reference,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    n: undefined,
+  };
+}
+
+export function createDateNode(id: number, current: Date): SerovalDateNode {
+  return {
+    t: SerovalNodeType.Date,
+    i: id,
+    s: current.toISOString(),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    n: undefined,
+    a: undefined,
+  };
+}
+
+export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode {
+  return {
+    t: SerovalNodeType.RegExp,
+    i: id,
+    s: String(current),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: 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,
+    s: current.toString(),
+    l: current.byteOffset,
+    c: constructor,
+    m: undefined,
+    d: undefined,
+    a: 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,
+    s: result,
+    l: (current as BigInt64Array).byteOffset,
+    c: constructor,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    n: undefined,
+  };
+}