seroval 1.1.1 → 1.2.0

package/src/core/compat.ts

@@ -10,6 +10,7 @@ export const enum Feature {
   ErrorPrototypeStack = 0x04,
   ObjectAssign = 0x08,
   BigIntTypedArray = 0x10,
+  AbortSignal = 0x20,
 }
 
-export const ALL_ENABLED = 0x1f;
+export const ALL_ENABLED = 0x2f;

package/src/core/constants.ts

@@ -45,6 +45,9 @@ export const enum SerovalNodeType {
   StreamNext = 32,
   StreamThrow = 33,
   StreamReturn = 34,
+  AbortSignalConstructor = 35,
+  AbortSignalAbort = 36,
+  AbortSignalSync = 37,
 }
 
 export const enum SerovalObjectFlags {
@@ -181,3 +184,5 @@ export const ERROR_CONSTRUCTOR: Record<ErrorConstructorTag, ErrorConstructors> =
     [ErrorConstructorTag.TypeError]: TypeError,
     [ErrorConstructorTag.URIError]: URIError,
   };
+
+export const NIL = undefined;

package/src/core/context/deserializer.ts

@@ -17,6 +17,9 @@ import type { Stream } from '../stream';
 import { createStream, streamToAsyncIterable } from '../stream';
 import { deserializeString } from '../string';
 import type {
+  SerovalAbortSignalAbortNode,
+  SerovalAbortSignalConstructorNode,
+  SerovalAbortSignalSyncNode,
   SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
   SerovalArrayNode,
@@ -198,7 +201,7 @@ export default abstract class BaseDeserializerContext
   private deserializeTypedArray(
     node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
   ): TypedArrayValue | BigIntTypedArrayValue {
-    const construct = getTypedArrayConstructor(node.c);
+    const construct = getTypedArrayConstructor(node.c) as Int8ArrayConstructor;
     const source = this.deserialize(node.f) as ArrayBuffer;
     const result = this.assignIndexedValue(
       node.i,
@@ -369,6 +372,30 @@ export default abstract class BaseDeserializerContext
     return undefined;
   }
 
+  private deserializeAbortSignalConstructor(
+    node: SerovalAbortSignalConstructorNode,
+  ): unknown {
+    return this.assignIndexedValue(node.i, new AbortController()).signal;
+  }
+
+  private deserializeAbortSignalAbort(
+    node: SerovalAbortSignalAbortNode,
+  ): unknown {
+    const controller = this.refs.get(node.i) as AbortController | undefined;
+    assert(controller, new SerovalMissingInstanceError('AbortSignal'));
+    controller.abort(this.deserialize(node.a[1]));
+    return undefined;
+  }
+
+  private deserializeAbortSignalSync(
+    node: SerovalAbortSignalSyncNode,
+  ): unknown {
+    return this.assignIndexedValue(
+      node.i,
+      AbortSignal.abort(this.deserialize(node.f)),
+    );
+  }
+
   deserialize(node: SerovalNode): unknown {
     try {
       switch (node.t) {
@@ -438,6 +465,12 @@ export default abstract class BaseDeserializerContext
           return this.deserializeIteratorFactory(node);
         case SerovalNodeType.AsyncIteratorFactory:
           return this.deserializeAsyncIteratorFactory(node);
+        case SerovalNodeType.AbortSignalAbort:
+          return this.deserializeAbortSignalAbort(node);
+        case SerovalNodeType.AbortSignalConstructor:
+          return this.deserializeAbortSignalConstructor(node);
+        case SerovalNodeType.AbortSignalSync:
+          return this.deserializeAbortSignalSync(node);
         // case SerovalNodeType.SpecialReference:
         default:
           throw new SerovalUnsupportedNodeError(node);

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

@@ -1,3 +1,4 @@
+import { abortSignalToPromise } from '../../abort-signal';
 import {
   createAggregateErrorNode,
   createArrayBufferNode,
@@ -22,7 +23,7 @@ import {
   createTypedArrayNode,
 } from '../../base-primitives';
 import { Feature } from '../../compat';
-import { SerovalNodeType } from '../../constants';
+import { NIL, SerovalNodeType } from '../../constants';
 import { SerovalParserError, SerovalUnsupportedTypeError } from '../../errors';
 import {
   FALSE_NODE,
@@ -30,12 +31,14 @@ 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 { createStreamFromAsyncIterable, isStream } from '../../stream';
 import { serializeString } from '../../string';
 import type {
+  SerovalAbortSignalSyncNode,
   SerovalAggregateErrorNode,
   SerovalArrayNode,
   SerovalBigIntTypedArrayNode,
@@ -194,7 +197,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     return createErrorNode(
       id,
       current,
-      options ? await this.parseProperties(options) : undefined,
+      options ? await this.parseProperties(options) : NIL,
     );
   }
 
@@ -206,7 +209,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     return createAggregateErrorNode(
       id,
       current,
-      options ? await this.parseProperties(options) : undefined,
+      options ? await this.parseProperties(options) : NIL,
     );
   }
 
@@ -239,20 +242,21 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     current: Promise<unknown>,
   ): Promise<SerovalPromiseNode> {
     const [status, result] = await promiseToResult(current);
-    return {
-      t: SerovalNodeType.Promise,
-      i: id,
-      s: status,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: undefined,
-      a: undefined,
-      f: await this.parse(result),
-      b: undefined,
-      o: undefined,
-    };
+
+    return createSerovalNode(
+      SerovalNodeType.Promise,
+      id,
+      status,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      await this.parse(result),
+      NIL,
+      NIL,
+    );
   }
 
   private async parsePlugin(
@@ -274,7 +278,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
         }
       }
     }
-    return undefined;
+    return NIL;
   }
 
   private async parseStream(
@@ -332,7 +336,37 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
     );
   }
 
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+  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)) {
       return this.parseArray(id, current);
@@ -357,7 +391,7 @@ export default abstract class BaseAsyncParserContext extends BaseParserContext {
           current as Record<string, unknown>,
           false,
         );
-      case undefined:
+      case NIL:
         return this.parsePlainObject(
           id,
           current as Record<string, unknown>,
@@ -406,6 +440,13 @@ 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) {

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

@@ -8,13 +8,16 @@ import {
   createStreamThrowNode,
   createStringNode,
 } from '../../base-primitives';
-import { SerovalNodeType } from '../../constants';
+import { NIL, SerovalNodeType } from '../../constants';
 import { FALSE_NODE, TRUE_NODE } from '../../literals';
+import { createSerovalNode } from '../../node';
 import { SpecialReference } from '../../special-reference';
 import type { Stream } from '../../stream';
 import { createStreamFromAsyncIterable } from '../../stream';
 import { serializeString } from '../../string';
 import type {
+  SerovalAbortSignalConstructorNode,
+  SerovalAbortSignalSyncNode,
   SerovalNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
@@ -164,23 +167,25 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
       data => {
         const parsed = this.parseWithError(data);
         if (parsed) {
-          this.onParse({
-            t: SerovalNodeType.PromiseResolve,
-            i: id,
-            s: undefined,
-            l: undefined,
-            c: undefined,
-            m: undefined,
-            p: undefined,
-            e: undefined,
-            a: [
-              this.parseSpecialReference(SpecialReference.PromiseResolve),
-              parsed,
-            ],
-            f: undefined,
-            b: undefined,
-            o: undefined,
-          });
+          this.onParse(
+            createSerovalNode(
+              SerovalNodeType.PromiseResolve,
+              id,
+              NIL,
+              NIL,
+              NIL,
+              NIL,
+              NIL,
+              NIL,
+              [
+                this.parseSpecialReference(SpecialReference.PromiseResolve),
+                parsed,
+              ],
+              NIL,
+              NIL,
+              NIL,
+            ),
+          );
         }
         this.popPendingState();
       },
@@ -188,23 +193,25 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
         if (this.alive) {
           const parsed = this.parseWithError(data);
           if (parsed) {
-            this.onParse({
-              t: SerovalNodeType.PromiseReject,
-              i: id,
-              s: undefined,
-              l: undefined,
-              c: undefined,
-              m: undefined,
-              p: undefined,
-              e: undefined,
-              a: [
-                this.parseSpecialReference(SpecialReference.PromiseReject),
-                parsed,
-              ],
-              f: undefined,
-              b: undefined,
-              o: undefined,
-            });
+            this.onParse(
+              createSerovalNode(
+                SerovalNodeType.PromiseReject,
+                id,
+                NIL,
+                NIL,
+                NIL,
+                NIL,
+                NIL,
+                NIL,
+                [
+                  this.parseSpecialReference(SpecialReference.PromiseReject),
+                  parsed,
+                ],
+                NIL,
+                NIL,
+                NIL,
+              ),
+            );
           }
         }
         this.popPendingState();
@@ -233,7 +240,7 @@ export default abstract class BaseStreamParserContext extends BaseSyncParserCont
         }
       }
     }
-    return undefined;
+    return NIL;
   }
 
   protected parseStream(id: number, current: Stream<unknown>): SerovalNode {
@@ -274,12 +281,57 @@ 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 {
     try {
       return this.parse(current);
     } catch (err) {
       this.onError(err);
-      return undefined;
+      return NIL;
     }
   }
 

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

@@ -19,6 +19,7 @@ import {
   createTypedArrayNode,
 } from '../../base-primitives';
 import { Feature } from '../../compat';
+import { NIL, SerovalNodeType } from '../../constants';
 import { SerovalParserError, SerovalUnsupportedTypeError } from '../../errors';
 import {
   FALSE_NODE,
@@ -26,12 +27,15 @@ 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,
@@ -167,7 +171,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return createErrorNode(
       id,
       current,
-      options ? this.parseProperties(options) : undefined,
+      options ? this.parseProperties(options) : NIL,
     );
   }
 
@@ -179,7 +183,7 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return createAggregateErrorNode(
       id,
       current,
-      options ? this.parseProperties(options) : undefined,
+      options ? this.parseProperties(options) : NIL,
     );
   }
 
@@ -241,7 +245,37 @@ export default abstract class BaseSyncParserContext extends BaseParserContext {
     return this.createPromiseConstructorNode(id);
   }
 
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+  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);
+  }
+
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ehh
   protected parseObject(id: number, current: object): SerovalNode {
     if (Array.isArray(current)) {
       return this.parseArray(id, current);
@@ -315,6 +349,13 @@ 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) {