seroval 0.4.1 → 0.5.0

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,
@@ -189,16 +192,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;
@@ -238,7 +239,7 @@ function serializeArray(
   return assignRef(ctx, node.i, result);
 }
 
-function serializeObject(
+function serializeProperties(
   ctx: SerializationContext,
   sourceID: number,
   node: SerovalObjectRecordNode,
@@ -260,19 +261,19 @@ 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 += isIdentifier ? key : ('"' + quote(key) + '"');
       result += ':' + serializeTree(ctx, val);
       hasPrev = true;
     }
@@ -287,7 +288,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 +319,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;
   }
@@ -358,12 +359,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);
@@ -462,7 +470,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 +482,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);
 }
 
@@ -509,7 +517,17 @@ function serializeTypedArray(
   ctx: SerializationContext,
   node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
 ) {
-  let args = '[' + node.s + ']';
+  let result = '';
+  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();
   }
@@ -545,22 +563,38 @@ export default function serializeTree(
   node: SerovalNode,
 ): string {
   switch (node.t) {
-    case SerovalNodeType.Primitive:
+    case SerovalNodeType.Number:
       return String(node.s);
+    case SerovalNodeType.String:
+      return '"' + node.s + '"';
+    case SerovalNodeType.Boolean:
+      return node.s ? '!0' : '!1';
+    case SerovalNodeType.Undefined:
+      return 'undefined';
+    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');
   }

package/src/tree/shared.ts

@@ -5,7 +5,7 @@ import {
   ErrorValue,
 } from '../types';
 
-export function getErrorConstructor(error: ErrorValue) {
+export function getErrorConstructorName(error: ErrorValue) {
   if (error instanceof EvalError) {
     return 'EvalError';
   }
@@ -27,12 +27,26 @@ export function getErrorConstructor(error: ErrorValue) {
   return 'Error';
 }
 
+export function getErrorConstructor(errorName: string) {
+  switch (errorName) {
+    case 'Error': return Error;
+    case 'EvalError': return EvalError;
+    case 'RangeError': return RangeError;
+    case 'ReferenceError': return ReferenceError;
+    case 'SyntaxError': return SyntaxError;
+    case 'TypeError': return TypeError;
+    case 'URIError': return URIError;
+    default:
+      throw new Error(`Unknown Error constructor "${errorName}"`);
+  }
+}
+
 export function getErrorOptions(
   ctx: ParserContext,
   error: Error,
 ) {
   let options: Record<string, any> | undefined;
-  const constructor = getErrorConstructor(error);
+  const constructor = getErrorConstructorName(error);
   // Name has been modified
   if (error.name !== constructor) {
     options = { name: error.name };
@@ -99,3 +113,33 @@ export function isIterable(
   }
   return Symbol.iterator in value;
 }
+
+export function getTypedArrayConstructor(name: string) {
+  switch (name) {
+    case 'Int8Array': return Int8Array;
+    case 'Int16Array': return Int16Array;
+    case 'Int32Array': return Int32Array;
+    case 'Uint8Array': return Uint8Array;
+    case 'Uint16Array': return Uint16Array;
+    case 'Uint32Array': return Uint32Array;
+    case 'Uint8ClampedArray': return Uint8ClampedArray;
+    case 'Float32Array': return Float32Array;
+    case 'Float64Array': return Float64Array;
+    case 'BigInt64Array': return BigInt64Array;
+    case 'BigUint64Array': return BigUint64Array;
+    default:
+      throw new Error(`Unknown TypedArray "${name}"`);
+  }
+}
+
+const IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
+
+export function isValidIdentifier(name: string) {
+  const char = name[0];
+  return (
+    char === '$'
+    || char === '_'
+    || (char >= 'A' && char <= 'Z')
+    || (char >= 'a' && char <= 'z')
+  ) && IDENTIFIER_CHECK.test(name);
+}

package/src/tree/symbols.ts

@@ -0,0 +1,65 @@
+export const enum Symbols {
+  AsyncIterator,
+  HasInstance,
+  IsConcatSpreadable,
+  Iterator,
+  Match,
+  MatchAll,
+  Replace,
+  Search,
+  Species,
+  Split,
+  ToPrimitive,
+  ToStringTag,
+  Unscopables
+}
+
+export const SYMBOL_STRING: Record<Symbols, string> = {
+  [Symbols.AsyncIterator]: 'Symbol.asyncIterator',
+  [Symbols.HasInstance]: 'Symbol.hasInstance',
+  [Symbols.IsConcatSpreadable]: 'Symbol.isConcatSpreadable',
+  [Symbols.Iterator]: 'Symbol.iterator',
+  [Symbols.Match]: 'Symbol.match',
+  [Symbols.MatchAll]: 'Symbol.matchAll',
+  [Symbols.Replace]: 'Symbol.replace',
+  [Symbols.Search]: 'Symbol.search',
+  [Symbols.Species]: 'Symbol.species',
+  [Symbols.Split]: 'Symbol.split',
+  [Symbols.ToPrimitive]: 'Symbol.toPrimitive',
+  [Symbols.ToStringTag]: 'Symbol.toStringTag',
+  [Symbols.Unscopables]: 'Symbol.unscopables',
+};
+
+export const INV_SYMBOL_REF = {
+  [Symbol.asyncIterator]: Symbols.AsyncIterator,
+  [Symbol.hasInstance]: Symbols.HasInstance,
+  [Symbol.isConcatSpreadable]: Symbols.IsConcatSpreadable,
+  [Symbol.iterator]: Symbols.Iterator,
+  [Symbol.match]: Symbols.Match,
+  [Symbol.matchAll]: Symbols.MatchAll,
+  [Symbol.replace]: Symbols.Replace,
+  [Symbol.search]: Symbols.Search,
+  [Symbol.species]: Symbols.Species,
+  [Symbol.split]: Symbols.Split,
+  [Symbol.toPrimitive]: Symbols.ToPrimitive,
+  [Symbol.toStringTag]: Symbols.ToStringTag,
+  [Symbol.unscopables]: Symbols.Unscopables,
+};
+
+export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
+
+export const SYMBOL_REF: Record<Symbols, WellKnownSymbols> = {
+  [Symbols.AsyncIterator]: Symbol.asyncIterator,
+  [Symbols.HasInstance]: Symbol.hasInstance,
+  [Symbols.IsConcatSpreadable]: Symbol.isConcatSpreadable,
+  [Symbols.Iterator]: Symbol.iterator,
+  [Symbols.Match]: Symbol.match,
+  [Symbols.MatchAll]: Symbol.matchAll,
+  [Symbols.Replace]: Symbol.replace,
+  [Symbols.Search]: Symbol.search,
+  [Symbols.Species]: Symbol.species,
+  [Symbols.Split]: Symbol.split,
+  [Symbols.ToPrimitive]: Symbol.toPrimitive,
+  [Symbols.ToStringTag]: Symbol.toStringTag,
+  [Symbols.Unscopables]: Symbol.unscopables,
+};

package/src/tree/sync.ts

@@ -2,28 +2,33 @@
 import assert from '../assert';
 import { Feature } from '../compat';
 import { createRef, ParserContext } from '../context';
-import quote from '../quote';
 import { BigIntTypedArrayValue, ServerValue, TypedArrayValue } from '../types';
 import {
   createBigIntNode,
   createBigIntTypedArrayNode,
   createDateNode,
-  createPrimitiveNode,
+  createNumberNode,
   createReferenceNode,
   createRegExpNode,
+  createStringNode,
   createTypedArrayNode,
+  createWKSymbolNode,
   FALSE_NODE,
+  INFINITY_NODE,
+  NAN_NODE,
+  NEG_INFINITY_NODE,
   NEG_ZERO_NODE,
   NULL_NODE,
   TRUE_NODE,
   UNDEFINED_NODE,
 } from './primitives';
 import {
-  getErrorConstructor,
+  getErrorConstructorName,
   getErrorOptions,
   getIterableOptions,
   isIterable,
 } from './shared';
+import { INV_SYMBOL_REF } from './symbols';
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -72,7 +77,7 @@ function generateArrayNode(
     t: SerovalNodeType.Array,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.length,
     c: undefined,
     m: undefined,
     d: undefined,
@@ -150,7 +155,7 @@ function generateSetNode(
     t: SerovalNodeType.Set,
     i: id,
     s: undefined,
-    l: undefined,
+    l: len,
     c: undefined,
     m: undefined,
     d: undefined,
@@ -200,20 +205,21 @@ function generateIterableNode(
   id: number,
   current: Iterable<ServerValue>,
 ): SerovalIterableNode {
-  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+  assert(ctx.features & Feature.Symbol, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
+  const array = Array.from(current);
   return {
     t: SerovalNodeType.Iterable,
     i: id,
     s: undefined,
-    l: undefined,
+    l: array.length,
     c: undefined,
     m: undefined,
     // Parse options first before the items
     d: options
       ? generateProperties(ctx, options as Record<string, ServerValue>)
       : undefined,
-    a: generateNodeList(ctx, Array.from(current)),
+    a: generateNodeList(ctx, array),
     n: undefined,
   };
 }
@@ -253,12 +259,12 @@ function generateAggregateErrorNode(
     t: SerovalNodeType.AggregateError,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.errors.length,
     c: undefined,
     m: current.message,
     d: optionsNode,
-    a: undefined,
-    n: parse(ctx, current.errors),
+    a: generateNodeList(ctx, current.errors as ServerValue[]),
+    n: undefined,
   };
 }
 
@@ -276,7 +282,7 @@ function generateErrorNode(
     i: id,
     s: undefined,
     l: undefined,
-    c: getErrorConstructor(current),
+    c: getErrorConstructorName(current),
     m: current.message,
     d: optionsNode,
     a: undefined,
@@ -294,18 +300,22 @@ function parse(
     case 'undefined':
       return UNDEFINED_NODE;
     case 'string':
-      return createPrimitiveNode(quote(current));
+      return createStringNode(current);
     case 'number':
+      // eslint-disable-next-line no-self-compare
+      if (current !== current) {
+        return NAN_NODE;
+      }
       if (Object.is(current, -0)) {
         return NEG_ZERO_NODE;
       }
       if (Object.is(current, Infinity)) {
-        return createPrimitiveNode('1/0');
+        return INFINITY_NODE;
       }
       if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode('-1/0');
+        return NEG_INFINITY_NODE;
       }
-      return createPrimitiveNode(current);
+      return createNumberNode(current);
     case 'bigint':
       return createBigIntNode(ctx, current);
     case 'object': {
@@ -375,6 +385,10 @@ function parse(
       }
       throw new Error('Unsupported type');
     }
+    case 'symbol':
+      assert(ctx.features & Feature.Symbol, 'Unsupported type "symbol"');
+      assert(current in INV_SYMBOL_REF, 'seroval only supports well-known symbols');
+      return createWKSymbolNode(current);
     default:
       throw new Error('Unsupported type');
   }

package/src/tree/types.ts

@@ -1,7 +1,15 @@
-import { PrimitiveValue } from '../types';
+import { Symbols } from './symbols';
 
 export const enum SerovalNodeType {
-  Primitive,
+  Number,
+  String,
+  Boolean,
+  Null,
+  Undefined,
+  NegativeZero,
+  Infinity,
+  NegativeInfinity,
+  NaN,
   BigInt,
   Reference,
   Date,
@@ -17,27 +25,28 @@ export const enum SerovalNodeType {
   Iterable,
   TypedArray,
   BigIntTypedArray,
+  WKSymbol,
 }
 
 export interface SerovalBaseNode {
   // Type of the node
   t: SerovalNodeType;
-  // Serialized value
-  s: PrimitiveValue | undefined;
   // Reference ID
   i: number | undefined;
+  // Serialized value
+  s: any;
   // Size/Byte offset
   l: number | undefined;
-  // Constructor name
+  // Constructor name / RegExp source
   c: string | undefined;
+  // message /flags
+  m: string | undefined;
   // dictionary
   d: SerovalDictionaryNode | undefined;
-  // message
-  m: string | undefined;
-  // next node
-  n: SerovalNode | undefined;
   // array of nodes
   a: SerovalNode[] | undefined;
+  // next node
+  n: SerovalNode | undefined;
 }
 
 export interface SerovalObjectRecordNode {
@@ -56,10 +65,56 @@ export type SerovalDictionaryNode =
   | SerovalObjectRecordNode
   | SerovalMapRecordNode;
 
-export interface SerovalPrimitiveNode extends SerovalBaseNode {
-  t: SerovalNodeType.Primitive;
+export interface SerovalNumberNode extends SerovalBaseNode {
+  t: SerovalNodeType.Number;
+  s: number;
+}
+
+export interface SerovalStringNode extends SerovalBaseNode {
+  t: SerovalNodeType.String;
+  s: string;
+}
+
+export interface SerovalBooleanNode extends SerovalBaseNode {
+  t: SerovalNodeType.Boolean;
+  s: boolean;
+}
+
+export interface SerovalNullNode extends SerovalBaseNode {
+  t: SerovalNodeType.Null;
+}
+
+export interface SerovalUndefinedNode extends SerovalBaseNode {
+  t: SerovalNodeType.Undefined;
+}
+
+export interface SerovalNegativeZeroNode extends SerovalBaseNode {
+  t: SerovalNodeType.NegativeZero;
 }
 
+export interface SerovalInfinityNode extends SerovalBaseNode {
+  t: SerovalNodeType.Infinity;
+}
+
+export interface SerovalNegativeInfinityNode extends SerovalBaseNode {
+  t: SerovalNodeType.NegativeInfinity;
+}
+
+export interface SerovalNaNNode extends SerovalBaseNode {
+  t: SerovalNodeType.NaN;
+}
+
+export type SerovalPrimitiveNode =
+  | SerovalNumberNode
+  | SerovalStringNode
+  | SerovalBooleanNode
+  | SerovalNullNode
+  | SerovalUndefinedNode
+  | SerovalNegativeZeroNode
+  | SerovalNegativeInfinityNode
+  | SerovalInfinityNode
+  | SerovalNaNNode;
+
 export interface SerovalReferenceNode extends SerovalBaseNode {
   t: SerovalNodeType.Reference;
   i: number;
@@ -79,13 +134,16 @@ export interface SerovalDateNode extends SerovalBaseNode {
 export interface SerovalRegExpNode extends SerovalBaseNode {
   t: SerovalNodeType.RegExp;
   i: number;
-  s: string;
+  // source
+  c: string;
+  // flags
+  m: string;
 }
 
 export interface SerovalTypedArrayNode extends SerovalBaseNode {
   t: SerovalNodeType.TypedArray;
   i: number;
-  s: string;
+  s: string[];
   l: number;
   c: string;
 }
@@ -93,7 +151,7 @@ export interface SerovalTypedArrayNode extends SerovalBaseNode {
 export interface SerovalBigIntTypedArrayNode extends SerovalBaseNode {
   t: SerovalNodeType.BigIntTypedArray;
   i: number;
-  s: string;
+  s: string[];
   l: number;
   c: string;
 }
@@ -107,6 +165,7 @@ export type SerovalSemiPrimitiveNode =
 
 export interface SerovalSetNode extends SerovalBaseNode {
   t: SerovalNodeType.Set;
+  l: number;
   a: SerovalNode[];
   i: number;
 }
@@ -119,6 +178,7 @@ export interface SerovalMapNode extends SerovalBaseNode {
 
 export interface SerovalArrayNode extends SerovalBaseNode {
   t: SerovalNodeType.Array;
+  l: number;
   a: SerovalNode[];
   i: number;
 }
@@ -153,17 +213,24 @@ export interface SerovalAggregateErrorNode extends SerovalBaseNode {
   t: SerovalNodeType.AggregateError;
   m: string;
   d: SerovalObjectRecordNode | undefined;
-  n: SerovalNode;
+  l: number;
+  a: SerovalNode[];
   i: number;
 }
 
 export interface SerovalIterableNode extends SerovalBaseNode {
   t: SerovalNodeType.Iterable;
   d: SerovalObjectRecordNode | undefined;
+  l: number;
   a: SerovalNode[];
   i: number;
 }
 
+export interface SerovalWKSymbolNode extends SerovalBaseNode {
+  t: SerovalNodeType.WKSymbol;
+  s: Symbols;
+}
+
 export type SerovalNode =
   | SerovalPrimitiveNode
   | SerovalReferenceNode
@@ -176,4 +243,5 @@ export type SerovalNode =
   | SerovalPromiseNode
   | SerovalErrorNode
   | SerovalAggregateErrorNode
-  | SerovalIterableNode;
+  | SerovalIterableNode
+  | SerovalWKSymbolNode;

package/src/types.ts

@@ -1,10 +1,13 @@
+import { WellKnownSymbols } from './tree/symbols';
+
 // Values that are non-recursive
 export type PrimitiveValue =
   | boolean
   | string
   | number
   | undefined
-  | null;
+  | null
+  | WellKnownSymbols;
 
 export type ErrorValue =
   | Error