seroval 0.5.0 → 0.5.1

package/src/tree/serialize.ts

@@ -48,35 +48,55 @@ function mergeAssignments(assignments: Assignment[]) {
   for (let i = 1, len = assignments.length; i < len; i++) {
     item = assignments[i];
     if (item.t === prev.t) {
-      if (item.t === 'index' && item.v === prev.v) {
-        // Merge if the right-hand value is the same
-        // saves at least 2 chars
-        current = {
-          t: 'index',
-          s: item.s,
-          k: undefined,
-          v: getAssignmentExpression(current),
-        };
-      } else if (item.t === 'map' && item.s === prev.s) {
-        // Maps has chaining methods, merge if source is the same
-        current = {
-          t: 'map',
-          s: getAssignmentExpression(current),
-          k: item.k,
-          v: item.v,
-        };
-      } else if (item.t === 'set' && item.s === prev.s) {
-        // Sets has chaining methods too
-        current = {
-          t: 'set',
-          s: getAssignmentExpression(current),
-          k: undefined,
-          v: item.v,
-        };
-      } else {
-        // Different assignment, push current
-        newAssignments.push(current);
-        current = item;
+      switch (item.t) {
+        case 'index':
+          if (item.v === prev.v) {
+            // Merge if the right-hand value is the same
+            // saves at least 2 chars
+            current = {
+              t: 'index',
+              s: item.s,
+              k: undefined,
+              v: getAssignmentExpression(current),
+            };
+          } else {
+            // Different assignment, push current
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case 'map':
+          if (item.s === prev.s) {
+            // Maps has chaining methods, merge if source is the same
+            current = {
+              t: 'map',
+              s: getAssignmentExpression(current),
+              k: item.k,
+              v: item.v,
+            };
+          } else {
+            // Different assignment, push current
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case 'set':
+          if (item.s === prev.s) {
+            // Sets has chaining methods too
+            current = {
+              t: 'set',
+              s: getAssignmentExpression(current),
+              k: undefined,
+              v: item.v,
+            };
+          } else {
+            // Different assignment, push current
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        default:
+          break;
       }
     } else {
       newAssignments.push(current);
@@ -161,7 +181,7 @@ function createArrayAssign(
   value: string,
 ) {
   markRef(ctx, ref);
-  createAssignment(ctx, getRefParam(ctx, ref) + '[' + index.toString() + ']', value);
+  createAssignment(ctx, getRefParam(ctx, ref) + '[' + index + ']', value);
 }
 
 function createObjectAssign(
@@ -223,10 +243,7 @@ function serializeNodeList(
       isHoley = true;
     }
   }
-  if (isHoley) {
-    values += ',';
-  }
-  return '[' + values + ']';
+  return '[' + values + (isHoley ? ',]' : ']');
 }
 
 function serializeArray(
@@ -270,11 +287,9 @@ function serializeProperties(
         createArrayAssign(ctx, sourceID, isIdentifier ? key : ('"' + quote(key) + '"'), refParam);
       }
     } else {
-      if (hasPrev) {
-        result += ',';
-      }
-      result += isIdentifier ? key : ('"' + quote(key) + '"');
-      result += ':' + serializeTree(ctx, val);
+      result += (hasPrev ? ',' : '')
+        + (isIdentifier ? key : ('"' + quote(key) + '"'))
+        + ':' + serializeTree(ctx, val);
       hasPrev = true;
     }
   }
@@ -344,8 +359,7 @@ function serializeDictionary(
       markRef(ctx, i);
       const assignments = serializeAssignments(ctx, i, d);
       if (assignments) {
-        const ref = getRefParam(ctx, i);
-        return '(' + assignRef(ctx, i, init) + ',' + assignments + ref + ')';
+        return '(' + assignRef(ctx, i, init) + ',' + assignments + getRefParam(ctx, i) + ')';
       }
     }
   }
@@ -383,10 +397,7 @@ function serializeSet(
         createSetAdd(ctx, node.i, getRefParam(ctx, item.i));
       } else {
         // Push directly
-        if (hasPrev) {
-          result += ',';
-        }
-        result += serializeTree(ctx, item);
+        result += (hasPrev ? ',' : '') + serializeTree(ctx, item);
         hasPrev = true;
       }
     }
@@ -446,10 +457,7 @@ function serializeMap(
         createMapSet(ctx, node.i, serializeTree(ctx, key), valueRef);
         ctx.stack = parent;
       } else {
-        if (hasPrev) {
-          result += ',';
-        }
-        result += '[' + serializeTree(ctx, key) + ',' + serializeTree(ctx, val) + ']';
+        result += (hasPrev ? ',[' : '[') + serializeTree(ctx, key) + ',' + serializeTree(ctx, val) + ']';
         hasPrev = true;
       }
     }
@@ -492,12 +500,12 @@ function serializePromise(
 ) {
   let serialized: string;
   // Check if resolved value is a parent expression
-  if (isReferenceInStack(ctx, node.n)) {
+  if (isReferenceInStack(ctx, node.f)) {
     // A Promise trick, reference the value
     // inside the `then` expression so that
     // the Promise evaluates after the parent
     // has initialized
-    const ref = getRefParam(ctx, node.n.i);
+    const ref = getRefParam(ctx, node.f.i);
     if (ctx.features & Feature.ArrowFunction) {
       serialized = 'Promise.resolve().then(()=>' + ref + ')';
     } else {
@@ -505,7 +513,7 @@ function serializePromise(
     }
   } else {
     ctx.stack.push(node.i);
-    const result = serializeTree(ctx, node.n);
+    const result = serializeTree(ctx, node.f);
     ctx.stack.pop();
     // just inline the value/reference here
     serialized = 'Promise.resolve(' + result + ')';
@@ -518,19 +526,11 @@ function serializeTypedArray(
   node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
 ) {
   let result = '';
+  const isBigInt = node.t === SerovalNodeType.BigIntTypedArray;
   for (let i = 0, len = node.s.length; i < len; i++) {
-    if (i !== 0) {
-      result += ',';
-    }
-    result += node.s[i];
-    if (node.t === SerovalNodeType.BigIntTypedArray) {
-      result += 'n';
-    }
-  }
-  let args = '[' + result + ']';
-  if (node.l !== 0) {
-    args += ',' + node.l.toString();
+    result += (i !== 0 ? ',' : '') + node.s[i] + (isBigInt ? 'n' : '');
   }
+  const args = '[' + result + ']' + (node.l !== 0 ? (',' + node.l) : '');
   return assignRef(ctx, node.i, 'new ' + node.c + '(' + args + ')');
 }
 
@@ -564,13 +564,13 @@ export default function serializeTree(
 ): string {
   switch (node.t) {
     case SerovalNodeType.Number:
-      return String(node.s);
+      return '' + node.s;
     case SerovalNodeType.String:
       return '"' + node.s + '"';
     case SerovalNodeType.Boolean:
       return node.s ? '!0' : '!1';
     case SerovalNodeType.Undefined:
-      return 'undefined';
+      return 'void 0';
     case SerovalNodeType.Null:
       return 'null';
     case SerovalNodeType.NegativeZero:

package/src/tree/sync.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import { createRef, ParserContext } from '../context';
+import { createRef, getRootID, ParserContext } from '../context';
 import { BigIntTypedArrayValue, ServerValue, TypedArrayValue } from '../types';
 import {
   createBigIntNode,
@@ -82,7 +82,7 @@ function generateArrayNode(
     m: undefined,
     d: undefined,
     a: generateNodeList(ctx, current),
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -124,7 +124,7 @@ function generateMapNode(
     m: undefined,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -160,7 +160,7 @@ function generateSetNode(
     m: undefined,
     d: undefined,
     a: nodes,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -220,7 +220,7 @@ function generateIterableNode(
       ? generateProperties(ctx, options as Record<string, ServerValue>)
       : undefined,
     a: generateNodeList(ctx, array),
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -242,7 +242,7 @@ function generateObjectNode(
     m: undefined,
     d: generateProperties(ctx, current),
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -264,7 +264,7 @@ function generateAggregateErrorNode(
     m: current.message,
     d: optionsNode,
     a: generateNodeList(ctx, current.errors as ServerValue[]),
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -286,7 +286,7 @@ function generateErrorNode(
     m: current.message,
     d: optionsNode,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -302,6 +302,11 @@ function parse(
     case 'string':
       return createStringNode(current);
     case 'number':
+      switch (current) {
+        case Infinity: return INFINITY_NODE;
+        case -Infinity: return NEG_INFINITY_NODE;
+        default: break;
+      }
       // eslint-disable-next-line no-self-compare
       if (current !== current) {
         return NAN_NODE;
@@ -309,12 +314,6 @@ function parse(
       if (Object.is(current, -0)) {
         return NEG_ZERO_NODE;
       }
-      if (Object.is(current, Infinity)) {
-        return INFINITY_NODE;
-      }
-      if (Object.is(current, -Infinity)) {
-        return NEG_INFINITY_NODE;
-      }
       return createNumberNode(current);
     case 'bigint':
       return createBigIntNode(ctx, current);
@@ -324,7 +323,7 @@ function parse(
       }
       // Non-primitive values needs a reference ID
       // mostly because the values themselves are stateful
-      const id = createRef(ctx, current, true);
+      const id = createRef(ctx, current);
       if (ctx.markedRefs.has(id)) {
         return createReferenceNode(id);
       }
@@ -373,8 +372,11 @@ function parse(
         default:
           break;
       }
-      if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
-        return generateAggregateErrorNode(ctx, id, current);
+      if (current instanceof AggregateError) {
+        if (ctx.features & Feature.AggregateError) {
+          return generateAggregateErrorNode(ctx, id, current);
+        }
+        return generateErrorNode(ctx, id, current);
       }
       if (current instanceof Error) {
         return generateErrorNode(ctx, id, current);
@@ -401,5 +403,5 @@ export default function parseSync(
   const result = parse(ctx, current);
   const isObject = result.t === SerovalNodeType.Object
     || result.t === SerovalNodeType.Iterable;
-  return [result, createRef(ctx, current, false), isObject] as const;
+  return [result, getRootID(ctx, current), isObject] as const;
 }

package/src/tree/types.ts

@@ -45,8 +45,8 @@ export interface SerovalBaseNode {
   d: SerovalDictionaryNode | undefined;
   // array of nodes
   a: SerovalNode[] | undefined;
-  // next node
-  n: SerovalNode | undefined;
+  // fulfilled node
+  f: SerovalNode | undefined;
 }
 
 export interface SerovalObjectRecordNode {
@@ -197,7 +197,7 @@ export interface SerovalNullConstructorNode extends SerovalBaseNode {
 
 export interface SerovalPromiseNode extends SerovalBaseNode {
   t: SerovalNodeType.Promise;
-  n: SerovalNode;
+  f: SerovalNode;
   i: number;
 }