seroval 0.4.1 → 0.5.1

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

@@ -1,29 +1,34 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import { createRef, ParserContext } from '../context';
-import quote from '../quote';
+import { createRef, getRootID, ParserContext } from '../context';
 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,12 +77,12 @@ function generateArrayNode(
     t: SerovalNodeType.Array,
     i: id,
     s: undefined,
-    l: undefined,
+    l: current.length,
     c: undefined,
     m: undefined,
     d: undefined,
     a: generateNodeList(ctx, current),
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -119,7 +124,7 @@ function generateMapNode(
     m: undefined,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -150,12 +155,12 @@ function generateSetNode(
     t: SerovalNodeType.Set,
     i: id,
     s: undefined,
-    l: undefined,
+    l: len,
     c: undefined,
     m: undefined,
     d: undefined,
     a: nodes,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -200,21 +205,22 @@ 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)),
-    n: undefined,
+    a: generateNodeList(ctx, array),
+    f: undefined,
   };
 }
 
@@ -236,7 +242,7 @@ function generateObjectNode(
     m: undefined,
     d: generateProperties(ctx, current),
     a: undefined,
-    n: undefined,
+    f: 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[]),
+    f: undefined,
   };
 }
 
@@ -276,11 +282,11 @@ function generateErrorNode(
     i: id,
     s: undefined,
     l: undefined,
-    c: getErrorConstructor(current),
+    c: getErrorConstructorName(current),
     m: current.message,
     d: optionsNode,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -294,18 +300,21 @@ function parse(
     case 'undefined':
       return UNDEFINED_NODE;
     case 'string':
-      return createPrimitiveNode(quote(current));
+      return createStringNode(current);
     case 'number':
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+      switch (current) {
+        case Infinity: return INFINITY_NODE;
+        case -Infinity: return NEG_INFINITY_NODE;
+        default: break;
       }
-      if (Object.is(current, Infinity)) {
-        return createPrimitiveNode('1/0');
+      // eslint-disable-next-line no-self-compare
+      if (current !== current) {
+        return NAN_NODE;
       }
-      if (Object.is(current, -Infinity)) {
-        return createPrimitiveNode('-1/0');
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
       }
-      return createPrimitiveNode(current);
+      return createNumberNode(current);
     case 'bigint':
       return createBigIntNode(ctx, current);
     case 'object': {
@@ -314,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);
       }
@@ -363,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);
@@ -375,6 +387,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');
   }
@@ -387,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

@@ -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;
+  // fulfilled node
+  f: 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;
 }
@@ -137,7 +197,7 @@ export interface SerovalNullConstructorNode extends SerovalBaseNode {
 
 export interface SerovalPromiseNode extends SerovalBaseNode {
   t: SerovalNodeType.Promise;
-  n: SerovalNode;
+  f: 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