seroval 1.2.1 → 1.3.0

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/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 + '}';
+}

package/src/core/special-reference.ts

@@ -1,3 +1,5 @@
+import { createEffectfulFunction, createFunction } from './function-string';
+
 export const ITERATOR = {};
 
 export const ASYNC_ITERATOR = {};
@@ -5,11 +7,9 @@ export const ASYNC_ITERATOR = {};
 export const enum SpecialReference {
   MapSentinel = 0,
   PromiseConstructor = 1,
-  PromiseResolve = 2,
-  PromiseReject = 3,
+  PromiseSuccess = 2,
+  PromiseFailure = 3,
   StreamConstructor = 4,
-  AbortSignalConstructor = 5,
-  AbortSignalAbort = 6,
 }
 
 /**
@@ -18,9 +18,97 @@ export const enum SpecialReference {
 export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
   [SpecialReference.MapSentinel]: {},
   [SpecialReference.PromiseConstructor]: {},
-  [SpecialReference.PromiseResolve]: {},
-  [SpecialReference.PromiseReject]: {},
+  [SpecialReference.PromiseSuccess]: {},
+  [SpecialReference.PromiseFailure]: {},
   [SpecialReference.StreamConstructor]: {},
-  [SpecialReference.AbortSignalConstructor]: {},
-  [SpecialReference.AbortSignalAbort]: {},
 };
+
+function serializePromiseConstructor(features: number): string {
+  return createFunction(
+    features,
+    ['r'],
+    '(r.p=new Promise(' +
+      createEffectfulFunction(features, ['s', 'f'], 'r.s=s,r.f=f') +
+      '))',
+  );
+}
+
+function serializePromiseSuccess(features: number): string {
+  return createEffectfulFunction(
+    features,
+    ['r', 'd'],
+    'r.s(d),r.p.s=1,r.p.v=d',
+  );
+}
+
+function serializePromiseFailure(features: number): string {
+  return createEffectfulFunction(
+    features,
+    ['r', 'd'],
+    'r.f(d),r.p.s=2,r.p.v=d',
+  );
+}
+
+function serializeStreamConstructor(features: number): string {
+  return createFunction(
+    features,
+    ['b', 'a', 's', 'l', 'p', 'f', 'e', 'n'],
+    '(b=[],a=!0,s=!1,l=[],p=0,f=' +
+      createEffectfulFunction(
+        features,
+        ['v', 'm', 'x'],
+        'for(x=0;x<p;x++)l[x]&&l[x][m](v)',
+      ) +
+      ',n=' +
+      createEffectfulFunction(
+        features,
+        ['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=' +
+      createFunction(
+        features,
+        ['o', 't'],
+        '(a&&(l[t=p++]=o),n(o),' +
+          createEffectfulFunction(features, [], 'a&&(l[t]=void 0)') +
+          ')',
+      ) +
+      ',{__SEROVAL_STREAM__:!0,on:' +
+      createFunction(features, ['o'], 'e(o)') +
+      ',next:' +
+      createEffectfulFunction(features, ['v'], 'a&&(b.push(v),f(v,"next"))') +
+      ',throw:' +
+      createEffectfulFunction(
+        features,
+        ['v'],
+        'a&&(b.push(v),f(v,"throw"),a=s=!1,l.length=0)',
+      ) +
+      ',return:' +
+      createEffectfulFunction(
+        features,
+        ['v'],
+        'a&&(b.push(v),f(v,"return"),a=!1,s=!0,l.length=0)',
+      ) +
+      '})',
+  );
+}
+
+export function serializeSpecialReferenceValue(
+  features: number,
+  ref: SpecialReference,
+): string {
+  switch (ref) {
+    case SpecialReference.MapSentinel:
+      return '[]';
+    case SpecialReference.PromiseConstructor:
+      return serializePromiseConstructor(features);
+    case SpecialReference.PromiseSuccess:
+      return serializePromiseSuccess(features);
+    case SpecialReference.PromiseFailure:
+      return serializePromiseFailure(features);
+    case SpecialReference.StreamConstructor:
+      return serializeStreamConstructor(features);
+    default:
+      return '';
+  }
+}

package/src/core/tree/serializer.ts

@@ -4,7 +4,6 @@ import BaseSerializerContext from '../context/serializer';
 import { SerovalUnsupportedNodeError } from '../errors';
 import type { SerovalMode } from '../plugin';
 import type {
-  SerovalAbortSignalAbortNode,
   SerovalNode,
   SerovalPromiseConstructorNode,
   SerovalPromiseRejectNode,
@@ -74,12 +73,6 @@ 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

@@ -245,17 +245,18 @@ export interface SerovalBoxedNode extends SerovalBaseNode {
 export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
   t: SerovalNodeType.PromiseConstructor;
   i: number;
+  s: number;
   f: SerovalNodeWithID;
 }
 
 export interface SerovalPromiseResolveNode extends SerovalBaseNode {
-  t: SerovalNodeType.PromiseResolve;
+  t: SerovalNodeType.PromiseSuccess;
   i: number;
   a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
 }
 
 export interface SerovalPromiseRejectNode extends SerovalBaseNode {
-  t: SerovalNodeType.PromiseReject;
+  t: SerovalNodeType.PromiseFailure;
   i: number;
   a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
 }
@@ -330,26 +331,6 @@ export interface SerovalStreamReturnNode extends SerovalBaseNode {
   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;
-}
-
 export type SerovalSyncNode =
   | SerovalPrimitiveNode
   | SerovalIndexedValueNode
@@ -372,8 +353,7 @@ export type SerovalSyncNode =
   | SerovalIteratorFactoryNode
   | SerovalIteratorFactoryInstanceNode
   | SerovalAsyncIteratorFactoryNode
-  | SerovalAsyncIteratorFactoryInstanceNode
-  | SerovalAbortSignalSyncNode;
+  | SerovalAsyncIteratorFactoryInstanceNode;
 
 export type SerovalAsyncNode =
   | SerovalPromiseNode
@@ -383,9 +363,7 @@ export type SerovalAsyncNode =
   | SerovalStreamConstructorNode
   | SerovalStreamNextNode
   | SerovalStreamThrowNode
-  | SerovalStreamReturnNode
-  | SerovalAbortSignalConstructorNode
-  | SerovalAbortSignalAbortNode;
+  | SerovalStreamReturnNode;
 
 export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
 

package/dist/types/core/abort-signal.d.ts

@@ -1,2 +0,0 @@
-export declare function abortSignalToPromise(signal: AbortSignal): Promise<any>;
-//# sourceMappingURL=abort-signal.d.ts.map

package/dist/types/core/abort-signal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abort-signal.d.ts","sourceRoot":"","sources":["../../../src/core/abort-signal.ts"],"names":[],"mappings":"AAgBA,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAEtE"}

package/src/core/abort-signal.ts

@@ -1,19 +0,0 @@
-function resolveAbortSignalResult(
-  this: AbortSignal,
-  resolve: (value: any) => void,
-): void {
-  resolve(this.reason);
-}
-
-function resolveAbortSignal(
-  this: AbortSignal,
-  resolve: (value: any) => void,
-): void {
-  this.addEventListener('abort', resolveAbortSignalResult.bind(this, resolve), {
-    once: true,
-  });
-}
-
-export function abortSignalToPromise(signal: AbortSignal): Promise<any> {
-  return new Promise(resolveAbortSignal.bind(signal));
-}