seroval 1.2.1 → 1.3.1

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,56 +281,9 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
     return result;
   }
 
-  protected handleAbortSignal(id: number, current: AbortSignal): void {
-    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();
-  }
-
-  protected parseAbortSignal(
-    id: number,
-    current: AbortSignal,
-  ): SerovalAbortSignalConstructorNode | SerovalAbortSignalSyncNode {
-    if (current.aborted) {
-      return this.parseAbortSignalSync(id, current);
-    }
-
-    this.pushPendingState();
-
-    current.addEventListener(
-      'abort',
-      this.handleAbortSignal.bind(this, id, current),
-      { 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;

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

@@ -19,7 +19,7 @@ import {
   createTypedArrayNode,
 } from '../../base-primitives';
 import { Feature } from '../../compat';
-import { NIL, SerovalNodeType } from '../../constants';
+import { NIL } from '../../constants';
 import { SerovalParserError, SerovalUnsupportedTypeError } from '../../errors';
 import {
   FALSE_NODE,
@@ -27,15 +27,12 @@ import {
   TRUE_NODE,
   UNDEFINED_NODE,
 } from '../../literals';
-import { createSerovalNode } from '../../node';
 import { OpaqueReference } from '../../opaque-reference';
 import { SpecialReference } from '../../special-reference';
 import type { Stream } from '../../stream';
 import { createStream, isStream } from '../../stream';
 import { serializeString } from '../../string';
 import type {
-  SerovalAbortSignalConstructorNode,
-  SerovalAbortSignalSyncNode,
   SerovalAggregateErrorNode,
   SerovalArrayNode,
   SerovalBigIntTypedArrayNode,
@@ -71,7 +68,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     const nodes = [];
     for (let i = 0, len = current.length; i < len; i++) {
       if (i in current) {
-        nodes[i] = this.parse(current[i]);
+        nodes[i] = this.parseTop(current[i]);
       }
     }
     return nodes;
@@ -89,7 +86,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     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;
@@ -98,7 +95,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
       valueNodes.push(
         createIteratorFactoryInstanceNode(
           this.parseIteratorFactory(),
-          this.parse(
+          this.parseTop(
             iteratorToSequence(properties as unknown as Iterable<unknown>),
           ),
         ),
@@ -110,7 +107,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
       valueNodes.push(
         createAsyncIteratorFactoryInstanceNode(
           this.parseAsyncIteratorFactory(),
-          this.parse(createStream()),
+          this.parseTop(createStream()),
         ),
       );
     }
@@ -145,25 +142,29 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
   }
 
   protected parseBoxed(id: number, current: object): SerovalBoxedNode {
-    return createBoxedNode(id, this.parse(current.valueOf()));
+    return createBoxedNode(id, this.parseTop(current.valueOf()));
   }
 
   protected parseTypedArray(
     id: number,
     current: TypedArrayValue,
   ): SerovalTypedArrayNode {
-    return createTypedArrayNode(id, current, this.parse(current.buffer));
+    return createTypedArrayNode(id, current, this.parseTop(current.buffer));
   }
 
   protected parseBigIntTypedArray(
     id: number,
     current: BigIntTypedArrayValue,
   ): SerovalBigIntTypedArrayNode {
-    return createBigIntTypedArrayNode(id, current, this.parse(current.buffer));
+    return createBigIntTypedArrayNode(
+      id,
+      current,
+      this.parseTop(current.buffer),
+    );
   }
 
   protected parseDataView(id: number, current: DataView): SerovalDataViewNode {
-    return createDataViewNode(id, current, this.parse(current.buffer));
+    return createDataViewNode(id, current, this.parseTop(current.buffer));
   }
 
   protected parseError(id: number, current: Error): SerovalErrorNode {
@@ -194,8 +195,8 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     const keyNodes: SerovalNode[] = [];
     const valueNodes: SerovalNode[] = [];
     for (const [key, value] of current.entries()) {
-      keyNodes.push(this.parse(key));
-      valueNodes.push(this.parse(value));
+      keyNodes.push(this.parseTop(key));
+      valueNodes.push(this.parseTop(value));
     }
     return this.createMapNode(id, keyNodes, valueNodes, current.size);
   }
@@ -203,7 +204,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
   protected parseSet(id: number, current: Set<unknown>): SerovalSetNode {
     const items: SerovalNode[] = [];
     for (const item of current.keys()) {
-      items.push(this.parse(item));
+      items.push(this.parseTop(item));
     }
     return createSetNode(id, current.size, items);
   }
@@ -242,37 +243,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     id: number,
     _current: Promise<unknown>,
   ): SerovalPromiseConstructorNode {
-    return this.createPromiseConstructorNode(id);
-  }
-
-  protected parseAbortSignalSync(
-    id: number,
-    current: AbortSignal,
-  ): SerovalAbortSignalSyncNode {
-    return createSerovalNode(
-      SerovalNodeType.AbortSignalSync,
-      id,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      this.parse(current.reason),
-      NIL,
-      NIL,
-    );
-  }
-
-  protected parseAbortSignal(
-    id: number,
-    current: AbortSignal,
-  ): SerovalAbortSignalConstructorNode | SerovalAbortSignalSyncNode {
-    if (current.aborted) {
-      return this.parseAbortSignalSync(id, current);
-    }
-    return this.createAbortSignalConstructorNode(id);
+    return this.createPromiseConstructorNode(id, this.createIndex({}));
   }
 
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ehh
@@ -285,7 +256,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     }
     const currentClass = current.constructor;
     if (currentClass === OpaqueReference) {
-      return this.parse(
+      return this.parseTop(
         (current as OpaqueReference<unknown, unknown>).replacement,
       );
     }
@@ -349,13 +320,6 @@ export default abstract class BaseSyncParserContext 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) {
@@ -401,38 +365,44 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     throw new SerovalUnsupportedTypeError(current);
   }
 
-  parse<T>(current: T): 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 === ParserNodeType.Fresh
-              ? this.parseObject(ref.value, current as object)
-              : ref.value;
-          }
-          return NULL_NODE;
+  parseTop<T>(current: T): 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 === ParserNodeType.Fresh
+            ? this.parseObject(ref.value, current as object)
+            : ref.value;
         }
-        case 'symbol':
-          return this.parseWellKnownSymbol(current);
-        case 'function': {
-          return this.parseFunction(current);
-        }
-        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);
+    }
+  }
+
+  parse<T>(current: T): SerovalNode {
+    try {
+      return this.parseTop(current);
     } catch (error) {
-      throw new SerovalParserError(error);
+      throw error instanceof SerovalParserError
+        ? error
+        : new SerovalParserError(error);
     }
   }
 }

package/src/core/context/parser.ts

@@ -17,7 +17,6 @@ import {
   SpecialReference,
 } from '../special-reference';
 import type {
-  SerovalAbortSignalConstructorNode,
   SerovalAsyncIteratorFactoryNode,
   SerovalIndexedValueNode,
   SerovalIteratorFactoryNode,
@@ -87,6 +86,12 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     return this.marked.has(id);
   }
 
+  protected createIndex<T>(current: T): number {
+    const id = this.refs.size;
+    this.refs.set(current, id);
+    return id;
+  }
+
   protected getIndexedValue<T>(current: T): FreshNode | IndexedNode {
     const registeredId = this.refs.get(current);
     if (registeredId != null) {
@@ -96,11 +101,9 @@ export abstract class BaseParserContext implements PluginAccessOptions {
         value: createIndexedValueNode(registeredId),
       };
     }
-    const id = this.refs.size;
-    this.refs.set(current, id);
     return {
       type: ParserNodeType.Fresh,
-      value: id,
+      value: this.createIndex(current),
     };
   }
 
@@ -247,11 +250,12 @@ export abstract class BaseParserContext implements PluginAccessOptions {
 
   protected createPromiseConstructorNode(
     id: number,
+    resolver: number,
   ): SerovalPromiseConstructorNode {
     return createSerovalNode(
       SerovalNodeType.PromiseConstructor,
       id,
-      NIL,
+      resolver,
       NIL,
       NIL,
       NIL,
@@ -263,23 +267,4 @@ export abstract class BaseParserContext implements PluginAccessOptions {
       NIL,
     );
   }
-
-  protected createAbortSignalConstructorNode(
-    id: number,
-  ): SerovalAbortSignalConstructorNode {
-    return createSerovalNode(
-      SerovalNodeType.AbortSignalConstructor,
-      id,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      NIL,
-      this.parseSpecialReference(SpecialReference.AbortSignalConstructor),
-      NIL,
-      NIL,
-    );
-  }
 }