seroval 0.4.1 → 0.5.1

package/src/tree/primitives.ts

@@ -1,23 +1,121 @@
 import assert from '../assert';
 import { Feature } from '../compat';
 import { ParserContext } from '../context';
+import quote from '../quote';
 import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import { INV_SYMBOL_REF, WellKnownSymbols } from './symbols';
 import {
   SerovalBigIntNode,
   SerovalBigIntTypedArrayNode,
+  SerovalBooleanNode,
   SerovalDateNode,
+  SerovalInfinityNode,
+  SerovalNaNNode,
+  SerovalNegativeInfinityNode,
+  SerovalNegativeZeroNode,
   SerovalNodeType,
-  SerovalPrimitiveNode,
+  SerovalNullNode,
+  SerovalNumberNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalStringNode,
   SerovalTypedArrayNode,
+  SerovalUndefinedNode,
+  SerovalWKSymbolNode,
 } from './types';
 
-export function createPrimitiveNode(
-  value: string | number | null,
-): SerovalPrimitiveNode {
+export const TRUE_NODE: SerovalBooleanNode = {
+  t: SerovalNodeType.Boolean,
+  i: undefined,
+  s: true,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const FALSE_NODE: SerovalBooleanNode = {
+  t: SerovalNodeType.Boolean,
+  i: undefined,
+  s: false,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const UNDEFINED_NODE: SerovalUndefinedNode = {
+  t: SerovalNodeType.Undefined,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const NULL_NODE: SerovalNullNode = {
+  t: SerovalNodeType.Null,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
+  t: SerovalNodeType.NegativeZero,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const INFINITY_NODE: SerovalInfinityNode = {
+  t: SerovalNodeType.Infinity,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
+  t: SerovalNodeType.NegativeInfinity,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+export const NAN_NODE: SerovalNaNNode = {
+  t: SerovalNodeType.NaN,
+  i: undefined,
+  s: undefined,
+  l: undefined,
+  c: undefined,
+  m: undefined,
+  d: undefined,
+  a: undefined,
+  f: undefined,
+};
+
+export function createNumberNode(value: number): SerovalNumberNode {
   return {
-    t: SerovalNodeType.Primitive,
+    t: SerovalNodeType.Number,
     i: undefined,
     s: value,
     l: undefined,
@@ -25,17 +123,23 @@ export function createPrimitiveNode(
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: 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 createStringNode(value: string): SerovalStringNode {
+  return {
+    t: SerovalNodeType.String,
+    i: undefined,
+    s: quote(value),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    f: undefined,
+  };
+}
 
 export function createBigIntNode(
   ctx: ParserContext,
@@ -45,13 +149,13 @@ export function createBigIntNode(
   return {
     t: SerovalNodeType.BigInt,
     i: undefined,
-    s: current.toString() + 'n',
+    s: '' + current,
     l: undefined,
     c: undefined,
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -65,7 +169,7 @@ export function createReferenceNode(id: number): SerovalReferenceNode {
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -78,7 +182,7 @@ export function createDateNode(id: number, current: Date): SerovalDateNode {
     c: undefined,
     m: undefined,
     d: undefined,
-    n: undefined,
+    f: undefined,
     a: undefined,
   };
 }
@@ -87,13 +191,13 @@ export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode
   return {
     t: SerovalNodeType.RegExp,
     i: id,
-    s: String(current),
+    s: undefined,
     l: undefined,
-    c: undefined,
-    m: undefined,
+    c: current.source,
+    m: current.flags,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -104,16 +208,21 @@ export function createTypedArrayNode(
 ): SerovalTypedArrayNode {
   const constructor = current.constructor.name;
   assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
+  const len = current.length;
+  const values = new Array<string>(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = '' + current[i];
+  }
   return {
     t: SerovalNodeType.TypedArray,
     i: id,
-    s: current.toString(),
+    s: values,
     l: current.byteOffset,
     c: constructor,
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -129,22 +238,36 @@ export function createBigIntTypedArrayNode(
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
     `Unsupported value type "${constructor}"`,
   );
-  let result = '';
-  for (let i = 0, len = current.length; i < len; i++) {
-    if (i !== 0) {
-      result += ',';
-    }
-    result += current[i].toString() + 'n';
+  const len = current.length;
+  const values = new Array<string>(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = '' + current[i];
   }
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,
-    s: result,
-    l: (current as BigInt64Array).byteOffset,
+    s: values,
+    l: current.byteOffset,
     c: constructor,
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
+  };
+}
+
+export function createWKSymbolNode(
+  current: WellKnownSymbols,
+): SerovalWKSymbolNode {
+  return {
+    t: SerovalNodeType.WKSymbol,
+    i: undefined,
+    s: INV_SYMBOL_REF[current],
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    f: undefined,
   };
 }

package/src/tree/serialize.ts

@@ -7,6 +7,8 @@ import {
   markRef,
 } from '../context';
 import quote from '../quote';
+import { isValidIdentifier } from './shared';
+import { SYMBOL_STRING } from './symbols';
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -17,6 +19,7 @@ import {
   SerovalNode,
   SerovalNodeType,
   SerovalNullConstructorNode,
+  SerovalObjectNode,
   SerovalObjectRecordNode,
   SerovalPromiseNode,
   SerovalReferenceNode,
@@ -45,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);
@@ -158,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(
@@ -189,16 +212,14 @@ function isReferenceInStack(
   return node.t === SerovalNodeType.Reference && ctx.stack.includes(node.i);
 }
 
-const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-
 function serializeNodeList(
   ctx: SerializationContext,
-  node: SerovalArrayNode | SerovalIterableNode,
+  node: SerovalArrayNode | SerovalIterableNode | SerovalAggregateErrorNode,
 ) {
   // This is different than Map and Set
   // because we also need to serialize
   // the holes of the Array
-  const size = node.a.length;
+  const size = node.l;
   let values = '';
   let item: SerovalNode;
   let isHoley = false;
@@ -222,10 +243,7 @@ function serializeNodeList(
       isHoley = true;
     }
   }
-  if (isHoley) {
-    values += ',';
-  }
-  return '[' + values + ']';
+  return '[' + values + (isHoley ? ',]' : ']');
 }
 
 function serializeArray(
@@ -238,7 +256,7 @@ function serializeArray(
   return assignRef(ctx, node.i, result);
 }
 
-function serializeObject(
+function serializeProperties(
   ctx: SerializationContext,
   sourceID: number,
   node: SerovalObjectRecordNode,
@@ -260,20 +278,18 @@ function serializeObject(
     check = Number(key);
     // Test if key is a valid number or JS identifier
     // so that we don't have to serialize the key and wrap with brackets
-    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    isIdentifier = check >= 0 || isValidIdentifier(key);
     if (isReferenceInStack(ctx, val)) {
       refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
       } else {
-        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+        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;
     }
   }
@@ -287,7 +303,7 @@ function serializeWithObjectAssign(
   id: number,
   serialized: string,
 ) {
-  const fields = serializeObject(ctx, id, value);
+  const fields = serializeProperties(ctx, id, value);
   if (fields !== '{}') {
     return 'Object.assign(' + serialized + ',' + fields + ')';
   }
@@ -318,11 +334,11 @@ function serializeAssignments(
     ctx.assignments = mainAssignments;
     // Test if key is a valid number or JS identifier
     // so that we don't have to serialize the key and wrap with brackets
-    isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
+    isIdentifier = check >= 0 || isValidIdentifier(key);
     if (isIdentifier && Number.isNaN(check)) {
       createObjectAssign(ctx, sourceID, key, refParam);
     } else {
-      createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+      createArrayAssign(ctx, sourceID, isIdentifier ? key : ('"' + quote(key) + '"'), refParam);
     }
     ctx.assignments = parentAssignment;
   }
@@ -343,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) + ')';
       }
     }
   }
@@ -358,12 +373,19 @@ function serializeNullConstructor(
   return serializeDictionary(ctx, node.i, node.d, 'Object.create(null)');
 }
 
+function serializeObject(
+  ctx: SerializationContext,
+  node: SerovalObjectNode,
+) {
+  return assignRef(ctx, node.i, serializeProperties(ctx, node.i, node.d));
+}
+
 function serializeSet(
   ctx: SerializationContext,
   node: SerovalSetNode,
 ) {
   let serialized = 'new Set';
-  const size = node.a.length;
+  const size = node.l;
   if (size) {
     let result = '';
     ctx.stack.push(node.i);
@@ -375,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;
       }
     }
@@ -438,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;
       }
     }
@@ -462,7 +478,7 @@ function serializeAggregateError(
 ) {
   // Serialize the required arguments
   ctx.stack.push(node.i);
-  const serialized = 'new AggregateError(' + serializeTree(ctx, node.n) + ',' + quote(node.m) + ')';
+  const serialized = 'new AggregateError(' + serializeNodeList(ctx, node) + ',"' + quote(node.m) + '")';
   ctx.stack.pop();
   // `AggregateError` might've been extended
   // either through class or custom properties
@@ -474,7 +490,7 @@ function serializeError(
   ctx: SerializationContext,
   node: SerovalErrorNode,
 ) {
-  const serialized = 'new ' + node.c + '(' + quote(node.m) + ')';
+  const serialized = 'new ' + node.c + '("' + quote(node.m) + '")';
   return serializeDictionary(ctx, node.i, node.d, serialized);
 }
 
@@ -484,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 {
@@ -497,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 + ')';
@@ -509,10 +525,12 @@ function serializeTypedArray(
   ctx: SerializationContext,
   node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
 ) {
-  let args = '[' + node.s + ']';
-  if (node.l !== 0) {
-    args += ',' + node.l.toString();
+  let result = '';
+  const isBigInt = node.t === SerovalNodeType.BigIntTypedArray;
+  for (let i = 0, len = node.s.length; i < len; i++) {
+    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 + ')');
 }
 
@@ -545,22 +563,38 @@ export default function serializeTree(
   node: SerovalNode,
 ): string {
   switch (node.t) {
-    case SerovalNodeType.Primitive:
-      return String(node.s);
+    case SerovalNodeType.Number:
+      return '' + node.s;
+    case SerovalNodeType.String:
+      return '"' + node.s + '"';
+    case SerovalNodeType.Boolean:
+      return node.s ? '!0' : '!1';
+    case SerovalNodeType.Undefined:
+      return 'void 0';
+    case SerovalNodeType.Null:
+      return 'null';
+    case SerovalNodeType.NegativeZero:
+      return '-0';
+    case SerovalNodeType.Infinity:
+      return '1/0';
+    case SerovalNodeType.NegativeInfinity:
+      return '-1/0';
+    case SerovalNodeType.NaN:
+      return 'NaN';
     case SerovalNodeType.BigInt:
-      return node.s;
+      return node.s + 'n';
     case SerovalNodeType.Reference:
       return getRefParam(ctx, node.i);
     case SerovalNodeType.Array:
       return serializeArray(ctx, node);
     case SerovalNodeType.Object:
-      return assignRef(ctx, node.i, serializeObject(ctx, node.i, node.d));
+      return serializeObject(ctx, node);
     case SerovalNodeType.NullConstructor:
       return serializeNullConstructor(ctx, node);
     case SerovalNodeType.Date:
       return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
     case SerovalNodeType.RegExp:
-      return assignRef(ctx, node.i, node.s);
+      return assignRef(ctx, node.i, '/' + node.c + '/' + node.m);
     case SerovalNodeType.Set:
       return serializeSet(ctx, node);
     case SerovalNodeType.Map:
@@ -576,6 +610,8 @@ export default function serializeTree(
       return serializeIterable(ctx, node);
     case SerovalNodeType.Promise:
       return serializePromise(ctx, node);
+    case SerovalNodeType.WKSymbol:
+      return SYMBOL_STRING[node.s];
     default:
       throw new Error('Unsupported type');
   }