seroval 1.2.0 → 1.3.0

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":"AAAA,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAYtE"}

package/src/core/abort-signal.ts

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