seroval 0.5.1 → 0.6.0

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';
@@ -194,7 +195,7 @@ function createObjectAssign(
   createAssignment(ctx, getRefParam(ctx, ref) + '.' + key, value);
 }
 
-function assignRef(
+function assignIndexedValue(
   ctx: SerializationContext,
   index: number,
   value: string,
@@ -205,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(
@@ -232,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 {
@@ -253,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(
@@ -279,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);
@@ -359,11 +360,11 @@ function serializeDictionary(
       markRef(ctx, i);
       const assignments = serializeAssignments(ctx, i, d);
       if (assignments) {
-        return '(' + assignRef(ctx, i, init) + ',' + assignments + getRefParam(ctx, i) + ')';
+        return '(' + assignIndexedValue(ctx, i, init) + ',' + assignments + getRefParam(ctx, i) + ')';
       }
     }
   }
-  return assignRef(ctx, i, init);
+  return assignIndexedValue(ctx, i, init);
 }
 
 function serializeNullConstructor(
@@ -377,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(
@@ -393,7 +394,7 @@ 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
@@ -406,7 +407,7 @@ function serializeSet(
       serialized += '([' + result + '])';
     }
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignIndexedValue(ctx, node.i, serialized);
 }
 
 function serializeMap(
@@ -427,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
@@ -448,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
@@ -469,7 +470,7 @@ function serializeMap(
       serialized += '([' + result + '])';
     }
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignIndexedValue(ctx, node.i, serialized);
 }
 
 function serializeAggregateError(
@@ -500,7 +501,7 @@ function serializePromise(
 ) {
   let serialized: string;
   // Check if resolved value is a parent expression
-  if (isReferenceInStack(ctx, node.f)) {
+  if (isIndexedValueInStack(ctx, node.f)) {
     // A Promise trick, reference the value
     // inside the `then` expression so that
     // the Promise evaluates after the parent
@@ -518,7 +519,7 @@ function serializePromise(
     // just inline the value/reference here
     serialized = 'Promise.resolve(' + result + ')';
   }
-  return assignRef(ctx, node.i, serialized);
+  return assignIndexedValue(ctx, node.i, serialized);
 }
 
 function serializeTypedArray(
@@ -531,7 +532,7 @@ function serializeTypedArray(
     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 + ')');
+  return assignIndexedValue(ctx, node.i, 'new ' + node.c + '(' + args + ')');
 }
 
 function serializeIterable(
@@ -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');
   }

package/src/tree/sync.ts

@@ -1,14 +1,15 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import { createRef, getRootID, ParserContext } from '../context';
-import { BigIntTypedArrayValue, ServerValue, TypedArrayValue } from '../types';
+import { createIndexedValue, getRootID, ParserContext } from '../context';
+import quote from '../quote';
+import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
 import {
   createBigIntNode,
   createBigIntTypedArrayNode,
   createDateNode,
   createNumberNode,
-  createReferenceNode,
+  createIndexedValueNode,
   createRegExpNode,
   createStringNode,
   createTypedArrayNode,
@@ -21,14 +22,18 @@ import {
   NULL_NODE,
   TRUE_NODE,
   UNDEFINED_NODE,
+  createReferenceNode,
 } from './primitives';
+import {
+  hasReferenceID,
+} from './reference';
 import {
   getErrorConstructorName,
   getErrorOptions,
   getIterableOptions,
   isIterable,
 } from './shared';
-import { INV_SYMBOL_REF } from './symbols';
+import { WellKnownSymbols } from './symbols';
 import {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -42,14 +47,15 @@ import {
   SerovalObjectRecordNode,
   SerovalSetNode,
 } from './types';
+import { createURLNode, createURLSearchParamsNode } from './web-api';
 
 type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode | SerovalIterableNode;
 
-function generateNodeList(ctx: ParserContext, current: ServerValue[]) {
+function generateNodeList(ctx: ParserContext, current: unknown[]) {
   const size = current.length;
   const nodes = new Array<SerovalNode>(size);
-  const deferred = new Array<ServerValue>(size);
-  let item: ServerValue;
+  const deferred = new Array<unknown>(size);
+  let item: unknown;
   for (let i = 0; i < size; i++) {
     if (i in current) {
       item = current[i];
@@ -71,7 +77,7 @@ function generateNodeList(ctx: ParserContext, current: ServerValue[]) {
 function generateArrayNode(
   ctx: ParserContext,
   id: number,
-  current: ServerValue[],
+  current: unknown[],
 ): SerovalArrayNode {
   return {
     t: SerovalNodeType.Array,
@@ -89,14 +95,14 @@ function generateArrayNode(
 function generateMapNode(
   ctx: ParserContext,
   id: number,
-  current: Map<ServerValue, ServerValue>,
+  current: Map<unknown, unknown>,
 ): SerovalMapNode {
   assert(ctx.features & Feature.Map, 'Unsupported type "Map"');
   const len = current.size;
   const keyNodes = new Array<SerovalNode>(len);
   const valueNodes = new Array<SerovalNode>(len);
-  const deferredKey = new Array<ServerValue>(len);
-  const deferredValue = new Array<ServerValue>(len);
+  const deferredKey = new Array<unknown>(len);
+  const deferredValue = new Array<unknown>(len);
   let deferredSize = 0;
   let nodeSize = 0;
   for (const [key, value] of current.entries()) {
@@ -131,12 +137,12 @@ function generateMapNode(
 function generateSetNode(
   ctx: ParserContext,
   id: number,
-  current: Set<ServerValue>,
+  current: Set<unknown>,
 ): SerovalSetNode {
   assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
   const len = current.size;
   const nodes = new Array<SerovalNode>(len);
-  const deferred = new Array<ServerValue>(len);
+  const deferred = new Array<unknown>(len);
   let deferredSize = 0;
   let nodeSize = 0;
   for (const item of current.keys()) {
@@ -166,17 +172,17 @@ function generateSetNode(
 
 function generateProperties(
   ctx: ParserContext,
-  properties: Record<string, ServerValue>,
+  properties: Record<string, unknown>,
 ): SerovalObjectRecordNode {
   const keys = Object.keys(properties);
   const size = keys.length;
   const keyNodes = new Array<string>(size);
   const valueNodes = new Array<SerovalNode>(size);
   const deferredKeys = new Array<string>(size);
-  const deferredValues = new Array<ServerValue>(size);
+  const deferredValues = new Array<unknown>(size);
   let deferredSize = 0;
   let nodesSize = 0;
-  let item: ServerValue;
+  let item: unknown;
   for (const key of keys) {
     item = properties[key];
     if (isIterable(item)) {
@@ -203,7 +209,7 @@ function generateProperties(
 function generateIterableNode(
   ctx: ParserContext,
   id: number,
-  current: Iterable<ServerValue>,
+  current: Iterable<unknown>,
 ): SerovalIterableNode {
   assert(ctx.features & Feature.Symbol, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
@@ -217,7 +223,7 @@ function generateIterableNode(
     m: undefined,
     // Parse options first before the items
     d: options
-      ? generateProperties(ctx, options as Record<string, ServerValue>)
+      ? generateProperties(ctx, options)
       : undefined,
     a: generateNodeList(ctx, array),
     f: undefined,
@@ -227,7 +233,7 @@ function generateIterableNode(
 function generateObjectNode(
   ctx: ParserContext,
   id: number,
-  current: Record<string, ServerValue> | Iterable<ServerValue>,
+  current: Record<string, unknown> | Iterable<unknown>,
   empty: boolean,
 ): ObjectLikeNode {
   if (Symbol.iterator in current) {
@@ -261,9 +267,9 @@ function generateAggregateErrorNode(
     s: undefined,
     l: current.errors.length,
     c: undefined,
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
-    a: generateNodeList(ctx, current.errors as ServerValue[]),
+    a: generateNodeList(ctx, current.errors as unknown[]),
     f: undefined,
   };
 }
@@ -283,16 +289,16 @@ function generateErrorNode(
     s: undefined,
     l: undefined,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
     a: undefined,
     f: undefined,
   };
 }
 
-function parse(
+function parse<T>(
   ctx: ParserContext,
-  current: ServerValue,
+  current: T,
 ): SerovalNode {
   switch (typeof current) {
     case 'boolean':
@@ -305,16 +311,16 @@ function parse(
       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;
-      }
-      if (Object.is(current, -0)) {
-        return NEG_ZERO_NODE;
+        default:
+          // eslint-disable-next-line no-self-compare
+          if (current !== current) {
+            return NAN_NODE;
+          }
+          if (Object.is(current, -0)) {
+            return NEG_ZERO_NODE;
+          }
+          return createNumberNode(current);
       }
-      return createNumberNode(current);
     case 'bigint':
       return createBigIntNode(ctx, current);
     case 'object': {
@@ -323,18 +329,21 @@ function parse(
       }
       // Non-primitive values needs a reference ID
       // mostly because the values themselves are stateful
-      const id = createRef(ctx, current);
+      const id = createIndexedValue(ctx, current);
       if (ctx.markedRefs.has(id)) {
-        return createReferenceNode(id);
+        return createIndexedValueNode(id);
+      }
+      if (hasReferenceID(current)) {
+        return createReferenceNode(id, current);
       }
       if (Array.isArray(current)) {
         return generateArrayNode(ctx, id, current);
       }
       switch (current.constructor) {
         case Date:
-          return createDateNode(id, current as Date);
+          return createDateNode(id, current as unknown as Date);
         case RegExp:
-          return createRegExpNode(id, current as RegExp);
+          return createRegExpNode(id, current as unknown as RegExp);
         case Int8Array:
         case Int16Array:
         case Int32Array:
@@ -344,23 +353,33 @@ function parse(
         case Uint8ClampedArray:
         case Float32Array:
         case Float64Array:
-          return createTypedArrayNode(ctx, id, current as TypedArrayValue);
+          return createTypedArrayNode(ctx, id, current as unknown as TypedArrayValue);
         case BigInt64Array:
         case BigUint64Array:
-          return createBigIntTypedArrayNode(ctx, id, current as BigIntTypedArrayValue);
+          return createBigIntTypedArrayNode(ctx, id, current as unknown as BigIntTypedArrayValue);
         case Map:
-          return generateMapNode(ctx, id, current as Map<ServerValue, ServerValue>);
+          return generateMapNode(ctx, id, current as unknown as Map<unknown, unknown>);
         case Set:
-          return generateSetNode(ctx, id, current as Set<ServerValue>);
+          return generateSetNode(ctx, id, current as unknown as Set<unknown>);
         case Object:
-          return generateObjectNode(ctx, id, current as Record<string, ServerValue>, false);
+          return generateObjectNode(
+            ctx,
+            id,
+            current as unknown as Record<string, unknown>,
+            false,
+          );
         case undefined:
-          return generateObjectNode(ctx, id, current as Record<string, ServerValue>, true);
+          return generateObjectNode(
+            ctx,
+            id,
+            current as unknown as Record<string, unknown>,
+            true,
+          );
         case AggregateError:
           if (ctx.features & Feature.AggregateError) {
-            return generateAggregateErrorNode(ctx, id, current as AggregateError);
+            return generateAggregateErrorNode(ctx, id, current as unknown as AggregateError);
           }
-          return generateErrorNode(ctx, id, current as AggregateError);
+          return generateErrorNode(ctx, id, current as unknown as AggregateError);
         case Error:
         case EvalError:
         case RangeError:
@@ -368,7 +387,11 @@ function parse(
         case SyntaxError:
         case TypeError:
         case URIError:
-          return generateErrorNode(ctx, id, current as Error);
+          return generateErrorNode(ctx, id, current as unknown as Error);
+        case URL:
+          return createURLNode(ctx, id, current as unknown as URL);
+        case URLSearchParams:
+          return createURLSearchParamsNode(ctx, id, current as unknown as URLSearchParams);
         default:
           break;
       }
@@ -383,22 +406,35 @@ function parse(
       }
       // Generator functions don't have a global constructor
       if (Symbol.iterator in current) {
-        return generateIterableNode(ctx, id, current);
+        return generateIterableNode(ctx, id, current as Iterable<unknown>);
       }
       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);
+      if (hasReferenceID(current)) {
+        const id = createIndexedValue(ctx, current);
+        if (ctx.markedRefs.has(id)) {
+          return createIndexedValueNode(id);
+        }
+        return createReferenceNode(id, current);
+      }
+      return createWKSymbolNode(ctx, current as WellKnownSymbols);
+    case 'function': {
+      assert(hasReferenceID(current), 'Cannot serialize function without reference ID.');
+      const id = createIndexedValue(ctx, current);
+      if (ctx.markedRefs.has(id)) {
+        return createIndexedValueNode(id);
+      }
+      return createReferenceNode(id, current);
+    }
     default:
       throw new Error('Unsupported type');
   }
 }
 
-export default function parseSync(
+export default function parseSync<T>(
   ctx: ParserContext,
-  current: ServerValue,
+  current: T,
 ) {
   const result = parse(ctx, current);
   const isObject = result.t === SerovalNodeType.Object

package/src/tree/types.ts

@@ -11,7 +11,7 @@ export const enum SerovalNodeType {
   NegativeInfinity,
   NaN,
   BigInt,
-  Reference,
+  IndexedValue,
   Date,
   RegExp,
   Set,
@@ -26,6 +26,9 @@ export const enum SerovalNodeType {
   TypedArray,
   BigIntTypedArray,
   WKSymbol,
+  URL,
+  URLSearchParams,
+  Reference,
 }
 
 export interface SerovalBaseNode {
@@ -115,8 +118,8 @@ export type SerovalPrimitiveNode =
   | SerovalInfinityNode
   | SerovalNaNNode;
 
-export interface SerovalReferenceNode extends SerovalBaseNode {
-  t: SerovalNodeType.Reference;
+export interface SerovalIndexedValueNode extends SerovalBaseNode {
+  t: SerovalNodeType.IndexedValue;
   i: number;
 }
 
@@ -231,9 +234,27 @@ export interface SerovalWKSymbolNode extends SerovalBaseNode {
   s: Symbols;
 }
 
+export interface SerovalURLNode extends SerovalBaseNode {
+  t: SerovalNodeType.URL;
+  i: number;
+  s: string;
+}
+
+export interface SerovalURLSearchParamsNode extends SerovalBaseNode {
+  t: SerovalNodeType.URLSearchParams;
+  i: number;
+  s: string;
+}
+
+export interface SerovalReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.Reference;
+  i: number;
+  s: string;
+}
+
 export type SerovalNode =
   | SerovalPrimitiveNode
-  | SerovalReferenceNode
+  | SerovalIndexedValueNode
   | SerovalSemiPrimitiveNode
   | SerovalSetNode
   | SerovalMapNode
@@ -244,4 +265,7 @@ export type SerovalNode =
   | SerovalErrorNode
   | SerovalAggregateErrorNode
   | SerovalIterableNode
-  | SerovalWKSymbolNode;
+  | SerovalWKSymbolNode
+  | SerovalURLNode
+  | SerovalURLSearchParamsNode
+  | SerovalReferenceNode;

package/src/tree/web-api.ts

@@ -0,0 +1,42 @@
+import assert from '../assert';
+import { Feature } from '../compat';
+import { ParserContext } from '../context';
+import { SerovalNodeType, SerovalURLNode, SerovalURLSearchParamsNode } from './types';
+
+export function createURLNode(
+  ctx: ParserContext,
+  id: number,
+  current: URL,
+): SerovalURLNode {
+  assert(ctx.features & Feature.WebAPI, 'Unsupported type "URL"');
+  return {
+    t: SerovalNodeType.URL,
+    i: id,
+    s: current.href,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    f: undefined,
+    a: undefined,
+  };
+}
+
+export function createURLSearchParamsNode(
+  ctx: ParserContext,
+  id: number,
+  current: URLSearchParams,
+): SerovalURLSearchParamsNode {
+  assert(ctx.features & Feature.WebAPI, 'Unsupported type "URLSearchParams"');
+  return {
+    t: SerovalNodeType.URLSearchParams,
+    i: id,
+    s: current.toString(),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    f: undefined,
+    a: undefined,
+  };
+}

package/src/types.ts

@@ -34,12 +34,17 @@ export type BigIntTypedArrayValue =
   | BigInt64Array
   | BigUint64Array;
 
+export type WebAPIValue =
+  | URL
+  | URLSearchParams;
+
 export type SemiPrimitiveValue =
   | RegExp
   | Date
   | TypedArrayValue
   | BigIntTypedArrayValue
-  | bigint;
+  | bigint
+  | WebAPIValue;
 
 export type CommonServerValue =
   | PrimitiveValue