seroval 0.4.0-alpha.7 → 0.4.0-alpha.9

package/dist/types/tree/types.d.ts

@@ -17,63 +17,112 @@ export declare const enum SerovalNodeType {
     TypedArray = 14,
     BigIntTypedArray = 15
 }
-export type SerovalPrimitiveNode = [
-    type: SerovalNodeType.Primitive,
-    value: PrimitiveValue
-];
-export type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
-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
-];
+export interface SerovalBaseNode {
+    t: SerovalNodeType;
+    s: PrimitiveValue | undefined;
+    i: number | undefined;
+    l: number | undefined;
+    c: string | undefined;
+    d: SerovalDictionaryNode | undefined;
+    m: string | undefined;
+    n: SerovalNode | undefined;
+    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 = 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 | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.4.0-alpha.7",
+  "version": "0.4.0-alpha.9",
   "files": [
     "dist",
     "src"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "30e67c013299a4e75136a9a2b41945ee54d8b6b8"
+  "gitHead": "27ff8d23e589e5968ebe968b14d050cd468ca49f"
 }

package/src/context.ts

@@ -28,16 +28,17 @@ export type Assignment =
 
 export interface ParserContext {
   refs: Map<unknown, number>;
-  markedRefs: Set<number>;
+  markedRefs: Record<number, number>;
   features: number;
 }
 
 export interface SerializationContext {
   stack: number[];
   // Map tree refs to actual refs
-  validRefs: Map<number, number>;
+  validRefs: number[];
+  refSize: number;
   // Refs that are...referenced
-  markedRefs: Set<number>;
+  markedRefs: Record<number, number>;
   // Variables
   vars: string[];
   // Array of assignments to be done (used for recursion)
@@ -58,14 +59,14 @@ export function createParserContext(options: Partial<Options> = {}): ParserConte
   // eslint-disable-next-line prefer-object-spread
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: new Set(),
+    markedRefs: {},
     refs: new Map(),
     features: parseTargets(result.target),
   };
 }
 
 export interface SerializationOptions {
-  markedRefs: number[] | Set<number>;
+  markedRefs: Record<number, number>;
   features: number;
 }
 
@@ -74,9 +75,10 @@ export function createSerializationContext(options: SerializationOptions): Seria
     stack: [],
     vars: [],
     assignments: [],
-    validRefs: new Map(),
+    validRefs: [],
+    refSize: 0,
     features: options.features,
-    markedRefs: new Set(options.markedRefs),
+    markedRefs: options.markedRefs,
   };
 }
 
@@ -84,7 +86,7 @@ export function createSerializationContext(options: SerializationOptions): Seria
  * Increments the number of references the referenced value has
  */
 export function markRef(ctx: ParserContext | SerializationContext, current: number) {
-  ctx.markedRefs.add(current);
+  ctx.markedRefs[current] = 1;
 }
 
 /**
@@ -97,13 +99,13 @@ function createValidRef(
   ctx: SerializationContext,
   index: number,
 ) {
-  const current = ctx.validRefs.get(index);
-  if (current != null) {
-    return current;
+  const current = ctx.validRefs[index];
+  if (current == null) {
+    const value = ctx.refSize++;
+    ctx.validRefs[index] = value;
+    return value;
   }
-  const id = ctx.validRefs.size;
-  ctx.validRefs.set(index, id);
-  return id;
+  return current;
 }
 
 /**

package/src/index.ts

@@ -106,7 +106,7 @@ type SerovalJSON = [
   root: number,
   isObject: boolean,
   feature: number,
-  markedRefs: number[],
+  markedRefs: Record<number, number>,
 ];
 
 export function toJSON<T extends ServerValue>(
@@ -120,7 +120,7 @@ export function toJSON<T extends ServerValue>(
     root,
     isObject,
     ctx.features,
-    [...ctx.markedRefs],
+    ctx.markedRefs,
   ]);
 }
 
@@ -135,7 +135,7 @@ export async function toJSONAsync<T extends AsyncServerValue>(
     root,
     isObject,
     ctx.features,
-    [...ctx.markedRefs],
+    ctx.markedRefs,
   ]);
 }
 

package/src/tree/async.ts

@@ -21,19 +21,19 @@ import {
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
-  SerovalDictionaryNode,
   SerovalErrorNode,
   SerovalIterableNode,
   SerovalMapNode,
   SerovalNode,
   SerovalNodeType,
+  SerovalObjectRecordNode,
   SerovalSetNode,
 } from './types';
 
 async function serializePropertiesAsync(
   ctx: ParserContext,
   properties: Record<string, unknown>,
-): Promise<SerovalDictionaryNode> {
+): Promise<SerovalObjectRecordNode> {
   const keys = Object.keys(properties);
   const size = keys.length;
   const keyNodes = new Array<string>(size);
@@ -57,7 +57,11 @@ async function serializePropertiesAsync(
     keyNodes[nodesSize + i] = deferredKeys[i];
     valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, size];
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size,
+  };
 }
 
 async function generateSetNode(
@@ -83,7 +87,17 @@ async function generateSetNode(
   for (let i = 0; i < deferredSize; i++) {
     nodes[nodeSize + i] = await generateTreeAsync(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,
+  };
 }
 
 async function generateMapNode(
@@ -115,7 +129,17 @@ async function generateMapNode(
     keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
     valueNodes[nodeSize + i] = await generateTreeAsync(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,
+  };
 }
 
 async function generateNodeList(
@@ -147,7 +171,17 @@ async function generateArrayNode(
   current: AsyncServerValue[],
   id: number,
 ): Promise<SerovalArrayNode> {
-  return [SerovalNodeType.Array, await generateNodeList(ctx, current), id];
+  return {
+    t: SerovalNodeType.Array,
+    i: id,
+    a: await generateNodeList(ctx, current),
+    s: undefined,
+    l: undefined,
+    m: undefined,
+    c: undefined,
+    d: undefined,
+    n: undefined,
+  };
 }
 
 async function generateAggregateErrorNode(
@@ -159,12 +193,17 @@ async function generateAggregateErrorNode(
   const optionsNode = options
     ? await serializePropertiesAsync(ctx, options)
     : undefined;
-  const errorsNode = await generateTreeAsync(ctx, current.errors as AsyncServerValue);
-  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: await generateTreeAsync(ctx, current.errors as AsyncServerValue),
+  };
 }
 
 async function generateErrorNode(
@@ -176,11 +215,17 @@ async function generateErrorNode(
   const optionsNode = options
     ? await serializePropertiesAsync(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,
+  };
 }
 
 async function generateIterableNode(
@@ -190,11 +235,18 @@ async function generateIterableNode(
 ): Promise<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 ? await serializePropertiesAsync(ctx, options) : undefined,
-    await generateNodeList(ctx, Array.from(current)),
-  ], id];
+    d: options ? await serializePropertiesAsync(ctx, options) : undefined,
+    a: await generateNodeList(ctx, Array.from(current)),
+    n: undefined,
+  };
 }
 
 async function generateTreeAsync(
@@ -202,12 +254,23 @@ async function generateTreeAsync(
   current: AsyncServerValue,
 ): Promise<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);
@@ -216,11 +279,18 @@ async function generateTreeAsync(
   }
   if (isPromise(current)) {
     assert(ctx.features & Feature.Promise, 'Unsupported type "Promise"');
-    return current.then(async (value) => [
-      SerovalNodeType.Promise,
-      await generateTreeAsync(ctx, value),
-      id,
-    ]);
+    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 generateTreeAsync(ctx, value),
+    }));
   }
   if (constructorCheck<Set<AsyncServerValue>>(current, Set)) {
     return generateSetNode(ctx, current, id);
@@ -242,11 +312,18 @@ async function generateTreeAsync(
   }
   const empty = current.constructor == null;
   if (current.constructor === Object || empty) {
-    return [
-      empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      await serializePropertiesAsync(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: await serializePropertiesAsync(ctx, current as Record<string, unknown>),
+      a: undefined,
+      n: undefined,
+    };
   }
   throw new Error('Unsupported value');
 }
@@ -256,5 +333,5 @@ export default async function parseAsync(
   current: AsyncServerValue,
 ) {
   const result = await generateTreeAsync(ctx, current);
-  return [result, createRef(ctx, current), result[0] === SerovalNodeType.Object] as const;
+  return [result, createRef(ctx, current), result.t === SerovalNodeType.Object] as const;
 }