seroval 0.5.0 → 0.6.0

package/src/tree/primitives.ts

@@ -3,6 +3,7 @@ import { Feature } from '../compat';
 import { ParserContext } from '../context';
 import quote from '../quote';
 import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import { getReferenceID } from './reference';
 import { INV_SYMBOL_REF, WellKnownSymbols } from './symbols';
 import {
   SerovalBigIntNode,
@@ -16,12 +17,13 @@ import {
   SerovalNodeType,
   SerovalNullNode,
   SerovalNumberNode,
-  SerovalReferenceNode,
+  SerovalIndexedValueNode,
   SerovalRegExpNode,
   SerovalStringNode,
   SerovalTypedArrayNode,
   SerovalUndefinedNode,
   SerovalWKSymbolNode,
+  SerovalReferenceNode,
 } from './types';
 
 export const TRUE_NODE: SerovalBooleanNode = {
@@ -33,7 +35,7 @@ export const TRUE_NODE: SerovalBooleanNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const FALSE_NODE: SerovalBooleanNode = {
   t: SerovalNodeType.Boolean,
@@ -44,7 +46,7 @@ export const FALSE_NODE: SerovalBooleanNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const UNDEFINED_NODE: SerovalUndefinedNode = {
   t: SerovalNodeType.Undefined,
@@ -55,7 +57,7 @@ export const UNDEFINED_NODE: SerovalUndefinedNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const NULL_NODE: SerovalNullNode = {
   t: SerovalNodeType.Null,
@@ -66,7 +68,7 @@ export const NULL_NODE: SerovalNullNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
   t: SerovalNodeType.NegativeZero,
@@ -77,7 +79,7 @@ export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const INFINITY_NODE: SerovalInfinityNode = {
   t: SerovalNodeType.Infinity,
@@ -88,7 +90,7 @@ export const INFINITY_NODE: SerovalInfinityNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
   t: SerovalNodeType.NegativeInfinity,
@@ -99,7 +101,7 @@ export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 export const NAN_NODE: SerovalNaNNode = {
   t: SerovalNodeType.NaN,
@@ -110,7 +112,7 @@ export const NAN_NODE: SerovalNaNNode = {
   m: undefined,
   d: undefined,
   a: undefined,
-  n: undefined,
+  f: undefined,
 };
 
 export function createNumberNode(value: number): SerovalNumberNode {
@@ -123,7 +125,7 @@ export function createNumberNode(value: number): SerovalNumberNode {
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -137,7 +139,7 @@ export function createStringNode(value: string): SerovalStringNode {
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -149,19 +151,19 @@ export function createBigIntNode(
   return {
     t: SerovalNodeType.BigInt,
     i: undefined,
-    s: current.toString(),
+    s: '' + current,
     l: undefined,
     c: undefined,
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
-export function createReferenceNode(id: number): SerovalReferenceNode {
+export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
   return {
-    t: SerovalNodeType.Reference,
+    t: SerovalNodeType.IndexedValue,
     i: id,
     s: undefined,
     l: undefined,
@@ -169,7 +171,7 @@ export function createReferenceNode(id: number): SerovalReferenceNode {
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -182,7 +184,7 @@ export function createDateNode(id: number, current: Date): SerovalDateNode {
     c: undefined,
     m: undefined,
     d: undefined,
-    n: undefined,
+    f: undefined,
     a: undefined,
   };
 }
@@ -197,7 +199,7 @@ export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode
     m: current.flags,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -211,7 +213,7 @@ export function createTypedArrayNode(
   const len = current.length;
   const values = new Array<string>(len);
   for (let i = 0; i < len; i++) {
-    values[i] = current[i].toString();
+    values[i] = '' + current[i];
   }
   return {
     t: SerovalNodeType.TypedArray,
@@ -222,7 +224,7 @@ export function createTypedArrayNode(
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -241,24 +243,27 @@ export function createBigIntTypedArrayNode(
   const len = current.length;
   const values = new Array<string>(len);
   for (let i = 0; i < len; i++) {
-    values[i] = current[i].toString();
+    values[i] = '' + current[i];
   }
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,
     s: values,
-    l: (current as BigInt64Array).byteOffset,
+    l: current.byteOffset,
     c: constructor,
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
 export function createWKSymbolNode(
+  ctx: ParserContext,
   current: WellKnownSymbols,
 ): SerovalWKSymbolNode {
+  assert(ctx.features & Feature.Symbol, 'Unsupported type "symbol"');
+  assert(current in INV_SYMBOL_REF, 'seroval only supports well-known symbols');
   return {
     t: SerovalNodeType.WKSymbol,
     i: undefined,
@@ -268,6 +273,23 @@ export function createWKSymbolNode(
     m: undefined,
     d: undefined,
     a: undefined,
-    n: undefined,
+    f: undefined,
+  };
+}
+
+export function createReferenceNode<T>(
+  id: number,
+  ref: T,
+): SerovalReferenceNode {
+  return {
+    t: SerovalNodeType.Reference,
+    i: id,
+    s: quote(getReferenceID(ref)),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    f: undefined,
   };
 }

package/src/tree/reference.ts

@@ -0,0 +1,61 @@
+/* eslint-disable no-restricted-globals */
+import assert from '../assert';
+
+const REFERENCE = new Map<unknown, string>();
+const INV_REFERENCE = new Map<string, unknown>();
+
+export function createReference<T>(id: string, value: T): T {
+  REFERENCE.set(value, id);
+  INV_REFERENCE.set(id, value);
+  return value;
+}
+
+export function hasReferenceID<T>(value: T): boolean {
+  return REFERENCE.has(value);
+}
+
+export function hasReference(id: string): boolean {
+  return INV_REFERENCE.has(id);
+}
+
+export function getReferenceID<T>(value: T): string {
+  assert(hasReferenceID(value), 'Missing reference id');
+  return REFERENCE.get(value) as string;
+}
+
+export function getReference<T>(id: string): T {
+  assert(hasReference(id), 'Missing reference for id:' + id);
+  return INV_REFERENCE.get(id) as T;
+}
+
+export const GLOBAL_KEY = '__SEROVAL__';
+
+if (typeof globalThis !== undefined) {
+  Object.defineProperty(globalThis, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof window !== undefined) {
+  Object.defineProperty(window, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof self !== undefined) {
+  Object.defineProperty(self, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof global !== undefined) {
+  Object.defineProperty(global, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+}

package/src/tree/serialize.ts

@@ -7,6 +7,7 @@ import {
   markRef,
 } from '../context';
 import quote from '../quote';
+import { GLOBAL_KEY } from './reference';
 import { isValidIdentifier } from './shared';
 import { SYMBOL_STRING } from './symbols';
 import {
@@ -22,7 +23,7 @@ import {
   SerovalObjectNode,
   SerovalObjectRecordNode,
   SerovalPromiseNode,
-  SerovalReferenceNode,
+  SerovalIndexedValueNode,
   SerovalSetNode,
   SerovalTypedArrayNode,
 } from './types';
@@ -48,35 +49,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 +182,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(
@@ -174,7 +195,7 @@ function createObjectAssign(
   createAssignment(ctx, getRefParam(ctx, ref) + '.' + key, value);
 }
 
-function assignRef(
+function assignIndexedValue(
   ctx: SerializationContext,
   index: number,
   value: string,
@@ -185,11 +206,11 @@ function assignRef(
   return value;
 }
 
-function isReferenceInStack(
+function isIndexedValueInStack(
   ctx: SerializationContext,
   node: SerovalNode,
-): node is SerovalReferenceNode {
-  return node.t === SerovalNodeType.Reference && ctx.stack.includes(node.i);
+): node is SerovalIndexedValueNode {
+  return node.t === SerovalNodeType.IndexedValue && ctx.stack.includes(node.i);
 }
 
 function serializeNodeList(
@@ -212,7 +233,7 @@ function serializeNodeList(
     // Check if index is a hole
     if (item) {
       // Check if item is a parent
-      if (isReferenceInStack(ctx, item)) {
+      if (isIndexedValueInStack(ctx, item)) {
         createArrayAssign(ctx, node.i, i, getRefParam(ctx, item.i));
         isHoley = true;
       } else {
@@ -223,10 +244,7 @@ function serializeNodeList(
       isHoley = true;
     }
   }
-  if (isHoley) {
-    values += ',';
-  }
-  return '[' + values + ']';
+  return '[' + values + (isHoley ? ',]' : ']');
 }
 
 function serializeArray(
@@ -236,7 +254,7 @@ function serializeArray(
   ctx.stack.push(node.i);
   const result = serializeNodeList(ctx, node);
   ctx.stack.pop();
-  return assignRef(ctx, node.i, result);
+  return assignIndexedValue(ctx, node.i, result);
 }
 
 function serializeProperties(
@@ -262,7 +280,7 @@ function serializeProperties(
     // 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 || isValidIdentifier(key);
-    if (isReferenceInStack(ctx, val)) {
+    if (isIndexedValueInStack(ctx, val)) {
       refParam = getRefParam(ctx, val.i);
       if (isIdentifier && Number.isNaN(check)) {
         createObjectAssign(ctx, sourceID, key, refParam);
@@ -270,11 +288,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,12 +360,11 @@ 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 '(' + assignIndexedValue(ctx, i, init) + ',' + assignments + getRefParam(ctx, i) + ')';
       }
     }
   }
-  return assignRef(ctx, i, init);
+  return assignIndexedValue(ctx, i, init);
 }
 
 function serializeNullConstructor(
@@ -363,7 +378,7 @@ function serializeObject(
   ctx: SerializationContext,
   node: SerovalObjectNode,
 ) {
-  return assignRef(ctx, node.i, serializeProperties(ctx, node.i, node.d));
+  return assignIndexedValue(ctx, node.i, serializeProperties(ctx, node.i, node.d));
 }
 
 function serializeSet(
@@ -379,14 +394,11 @@ function serializeSet(
     let hasPrev = false;
     for (let i = 0; i < size; i++) {
       item = node.a[i];
-      if (isReferenceInStack(ctx, item)) {
+      if (isIndexedValueInStack(ctx, item)) {
         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;
       }
     }
@@ -395,7 +407,7 @@ function serializeSet(
       serialized += '([' + result + '])';
     }
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignIndexedValue(ctx, node.i, serialized);
 }
 
 function serializeMap(
@@ -416,11 +428,11 @@ function serializeMap(
       // Check if key is a parent
       key = node.d.k[i];
       val = node.d.v[i];
-      if (isReferenceInStack(ctx, key)) {
+      if (isIndexedValueInStack(ctx, key)) {
         // Create reference for the map instance
         keyRef = getRefParam(ctx, key.i);
         // Check if value is a parent
-        if (isReferenceInStack(ctx, val)) {
+        if (isIndexedValueInStack(ctx, val)) {
           valueRef = getRefParam(ctx, val.i);
           // Register an assignment since
           // both key and value are a parent of this
@@ -437,7 +449,7 @@ function serializeMap(
           createMapSet(ctx, node.i, keyRef, serializeTree(ctx, val));
           ctx.stack = parent;
         }
-      } else if (isReferenceInStack(ctx, val)) {
+      } else if (isIndexedValueInStack(ctx, val)) {
         // Create ref for the Map instance
         valueRef = getRefParam(ctx, val.i);
         // Reset stack for the key serialization
@@ -446,10 +458,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;
       }
     }
@@ -461,7 +470,7 @@ function serializeMap(
       serialized += '([' + result + '])';
     }
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignIndexedValue(ctx, node.i, serialized);
 }
 
 function serializeAggregateError(
@@ -492,12 +501,12 @@ function serializePromise(
 ) {
   let serialized: string;
   // Check if resolved value is a parent expression
-  if (isReferenceInStack(ctx, node.n)) {
+  if (isIndexedValueInStack(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,12 +514,12 @@ 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 + ')';
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignIndexedValue(ctx, node.i, serialized);
 }
 
 function serializeTypedArray(
@@ -518,20 +527,12 @@ 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' : '');
   }
-  return assignRef(ctx, node.i, 'new ' + node.c + '(' + args + ')');
+  const args = '[' + result + ']' + (node.l !== 0 ? (',' + node.l) : '');
+  return assignIndexedValue(ctx, node.i, 'new ' + node.c + '(' + args + ')');
 }
 
 function serializeIterable(
@@ -564,13 +565,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:
@@ -583,7 +584,7 @@ export default function serializeTree(
       return 'NaN';
     case SerovalNodeType.BigInt:
       return node.s + 'n';
-    case SerovalNodeType.Reference:
+    case SerovalNodeType.IndexedValue:
       return getRefParam(ctx, node.i);
     case SerovalNodeType.Array:
       return serializeArray(ctx, node);
@@ -592,9 +593,9 @@ export default function serializeTree(
     case SerovalNodeType.NullConstructor:
       return serializeNullConstructor(ctx, node);
     case SerovalNodeType.Date:
-      return assignRef(ctx, node.i, 'new Date("' + node.s + '")');
+      return assignIndexedValue(ctx, node.i, 'new Date("' + node.s + '")');
     case SerovalNodeType.RegExp:
-      return assignRef(ctx, node.i, '/' + node.c + '/' + node.m);
+      return assignIndexedValue(ctx, node.i, '/' + node.c + '/' + node.m);
     case SerovalNodeType.Set:
       return serializeSet(ctx, node);
     case SerovalNodeType.Map:
@@ -612,6 +613,12 @@ export default function serializeTree(
       return serializePromise(ctx, node);
     case SerovalNodeType.WKSymbol:
       return SYMBOL_STRING[node.s];
+    case SerovalNodeType.URL:
+      return assignIndexedValue(ctx, node.i, 'new URL("' + node.s + '")');
+    case SerovalNodeType.URLSearchParams:
+      return assignIndexedValue(ctx, node.i, node.s ? 'new URLSearchParams("' + node.s + '")' : 'new URLSearchParams');
+    case SerovalNodeType.Reference:
+      return assignIndexedValue(ctx, node.i, GLOBAL_KEY + '.get("' + node.s + '")');
     default:
       throw new Error('Unsupported type');
   }