seroval 1.2.0 → 1.3.0

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,
@@ -60,7 +57,7 @@ import type {
   TypedArrayValue,
 } from '../../utils/typed-array';
 import type { BaseParserContextOptions } from '../parser';
-import { BaseParserContext } from '../parser';
+import { BaseParserContext, ParserNodeType } from '../parser';
 
 type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;
 
@@ -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) {
@@ -389,37 +353,56 @@ 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 === 0
-              ? this.parseObject(ref.value, current as object)
-              : ref.value;
-          }
-          return NULL_NODE;
+  protected parseFunction(current: unknown): SerovalNode {
+    const ref = this.getReference(current);
+    if (ref.type !== ParserNodeType.Fresh) {
+      return ref.value;
+    }
+    const plugin = this.parsePlugin(ref.value, current);
+    if (plugin) {
+      return plugin;
+    }
+    throw new SerovalUnsupportedTypeError(current);
+  }
+
+  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 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);
+    }
+  }
+
+  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,
@@ -39,24 +38,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;
 }
 
@@ -87,59 +86,46 @@ 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) {
       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,
-      value: id,
+      type: ParserNodeType.Fresh,
+      value: this.createIndex(current),
     };
   }
 
   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));
@@ -150,7 +136,7 @@ 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 createSerovalNode(
@@ -173,7 +159,7 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     | SerovalIndexedValueNode
     | SerovalIteratorFactoryNode {
     const result = this.getIndexedValue(ITERATOR);
-    if (result.type === NodeType.Indexed) {
+    if (result.type === ParserNodeType.Indexed) {
       return result.value;
     }
     return createSerovalNode(
@@ -196,7 +182,7 @@ export abstract class BaseParserContext implements PluginAccessOptions {
     | SerovalIndexedValueNode
     | SerovalAsyncIteratorFactoryNode {
     const result = this.getIndexedValue(ASYNC_ITERATOR);
-    if (result.type === NodeType.Indexed) {
+    if (result.type === ParserNodeType.Indexed) {
       return result.value;
     }
     return createSerovalNode(
@@ -264,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,
@@ -280,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,
-    );
-  }
 }

package/src/core/context/serializer.ts

@@ -12,13 +12,11 @@ import {
   SerovalSerializationError,
   SerovalUnsupportedNodeError,
 } from '../errors';
+import { createEffectfulFunction, createFunction } from '../function-string';
 import { REFERENCES_KEY } from '../keys';
 import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
-import { SpecialReference } from '../special-reference';
+import { serializeSpecialReferenceValue } from '../special-reference';
 import type {
-  SerovalAbortSignalAbortNode,
-  SerovalAbortSignalConstructorNode,
-  SerovalAbortSignalSyncNode,
   SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
   SerovalArrayNode,
@@ -253,25 +251,11 @@ export default abstract class BaseSerializerContext
   abstract readonly mode: SerovalMode;
 
   createFunction(parameters: string[], body: string): string {
-    if (this.features & Feature.ArrowFunction) {
-      const joined =
-        parameters.length === 1
-          ? parameters[0]
-          : '(' + parameters.join(',') + ')';
-      return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);
-    }
-    return 'function(' + parameters.join(',') + '){return ' + body + '}';
+    return createFunction(this.features, parameters, body);
   }
 
   createEffectfulFunction(parameters: string[], body: string): string {
-    if (this.features & Feature.ArrowFunction) {
-      const joined =
-        parameters.length === 1
-          ? parameters[0]
-          : '(' + parameters.join(',') + ')';
-      return joined + '=>{' + body + '}';
-    }
-    return 'function(' + parameters.join(',') + '){' + body + '}';
+    return createEffectfulFunction(this.features, parameters, body);
   }
 
   /**
@@ -919,7 +903,11 @@ export default abstract class BaseSerializerContext
   protected serializePromiseConstructor(
     node: SerovalPromiseConstructorNode,
   ): string {
-    return this.assignIndexedValue(node.i, this.getConstructor(node.f) + '()');
+    const resolver = this.assignIndexedValue(node.s, '{p:0,s:0,f:0}');
+    return this.assignIndexedValue(
+      node.i,
+      this.getConstructor(node.f) + '(' + resolver + ')',
+    );
   }
 
   protected serializePromiseResolve(node: SerovalPromiseResolveNode): string {
@@ -944,84 +932,12 @@ export default abstract class BaseSerializerContext
     );
   }
 
-  private serializeSpecialReferenceValue(ref: SpecialReference): string {
-    switch (ref) {
-      case SpecialReference.MapSentinel:
-        return '[]';
-      case SpecialReference.PromiseConstructor:
-        return this.createFunction(
-          ['s', 'f', 'p'],
-          '((p=new Promise(' +
-            this.createEffectfulFunction(['a', 'b'], 's=a,f=b') +
-            ')).s=s,p.f=f,p)',
-        );
-      case SpecialReference.PromiseResolve:
-        return this.createEffectfulFunction(
-          ['p', 'd'],
-          'p.s(d),p.status="success",p.value=d;delete p.s;delete p.f',
-        );
-      case SpecialReference.PromiseReject:
-        return this.createEffectfulFunction(
-          ['p', 'd'],
-          'p.f(d),p.status="failure",p.value=d;delete p.s;delete p.f',
-        );
-      case SpecialReference.StreamConstructor:
-        return this.createFunction(
-          ['b', 'a', 's', 'l', 'p', 'f', 'e', 'n'],
-          '(b=[],a=!0,s=!1,l=[],p=0,f=' +
-            this.createEffectfulFunction(
-              ['v', 'm', 'x'],
-              'for(x=0;x<p;x++)l[x]&&l[x][m](v)',
-            ) +
-            ',n=' +
-            this.createEffectfulFunction(
-              ['o', 'x', 'z', 'c'],
-              'for(x=0,z=b.length;x<z;x++)(c=b[x],(!a&&x===z-1)?o[s?"return":"throw"](c):o.next(c))',
-            ) +
-            ',e=' +
-            this.createFunction(
-              ['o', 't'],
-              '(a&&(l[t=p++]=o),n(o),' +
-                this.createEffectfulFunction([], 'a&&(l[t]=void 0)') +
-                ')',
-            ) +
-            ',{__SEROVAL_STREAM__:!0,on:' +
-            this.createFunction(['o'], 'e(o)') +
-            ',next:' +
-            this.createEffectfulFunction(['v'], 'a&&(b.push(v),f(v,"next"))') +
-            ',throw:' +
-            this.createEffectfulFunction(
-              ['v'],
-              'a&&(b.push(v),f(v,"throw"),a=s=!1,l.length=0)',
-            ) +
-            ',return:' +
-            this.createEffectfulFunction(
-              ['v'],
-              'a&&(b.push(v),f(v,"return"),a=!1,s=!0,l.length=0)',
-            ) +
-            '})',
-        );
-      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 '';
-    }
-  }
-
   protected serializeSpecialReference(
     node: SerovalSpecialReferenceNode,
   ): string {
     return this.assignIndexedValue(
       node.i,
-      this.serializeSpecialReferenceValue(node.s),
+      serializeSpecialReferenceValue(this.features, node.s),
     );
   }
 
@@ -1173,32 +1089,6 @@ 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) {
@@ -1247,9 +1137,9 @@ export default abstract class BaseSerializerContext
           return this.serializeBoxed(node);
         case SerovalNodeType.PromiseConstructor:
           return this.serializePromiseConstructor(node);
-        case SerovalNodeType.PromiseResolve:
+        case SerovalNodeType.PromiseSuccess:
           return this.serializePromiseResolve(node);
-        case SerovalNodeType.PromiseReject:
+        case SerovalNodeType.PromiseFailure:
           return this.serializePromiseReject(node);
         case SerovalNodeType.Plugin:
           return this.serializePlugin(node);
@@ -1271,12 +1161,6 @@ 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/function-string.ts

@@ -0,0 +1,31 @@
+import { Feature } from './compat';
+
+export function createFunction(
+  features: number,
+  parameters: string[],
+  body: string,
+): string {
+  if (features & Feature.ArrowFunction) {
+    const joined =
+      parameters.length === 1
+        ? parameters[0]
+        : '(' + parameters.join(',') + ')';
+    return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);
+  }
+  return 'function(' + parameters.join(',') + '){return ' + body + '}';
+}
+
+export function createEffectfulFunction(
+  features: number,
+  parameters: string[],
+  body: string,
+): string {
+  if (features & Feature.ArrowFunction) {
+    const joined =
+      parameters.length === 1
+        ? parameters[0]
+        : '(' + parameters.join(',') + ')';
+    return joined + '=>{' + body + '}';
+  }
+  return 'function(' + parameters.join(',') + '){' + body + '}';
+}