seroval 0.5.0 → 0.6.0

package/src/tree/async.ts

@@ -2,9 +2,9 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import { createRef, ParserContext } from '../context';
+import { createIndexedValue, getRootID, ParserContext } from '../context';
+import quote from '../quote';
 import {
-  AsyncServerValue,
   BigIntTypedArrayValue,
   TypedArrayValue,
 } from '../types';
@@ -13,7 +13,7 @@ import {
   createBigIntTypedArrayNode,
   createDateNode,
   createNumberNode,
-  createReferenceNode,
+  createIndexedValueNode,
   createRegExpNode,
   createStringNode,
   createTypedArrayNode,
@@ -26,14 +26,16 @@ 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,
@@ -48,6 +50,7 @@ import {
   SerovalPromiseNode,
   SerovalSetNode,
 } from './types';
+import { createURLNode, createURLSearchParamsNode } from './web-api';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -56,18 +59,18 @@ type ObjectLikeNode =
   | SerovalPromiseNode;
 
 type ObjectLikeValue =
-  | Record<string, AsyncServerValue>
-  | Iterable<AsyncServerValue>
-  | PromiseLike<AsyncServerValue>;
+  | Record<string, unknown>
+  | Iterable<unknown>
+  | PromiseLike<unknown>;
 
 async function generateNodeList(
   ctx: ParserContext,
-  current: AsyncServerValue[],
+  current: unknown[],
 ) {
   const size = current.length;
   const nodes = new Array<SerovalNode>(size);
-  const deferred = new Array<AsyncServerValue>(size);
-  let item: AsyncServerValue;
+  const deferred = new Array<unknown>(size);
+  let item: unknown;
   for (let i = 0; i < size; i++) {
     if (i in current) {
       item = current[i];
@@ -89,7 +92,7 @@ async function generateNodeList(
 async function generateArrayNode(
   ctx: ParserContext,
   id: number,
-  current: AsyncServerValue[],
+  current: unknown[],
 ): Promise<SerovalArrayNode> {
   return {
     t: SerovalNodeType.Array,
@@ -100,21 +103,21 @@ async function generateArrayNode(
     m: undefined,
     d: undefined,
     a: await generateNodeList(ctx, current),
-    n: undefined,
+    f: undefined,
   };
 }
 
 async function generateMapNode(
   ctx: ParserContext,
   id: number,
-  current: Map<AsyncServerValue, AsyncServerValue>,
+  current: Map<unknown, unknown>,
 ): Promise<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<AsyncServerValue>(len);
-  const deferredValue = new Array<AsyncServerValue>(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()) {
@@ -142,19 +145,19 @@ async function generateMapNode(
     m: undefined,
     d: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
 async function generateSetNode(
   ctx: ParserContext,
   id: number,
-  current: Set<AsyncServerValue>,
+  current: Set<unknown>,
 ): Promise<SerovalSetNode> {
   assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
   const len = current.size;
   const nodes = new Array<SerovalNode>(len);
-  const deferred = new Array<AsyncServerValue>(len);
+  const deferred = new Array<unknown>(len);
   let deferredSize = 0;
   let nodeSize = 0;
   for (const item of current.keys()) {
@@ -178,23 +181,23 @@ async function generateSetNode(
     m: undefined,
     d: undefined,
     a: nodes,
-    n: undefined,
+    f: undefined,
   };
 }
 
 async function generateProperties(
   ctx: ParserContext,
-  properties: Record<string, AsyncServerValue>,
+  properties: Record<string, unknown>,
 ): Promise<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<AsyncServerValue>(size);
+  const deferredValues = new Array<unknown>(size);
   let deferredSize = 0;
   let nodesSize = 0;
-  let item: AsyncServerValue;
+  let item: unknown;
   for (const key of keys) {
     item = properties[key];
     if (isIterable(item)) {
@@ -221,7 +224,7 @@ async function generateProperties(
 async function generateIterableNode(
   ctx: ParserContext,
   id: number,
-  current: Iterable<AsyncServerValue>,
+  current: Iterable<unknown>,
 ): Promise<SerovalIterableNode> {
   assert(ctx.features & Feature.Symbol, 'Unsupported type "Iterable"');
   const options = getIterableOptions(current);
@@ -235,17 +238,17 @@ async function generateIterableNode(
     m: undefined,
     // Parse options first before the items
     d: options
-      ? await generateProperties(ctx, options as Record<string, AsyncServerValue>)
+      ? await generateProperties(ctx, options)
       : undefined,
     a: await generateNodeList(ctx, array),
-    n: undefined,
+    f: undefined,
   };
 }
 
 async function generatePromiseNode(
   ctx: ParserContext,
   id: number,
-  current: PromiseLike<AsyncServerValue>,
+  current: PromiseLike<unknown>,
 ): Promise<SerovalPromiseNode> {
   assert(ctx.features & Feature.Promise, 'Unsupported type "Promise"');
   return current.then(async (value) => ({
@@ -258,7 +261,7 @@ async function generatePromiseNode(
     // Parse options first before the items
     d: undefined,
     a: undefined,
-    n: await parse(ctx, value),
+    f: await parse(ctx, value),
   }));
 }
 
@@ -272,7 +275,7 @@ async function generateObjectNode(
     return generateIterableNode(ctx, id, current);
   }
   if ('then' in current && typeof current.then === 'function') {
-    return generatePromiseNode(ctx, id, current as PromiseLike<AsyncServerValue>);
+    return generatePromiseNode(ctx, id, current as PromiseLike<unknown>);
   }
   return {
     t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
@@ -281,9 +284,9 @@ async function generateObjectNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: await generateProperties(ctx, current as Record<string, AsyncServerValue>),
+    d: await generateProperties(ctx, current as Record<string, unknown>),
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
@@ -302,10 +305,10 @@ async function generateAggregateErrorNode(
     s: undefined,
     l: current.errors.length,
     c: undefined,
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
-    a: await generateNodeList(ctx, current.errors as AsyncServerValue[]),
-    n: undefined,
+    a: await generateNodeList(ctx, current.errors as unknown[]),
+    f: undefined,
   };
 }
 
@@ -324,16 +327,16 @@ async function generateErrorNode(
     s: undefined,
     l: undefined,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: quote(current.message),
     d: optionsNode,
     a: undefined,
-    n: undefined,
+    f: undefined,
   };
 }
 
-async function parse(
+async function parse<T>(
   ctx: ParserContext,
-  current: AsyncServerValue,
+  current: T,
 ): Promise<SerovalNode> {
   switch (typeof current) {
     case 'boolean':
@@ -343,20 +346,19 @@ async function parse(
     case 'string':
       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 INFINITY_NODE;
-      }
-      if (Object.is(current, -Infinity)) {
-        return NEG_INFINITY_NODE;
+      switch (current) {
+        case Infinity: return INFINITY_NODE;
+        case -Infinity: return NEG_INFINITY_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': {
@@ -365,20 +367,23 @@ async function parse(
       }
       // Non-primitive values needs a reference ID
       // mostly because the values themselves are stateful
-      const id = createRef(ctx, current, true);
+      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 Promise:
-          return generatePromiseNode(ctx, id, current as Promise<AsyncServerValue>);
+          return generatePromiseNode(ctx, id, current as unknown as Promise<unknown>);
         case Int8Array:
         case Int16Array:
         case Int32Array:
@@ -388,41 +393,41 @@ async 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<AsyncServerValue, AsyncServerValue>,
+            current as unknown as Map<unknown, unknown>,
           );
         case Set:
           return generateSetNode(
             ctx,
             id,
-            current as Set<AsyncServerValue>,
+            current as unknown as Set<unknown>,
           );
         case Object:
           return generateObjectNode(
             ctx,
             id,
-            current as Record<string, AsyncServerValue>,
+            current as Record<string, unknown>,
             false,
           );
         case undefined:
           return generateObjectNode(
             ctx,
             id,
-            current as Record<string, AsyncServerValue>,
+            current 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:
@@ -430,12 +435,19 @@ async 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;
       }
-      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);
@@ -445,29 +457,42 @@ async 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>);
       }
       // For Promise-like objects
       if ('then' in current && typeof current.then === 'function') {
-        return generatePromiseNode(ctx, id, current as PromiseLike<AsyncServerValue>);
+        return generatePromiseNode(ctx, id, current as PromiseLike<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 async function parseAsync(
+export default async function parseAsync<T>(
   ctx: ParserContext,
-  current: AsyncServerValue,
+  current: T,
 ) {
   const result = await 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/deserialize.ts

@@ -4,6 +4,7 @@ import {
 } from '../context';
 import { invQuote } from '../quote';
 import { AsyncServerValue } from '../types';
+import { getReference } from './reference';
 import { getErrorConstructor, getTypedArrayConstructor } from './shared';
 import { SYMBOL_REF } from './symbols';
 import {
@@ -23,7 +24,7 @@ import {
   SerovalTypedArrayNode,
 } from './types';
 
-function assignRef<T extends AsyncServerValue>(
+function assignIndexedValue<T>(
   ctx: SerializationContext,
   index: number,
   value: T,
@@ -35,7 +36,7 @@ function assignRef<T extends AsyncServerValue>(
 function deserializeNodeList(
   ctx: SerializationContext,
   node: SerovalArrayNode | SerovalIterableNode | SerovalAggregateErrorNode,
-  result: AsyncServerValue[],
+  result: unknown[],
 ) {
   let item: SerovalNode;
   for (let i = 0, len = node.a.length; i < len; i++) {
@@ -51,7 +52,7 @@ function deserializeArray(
   ctx: SerializationContext,
   node: SerovalArrayNode,
 ) {
-  const result: AsyncServerValue[] = assignRef(
+  const result: AsyncServerValue[] = assignIndexedValue(
     ctx,
     node.i,
     new Array<AsyncServerValue>(node.l),
@@ -65,7 +66,7 @@ function deserializeArray(
 function deserializeProperties(
   ctx: SerializationContext,
   node: SerovalObjectRecordNode,
-  result: Record<string, AsyncServerValue>,
+  result: Record<string, unknown>,
 ) {
   if (node.s === 0) {
     return {};
@@ -80,7 +81,11 @@ function deserializeNullConstructor(
   ctx: SerializationContext,
   node: SerovalNullConstructorNode,
 ) {
-  const result = assignRef(ctx, node.i, Object.create(null) as Record<string, AsyncServerValue>);
+  const result = assignIndexedValue(
+    ctx,
+    node.i,
+    Object.create(null) as Record<string, AsyncServerValue>,
+  );
   ctx.stack.push(node.i);
   deserializeProperties(ctx, node.d, result);
   ctx.stack.pop();
@@ -91,7 +96,7 @@ function deserializeObject(
   ctx: SerializationContext,
   node: SerovalObjectNode,
 ) {
-  const result = assignRef(ctx, node.i, {} as Record<string, AsyncServerValue>);
+  const result = assignIndexedValue(ctx, node.i, {} as Record<string, AsyncServerValue>);
   ctx.stack.push(node.i);
   deserializeProperties(ctx, node.d, result);
   ctx.stack.pop();
@@ -102,7 +107,7 @@ function deserializeSet(
   ctx: SerializationContext,
   node: SerovalSetNode,
 ) {
-  const result = assignRef(ctx, node.i, new Set<AsyncServerValue>());
+  const result = assignIndexedValue(ctx, node.i, new Set<unknown>());
   ctx.stack.push(node.i);
   for (let i = 0, len = node.a.length; i < len; i++) {
     result.add(deserializeTree(ctx, node.a[i]));
@@ -115,10 +120,10 @@ function deserializeMap(
   ctx: SerializationContext,
   node: SerovalMapNode,
 ) {
-  const result = assignRef(
+  const result = assignIndexedValue(
     ctx,
     node.i,
-    new Map<AsyncServerValue, AsyncServerValue>(),
+    new Map<unknown, unknown>(),
   );
   ctx.stack.push(node.i);
   for (let i = 0; i < node.d.s; i++) {
@@ -153,7 +158,7 @@ function deserializeAggregateError(
   node: SerovalAggregateErrorNode,
 ) {
   // Serialize the required arguments
-  const result = assignRef(ctx, node.i, new AggregateError([], node.m));
+  const result = assignIndexedValue(ctx, node.i, new AggregateError([], invQuote(node.m)));
   ctx.stack.push(node.i);
   result.errors = deserializeNodeList(ctx, node, new Array<AsyncServerValue>(node.l));
   ctx.stack.pop();
@@ -168,13 +173,13 @@ function deserializeError(
   node: SerovalErrorNode,
 ) {
   const ErrorConstructor = getErrorConstructor(node.c);
-  const result = assignRef(ctx, node.i, new ErrorConstructor(node.m));
+  const result = assignIndexedValue(ctx, node.i, new ErrorConstructor(invQuote(node.m)));
   return deserializeDictionary(ctx, node, result);
 }
 
 interface Deferred {
-  resolve(value: AsyncServerValue): void;
-  promise: Promise<AsyncServerValue>;
+  resolve(value: unknown): void;
+  promise: Promise<unknown>;
 }
 
 function createDeferred(): Deferred {
@@ -194,8 +199,8 @@ function deserializePromise(
   node: SerovalPromiseNode,
 ) {
   const deferred = createDeferred();
-  const result = assignRef(ctx, node.i, deferred.promise);
-  deferred.resolve(deserializeTree(ctx, node.n));
+  const result = assignIndexedValue(ctx, node.i, deferred.promise);
+  deferred.resolve(deserializeTree(ctx, node.f));
   return result;
 }
 
@@ -205,7 +210,7 @@ function deserializeTypedArray(
 ) {
   const TypedArray = getTypedArrayConstructor(node.c);
   const dummy = new TypedArray();
-  const result = assignRef(ctx, node.i, new TypedArray(
+  const result = assignIndexedValue(ctx, node.i, new TypedArray(
     dummy.buffer,
     node.l,
   ));
@@ -223,7 +228,7 @@ function deserializeIterable(
 ) {
   const values: AsyncServerValue[] = [];
   deserializeNodeList(ctx, node, values);
-  const result = assignRef(ctx, node.i, {
+  const result = assignIndexedValue(ctx, node.i, {
     [Symbol.iterator]: () => values.values(),
   });
   return deserializeDictionary(ctx, node, result);
@@ -232,7 +237,7 @@ function deserializeIterable(
 export default function deserializeTree(
   ctx: SerializationContext,
   node: SerovalNode,
-): AsyncServerValue {
+): unknown {
   switch (node.t) {
     case SerovalNodeType.Number:
     case SerovalNodeType.Boolean:
@@ -253,7 +258,7 @@ export default function deserializeTree(
       return NaN;
     case SerovalNodeType.BigInt:
       return BigInt(node.s);
-    case SerovalNodeType.Reference:
+    case SerovalNodeType.IndexedValue:
       return ctx.valueMap.get(node.i);
     case SerovalNodeType.Array:
       return deserializeArray(ctx, node);
@@ -262,9 +267,9 @@ export default function deserializeTree(
     case SerovalNodeType.NullConstructor:
       return deserializeNullConstructor(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, new RegExp(node.c, node.m));
+      return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
     case SerovalNodeType.Set:
       return deserializeSet(ctx, node);
     case SerovalNodeType.Map:
@@ -282,6 +287,12 @@ export default function deserializeTree(
       return deserializePromise(ctx, node);
     case SerovalNodeType.WKSymbol:
       return SYMBOL_REF[node.s];
+    case SerovalNodeType.URL:
+      return assignIndexedValue(ctx, node.i, new URL(node.s));
+    case SerovalNodeType.URLSearchParams:
+      return assignIndexedValue(ctx, node.i, new URLSearchParams(node.s));
+    case SerovalNodeType.Reference:
+      return assignIndexedValue(ctx, node.i, getReference(invQuote(node.s)));
     default:
       throw new Error('Unsupported type');
   }