seroval 1.1.1 → 1.2.0

package/src/core/context/parser.ts

@@ -5,8 +5,9 @@ import {
 } from '../base-primitives';
 import { ALL_ENABLED } from '../compat';
 import type { WellKnownSymbols } from '../constants';
-import { INV_SYMBOL_REF, SerovalNodeType } from '../constants';
+import { INV_SYMBOL_REF, NIL, SerovalNodeType } from '../constants';
 import { SerovalUnsupportedTypeError } from '../errors';
+import { createSerovalNode } from '../node';
 import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
 import { hasReferenceID } from '../reference';
 import {
@@ -16,6 +17,7 @@ import {
   SpecialReference,
 } from '../special-reference';
 import type {
+  SerovalAbortSignalConstructorNode,
   SerovalAsyncIteratorFactoryNode,
   SerovalIndexedValueNode,
   SerovalIteratorFactoryNode,
@@ -151,20 +153,20 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     if (result.type === NodeType.Indexed) {
       return result.value;
     }
-    return {
-      t: SerovalNodeType.SpecialReference,
-      i: result.value,
-      s: ref,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: undefined,
-      a: undefined,
-      f: undefined,
-      b: undefined,
-      o: undefined,
-    };
+    return createSerovalNode(
+      SerovalNodeType.SpecialReference,
+      result.value,
+      ref,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+    );
   }
 
   protected parseIteratorFactory():
@@ -174,20 +176,20 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     if (result.type === NodeType.Indexed) {
       return result.value;
     }
-    return {
-      t: SerovalNodeType.IteratorFactory,
-      i: result.value,
-      s: undefined,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: undefined,
-      a: undefined,
-      f: this.parseWellKnownSymbol(Symbol.iterator),
-      b: undefined,
-      o: undefined,
-    };
+    return createSerovalNode(
+      SerovalNodeType.IteratorFactory,
+      result.value,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      this.parseWellKnownSymbol(Symbol.iterator),
+      NIL,
+      NIL,
+    );
   }
 
   protected parseAsyncIteratorFactory():
@@ -197,23 +199,23 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     if (result.type === NodeType.Indexed) {
       return result.value;
     }
-    return {
-      t: SerovalNodeType.AsyncIteratorFactory,
-      i: result.value,
-      s: undefined,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: undefined,
-      a: [
+    return createSerovalNode(
+      SerovalNodeType.AsyncIteratorFactory,
+      result.value,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      [
         this.parseSpecialReference(SpecialReference.PromiseConstructor),
         this.parseWellKnownSymbol(Symbol.asyncIterator),
       ],
-      f: undefined,
-      b: undefined,
-      o: undefined,
-    };
+      NIL,
+      NIL,
+      NIL,
+    );
   }
 
   protected createObjectNode(
@@ -222,20 +224,20 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     empty: boolean,
     record: SerovalObjectRecordNode,
   ): SerovalObjectNode | SerovalNullConstructorNode {
-    return {
-      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      i: id,
-      s: undefined,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: record,
-      e: undefined,
-      a: undefined,
-      f: undefined,
-      b: undefined,
-      o: getObjectFlag(current),
-    };
+    return createSerovalNode(
+      empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
+      id,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      record,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      getObjectFlag(current),
+    );
   }
 
   protected createMapNode(
@@ -244,38 +246,57 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     v: SerovalNode[],
     s: number,
   ): SerovalMapNode {
-    return {
-      t: SerovalNodeType.Map,
-      i: id,
-      s: undefined,
-      l: undefined,
-      c: undefined,
-      m: undefined,
-      p: undefined,
-      e: { k, v, s },
-      a: undefined,
-      f: this.parseSpecialReference(SpecialReference.MapSentinel),
-      b: undefined,
-      o: undefined,
-    };
+    return createSerovalNode(
+      SerovalNodeType.Map,
+      id,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      { k, v, s },
+      NIL,
+      this.parseSpecialReference(SpecialReference.MapSentinel),
+      NIL,
+      NIL,
+    );
   }
 
   protected createPromiseConstructorNode(
     id: number,
   ): 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,
-    };
+    return createSerovalNode(
+      SerovalNodeType.PromiseConstructor,
+      id,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      this.parseSpecialReference(SpecialReference.PromiseConstructor),
+      NIL,
+      NIL,
+    );
+  }
+
+  protected createAbortSignalConstructorNode(
+    id: number,
+  ): SerovalAbortSignalConstructorNode {
+    return createSerovalNode(
+      SerovalNodeType.AbortSignalConstructor,
+      id,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      NIL,
+      this.parseSpecialReference(SpecialReference.AbortSignalConstructor),
+      NIL,
+      NIL,
+    );
   }
 }

package/src/core/context/serializer.ts

@@ -2,6 +2,7 @@ import { Feature } from '../compat';
 import {
   CONSTANT_STRING,
   ERROR_CONSTRUCTOR_STRING,
+  NIL,
   SYMBOL_STRING,
   SerovalNodeType,
   SerovalObjectFlags,
@@ -15,6 +16,9 @@ import { REFERENCES_KEY } from '../keys';
 import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
 import { SpecialReference } from '../special-reference';
 import type {
+  SerovalAbortSignalAbortNode,
+  SerovalAbortSignalConstructorNode,
+  SerovalAbortSignalSyncNode,
   SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
   SerovalArrayNode,
@@ -128,7 +132,7 @@ function mergeAssignments(assignments: Assignment[]): Assignment[] {
       current = {
         t: AssignmentType.Index,
         s: item.s,
-        k: undefined,
+        k: NIL,
         v: getAssignmentExpression(current),
       } as IndexAssignment;
     } else if (item.t === AssignmentType.Set && item.s === prev.s) {
@@ -144,7 +148,7 @@ function mergeAssignments(assignments: Assignment[]): Assignment[] {
       current = {
         t: AssignmentType.Add,
         s: getAssignmentExpression(current),
-        k: undefined,
+        k: NIL,
         v: item.v,
       } as AddAssignment;
     } else if (item.t === AssignmentType.Delete && item.s === prev.s) {
@@ -153,7 +157,7 @@ function mergeAssignments(assignments: Assignment[]): Assignment[] {
         t: AssignmentType.Delete,
         s: getAssignmentExpression(current),
         k: item.k,
-        v: undefined,
+        v: NIL,
       } as DeleteAssignment;
     } else {
       // Different assignment, push current
@@ -177,7 +181,7 @@ function resolveAssignments(assignments: Assignment[]): string | undefined {
     }
     return result;
   }
-  return undefined;
+  return NIL;
 }
 
 const NULL_CONSTRUCTOR = 'Object.create(null)';
@@ -192,7 +196,7 @@ const OBJECT_FLAG_CONSTRUCTOR: Record<SerovalObjectFlags, string | undefined> =
     [SerovalObjectFlags.Frozen]: 'Object.freeze',
     [SerovalObjectFlags.Sealed]: 'Object.seal',
     [SerovalObjectFlags.NonExtensible]: 'Object.preventExtensions',
-    [SerovalObjectFlags.None]: undefined,
+    [SerovalObjectFlags.None]: NIL,
   };
 
 type SerovalNodeWithProperties =
@@ -331,7 +335,7 @@ export default abstract class BaseSerializerContext
     this.assignments.push({
       t: AssignmentType.Index,
       s: source,
-      k: undefined,
+      k: NIL,
       v: value,
     });
   }
@@ -340,7 +344,7 @@ export default abstract class BaseSerializerContext
     this.assignments.push({
       t: AssignmentType.Add,
       s: this.getRefParam(ref),
-      k: undefined,
+      k: NIL,
       v: value,
     });
   }
@@ -359,7 +363,7 @@ export default abstract class BaseSerializerContext
       t: AssignmentType.Delete,
       s: this.getRefParam(ref),
       k: key,
-      v: undefined,
+      v: NIL,
     });
   }
 
@@ -610,7 +614,7 @@ export default abstract class BaseSerializerContext
       this.stack.pop();
       return resolveAssignments(mainAssignments);
     }
-    return undefined;
+    return NIL;
   }
 
   protected serializeDictionary(
@@ -997,6 +1001,16 @@ export default abstract class BaseSerializerContext
             ) +
             '})',
         );
+      case SpecialReference.AbortSignalConstructor:
+        return this.createFunction(
+          ['a', 's'],
+          '((s=(a=new AbortController).signal).a=a,s)',
+        );
+      case SpecialReference.AbortSignalAbort:
+        return this.createEffectfulFunction(
+          ['s', 'r'],
+          's.a.abort(r);delete s.a',
+        );
       default:
         return '';
     }
@@ -1159,6 +1173,32 @@ export default abstract class BaseSerializerContext
     return this.getRefParam(node.i) + '.return(' + this.serialize(node.f) + ')';
   }
 
+  protected serializeAbortSignalSync(node: SerovalAbortSignalSyncNode): string {
+    return this.assignIndexedValue(
+      node.i,
+      'AbortSignal.abort(' + this.serialize(node.f) + ')',
+    );
+  }
+
+  protected serializeAbortSignalConstructor(
+    node: SerovalAbortSignalConstructorNode,
+  ): string {
+    return this.assignIndexedValue(node.i, this.getConstructor(node.f) + '()');
+  }
+
+  protected serializeAbortSignalAbort(
+    node: SerovalAbortSignalAbortNode,
+  ): string {
+    return (
+      this.getConstructor(node.a[0]) +
+      '(' +
+      this.getRefParam(node.i) +
+      ',' +
+      this.serialize(node.a[1]) +
+      ')'
+    );
+  }
+
   serialize(node: SerovalNode): string {
     try {
       switch (node.t) {
@@ -1231,6 +1271,12 @@ export default abstract class BaseSerializerContext
           return this.serializeStreamThrow(node);
         case SerovalNodeType.StreamReturn:
           return this.serializeStreamReturn(node);
+        case SerovalNodeType.AbortSignalAbort:
+          return this.serializeAbortSignalAbort(node);
+        case SerovalNodeType.AbortSignalConstructor:
+          return this.serializeAbortSignalConstructor(node);
+        case SerovalNodeType.AbortSignalSync:
+          return this.serializeAbortSignalSync(node);
         default:
           throw new SerovalUnsupportedNodeError(node);
       }

package/src/core/literals.ts

@@ -1,21 +1,22 @@
-import { SerovalConstant, SerovalNodeType } from './constants';
+import { NIL, SerovalConstant, SerovalNodeType } from './constants';
+import { createSerovalNode } from './node';
 import type { SerovalConstantNode } from './types';
 
 function createConstantNode(value: SerovalConstant): SerovalConstantNode {
-  return {
-    t: SerovalNodeType.Constant,
-    i: undefined,
-    s: value,
-    l: undefined,
-    c: undefined,
-    m: undefined,
-    p: undefined,
-    e: undefined,
-    a: undefined,
-    f: undefined,
-    b: undefined,
-    o: undefined,
-  };
+  return createSerovalNode(
+    SerovalNodeType.Constant,
+    NIL,
+    value,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
 }
 
 export const TRUE_NODE = /* @__PURE__ */ createConstantNode(

package/src/core/node.ts

@@ -0,0 +1,40 @@
+import type { SerovalNodeType } from './constants';
+import type { SerovalNode } from './types';
+
+type ExtractedNodeType<T extends SerovalNodeType> = Extract<
+  SerovalNode,
+  { t: T }
+>;
+
+export function createSerovalNode<
+  T extends SerovalNodeType,
+  N extends ExtractedNodeType<T>,
+>(
+  t: T,
+  i: N['i'],
+  s: N['s'],
+  l: N['l'],
+  c: N['c'],
+  m: N['m'],
+  p: N['p'],
+  e: N['e'],
+  a: N['a'],
+  f: N['f'],
+  b: N['b'],
+  o: N['o'],
+): N {
+  return {
+    t,
+    i,
+    s,
+    l,
+    c,
+    m,
+    p,
+    e,
+    a,
+    f,
+    b,
+    o,
+  } as N;
+}

package/src/core/special-reference.ts

@@ -8,12 +8,19 @@ export const enum SpecialReference {
   PromiseResolve = 2,
   PromiseReject = 3,
   StreamConstructor = 4,
+  AbortSignalConstructor = 5,
+  AbortSignalAbort = 6,
 }
 
+/**
+ * Placeholder references
+ */
 export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
   [SpecialReference.MapSentinel]: {},
   [SpecialReference.PromiseConstructor]: {},
   [SpecialReference.PromiseResolve]: {},
   [SpecialReference.PromiseReject]: {},
   [SpecialReference.StreamConstructor]: {},
+  [SpecialReference.AbortSignalConstructor]: {},
+  [SpecialReference.AbortSignalAbort]: {},
 };

package/src/core/tree/serializer.ts

@@ -4,6 +4,7 @@ import BaseSerializerContext from '../context/serializer';
 import { SerovalUnsupportedNodeError } from '../errors';
 import type { SerovalMode } from '../plugin';
 import type {
+  SerovalAbortSignalAbortNode,
   SerovalNode,
   SerovalPromiseConstructorNode,
   SerovalPromiseRejectNode,
@@ -73,6 +74,12 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
     throw new SerovalUnsupportedNodeError(node);
   }
 
+  protected serializeAbortSignalAbort(
+    node: SerovalAbortSignalAbortNode,
+  ): string {
+    throw new SerovalUnsupportedNodeError(node);
+  }
+
   serializeTop(tree: SerovalNode): string {
     const result = this.serialize(tree);
     // Shared references detected

package/src/core/types.ts

@@ -269,6 +269,9 @@ export interface SerovalPluginNode extends SerovalBaseNode {
   c: string;
 }
 
+/**
+ * Represents special values as placeholders
+ */
 export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
   t: SerovalNodeType.SpecialReference;
   i: number;
@@ -302,24 +305,48 @@ export interface SerovalStreamConstructorNode extends SerovalBaseNode {
   t: SerovalNodeType.StreamConstructor;
   i: number;
   a: SerovalNode[];
+  // special reference to the constructor
   f: SerovalNodeWithID;
 }
 
 export interface SerovalStreamNextNode extends SerovalBaseNode {
   t: SerovalNodeType.StreamNext;
   i: number;
+  // Next value
   f: SerovalNode;
 }
 
 export interface SerovalStreamThrowNode extends SerovalBaseNode {
   t: SerovalNodeType.StreamThrow;
   i: number;
+  // Throw value
   f: SerovalNode;
 }
 
 export interface SerovalStreamReturnNode extends SerovalBaseNode {
   t: SerovalNodeType.StreamReturn;
   i: number;
+  // Return value
+  f: SerovalNode;
+}
+
+export interface SerovalAbortSignalConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.AbortSignalConstructor;
+  i: number;
+  // special reference to the constructor
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalAbortSignalAbortNode extends SerovalBaseNode {
+  t: SerovalNodeType.AbortSignalAbort;
+  i: number;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
+}
+
+export interface SerovalAbortSignalSyncNode extends SerovalBaseNode {
+  t: SerovalNodeType.AbortSignalSync;
+  i: number;
+  // Abort reason
   f: SerovalNode;
 }
 
@@ -345,7 +372,8 @@ export type SerovalSyncNode =
   | SerovalIteratorFactoryNode
   | SerovalIteratorFactoryInstanceNode
   | SerovalAsyncIteratorFactoryNode
-  | SerovalAsyncIteratorFactoryInstanceNode;
+  | SerovalAsyncIteratorFactoryInstanceNode
+  | SerovalAbortSignalSyncNode;
 
 export type SerovalAsyncNode =
   | SerovalPromiseNode
@@ -355,7 +383,9 @@ export type SerovalAsyncNode =
   | SerovalStreamConstructorNode
   | SerovalStreamNextNode
   | SerovalStreamThrowNode
-  | SerovalStreamReturnNode;
+  | SerovalStreamReturnNode
+  | SerovalAbortSignalConstructorNode
+  | SerovalAbortSignalAbortNode;
 
 export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
 

package/src/core/utils/iterator-to-sequence.ts

@@ -1,3 +1,5 @@
+import { NIL } from "../constants";
+
 export interface Sequence {
   v: unknown[];
   t: number;
@@ -46,7 +48,7 @@ export function sequenceToIterator<T>(
         if (index > sequence.d) {
           return {
             done: true,
-            value: undefined,
+            value: NIL,
           };
         }
         const currentIndex = index++;