seroval 0.15.0 → 1.0.0

package/src/core/context/parser.ts

@@ -1,16 +1,12 @@
-import UnsupportedTypeError from '../UnsupportedTypeError';
 import assert from '../utils/assert';
 import {
   createIndexedValueNode,
   createReferenceNode,
   createWKSymbolNode,
 } from '../base-primitives';
-import { ALL_ENABLED, Feature } from '../compat';
+import { ALL_ENABLED } from '../compat';
 import type { WellKnownSymbols } from '../constants';
-import {
-  INV_SYMBOL_REF,
-  SerovalNodeType,
-} from '../constants';
+import { INV_SYMBOL_REF, SerovalNodeType } from '../constants';
 import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
 import { hasReferenceID } from '../reference';
 import {
@@ -39,6 +35,23 @@ export interface BaseParserContextOptions extends PluginAccessOptions {
   refs?: Map<unknown, number>;
 }
 
+interface FreshNode {
+  type: 0;
+  value: number;
+}
+
+interface IndexedNode {
+  type: 1;
+  value: SerovalIndexedValueNode;
+}
+
+interface ReferencedNode {
+  type: 2;
+  value: SerovalReferenceNode;
+}
+
+type ObjectNode = FreshNode | IndexedNode | ReferencedNode;
+
 export abstract class BaseParserContext implements PluginAccessOptions {
   abstract readonly mode: SerovalMode;
 
@@ -64,70 +77,83 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     return this.marked.has(id);
   }
 
-  protected getReference<T>(current: T): number | SerovalIndexedValueNode | SerovalReferenceNode {
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+  protected getIndexedValue<T>(current: T): FreshNode | IndexedNode {
+    const registeredId = this.refs.get(current);
+    if (registeredId != null) {
+      this.markRef(registeredId);
+      return {
+        type: 1,
+        value: createIndexedValueNode(registeredId),
+      };
     }
     const id = this.refs.size;
     this.refs.set(current, id);
+    return {
+      type: 0,
+      value: id,
+    };
+  }
+
+  protected getReference<T>(current: T): ObjectNode {
+    const indexed = this.getIndexedValue(current);
+    if (indexed.type === 1) {
+      return indexed;
+    }
     if (hasReferenceID(current)) {
-      return createReferenceNode(id, current);
+      return {
+        type: 2,
+        value: createReferenceNode(indexed.value, current),
+      };
     }
-    return id;
+    return indexed;
   }
 
-  protected getStrictReference<T>(current: T): SerovalIndexedValueNode | SerovalReferenceNode {
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+  protected getStrictReference<T>(
+    current: T,
+  ): SerovalIndexedValueNode | SerovalReferenceNode {
+    assert(
+      hasReferenceID(current),
+      new Error(
+        'Cannot serialize ' + typeof current + ' without reference ID.',
+      ),
+    );
+    const result = this.getIndexedValue(current);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    return createReferenceNode(id, current);
+    return createReferenceNode(result.value, current);
   }
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  protected parseFunction(current: Function): SerovalNode {
-    assert(hasReferenceID(current), new Error('Cannot serialize function without reference ID.'));
+  protected parseFunction(
+    current: (...args: unknown[]) => unknown,
+  ): SerovalNode {
     return this.getStrictReference(current);
   }
 
-  protected parseWKSymbol(
+  protected parseWellKnownSymbol(
     current: symbol,
   ): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode {
-    assert(this.features & Feature.Symbol, new UnsupportedTypeError(current));
-    const registeredID = this.refs.get(current);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
-    }
-    const isValid = current in INV_SYMBOL_REF;
-    assert(current in INV_SYMBOL_REF || hasReferenceID(current), new Error('Cannot serialize symbol without reference ID.'));
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    if (isValid) {
-      return createWKSymbolNode(id, current as WellKnownSymbols);
+    const ref = this.getReference(current);
+    if (ref.type !== 0) {
+      return ref.value;
     }
-    return createReferenceNode(id, current);
+    assert(
+      current in INV_SYMBOL_REF,
+      new Error('Cannot serialized unsupported symbol.'),
+    );
+    return createWKSymbolNode(ref.value, current as WellKnownSymbols);
   }
 
   protected parseSpecialReference(
     ref: SpecialReference,
   ): SerovalIndexedValueNode | SerovalSpecialReferenceNode {
-    const specialRef = SPECIAL_REFS[ref];
-    const registeredID = this.refs.get(specialRef);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+    const result = this.getIndexedValue(SPECIAL_REFS[ref]);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(specialRef, id);
     return {
       t: SerovalNodeType.SpecialReference,
-      i: id,
+      i: result.value,
       s: ref,
       l: undefined,
       c: undefined,
@@ -141,17 +167,16 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     };
   }
 
-  protected parseIteratorFactory(): SerovalIndexedValueNode | SerovalIteratorFactoryNode {
-    const registeredID = this.refs.get(ITERATOR);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+  protected parseIteratorFactory():
+    | SerovalIndexedValueNode
+    | SerovalIteratorFactoryNode {
+    const result = this.getIndexedValue(ITERATOR);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(ITERATOR, id);
     return {
       t: SerovalNodeType.IteratorFactory,
-      i: id,
+      i: result.value,
       s: undefined,
       l: undefined,
       c: undefined,
@@ -159,33 +184,33 @@ export abstract class BaseParserContext implements PluginAccessOptions {
       p: undefined,
       e: undefined,
       a: undefined,
-      f: this.parseWKSymbol(Symbol.iterator),
+      f: this.parseWellKnownSymbol(Symbol.iterator),
       b: undefined,
       o: undefined,
     };
   }
 
-  protected parseAsyncIteratorFactory(
-    streaming: 0 | 1,
-  ): SerovalIndexedValueNode | SerovalAsyncIteratorFactoryNode {
-    const registeredID = this.refs.get(ASYNC_ITERATOR);
-    if (registeredID != null) {
-      this.markRef(registeredID);
-      return createIndexedValueNode(registeredID);
+  protected parseAsyncIteratorFactory():
+    | SerovalIndexedValueNode
+    | SerovalAsyncIteratorFactoryNode {
+    const result = this.getIndexedValue(ASYNC_ITERATOR);
+    if (result.type === 1) {
+      return result.value;
     }
-    const id = this.refs.size;
-    this.refs.set(ASYNC_ITERATOR, id);
     return {
       t: SerovalNodeType.AsyncIteratorFactory,
-      i: id,
-      s: streaming,
+      i: result.value,
+      s: undefined,
       l: undefined,
       c: undefined,
       m: undefined,
       p: undefined,
       e: undefined,
-      a: undefined,
-      f: this.parseWKSymbol(Symbol.asyncIterator),
+      a: [
+        this.parseSpecialReference(SpecialReference.PromiseConstructor),
+        this.parseWellKnownSymbol(Symbol.asyncIterator),
+      ],
+      f: undefined,
       b: undefined,
       o: undefined,
     };