seroval 1.1.1 → 1.2.1

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,
@@ -37,24 +39,24 @@ export interface BaseParserContextOptions extends PluginAccessOptions {
   refs?: Map<unknown, number>;
 }
 
-const enum NodeType {
+export const enum ParserNodeType {
   Fresh = 0,
   Indexed = 1,
   Referenced = 2,
 }
 
-interface FreshNode {
-  type: NodeType.Fresh;
+export interface FreshNode {
+  type: ParserNodeType.Fresh;
   value: number;
 }
 
-interface IndexedNode {
-  type: NodeType.Indexed;
+export interface IndexedNode {
+  type: ParserNodeType.Indexed;
   value: SerovalIndexedValueNode;
 }
 
-interface ReferencedNode {
-  type: NodeType.Referenced;
+export interface ReferencedNode {
+  type: ParserNodeType.Referenced;
   value: SerovalReferenceNode;
 }
 
@@ -90,54 +92,37 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     if (registeredId != null) {
       this.markRef(registeredId);
       return {
-        type: NodeType.Indexed,
+        type: ParserNodeType.Indexed,
         value: createIndexedValueNode(registeredId),
       };
     }
     const id = this.refs.size;
     this.refs.set(current, id);
     return {
-      type: NodeType.Fresh,
+      type: ParserNodeType.Fresh,
       value: id,
     };
   }
 
   protected getReference<T>(current: T): ObjectNode {
     const indexed = this.getIndexedValue(current);
-    if (indexed.type === NodeType.Indexed) {
+    if (indexed.type === ParserNodeType.Indexed) {
       return indexed;
     }
     if (hasReferenceID(current)) {
       return {
-        type: NodeType.Referenced,
+        type: ParserNodeType.Referenced,
         value: createReferenceNode(indexed.value, current),
       };
     }
     return indexed;
   }
 
-  protected getStrictReference<T>(
-    current: T,
-  ): SerovalIndexedValueNode | SerovalReferenceNode {
-    assert(hasReferenceID(current), new SerovalUnsupportedTypeError(current));
-    const result = this.getIndexedValue(current);
-    if (result.type === NodeType.Indexed) {
-      return result.value;
-    }
-    return createReferenceNode(result.value, current);
-  }
-
-  protected parseFunction(
-    current: (...args: unknown[]) => unknown,
-  ): SerovalNode {
-    return this.getStrictReference(current);
-  }
-
   protected parseWellKnownSymbol(
     current: symbol,
   ): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode {
     const ref = this.getReference(current);
-    if (ref.type !== NodeType.Fresh) {
+    if (ref.type !== ParserNodeType.Fresh) {
       return ref.value;
     }
     assert(current in INV_SYMBOL_REF, new SerovalUnsupportedTypeError(current));
@@ -148,72 +133,72 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     ref: SpecialReference,
   ): SerovalIndexedValueNode | SerovalSpecialReferenceNode {
     const result = this.getIndexedValue(SPECIAL_REFS[ref]);
-    if (result.type === NodeType.Indexed) {
+    if (result.type === ParserNodeType.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():
     | SerovalIndexedValueNode
     | SerovalIteratorFactoryNode {
     const result = this.getIndexedValue(ITERATOR);
-    if (result.type === NodeType.Indexed) {
+    if (result.type === ParserNodeType.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():
     | SerovalIndexedValueNode
     | SerovalAsyncIteratorFactoryNode {
     const result = this.getIndexedValue(ASYNC_ITERATOR);
-    if (result.type === NodeType.Indexed) {
+    if (result.type === ParserNodeType.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 +207,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 +229,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/cross/index.ts

@@ -131,9 +131,7 @@ export function crossSerializeStream<T>(
 
   ctx.start(source);
 
-  return () => {
-    ctx.destroy();
-  };
+  return ctx.destroy.bind(ctx);
 }
 
 export type ToCrossJSONStreamOptions = CrossStreamParserContextOptions;
@@ -154,9 +152,7 @@ export function toCrossJSONStream<T>(
 
   ctx.start(source);
 
-  return () => {
-    ctx.destroy();
-  };
+  return ctx.destroy.bind(ctx);
 }
 
 export type FromCrossJSONOptions = CrossDeserializerContextOptions;

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