seroval 0.14.0 → 0.14.1

package/src/core/context/serializer.ts

@@ -8,6 +8,7 @@ import {
 } from '../constants';
 import { REFERENCES_KEY } from '../keys';
 import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
+import { SpecialReference } from '../special-reference';
 import type {
   SerovalArrayNode,
   SerovalIndexedValueNode,
@@ -49,13 +50,13 @@ import type {
   SerovalReadableStreamEnqueueNode,
   SerovalReadableStreamErrorNode,
   SerovalReadableStreamCloseNode,
-  SerovalMapSentinelNode,
   SerovalIteratorFactoryInstanceNode,
   SerovalIteratorFactoryNode,
   SerovalAsyncIteratorFactoryInstanceNode,
   SerovalAsyncIteratorFactoryNode,
   SerovalReadableStreamNode,
-  SerovalReadableStreamFactoryNode,
+  SerovalSpecialReferenceNode,
+  SerovalNodeWithID,
 } from '../types';
 import { isValidIdentifier } from '../utils/is-valid-identifier';
 
@@ -746,7 +747,7 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
         serialized += '([' + result + '])';
       }
     }
-    if (sentinel.t === SerovalNodeType.MapSentinel) {
+    if (sentinel.t === SerovalNodeType.SpecialReference) {
       this.markRef(sentinel.i);
       serialized = '(' + this.serialize(sentinel) + ',' + serialized + ')';
     }
@@ -986,38 +987,118 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
     throw new Error('Missing plugin for tag "' + node.c + '".');
   }
 
-  protected abstract serializePromiseConstructor(
+  private getConstructor(node: SerovalNodeWithID): string {
+    const constructor = this.serialize(node);
+    return (constructor === this.getRefParam(node.i)) ? constructor : ('(' + constructor + ')');
+  }
+
+  protected serializePromiseConstructor(
     node: SerovalPromiseConstructorNode,
-  ): string;
+  ): string {
+    return this.assignIndexedValue(
+      node.i,
+      this.getConstructor(node.f) + '()',
+    );
+  }
 
-  protected abstract serializePromiseResolve(
+  protected serializePromiseResolve(
     node: SerovalPromiseResolveNode,
-  ): string;
+  ): string {
+    return this.getConstructor(node.a[0]) + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.a[1]) + ')';
+  }
 
-  protected abstract serializePromiseReject(
+  protected serializePromiseReject(
     node: SerovalPromiseRejectNode,
-  ): string;
+  ): string {
+    return this.getConstructor(node.a[0]) + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.a[1]) + ')';
+  }
 
-  protected abstract serializeReadableStreamConstructor(
+  protected serializeReadableStreamConstructor(
     node: SerovalReadableStreamConstructorNode,
-  ): string;
+  ): string {
+    return this.assignIndexedValue(
+      node.i,
+      this.getConstructor(node.f) + '()',
+    );
+  }
 
-  protected abstract serializeReadableStreamEnqueue(
+  protected serializeReadableStreamEnqueue(
     node: SerovalReadableStreamEnqueueNode,
-  ): string;
+  ): string {
+    return this.getConstructor(node.a[0]) + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.a[1]) + ')';
+  }
 
-  protected abstract serializeReadableStreamError(
+  protected serializeReadableStreamError(
     node: SerovalReadableStreamErrorNode,
-  ): string;
+  ): string {
+    return this.getConstructor(node.a[0]) + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.a[1]) + ')';
+  }
 
-  protected abstract serializeReadableStreamClose(
+  protected serializeReadableStreamClose(
     node: SerovalReadableStreamCloseNode,
-  ): string;
+  ): string {
+    return this.getConstructor(node.f) + '(' + this.getRefParam(node.i) + ')';
+  }
+
+  private serializeSpecialReferenceValue(ref: SpecialReference): string {
+    switch (ref) {
+      case SpecialReference.MapSentinel:
+        return '[]';
+      case SpecialReference.ReadableStream:
+        return this.createFunction(
+          ['s'],
+          'new ReadableStream({start:' + this.createFunction(
+            ['c'],
+            'Promise.resolve().then(' + this.createEffectfulFunction(
+              ['i', 'v'],
+              'for(i=0;i<s.d;i++)c.enqueue(s.v[i]);(s.t===-1)?c.close():c.error(s.v[i])',
+            ) + ')',
+          ) + '})',
+        );
+      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.ReadableStreamConstructor:
+        return this.createFunction(
+          ['s', 'c'],
+          '((s=new ReadableStream({start:' + this.createEffectfulFunction(['x'], 'c=x') + '})).c=c,s)',
+        );
+      case SpecialReference.ReadableStreamEnqueue:
+        return this.createEffectfulFunction(
+          ['s', 'd'],
+          's.c.enqueue(d)',
+        );
+      case SpecialReference.ReadableStreamError:
+        return this.createEffectfulFunction(
+          ['s', 'd'],
+          's.c.error(d);delete s.c',
+        );
+      case SpecialReference.ReadableStreamClose:
+        return this.createEffectfulFunction(
+          ['s'],
+          's.c.close();delete s.c',
+        );
+      default:
+        return '';
+    }
+  }
 
-  protected serializeMapSentinel(node: SerovalMapSentinelNode): string {
+  protected serializeSpecialReference(node: SerovalSpecialReferenceNode): string {
     return this.assignIndexedValue(
       node.i,
-      '[]',
+      this.serializeSpecialReferenceValue(node.s),
     );
   }
 
@@ -1038,7 +1119,7 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
   protected serializeIteratorFactoryInstance(
     node: SerovalIteratorFactoryInstanceNode,
   ): string {
-    return '(' + this.serialize(node.a[0]) + ')(' + this.serialize(node.a[1]) + ')';
+    return this.getConstructor(node.a[0]) + '(' + this.serialize(node.a[1]) + ')';
   }
 
   private getStreamingAsyncIteratorFactory(node: SerovalAsyncIteratorFactoryNode): string {
@@ -1087,14 +1168,14 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
   protected serializeAsyncIteratorFactoryInstance(
     node: SerovalAsyncIteratorFactoryInstanceNode,
   ): string {
-    return '(' + this.serialize(node.a[0]) + ')(' + this.serialize(node.a[1]) + ')';
+    return this.getConstructor(node.a[0]) + '(' + this.serialize(node.a[1]) + ')';
   }
 
   protected serializeReadableStream(
     node: SerovalReadableStreamNode,
   ): string {
     this.stack.push(node.i);
-    const result = '(' + this.serialize(node.a[0]) + ')(' + this.serialize(node.a[1]) + ')';
+    const result = this.getConstructor(node.a[0]) + '(' + this.serialize(node.a[1]) + ')';
     this.stack.pop();
     return this.assignIndexedValue(
       node.i,
@@ -1102,24 +1183,6 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
     );
   }
 
-  protected serializeReadableStreamFactory(
-    node: SerovalReadableStreamFactoryNode,
-  ): string {
-    return this.assignIndexedValue(
-      node.i,
-      this.createFunction(
-        ['s'],
-        'new ReadableStream({start:' + this.createFunction(
-          ['c'],
-          'Promise.resolve().then(' + this.createEffectfulFunction(
-            ['i', 'v'],
-            'for(i=0;i<s.d;i++)c.enqueue(s.v[i]);(s.t===-1)?c.close():c.error(s.v[i])',
-          ) + ')',
-        ) + '})',
-      ),
-    );
-  }
-
   serialize(node: SerovalNode): string {
     switch (node.t) {
       case SerovalNodeType.Constant:
@@ -1203,8 +1266,8 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
         return this.serializeDOMException(node);
       case SerovalNodeType.Plugin:
         return this.serializePlugin(node);
-      case SerovalNodeType.MapSentinel:
-        return this.serializeMapSentinel(node);
+      case SerovalNodeType.SpecialReference:
+        return this.serializeSpecialReference(node);
       case SerovalNodeType.IteratorFactory:
         return this.serializeIteratorFactory(node);
       case SerovalNodeType.IteratorFactoryInstance:
@@ -1215,8 +1278,6 @@ export default abstract class BaseSerializerContext implements PluginAccessOptio
         return this.serializeAsyncIteratorFactoryInstance(node);
       case SerovalNodeType.ReadableStream:
         return this.serializeReadableStream(node);
-      case SerovalNodeType.ReadableStreamFactory:
-        return this.serializeReadableStreamFactory(node);
       default:
         throw new Error('invariant');
     }

package/src/core/cross/serializer.ts

@@ -1,23 +1,8 @@
 import type {
-  SerovalPromiseConstructorNode,
-  SerovalPromiseResolveNode,
-  SerovalPromiseRejectNode,
-  SerovalReadableStreamCloseNode,
-  SerovalReadableStreamEnqueueNode,
-  SerovalReadableStreamErrorNode,
-  SerovalReadableStreamConstructorNode,
   SerovalNode,
 } from '../types';
 import {
-  GLOBAL_CONTEXT_PROMISE_REJECT,
-  GLOBAL_CONTEXT_PROMISE_RESOLVE,
-  GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR,
   GLOBAL_CONTEXT_REFERENCES,
-  GLOBAL_CONTEXT_STREAM_CONSTRUCTOR,
-  GLOBAL_CONTEXT_STREAM_ENQUEUE,
-  GLOBAL_CONTEXT_STREAM_CLOSE,
-  GLOBAL_CONTEXT_STREAM_ERROR,
-  GLOBAL_CONTEXT_API,
 } from '../keys';
 import type { BaseSerializerContextOptions } from '../context/serializer';
 import BaseSerializerContext from '../context/serializer';
@@ -53,48 +38,6 @@ export default class CrossSerializerContext extends BaseSerializerContext {
     return this.getRefParam(index) + '=' + value;
   }
 
-  protected serializePromiseConstructor(
-    node: SerovalPromiseConstructorNode,
-  ): string {
-    return this.assignIndexedValue(node.i, GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR + '()');
-  }
-
-  protected serializePromiseResolve(
-    node: SerovalPromiseResolveNode,
-  ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_PROMISE_RESOLVE + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.f) + ')';
-  }
-
-  protected serializePromiseReject(
-    node: SerovalPromiseRejectNode,
-  ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_PROMISE_REJECT + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.f) + ')';
-  }
-
-  protected serializeReadableStreamConstructor(
-    node: SerovalReadableStreamConstructorNode,
-  ): string {
-    return this.assignIndexedValue(node.i, GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_CONSTRUCTOR + '()');
-  }
-
-  protected serializeReadableStreamEnqueue(
-    node: SerovalReadableStreamEnqueueNode,
-  ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_ENQUEUE + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.f) + ')';
-  }
-
-  protected serializeReadableStreamError(
-    node: SerovalReadableStreamErrorNode,
-  ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_ERROR + '(' + this.getRefParam(node.i) + ',' + this.serialize(node.f) + ')';
-  }
-
-  protected serializeReadableStreamClose(
-    node: SerovalReadableStreamCloseNode,
-  ): string {
-    return GLOBAL_CONTEXT_API + '.' + GLOBAL_CONTEXT_STREAM_CLOSE + '(' + this.getRefParam(node.i) + ')';
-  }
-
   serializeTop(tree: SerovalNode): string {
     const result = this.serialize(tree);
     const id = tree.i;

package/src/core/keys.ts

@@ -3,44 +3,8 @@ import { serializeString } from './string';
 // Used for mapping isomorphic references
 export const REFERENCES_KEY = '__SEROVAL_REFS__';
 
-export const GLOBAL_CONTEXT_API = '_$';
-
 export const GLOBAL_CONTEXT_REFERENCES = '$R';
 
-export const LOCAL_CONTEXT_PROMISE_RESOLVE = 's';
-
-export const LOCAL_CONTEXT_PROMISE_REJECT = 'f';
-
-export const GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR = 'P';
-
-export const GLOBAL_CONTEXT_PROMISE_RESOLVE = 'Ps';
-
-export const GLOBAL_CONTEXT_PROMISE_REJECT = 'Pf';
-
-export const LOCAL_CONTEXT_STREAM_CONTROLLER = 'c';
-
-export const GLOBAL_CONTEXT_STREAM_CONSTRUCTOR = 'S';
-
-export const GLOBAL_CONTEXT_STREAM_ENQUEUE = 'Se';
-
-export const GLOBAL_CONTEXT_STREAM_ERROR = 'St';
-
-export const GLOBAL_CONTEXT_STREAM_CLOSE = 'Sc';
-
-const GLOBAL_CONTEXT_API_REF = `self.${GLOBAL_CONTEXT_API}`;
-
-export const GLOBAL_CONTEXT_API_SCRIPT = `${GLOBAL_CONTEXT_API_REF}=${GLOBAL_CONTEXT_API_REF}||{`
-  + `${GLOBAL_CONTEXT_PROMISE_CONSTRUCTOR}:function(s,f,p){return(p=new Promise(function(a,b){s=a,f=b})).${LOCAL_CONTEXT_PROMISE_RESOLVE}=s,p.${LOCAL_CONTEXT_PROMISE_REJECT}=f,p},`
-  + `uP:function(p){delete p.${LOCAL_CONTEXT_PROMISE_RESOLVE};delete p.${LOCAL_CONTEXT_PROMISE_REJECT}},`
-  + `${GLOBAL_CONTEXT_PROMISE_RESOLVE}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_RESOLVE}(d),p.status="success",p.value=d,this.uP(p)},`
-  + `${GLOBAL_CONTEXT_PROMISE_REJECT}:function(p,d){p.${LOCAL_CONTEXT_PROMISE_REJECT}(d),p.status="failure",p.value=d,this.uP(p)},`
-  + `uS:function(s){delete s.${LOCAL_CONTEXT_STREAM_CONTROLLER}},`
-  + `${GLOBAL_CONTEXT_STREAM_CLOSE}:function(s){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.close(),this.uS(s)},`
-  + `${GLOBAL_CONTEXT_STREAM_ERROR}:function(s,e){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.error(e),this.uS(s)},`
-  + `${GLOBAL_CONTEXT_STREAM_ENQUEUE}:function(s,d){s.${LOCAL_CONTEXT_STREAM_CONTROLLER}.enqueue(d)},`
-  + `${GLOBAL_CONTEXT_STREAM_CONSTRUCTOR}:function(s,c){return(s=new ReadableStream({start:function(x){c=x}})).${LOCAL_CONTEXT_STREAM_CONTROLLER}=c,s}`
-  + '}';
-
 const GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;
 
 export function getCrossReferenceHeader(id?: string): string {

package/src/core/special-reference.ts

@@ -1,9 +1,29 @@
-export const MAP_SENTINEL = {};
+export const UNIVERSAL_SENTINEL = {};
 
 export const ITERATOR = {};
 
 export const ASYNC_ITERATOR = {};
 
-export const READABLE_STREAM = {};
+export const enum SpecialReference {
+  MapSentinel = 0,
+  ReadableStream = 1,
+  PromiseConstructor = 2,
+  PromiseResolve = 3,
+  PromiseReject = 4,
+  ReadableStreamConstructor = 5,
+  ReadableStreamEnqueue = 6,
+  ReadableStreamError = 7,
+  ReadableStreamClose = 8,
+}
 
-export const UNIVERSAL_SENTINEL = {};
+export const SPECIAL_REFS: Record<SpecialReference, unknown> = {
+  [SpecialReference.MapSentinel]: {},
+  [SpecialReference.ReadableStream]: {},
+  [SpecialReference.PromiseConstructor]: {},
+  [SpecialReference.PromiseResolve]: {},
+  [SpecialReference.PromiseReject]: {},
+  [SpecialReference.ReadableStreamConstructor]: {},
+  [SpecialReference.ReadableStreamEnqueue]: {},
+  [SpecialReference.ReadableStreamError]: {},
+  [SpecialReference.ReadableStreamClose]: {},
+};

package/src/core/types.ts

@@ -5,6 +5,7 @@ import type {
   Symbols,
   ErrorConstructorTag,
 } from './constants';
+import type { SpecialReference } from './special-reference';
 
 export interface SerovalBaseNode {
   // Type of the node
@@ -162,7 +163,7 @@ export interface SerovalMapNode extends SerovalBaseNode {
   i: number;
   // key/value pairs
   e: SerovalMapRecordNode;
-  f: SerovalMapSentinelNode | SerovalIndexedValueNode;
+  f: SerovalNodeWithID;
 }
 
 export interface SerovalArrayNode extends SerovalBaseNode {
@@ -300,42 +301,55 @@ export interface SerovalBoxedNode extends SerovalBaseNode {
 export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
   t: SerovalNodeType.PromiseConstructor;
   i: number;
+  f: SerovalNodeWithID;
 }
 
 export interface SerovalPromiseResolveNode extends SerovalBaseNode {
   t: SerovalNodeType.PromiseResolve;
-  // reference to the resolver
   i: number;
-  f: SerovalNode;
+  a: [
+    resolver: SerovalNodeWithID,
+    resolved: SerovalNode,
+  ];
 }
 
 export interface SerovalPromiseRejectNode extends SerovalBaseNode {
   t: SerovalNodeType.PromiseReject;
-  // reference to the resolver
   i: number;
-  f: SerovalNode;
+  a: [
+    resolver: SerovalNodeWithID,
+    resolved: SerovalNode,
+  ];
 }
 
 export interface SerovalReadableStreamConstructorNode extends SerovalBaseNode {
   t: SerovalNodeType.ReadableStreamConstructor;
   i: number;
+  f: SerovalNodeWithID;
 }
 
 export interface SerovalReadableStreamEnqueueNode extends SerovalBaseNode {
   t: SerovalNodeType.ReadableStreamEnqueue;
   i: number;
-  f: SerovalNode;
+  a: [
+    resolver: SerovalNodeWithID,
+    resolved: SerovalNode,
+  ];
 }
 
-export interface SerovalReadableStreamCloseNode extends SerovalBaseNode {
-  t: SerovalNodeType.ReadableStreamClose;
+export interface SerovalReadableStreamErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamError;
   i: number;
+  a: [
+    resolver: SerovalNodeWithID,
+    resolved: SerovalNode,
+  ];
 }
 
-export interface SerovalReadableStreamErrorNode extends SerovalBaseNode {
-  t: SerovalNodeType.ReadableStreamError;
+export interface SerovalReadableStreamCloseNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamClose;
   i: number;
-  f: SerovalNode;
+  f: SerovalNodeWithID;
 }
 
 export interface SerovalRequestNode extends SerovalBaseNode {
@@ -389,9 +403,10 @@ export interface SerovalPluginNode extends SerovalBaseNode {
   c: string;
 }
 
-export interface SerovalMapSentinelNode extends SerovalBaseNode {
-  t: SerovalNodeType.MapSentinel;
+export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
+  t: SerovalNodeType.SpecialReference;
   i: number;
+  s: SpecialReference;
 }
 
 export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
@@ -403,7 +418,7 @@ export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
 export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
   t: SerovalNodeType.IteratorFactoryInstance;
   a: [
-    instance: SerovalNode,
+    instance: SerovalNodeWithID,
     sequence: SerovalNode,
   ];
 }
@@ -418,7 +433,7 @@ export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
 export interface SerovalAsyncIteratorFactoryInstanceNode extends SerovalBaseNode {
   t: SerovalNodeType.AsyncIteratorFactoryInstance;
   a: [
-    instance: SerovalNode,
+    instance: SerovalNodeWithID,
     sequence: SerovalNode,
   ];
 }
@@ -427,16 +442,11 @@ export interface SerovalReadableStreamNode extends SerovalBaseNode {
   t: SerovalNodeType.ReadableStream;
   i: number;
   a: [
-    instance: SerovalNode,
+    instance: SerovalNodeWithID,
     sequence: SerovalNode,
   ];
 }
 
-export interface SerovalReadableStreamFactoryNode extends SerovalBaseNode {
-  t: SerovalNodeType.ReadableStreamFactory;
-  i: number;
-}
-
 export type SerovalSyncNode =
   | SerovalPrimitiveNode
   | SerovalIndexedValueNode
@@ -464,7 +474,7 @@ export type SerovalSyncNode =
   | SerovalCustomEventNode
   | SerovalDOMExceptionNode
   | SerovalPluginNode
-  | SerovalMapSentinelNode
+  | SerovalSpecialReferenceNode
   | SerovalIteratorFactoryNode
   | SerovalIteratorFactoryInstanceNode
   | SerovalAsyncIteratorFactoryNode
@@ -483,8 +493,7 @@ export type SerovalAsyncNode =
   | SerovalReadableStreamErrorNode
   | SerovalRequestNode
   | SerovalResponseNode
-  | SerovalReadableStreamNode
-  | SerovalReadableStreamFactoryNode;
+  | SerovalReadableStreamNode;
 
 export type SerovalNode =
   | SerovalSyncNode

package/src/core/web-api.ts

@@ -5,6 +5,7 @@ import type {
   SerovalDOMExceptionNode,
   SerovalEventNode,
   SerovalNode,
+  SerovalNodeWithID,
   SerovalReadableStreamNode,
   SerovalURLNode,
   SerovalURLSearchParamsNode,
@@ -114,7 +115,7 @@ export function createCustomEventNode(
 
 export function createReadableStreamNode(
   id: number,
-  factory: SerovalNode,
+  factory: SerovalNodeWithID,
   items: SerovalNode,
 ): SerovalReadableStreamNode {
   return {

package/src/index.ts

@@ -14,7 +14,7 @@ export { createReference } from './core/reference';
 export * from './core/tree';
 export * from './core/cross';
 
-export { GLOBAL_CONTEXT_API_SCRIPT, getCrossReferenceHeader } from './core/keys';
+export { getCrossReferenceHeader } from './core/keys';
 
 export { default as Serializer } from './core/Serializer';
 export * from './core/plugin';