seroval 0.5.1 → 0.7.0

package/src/index.ts

@@ -12,14 +12,6 @@ import deserializeTree from './tree/deserialize';
 import serializeTree, { resolvePatches } from './tree/serialize';
 import parseSync from './tree/sync';
 import { SerovalNode } from './tree/types';
-import {
-  AsyncServerValue,
-  PrimitiveValue,
-  ServerValue,
-  CommonServerValue,
-  SemiPrimitiveValue,
-  ErrorValue,
-} from './types';
 
 export {
   AsyncServerValue,
@@ -28,8 +20,8 @@ export {
   CommonServerValue,
   SemiPrimitiveValue,
   ErrorValue,
-  Feature,
-};
+} from './types';
+export { Feature } from './compat';
 
 function finalize(
   ctx: SerializationContext,
@@ -67,7 +59,7 @@ function finalize(
   return result;
 }
 
-export function serialize<T extends ServerValue>(
+export function serialize<T>(
   source: T,
   options?: Partial<Options>,
 ) {
@@ -78,7 +70,7 @@ export function serialize<T extends ServerValue>(
   return finalize(serial, rootID, isObject, result);
 }
 
-export async function serializeAsync<T extends AsyncServerValue>(
+export async function serializeAsync<T>(
   source: T,
   options?: Partial<Options>,
 ) {
@@ -89,7 +81,7 @@ export async function serializeAsync<T extends AsyncServerValue>(
   return finalize(serial, rootID, isObject, result);
 }
 
-export function deserialize<T extends AsyncServerValue>(source: string): T {
+export function deserialize<T>(source: string): T {
   // eslint-disable-next-line no-eval
   return (0, eval)(source) as T;
 }
@@ -102,7 +94,7 @@ export interface SerovalJSON {
   m: number[],
 }
 
-export function toJSON<T extends ServerValue>(
+export function toJSON<T>(
   source: T,
   options?: Partial<Options>,
 ): SerovalJSON {
@@ -117,7 +109,7 @@ export function toJSON<T extends ServerValue>(
   };
 }
 
-export async function toJSONAsync<T extends AsyncServerValue>(
+export async function toJSONAsync<T>(
   source: T,
   options?: Partial<Options>,
 ): Promise<SerovalJSON> {
@@ -141,7 +133,7 @@ export function compileJSON(source: SerovalJSON): string {
   return finalize(serial, source.r, source.i, result);
 }
 
-export function fromJSON<T extends AsyncServerValue>(source: SerovalJSON): T {
+export function fromJSON<T>(source: SerovalJSON): T {
   const serial = createSerializationContext({
     features: source.f,
     markedRefs: source.m,
@@ -150,3 +142,5 @@ export function fromJSON<T extends AsyncServerValue>(source: SerovalJSON): T {
 }
 
 export default serialize;
+
+export { createReference } from './tree/reference';

package/src/{quote.ts → string.ts}

@@ -1,40 +1,34 @@
+export function serializeChar(str: string) {
+  switch (str) {
+    case '"': return '\\"';
+    case '\\': return '\\\\';
+    case '\n': return '\\n';
+    case '\r': return '\\r';
+    case '\b': return '\\b';
+    case '\t': return '\\t';
+    case '\f': return '\\f';
+    case '<': return '\\x3C';
+    case '\u2028': return '\\u2028';
+    case '\u2029': return '\\u2029';
+    default: return undefined;
+  }
+}
+
 // Written by https://github.com/DylanPiercey and is distributed under the MIT license.
 // Creates a JavaScript double quoted string and escapes all characters
 // not listed as DoubleStringCharacters on
 // Also includes "<" to escape "</script>" and "\" to avoid invalid escapes in the output.
 // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-export default function quote(str: string) {
+export function serializeString(str: string) {
   let result = '';
   let lastPos = 0;
+  let replacement: string | undefined;
   for (let i = 0, len = str.length; i < len; i++) {
-    let replacement;
-    switch (str[i]) {
-      case '"':
-        replacement = '\\"';
-        break;
-      case '\\':
-        replacement = '\\\\';
-        break;
-      case '<':
-        replacement = '\\x3C';
-        break;
-      case '\n':
-        replacement = '\\n';
-        break;
-      case '\r':
-        replacement = '\\r';
-        break;
-      case '\u2028':
-        replacement = '\\u2028';
-        break;
-      case '\u2029':
-        replacement = '\\u2029';
-        break;
-      default:
-        continue;
+    replacement = serializeChar(str[i]);
+    if (replacement) {
+      result += str.slice(lastPos, i) + replacement;
+      lastPos = i + 1;
     }
-    result += str.slice(lastPos, i) + replacement;
-    lastPos = i + 1;
   }
   if (lastPos === 0) {
     result = str;
@@ -44,13 +38,16 @@ export default function quote(str: string) {
   return result;
 }
 
-export function invQuote(str: string): string {
+export function deserializeString(str: string): string {
   return str
     .replace(/\\"/g, '"')
     .replace(/\\\\/g, '\\')
-    .replace(/\\x3C/g, '<')
     .replace(/\\n/g, '\n')
     .replace(/\\r/g, '\r')
+    .replace(/\\b/g, '\b')
+    .replace(/\\t/g, '\t')
+    .replace(/\\f/g, '\f')
+    .replace(/\\x3C/g, '<')
     .replace(/\\u2028/g, '\u2028')
     .replace(/\\u2029/g, '\u2029');
 }

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, getRootID, ParserContext } from '../context';
+import { createIndexedValue, getRootID, ParserContext } from '../context';
+import { serializeString } from '../string';
 import {
-  AsyncServerValue,
   BigIntTypedArrayValue,
   TypedArrayValue,
 } from '../types';
@@ -13,7 +13,7 @@ import {
   createBigIntTypedArrayNode,
   createDateNode,
   createNumberNode,
-  createReferenceNode,
+  createIndexedValueNode,
   createRegExpNode,
   createStringNode,
   createTypedArrayNode,
@@ -26,18 +26,24 @@ import {
   NULL_NODE,
   TRUE_NODE,
   UNDEFINED_NODE,
+  createReferenceNode,
+  createArrayBufferNode,
+  createDataViewNode,
 } 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,
   SerovalErrorNode,
+  SerovalFormDataNode,
+  SerovalHeadersNode,
   SerovalIterableNode,
   SerovalMapNode,
   SerovalNode,
@@ -48,6 +54,12 @@ import {
   SerovalPromiseNode,
   SerovalSetNode,
 } from './types';
+import {
+  createBlobNode,
+  createFileNode,
+  createURLNode,
+  createURLSearchParamsNode,
+} from './web-api';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -56,18 +68,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 +101,7 @@ async function generateNodeList(
 async function generateArrayNode(
   ctx: ParserContext,
   id: number,
-  current: AsyncServerValue[],
+  current: unknown[],
 ): Promise<SerovalArrayNode> {
   return {
     t: SerovalNodeType.Array,
@@ -101,20 +113,21 @@ async function generateArrayNode(
     d: undefined,
     a: await generateNodeList(ctx, current),
     f: undefined,
+    b: 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()) {
@@ -143,18 +156,19 @@ async function generateMapNode(
     d: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
     f: undefined,
+    b: 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()) {
@@ -179,30 +193,33 @@ async function generateSetNode(
     d: undefined,
     a: nodes,
     f: undefined,
+    b: 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;
+  let escaped: string;
   for (const key of keys) {
     item = properties[key];
+    escaped = serializeString(key);
     if (isIterable(item)) {
-      deferredKeys[deferredSize] = key;
+      deferredKeys[deferredSize] = escaped;
       deferredValues[deferredSize] = item;
       deferredSize++;
     } else {
-      keyNodes[nodesSize] = key;
+      keyNodes[nodesSize] = escaped;
       valueNodes[nodesSize] = await parse(ctx, item);
       nodesSize++;
     }
@@ -221,7 +238,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 +252,18 @@ 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),
     f: undefined,
+    b: 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) => ({
@@ -259,6 +277,7 @@ async function generatePromiseNode(
     d: undefined,
     a: undefined,
     f: await parse(ctx, value),
+    b: undefined,
   }));
 }
 
@@ -272,7 +291,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 +300,10 @@ 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,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -300,12 +320,13 @@ async function generateAggregateErrorNode(
     t: SerovalNodeType.AggregateError,
     i: id,
     s: undefined,
-    l: current.errors.length,
+    l: undefined,
     c: undefined,
-    m: current.message,
+    m: serializeString(current.message),
     d: optionsNode,
-    a: await generateNodeList(ctx, current.errors as AsyncServerValue[]),
+    a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -324,16 +345,65 @@ async function generateErrorNode(
     s: undefined,
     l: undefined,
     c: getErrorConstructorName(current),
-    m: current.message,
+    m: serializeString(current.message),
     d: optionsNode,
     a: undefined,
     f: undefined,
+    b: undefined,
+  };
+}
+
+async function generateHeadersNode(
+  ctx: ParserContext,
+  id: number,
+  current: Headers,
+): Promise<SerovalHeadersNode> {
+  assert(ctx.features & Feature.WebAPI, 'Unsupported type "Headers"');
+  const items: Record<string, string> = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: SerovalNodeType.Headers,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: await generateProperties(ctx, items),
+    a: undefined,
+    f: undefined,
+    b: undefined,
+  };
+}
+
+async function generateFormDataNode(
+  ctx: ParserContext,
+  id: number,
+  current: FormData,
+): Promise<SerovalFormDataNode> {
+  assert(ctx.features & Feature.WebAPI, 'Unsupported type "FormData"');
+  const items: Record<string, FormDataEntryValue> = {};
+  current.forEach((value, key) => {
+    items[key] = value;
+  });
+  return {
+    t: SerovalNodeType.FormData,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: await generateProperties(ctx, items),
+    a: undefined,
+    f: undefined,
+    b: undefined,
   };
 }
 
-async function parse(
+async function parse<T>(
   ctx: ParserContext,
-  current: AsyncServerValue,
+  current: T,
 ): Promise<SerovalNode> {
   switch (typeof current) {
     case 'boolean':
@@ -346,16 +416,16 @@ async 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': {
@@ -364,20 +434,25 @@ async 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 Promise:
-          return generatePromiseNode(ctx, id, current as Promise<AsyncServerValue>);
+          return generatePromiseNode(ctx, id, current as unknown as Promise<unknown>);
+        case ArrayBuffer:
+          return createArrayBufferNode(id, current as unknown as ArrayBuffer);
         case Int8Array:
         case Int16Array:
         case Int32Array:
@@ -387,41 +462,43 @@ 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 DataView:
+          return createDataViewNode(ctx, id, current as unknown as DataView);
         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:
@@ -429,7 +506,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);
+        case Blob:
+          return createBlobNode(ctx, id, current as unknown as Blob);
+        case File:
+          return createFileNode(ctx, id, current as unknown as File);
+        case Headers:
+          return generateHeadersNode(ctx, id, current as unknown as Headers);
+        case FormData:
+          return generateFormDataNode(ctx, id, current as unknown as FormData);
         default:
           break;
       }
@@ -447,26 +536,39 @@ 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