seroval 0.15.1 → 1.0.0

package/src/core/context/parser/sync.ts

@@ -1,11 +1,9 @@
-/* eslint-disable prefer-destructuring */
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../../../types';
 import UnsupportedTypeError from '../../UnsupportedTypeError';
-import assert from '../../utils/assert';
 import {
   createAggregateErrorNode,
   createArrayBufferNode,
   createArrayNode,
+  createAsyncIteratorFactoryInstanceNode,
   createBigIntNode,
   createBigIntTypedArrayNode,
   createBoxedNode,
@@ -17,16 +15,12 @@ import {
   createPluginNode,
   createRegExpNode,
   createSetNode,
+  createStreamConstructorNode,
   createStringNode,
   createTypedArrayNode,
-  createWKSymbolNode,
 } from '../../base-primitives';
-import { BIGINT_FLAG, Feature } from '../../compat';
-import type { WellKnownSymbols } from '../../constants';
-import {
-  SerovalNodeType,
-} from '../../constants';
-import { createCustomEventOptions, createEventOptions } from '../../utils/constructors';
+import { Feature } from '../../compat';
+import { SerovalNodeType } from '../../constants';
 import {
   FALSE_NODE,
   NULL_NODE,
@@ -36,7 +30,6 @@ import {
 import { iteratorToSequence } from '../../utils/iterator-to-sequence';
 import type { BaseParserContextOptions } from '../parser';
 import { BaseParserContext } from '../parser';
-import { hasReferenceID } from '../../reference';
 import { getErrorOptions } from '../../utils/error';
 import { serializeString } from '../../string';
 import type {
@@ -52,34 +45,25 @@ import type {
   SerovalSetNode,
   SerovalPluginNode,
   SerovalAggregateErrorNode,
-  SerovalCustomEventNode,
-  SerovalEventNode,
-  SerovalHeadersNode,
-  SerovalPlainRecordNode,
-  SerovalFormDataNode,
   SerovalTypedArrayNode,
   SerovalBigIntTypedArrayNode,
   SerovalDataViewNode,
+  SerovalPromiseConstructorNode,
 } from '../../types';
-import {
-  createCustomEventNode,
-  createDOMExceptionNode,
-  createEventNode,
-  createURLNode,
-  createURLSearchParamsNode,
-} from '../../web-api';
-import { UNIVERSAL_SENTINEL } from '../../special-reference';
+import { SpecialReference } from '../../special-reference';
+import type { Stream } from '../../stream';
+import { createStream, isStream } from '../../stream';
+import type {
+  BigIntTypedArrayValue,
+  TypedArrayValue,
+} from '../../utils/typed-array';
 
-type ObjectLikeNode =
-  | SerovalObjectNode
-  | SerovalNullConstructorNode;
+type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;
 
-export type BaseSyncParserContextOptions = BaseParserContextOptions
+export type BaseSyncParserContextOptions = BaseParserContextOptions;
 
 export default abstract class BaseSyncParserContext extends BaseParserContext {
-  protected parseItems(
-    current: unknown[],
-  ): SerovalNode[] {
+  protected parseItems(current: unknown[]): SerovalNode[] {
     const nodes = [];
     for (let i = 0, len = current.length; i < len; i++) {
       if (i in current) {
@@ -89,15 +73,8 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return nodes;
   }
 
-  protected parseArray(
-    id: number,
-    current: unknown[],
-  ): SerovalArrayNode {
-    return createArrayNode(
-      id,
-      current,
-      this.parseItems(current),
-    );
+  protected parseArray(id: number, current: unknown[]): SerovalArrayNode {
+    return createArrayNode(id, current, this.parseItems(current));
   }
 
   protected parseProperties(
@@ -106,40 +83,42 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     const entries = Object.entries(properties);
     const keyNodes: SerovalObjectRecordKey[] = [];
     const valueNodes: SerovalNode[] = [];
-    for (
-      let i = 0, len = entries.length;
-      i < len;
-      i++
-    ) {
+    for (let i = 0, len = entries.length; i < len; i++) {
       keyNodes.push(serializeString(entries[i][0]));
       valueNodes.push(this.parse(entries[i][1]));
     }
     // Check special properties, symbols in this case
-    if (this.features & Feature.Symbol) {
-      let symbol = Symbol.iterator;
-      if (symbol in properties) {
-        keyNodes.push(
-          this.parseWKSymbol(symbol),
-        );
-        valueNodes.push(
-          createIteratorFactoryInstanceNode(
-            this.parseIteratorFactory(),
-            this.parse(
-              iteratorToSequence(properties as unknown as Iterable<unknown>),
-            ),
+    let symbol = Symbol.iterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createIteratorFactoryInstanceNode(
+          this.parseIteratorFactory(),
+          this.parse(
+            iteratorToSequence(properties as unknown as Iterable<unknown>),
           ),
-        );
-      }
-      symbol = Symbol.toStringTag;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(createStringNode(properties[symbol] as string));
-      }
-      symbol = Symbol.isConcatSpreadable;
-      if (symbol in properties) {
-        keyNodes.push(this.parseWKSymbol(symbol));
-        valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
-      }
+        ),
+      );
+    }
+    symbol = Symbol.asyncIterator;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(
+        createAsyncIteratorFactoryInstanceNode(
+          this.parseAsyncIteratorFactory(),
+          this.parse(createStream()),
+        ),
+      );
+    }
+    symbol = Symbol.toStringTag;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(createStringNode(properties[symbol] as string));
+    }
+    symbol = Symbol.isConcatSpreadable;
+    if (symbol in properties) {
+      keyNodes.push(this.parseWellKnownSymbol(symbol));
+      valueNodes.push(properties[symbol] ? TRUE_NODE : FALSE_NODE);
     }
     return {
       k: keyNodes,
@@ -161,10 +140,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     );
   }
 
-  protected parseBoxed(
-    id: number,
-    current: object,
-  ): SerovalBoxedNode {
+  protected parseBoxed(id: number, current: object): SerovalBoxedNode {
     return createBoxedNode(id, this.parse(current.valueOf()));
   }
 
@@ -182,24 +158,16 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return createBigIntTypedArrayNode(id, current, this.parse(current.buffer));
   }
 
-  protected parseDataView(
-    id: number,
-    current: DataView,
-  ): SerovalDataViewNode {
+  protected parseDataView(id: number, current: DataView): SerovalDataViewNode {
     return createDataViewNode(id, current, this.parse(current.buffer));
   }
 
-  protected parseError(
-    id: number,
-    current: Error,
-  ): SerovalErrorNode {
+  protected parseError(id: number, current: Error): SerovalErrorNode {
     const options = getErrorOptions(current, this.features);
     return createErrorNode(
       id,
       current,
-      options
-        ? this.parseProperties(options)
-        : undefined,
+      options ? this.parseProperties(options) : undefined,
     );
   }
 
@@ -211,9 +179,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return createAggregateErrorNode(
       id,
       current,
-      options
-        ? this.parseProperties(options)
-        : undefined,
+      options ? this.parseProperties(options) : undefined,
     );
   }
 
@@ -227,18 +193,10 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
       keyNodes.push(this.parse(key));
       valueNodes.push(this.parse(value));
     }
-    return this.createMapNode(
-      id,
-      keyNodes,
-      valueNodes,
-      current.size,
-    );
+    return this.createMapNode(id, keyNodes, valueNodes, current.size);
   }
 
-  protected parseSet(
-    id: number,
-    current: Set<unknown>,
-  ): SerovalSetNode {
+  protected parseSet(id: number, current: Set<unknown>): SerovalSetNode {
     const items: SerovalNode[] = [];
     for (const item of current.keys()) {
       items.push(this.parse(item));
@@ -246,85 +204,6 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return createSetNode(id, current.size, items);
   }
 
-  protected parsePlainProperties(
-    entries: [key: string, value: unknown][],
-  ): SerovalPlainRecordNode {
-    const size = entries.length;
-    const keyNodes: string[] = [];
-    const valueNodes: SerovalNode[] = [];
-    for (let i = 0; i < size; i++) {
-      keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(this.parse(entries[i][1]));
-    }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size,
-    };
-  }
-
-  protected parseHeaders(
-    id: number,
-    current: Headers,
-  ): SerovalHeadersNode {
-    const items: [key: string, value: unknown][] = [];
-    current.forEach((value, key) => {
-      items.push([key, value]);
-    });
-    return {
-      t: SerovalNodeType.Headers,
-      i: id,
-      s: undefined,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: this.parsePlainProperties(items),
-      a: undefined,
-      f: undefined,
-      b: undefined,
-      o: undefined,
-    };
-  }
-
-  protected parseFormData(
-    id: number,
-    current: FormData,
-  ): SerovalFormDataNode {
-    const items: [key: string, value: unknown][] = [];
-    current.forEach((value, key) => {
-      items.push([key, value]);
-    });
-    return {
-      t: SerovalNodeType.FormData,
-      i: id,
-      s: undefined,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: this.parsePlainProperties(items),
-      a: undefined,
-      f: undefined,
-      b: undefined,
-      o: undefined,
-    };
-  }
-
-  protected parseEvent(
-    id: number,
-    current: Event,
-  ): SerovalEventNode {
-    return createEventNode(id, current.type, this.parse(createEventOptions(current)));
-  }
-
-  protected parseCustomEvent(
-    id: number,
-    current: CustomEvent,
-  ): SerovalCustomEventNode {
-    return createCustomEventNode(id, current.type, this.parse(createCustomEventOptions(current)));
-  }
-
   protected parsePlugin(
     id: number,
     current: unknown,
@@ -347,13 +226,45 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return undefined;
   }
 
-  protected parseObject(
+  protected parseStream(id: number, _current: Stream<unknown>): SerovalNode {
+    return createStreamConstructorNode(
+      id,
+      this.parseSpecialReference(SpecialReference.StreamConstructor),
+      [],
+    );
+  }
+
+  protected parsePromise(
     id: number,
-    current: object,
-  ): SerovalNode {
+    _current: Promise<unknown>,
+  ): SerovalPromiseConstructorNode {
+    return {
+      t: SerovalNodeType.PromiseConstructor,
+      i: id,
+      s: undefined,
+      l: undefined,
+      c: undefined,
+      m: undefined,
+      p: undefined,
+      e: undefined,
+      a: undefined,
+      f: this.parseSpecialReference(SpecialReference.PromiseConstructor),
+      b: undefined,
+      o: undefined,
+    };
+  }
+
+  protected parseObject(id: number, current: object): SerovalNode {
     if (Array.isArray(current)) {
       return this.parseArray(id, current);
     }
+    if (isStream(current)) {
+      return this.parseStream(id, current);
+    }
+    const parsed = this.parsePlugin(id, current);
+    if (parsed) {
+      return parsed;
+    }
     const currentClass = current.constructor;
     switch (currentClass) {
       case Object:
@@ -385,83 +296,49 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
       case String:
       case BigInt:
         return this.parseBoxed(id, current);
+      case ArrayBuffer:
+        return createArrayBufferNode(id, current as unknown as ArrayBuffer);
+      case Int8Array:
+      case Int16Array:
+      case Int32Array:
+      case Uint8Array:
+      case Uint16Array:
+      case Uint32Array:
+      case Uint8ClampedArray:
+      case Float32Array:
+      case Float64Array:
+        return this.parseTypedArray(id, current as unknown as TypedArrayValue);
+      case DataView:
+        return this.parseDataView(id, current as unknown as DataView);
+      case Map:
+        return this.parseMap(id, current as unknown as Map<unknown, unknown>);
+      case Set:
+        return this.parseSet(id, current as unknown as Set<unknown>);
       default:
         break;
     }
-    const currentFeatures = this.features;
-    // Typed Arrays
-    if (currentFeatures & Feature.TypedArray) {
-      switch (currentClass) {
-        case ArrayBuffer:
-          return createArrayBufferNode(id, current as unknown as ArrayBuffer);
-        case Int8Array:
-        case Int16Array:
-        case Int32Array:
-        case Uint8Array:
-        case Uint16Array:
-        case Uint32Array:
-        case Uint8ClampedArray:
-        case Float32Array:
-        case Float64Array:
-          return this.parseTypedArray(id, current as unknown as TypedArrayValue);
-        case DataView:
-          return this.parseDataView(id, current as unknown as DataView);
-        default:
-          break;
-      }
+    // Promises
+    if (currentClass === Promise || current instanceof Promise) {
+      return this.parsePromise(id, current as unknown as Promise<unknown>);
     }
+    const currentFeatures = this.features;
     // BigInt Typed Arrays
-    if ((currentFeatures & BIGINT_FLAG) === BIGINT_FLAG) {
+    if (currentFeatures & Feature.BigIntTypedArray) {
       switch (currentClass) {
         case BigInt64Array:
         case BigUint64Array:
-          return this.parseBigIntTypedArray(id, current as unknown as BigIntTypedArrayValue);
-        default:
-          break;
-      }
-    }
-    // ES Collection
-    if (currentFeatures & Feature.Map && currentClass === Map) {
-      return this.parseMap(
-        id,
-        current as unknown as Map<unknown, unknown>,
-      );
-    }
-    if (currentFeatures & Feature.Set && currentClass === Set) {
-      return this.parseSet(
-        id,
-        current as unknown as Set<unknown>,
-      );
-    }
-    // Web APIs
-    if (currentFeatures & Feature.WebAPI) {
-      switch (currentClass) {
-        case (typeof URL !== 'undefined' ? URL : UNIVERSAL_SENTINEL):
-          return createURLNode(id, current as unknown as URL);
-        case (typeof URLSearchParams !== 'undefined' ? URLSearchParams : UNIVERSAL_SENTINEL):
-          return createURLSearchParamsNode(id, current as unknown as URLSearchParams);
-        case (typeof Headers !== 'undefined' ? Headers : UNIVERSAL_SENTINEL):
-          return this.parseHeaders(id, current as unknown as Headers);
-        case (typeof FormData !== 'undefined' ? FormData : UNIVERSAL_SENTINEL):
-          return this.parseFormData(id, current as unknown as FormData);
-        case (typeof Event !== 'undefined' ? Event : UNIVERSAL_SENTINEL):
-          return this.parseEvent(id, current as unknown as Event);
-        case (typeof CustomEvent !== 'undefined' ? CustomEvent : UNIVERSAL_SENTINEL):
-          return this.parseCustomEvent(id, current as unknown as CustomEvent);
-        case (typeof DOMException !== 'undefined' ? DOMException : UNIVERSAL_SENTINEL):
-          return createDOMExceptionNode(id, current as unknown as DOMException);
+          return this.parseBigIntTypedArray(
+            id,
+            current as unknown as BigIntTypedArrayValue,
+          );
         default:
           break;
       }
     }
-    const parsed = this.parsePlugin(id, current);
-    if (parsed) {
-      return parsed;
-    }
     if (
-      (currentFeatures & Feature.AggregateError)
-      && typeof AggregateError !== 'undefined'
-      && (currentClass === AggregateError || current instanceof AggregateError)
+      currentFeatures & Feature.AggregateError &&
+      typeof AggregateError !== 'undefined' &&
+      (currentClass === AggregateError || current instanceof AggregateError)
     ) {
       return this.parseAggregateError(id, current as unknown as AggregateError);
     }
@@ -472,41 +349,37 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     }
     // Generator functions don't have a global constructor
     // despite existing
-    if (
-      currentFeatures & Feature.Symbol
-      && Symbol.iterator in current
-    ) {
+    if (Symbol.iterator in current || Symbol.asyncIterator in current) {
       return this.parsePlainObject(id, current, !!currentClass);
     }
     throw new UnsupportedTypeError(current);
   }
 
   parse<T>(current: T): SerovalNode {
-    switch (current) {
-      case true: return TRUE_NODE;
-      case false: return FALSE_NODE;
-      case undefined: return UNDEFINED_NODE;
-      case null: return NULL_NODE;
-      default: break;
-    }
     switch (typeof current) {
-      case 'string': return createStringNode(current as string);
-      case 'number': return createNumberNode(current as number);
+      case 'boolean':
+        return current ? TRUE_NODE : FALSE_NODE;
+      case 'undefined':
+        return UNDEFINED_NODE;
+      case 'string':
+        return createStringNode(current as string);
+      case 'number':
+        return createNumberNode(current as number);
       case 'bigint':
-        assert(this.features & Feature.BigInt, new UnsupportedTypeError(current));
         return createBigIntNode(current as bigint);
       case 'object': {
-        const id = this.getReference(current);
-        return typeof id === 'number' ? this.parseObject(id, current as object) : id;
-      }
-      case 'symbol': {
-        assert(this.features & Feature.Symbol, new UnsupportedTypeError(current));
-        const id = this.getReference(current);
-        return typeof id === 'number' ? createWKSymbolNode(id, current as WellKnownSymbols) : id;
+        if (current) {
+          const ref = this.getReference(current);
+          return ref.type === 0
+            ? this.parseObject(ref.value, current as object)
+            : ref.value;
+        }
+        return NULL_NODE;
       }
+      case 'symbol':
+        return this.parseWellKnownSymbol(current);
       case 'function':
-        assert(hasReferenceID(current), new Error('Cannot serialize function without reference ID.'));
-        return this.getStrictReference(current);
+        return this.parseFunction(current as (...args: unknown[]) => unknown);
       default:
         throw new UnsupportedTypeError(current);
     }