seroval 1.2.0 → 1.3.0

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

@@ -1,4 +1,3 @@
-import { abortSignalToPromise } from '../../abort-signal';
 import {
   createAggregateErrorNode,
   createArrayBufferNode,
@@ -38,7 +37,6 @@ import type { Stream } from '../../stream';
 import { createStreamFromAsyncIterable, isStream } from '../../stream';
 import { serializeString } from '../../string';
 import type {
-  SerovalAbortSignalSyncNode,
   SerovalAggregateErrorNode,
   SerovalArrayNode,
   SerovalBigIntTypedArrayNode,
@@ -64,7 +62,7 @@ import type {
   BigIntTypedArrayValue,
   TypedArrayValue,
 } from '../../utils/typed-array';
-import { BaseParserContext } from '../parser';
+import { BaseParserContext, ParserNodeType } from '../parser';
 
 type ObjectLikeNode =
   | SerovalObjectNode
@@ -77,7 +75,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     for (let i = 0, len = current.length; i < len; i++) {
       // For consistency in holes
       if (i in current) {
-        nodes[i] = await this.parse(current[i]);
+        nodes[i] = await this.parseTop(current[i]);
       }
     }
     return nodes;
@@ -98,7 +96,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     const valueNodes: SerovalNode[] = [];
     for (let i = 0, len = entries.length; i < len; i++) {
       keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(await this.parse(entries[i][1]));
+      valueNodes.push(await this.parseTop(entries[i][1]));
     }
     // Check special properties
     let symbol = Symbol.iterator;
@@ -107,7 +105,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
       valueNodes.push(
         createIteratorFactoryInstanceNode(
           this.parseIteratorFactory(),
-          await this.parse(
+          await this.parseTop(
             iteratorToSequence(properties as unknown as Iterable<unknown>),
           ),
         ),
@@ -119,7 +117,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
       valueNodes.push(
         createAsyncIteratorFactoryInstanceNode(
           this.parseAsyncIteratorFactory(),
-          await this.parse(
+          await this.parseTop(
             createStreamFromAsyncIterable(
               properties as unknown as AsyncIterable<unknown>,
             ),
@@ -161,14 +159,18 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     id: number,
     current: object,
   ): Promise<SerovalBoxedNode> {
-    return createBoxedNode(id, await this.parse(current.valueOf()));
+    return createBoxedNode(id, await this.parseTop(current.valueOf()));
   }
 
   private async parseTypedArray(
     id: number,
     current: TypedArrayValue,
   ): Promise<SerovalTypedArrayNode> {
-    return createTypedArrayNode(id, current, await this.parse(current.buffer));
+    return createTypedArrayNode(
+      id,
+      current,
+      await this.parseTop(current.buffer),
+    );
   }
 
   private async parseBigIntTypedArray(
@@ -178,7 +180,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     return createBigIntTypedArrayNode(
       id,
       current,
-      await this.parse(current.buffer),
+      await this.parseTop(current.buffer),
     );
   }
 
@@ -186,7 +188,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     id: number,
     current: DataView,
   ): Promise<SerovalDataViewNode> {
-    return createDataViewNode(id, current, await this.parse(current.buffer));
+    return createDataViewNode(id, current, await this.parseTop(current.buffer));
   }
 
   private async parseError(
@@ -220,8 +222,8 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     const keyNodes: SerovalNode[] = [];
     const valueNodes: SerovalNode[] = [];
     for (const [key, value] of current.entries()) {
-      keyNodes.push(await this.parse(key));
-      valueNodes.push(await this.parse(value));
+      keyNodes.push(await this.parseTop(key));
+      valueNodes.push(await this.parseTop(value));
     }
     return this.createMapNode(id, keyNodes, valueNodes, current.size);
   }
@@ -232,7 +234,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
   ): Promise<SerovalSetNode> {
     const items: SerovalNode[] = [];
     for (const item of current.keys()) {
-      items.push(await this.parse(item));
+      items.push(await this.parseTop(item));
     }
     return createSetNode(id, current.size, items);
   }
@@ -253,7 +255,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
       NIL,
       NIL,
       NIL,
-      await this.parse(result),
+      await this.parseTop(result),
       NIL,
       NIL,
     );
@@ -293,7 +295,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
         const cleanup = current.on({
           next: value => {
             this.markRef(id);
-            this.parse(value).then(
+            this.parseTop(value).then(
               data => {
                 sequence.push(createStreamNextNode(id, data));
               },
@@ -305,7 +307,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
           },
           throw: value => {
             this.markRef(id);
-            this.parse(value).then(
+            this.parseTop(value).then(
               data => {
                 sequence.push(createStreamThrowNode(id, data));
                 resolve(sequence);
@@ -319,7 +321,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
           },
           return: value => {
             this.markRef(id);
-            this.parse(value).then(
+            this.parseTop(value).then(
               data => {
                 sequence.push(createStreamReturnNode(id, data));
                 resolve(sequence);
@@ -336,36 +338,6 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     );
   }
 
-  private async parseAbortSignalSync(
-    id: number,
-    current: AbortSignal,
-  ): Promise<SerovalAbortSignalSyncNode> {
-    return createSerovalNode(
-      SerovalNodeType.AbortSignalSync,
-      id,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      await this.parse(current.reason),
-      NIL,
-      NIL,
-    );
-  }
-
-  private async parseAbortSignal(
-    id: number,
-    current: AbortSignal,
-  ): Promise<SerovalAbortSignalSyncNode> {
-    if (!current.aborted) {
-      await abortSignalToPromise(current);
-    }
-    return this.parseAbortSignalSync(id, current);
-  }
-
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ehh
   private async parseObject(id: number, current: object): Promise<SerovalNode> {
     if (Array.isArray(current)) {
@@ -376,7 +348,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     }
     const currentClass = current.constructor;
     if (currentClass === OpaqueReference) {
-      return this.parse(
+      return this.parseTop(
         (current as OpaqueReference<unknown, unknown>).replacement,
       );
     }
@@ -440,13 +412,6 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
       return this.parsePromise(id, current as unknown as Promise<unknown>);
     }
     const currentFeatures = this.features;
-    if (
-      currentFeatures & Feature.AbortSignal &&
-      typeof AbortSignal !== 'undefined' &&
-      currentClass === AbortSignal
-    ) {
-      return this.parseAbortSignal(id, current as unknown as AbortSignal);
-    }
     // BigInt Typed Arrays
     if (currentFeatures & Feature.BigIntTypedArray) {
       switch (currentClass) {
@@ -480,37 +445,55 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     throw new SerovalUnsupportedTypeError(current);
   }
 
-  async parse<T>(current: T): Promise<SerovalNode> {
-    try {
-      switch (typeof current) {
-        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':
-          return createBigIntNode(current as bigint);
-        case 'object': {
-          if (current) {
-            const ref = this.getReference(current);
-            return ref.type === 0
-              ? await this.parseObject(ref.value, current as object)
-              : ref.value;
-          }
-          return NULL_NODE;
+  protected async parseFunction(current: unknown): Promise<SerovalNode> {
+    const ref = this.getReference(current);
+    if (ref.type !== ParserNodeType.Fresh) {
+      return ref.value;
+    }
+    const plugin = await this.parsePlugin(ref.value, current);
+    if (plugin) {
+      return plugin;
+    }
+    throw new SerovalUnsupportedTypeError(current);
+  }
+
+  async parseTop<T>(current: T): Promise<SerovalNode> {
+    switch (typeof current) {
+      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':
+        return createBigIntNode(current as bigint);
+      case 'object': {
+        if (current) {
+          const ref = this.getReference(current);
+          return ref.type === 0
+            ? await this.parseObject(ref.value, current as object)
+            : ref.value;
         }
-        case 'symbol':
-          return this.parseWellKnownSymbol(current);
-        case 'function':
-          return this.parseFunction(current as (...args: unknown[]) => unknown);
-        default:
-          throw new SerovalUnsupportedTypeError(current);
+        return NULL_NODE;
       }
+      case 'symbol':
+        return this.parseWellKnownSymbol(current);
+      case 'function':
+        return this.parseFunction(current);
+      default:
+        throw new SerovalUnsupportedTypeError(current);
+    }
+  }
+
+  async parse<T>(current: T): Promise<SerovalNode> {
+    try {
+      return await this.parseTop(current);
     } catch (error) {
-      throw new SerovalParserError(error);
+      throw error instanceof SerovalParserError
+        ? error
+        : new SerovalParserError(error);
     }
   }
 }

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

@@ -16,8 +16,6 @@ import type { Stream } from '../../stream';
 import { createStreamFromAsyncIterable } from '../../stream';
 import { serializeString } from '../../string';
 import type {
-  SerovalAbortSignalConstructorNode,
-  SerovalAbortSignalSyncNode,
   SerovalNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
@@ -73,7 +71,7 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     }
   }
 
-  private onParse(node: SerovalNode): void {
+  onParse(node: SerovalNode): void {
     if (this.initial) {
       this.buffer.push(node);
     } else {
@@ -81,7 +79,7 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     }
   }
 
-  private onError(error: unknown): void {
+  onError(error: unknown): void {
     if (this.onErrorCallback) {
       this.onErrorCallback(error);
     } else {
@@ -95,11 +93,11 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     }
   }
 
-  private pushPendingState(): void {
+  pushPendingState(): void {
     this.pending++;
   }
 
-  private popPendingState(): void {
+  popPendingState(): void {
     if (--this.pending <= 0) {
       this.onDone();
     }
@@ -113,7 +111,7 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     const valueNodes: SerovalNode[] = [];
     for (let i = 0, len = entries.length; i < len; i++) {
       keyNodes.push(serializeString(entries[i][0]));
-      valueNodes.push(this.parse(entries[i][1]));
+      valueNodes.push(this.parseTop(entries[i][1]));
     }
     // Check special properties, symbols in this case
     let symbol = Symbol.iterator;
@@ -122,7 +120,7 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
       valueNodes.push(
         createIteratorFactoryInstanceNode(
           this.parseIteratorFactory(),
-          this.parse(
+          this.parseTop(
             iteratorToSequence(properties as unknown as Iterable<unknown>),
           ),
         ),
@@ -134,7 +132,7 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
       valueNodes.push(
         createAsyncIteratorFactoryInstanceNode(
           this.parseAsyncIteratorFactory(),
-          this.parse(
+          this.parseTop(
             createStreamFromAsyncIterable(
               properties as unknown as AsyncIterable<unknown>,
             ),
@@ -159,66 +157,68 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     };
   }
 
+  protected handlePromiseSuccess(id: number, data: unknown): void {
+    const parsed = this.parseWithError(data);
+    if (parsed) {
+      this.onParse(
+        createSerovalNode(
+          SerovalNodeType.PromiseSuccess,
+          id,
+          NIL,
+          NIL,
+          NIL,
+          NIL,
+          NIL,
+          NIL,
+          [this.parseSpecialReference(SpecialReference.PromiseSuccess), parsed],
+          NIL,
+          NIL,
+          NIL,
+        ),
+      );
+    }
+    this.popPendingState();
+  }
+
+  protected handlePromiseFailure(id: number, data: unknown): void {
+    if (this.alive) {
+      const parsed = this.parseWithError(data);
+      if (parsed) {
+        this.onParse(
+          createSerovalNode(
+            SerovalNodeType.PromiseFailure,
+            id,
+            NIL,
+            NIL,
+            NIL,
+            NIL,
+            NIL,
+            NIL,
+            [
+              this.parseSpecialReference(SpecialReference.PromiseFailure),
+              parsed,
+            ],
+            NIL,
+            NIL,
+            NIL,
+          ),
+        );
+      }
+    }
+    this.popPendingState();
+  }
+
   protected parsePromise(
     id: number,
     current: Promise<unknown>,
   ): SerovalPromiseConstructorNode {
+    const resolver = this.createIndex({});
     current.then(
-      data => {
-        const parsed = this.parseWithError(data);
-        if (parsed) {
-          this.onParse(
-            createSerovalNode(
-              SerovalNodeType.PromiseResolve,
-              id,
-              NIL,
-              NIL,
-              NIL,
-              NIL,
-              NIL,
-              NIL,
-              [
-                this.parseSpecialReference(SpecialReference.PromiseResolve),
-                parsed,
-              ],
-              NIL,
-              NIL,
-              NIL,
-            ),
-          );
-        }
-        this.popPendingState();
-      },
-      data => {
-        if (this.alive) {
-          const parsed = this.parseWithError(data);
-          if (parsed) {
-            this.onParse(
-              createSerovalNode(
-                SerovalNodeType.PromiseReject,
-                id,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                [
-                  this.parseSpecialReference(SpecialReference.PromiseReject),
-                  parsed,
-                ],
-                NIL,
-                NIL,
-                NIL,
-              ),
-            );
-          }
-        }
-        this.popPendingState();
-      },
+      this.handlePromiseSuccess.bind(this, resolver),
+      this.handlePromiseFailure.bind(this, resolver),
     );
     this.pushPendingState();
-    return this.createPromiseConstructorNode(id);
+    return this.createPromiseConstructorNode(id, resolver);
   }
 
   protected parsePlugin(
@@ -281,54 +281,9 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     return result;
   }
 
-  protected parseAbortSignal(
-    id: number,
-    current: AbortSignal,
-  ): SerovalAbortSignalConstructorNode | SerovalAbortSignalSyncNode {
-    if (current.aborted) {
-      return this.parseAbortSignalSync(id, current);
-    }
-
-    this.pushPendingState();
-
-    current.addEventListener(
-      'abort',
-      () => {
-        if (this.alive) {
-          const parsed = this.parseWithError(current.reason);
-          if (parsed) {
-            this.onParse(
-              createSerovalNode(
-                SerovalNodeType.AbortSignalAbort,
-                id,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                NIL,
-                [
-                  this.parseSpecialReference(SpecialReference.AbortSignalAbort),
-                  parsed,
-                ],
-                NIL,
-                NIL,
-                NIL,
-              ),
-            );
-          }
-        }
-        this.popPendingState();
-      },
-      { once: true },
-    );
-
-    return this.createAbortSignalConstructorNode(id);
-  }
-
-  private parseWithError<T>(current: T): SerovalNode | undefined {
+  parseWithError<T>(current: T): SerovalNode | undefined {
     try {
-      return this.parse(current);
+      return this.parseTop(current);
     } catch (err) {
       this.onError(err);
       return NIL;