seroval 0.15.0 → 1.0.0

package/src/core/types.ts

@@ -22,8 +22,8 @@ export interface SerovalBaseNode {
   m: string | undefined;
   // properties (objects)
   p: SerovalObjectRecordNode | undefined;
-  // entries (for Map, Headers, etc.)
-  e: SerovalMapRecordNode | SerovalPlainRecordNode | undefined;
+  // entries (for Map, etc.)
+  e: SerovalMapRecordNode | undefined;
   // array of nodes
   a: (SerovalNode | undefined)[] | undefined;
   // fulfilled node
@@ -34,15 +34,7 @@ export interface SerovalBaseNode {
   o: SerovalObjectFlags | undefined;
 }
 
-export type SerovalObjectRecordKey =
-  | string
-  | SerovalNode;
-
-export interface SerovalPlainRecordNode {
-  k: string[];
-  v: SerovalNode[];
-  s: number;
-}
+export type SerovalObjectRecordKey = string | SerovalNode;
 
 export interface SerovalObjectRecordNode {
   k: SerovalObjectRecordKey[];
@@ -226,20 +218,6 @@ export interface SerovalWKSymbolNode extends SerovalBaseNode {
   s: Symbols;
 }
 
-export interface SerovalURLNode extends SerovalBaseNode {
-  t: SerovalNodeType.URL;
-  i: number;
-  // raw URL
-  s: string;
-}
-
-export interface SerovalURLSearchParamsNode extends SerovalBaseNode {
-  t: SerovalNodeType.URLSearchParams;
-  i: number;
-  // raw URL search params
-  s: string;
-}
-
 export interface SerovalReferenceNode extends SerovalBaseNode {
   t: SerovalNodeType.Reference;
   i: number;
@@ -258,40 +236,6 @@ export interface SerovalDataViewNode extends SerovalBaseNode {
   b: number;
 }
 
-export interface SerovalBlobNode extends SerovalBaseNode {
-  t: SerovalNodeType.Blob;
-  i: number;
-  // file type
-  c: string;
-  // reference to array buffer
-  f: SerovalNode;
-}
-
-export interface SerovalFileNode extends SerovalBaseNode {
-  t: SerovalNodeType.File;
-  i: number;
-  // file type
-  c: string;
-  // file name
-  m: string;
-  // reference to array buffer
-  f: SerovalNode;
-  // last modified
-  b: number;
-}
-
-export interface SerovalHeadersNode extends SerovalBaseNode {
-  t: SerovalNodeType.Headers;
-  i: number;
-  e: SerovalPlainRecordNode;
-}
-
-export interface SerovalFormDataNode extends SerovalBaseNode {
-  t: SerovalNodeType.FormData;
-  i: number;
-  e: SerovalPlainRecordNode;
-}
-
 export interface SerovalBoxedNode extends SerovalBaseNode {
   t: SerovalNodeType.Boxed;
   i: number;
@@ -307,91 +251,13 @@ export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
 export interface SerovalPromiseResolveNode extends SerovalBaseNode {
   t: SerovalNodeType.PromiseResolve;
   i: number;
-  a: [
-    resolver: SerovalNodeWithID,
-    resolved: SerovalNode,
-  ];
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
 }
 
 export interface SerovalPromiseRejectNode extends SerovalBaseNode {
   t: SerovalNodeType.PromiseReject;
   i: number;
-  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;
-  a: [
-    resolver: SerovalNodeWithID,
-    resolved: SerovalNode,
-  ];
-}
-
-export interface SerovalReadableStreamErrorNode extends SerovalBaseNode {
-  t: SerovalNodeType.ReadableStreamError;
-  i: number;
-  a: [
-    resolver: SerovalNodeWithID,
-    resolved: SerovalNode,
-  ];
-}
-
-export interface SerovalReadableStreamCloseNode extends SerovalBaseNode {
-  t: SerovalNodeType.ReadableStreamClose;
-  i: number;
-  f: SerovalNodeWithID;
-}
-
-export interface SerovalRequestNode extends SerovalBaseNode {
-  t: SerovalNodeType.Request;
-  i: number;
-  // Request URL
-  s: string;
-  // This is just a shortcut for serializing the option fields
-  f: SerovalNode;
-}
-
-export interface SerovalResponseNode extends SerovalBaseNode {
-  t: SerovalNodeType.Response;
-  i: number;
-  // This is just a shortcut for serializing the option fields
-  a: [body: SerovalNode, options: SerovalNode];
-}
-
-export interface SerovalEventNode extends SerovalBaseNode {
-  t: SerovalNodeType.Event;
-  i: number;
-  // Event type
-  s: string;
-  // Event options
-  f: SerovalNode;
-}
-
-export interface SerovalCustomEventNode extends SerovalBaseNode {
-  t: SerovalNodeType.CustomEvent;
-  i: number;
-  // Event type
-  s: string;
-  f: SerovalNode;
-}
-
-export interface SerovalDOMExceptionNode extends SerovalBaseNode {
-  t: SerovalNodeType.DOMException;
-  i: number;
-  // Message
-  s: string;
-  // name
-  c: string;
+  a: [resolver: SerovalNodeWithID, resolved: SerovalNode];
 }
 
 export interface SerovalPluginNode extends SerovalBaseNode {
@@ -412,39 +278,49 @@ export interface SerovalSpecialReferenceNode extends SerovalBaseNode {
 export interface SerovalIteratorFactoryNode extends SerovalBaseNode {
   t: SerovalNodeType.IteratorFactory;
   i: number;
-  f: SerovalNode;
+  f: SerovalNodeWithID;
 }
 
 export interface SerovalIteratorFactoryInstanceNode extends SerovalBaseNode {
   t: SerovalNodeType.IteratorFactoryInstance;
-  a: [
-    instance: SerovalNodeWithID,
-    sequence: SerovalNode,
-  ];
+  a: [instance: SerovalNodeWithID, sequence: SerovalNode];
 }
 
 export interface SerovalAsyncIteratorFactoryNode extends SerovalBaseNode {
   t: SerovalNodeType.AsyncIteratorFactory;
   i: number;
-  s: 0 | 1;
-  f: SerovalNode;
+  a: [promise: SerovalNodeWithID, symbol: SerovalNodeWithID];
 }
 
-export interface SerovalAsyncIteratorFactoryInstanceNode extends SerovalBaseNode {
+export interface SerovalAsyncIteratorFactoryInstanceNode
+  extends SerovalBaseNode {
   t: SerovalNodeType.AsyncIteratorFactoryInstance;
-  a: [
-    instance: SerovalNodeWithID,
-    sequence: SerovalNode,
-  ];
+  a: [instance: SerovalNodeWithID, sequence: SerovalNode];
+}
+
+export interface SerovalStreamConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamConstructor;
+  i: number;
+  a: SerovalNode[];
+  f: SerovalNodeWithID;
+}
+
+export interface SerovalStreamNextNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamNext;
+  i: number;
+  f: SerovalNode;
 }
 
-export interface SerovalReadableStreamNode extends SerovalBaseNode {
-  t: SerovalNodeType.ReadableStream;
+export interface SerovalStreamThrowNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamThrow;
   i: number;
-  a: [
-    instance: SerovalNodeWithID,
-    sequence: SerovalNode,
-  ];
+  f: SerovalNode;
+}
+
+export interface SerovalStreamReturnNode extends SerovalBaseNode {
+  t: SerovalNodeType.StreamReturn;
+  i: number;
+  f: SerovalNode;
 }
 
 export type SerovalSyncNode =
@@ -460,19 +336,10 @@ export type SerovalSyncNode =
   | SerovalErrorNode
   | SerovalAggregateErrorNode
   | SerovalWKSymbolNode
-  | SerovalURLNode
-  | SerovalURLSearchParamsNode
   | SerovalReferenceNode
   | SerovalArrayBufferNode
   | SerovalDataViewNode
-  | SerovalBlobNode
-  | SerovalFileNode
-  | SerovalHeadersNode
-  | SerovalFormDataNode
   | SerovalBoxedNode
-  | SerovalEventNode
-  | SerovalCustomEventNode
-  | SerovalDOMExceptionNode
   | SerovalPluginNode
   | SerovalSpecialReferenceNode
   | SerovalIteratorFactoryNode
@@ -482,21 +349,14 @@ export type SerovalSyncNode =
 
 export type SerovalAsyncNode =
   | SerovalPromiseNode
-  | SerovalBlobNode
-  | SerovalFileNode
   | SerovalPromiseConstructorNode
   | SerovalPromiseResolveNode
   | SerovalPromiseRejectNode
-  | SerovalReadableStreamConstructorNode
-  | SerovalReadableStreamEnqueueNode
-  | SerovalReadableStreamCloseNode
-  | SerovalReadableStreamErrorNode
-  | SerovalRequestNode
-  | SerovalResponseNode
-  | SerovalReadableStreamNode;
-
-export type SerovalNode =
-  | SerovalSyncNode
-  | SerovalAsyncNode;
+  | SerovalStreamConstructorNode
+  | SerovalStreamNextNode
+  | SerovalStreamThrowNode
+  | SerovalStreamReturnNode;
+
+export type SerovalNode = SerovalSyncNode | SerovalAsyncNode;
 
 export type SerovalNodeWithID = Extract<SerovalNode, { i: number }>;

package/src/core/utils/deferred.ts

@@ -20,30 +20,3 @@ export function createDeferred(): Deferred {
     },
   };
 }
-
-export interface DeferredStream {
-  stream: ReadableStream;
-  close(): void;
-  enqueue(chunk?: unknown): void;
-  error(e?: any): void;
-}
-
-export function createDeferredStream(): DeferredStream {
-  let controller: ReadableStreamDefaultController;
-  return {
-    stream: new ReadableStream({
-      start(current): void {
-        controller = current;
-      },
-    }),
-    close(): void {
-      controller.close();
-    },
-    enqueue(data): void {
-      controller.enqueue(data);
-    },
-    error(e): void {
-      controller.error(e);
-    },
-  };
-}

package/src/core/utils/error.ts

@@ -1,11 +1,15 @@
-import type {
-  ErrorValue,
-} from '../../types';
 import { Feature } from '../compat';
-import {
-  ERROR_CONSTRUCTOR_STRING,
-  ErrorConstructorTag,
-} from '../constants';
+import { ERROR_CONSTRUCTOR_STRING, ErrorConstructorTag } from '../constants';
+
+type ErrorValue =
+  | Error
+  | AggregateError
+  | EvalError
+  | RangeError
+  | ReferenceError
+  | TypeError
+  | SyntaxError
+  | URIError;
 
 export function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {
   if (error instanceof EvalError) {
@@ -29,20 +33,27 @@ export function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {
   return ErrorConstructorTag.Error;
 }
 
-export function getErrorOptions(
+function getInitialErrorOptions(
   error: Error,
-  features: number,
 ): Record<string, unknown> | undefined {
-  let options: Record<string, unknown> | undefined;
-  const constructor = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
+  const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
   // Name has been modified
-  if (error.name !== constructor) {
-    options = { name: error.name };
-  } else if (error.constructor.name !== constructor) {
+  if (error.name !== construct) {
+    return { name: error.name };
+  }
+  if (error.constructor.name !== construct) {
     // Otherwise, name is overriden because
     // the Error class is extended
-    options = { name: error.constructor.name };
+    return { name: error.constructor.name };
   }
+  return {};
+}
+
+export function getErrorOptions(
+  error: Error,
+  features: number,
+): Record<string, unknown> | undefined {
+  let options = getInitialErrorOptions(error);
   const names = Object.getOwnPropertyNames(error);
   for (let i = 0, len = names.length, name: string; i < len; i++) {
     name = names[i];

package/src/core/utils/get-identifier.ts

@@ -1,8 +1,9 @@
 // Written by https://github.com/DylanPiercey and is distributed under the MIT license.
-const REF_START_CHARS = 'hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_'; // Avoids chars that could evaluate to a reserved word.
-const REF_START_CHARS_LEN = REF_START_CHARS.length;
-const REF_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';
-const REF_CHARS_LEN = REF_CHARS.length;
+const REF_START_CHARS = /* @__PURE__ */ 'hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_'; // Avoids chars that could evaluate to a reserved word.
+const REF_START_CHARS_LEN = /* @__PURE__ */ REF_START_CHARS.length;
+const REF_CHARS =
+  /* @__PURE__ */ 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';
+const REF_CHARS_LEN = /* @__PURE__ */ REF_CHARS.length;
 
 export default function getIdentifier(index: number): string {
   let mod = index % REF_START_CHARS_LEN;

package/src/core/utils/is-valid-identifier.ts

@@ -3,9 +3,10 @@ const IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
 export function isValidIdentifier(name: string): boolean {
   const char = name[0];
   return (
-    char === '$'
-    || char === '_'
-    || (char >= 'A' && char <= 'Z')
-    || (char >= 'a' && char <= 'z')
-  ) && IDENTIFIER_CHECK.test(name);
+    (char === '$' ||
+      char === '_' ||
+      (char >= 'A' && char <= 'Z') ||
+      (char >= 'a' && char <= 'z')) &&
+    IDENTIFIER_CHECK.test(name)
+  );
 }

package/src/core/utils/iterator-to-sequence.ts

@@ -1,6 +1,3 @@
-import type BaseStreamParserContext from '../context/parser/stream';
-
-/* eslint-disable no-await-in-loop */
 export interface Sequence {
   v: unknown[];
   t: number;
@@ -65,174 +62,3 @@ export function sequenceToIterator<T>(
     };
   };
 }
-
-export async function asyncIteratorToSequence<T>(source: AsyncIterable<T>): Promise<Sequence> {
-  const values: unknown[] = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-
-  const iterator = source[Symbol.asyncIterator]();
-
-  while (true) {
-    try {
-      const value = await iterator.next();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      values.push(error);
-    }
-  }
-
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt,
-  };
-}
-
-export function sequenceToAsyncIterator<T>(
-  sequence: Sequence,
-): () => AsyncIterableIterator<T> {
-  return (): AsyncIterableIterator<T> => {
-    let index = 0;
-    return {
-      [Symbol.asyncIterator](): AsyncIterableIterator<T> {
-        return this;
-      },
-      async next(): Promise<IteratorResult<T>> {
-        if (index > sequence.d) {
-          return {
-            done: true,
-            value: undefined,
-          };
-        }
-        const currentIndex = index++;
-        const currentItem = sequence.v[currentIndex];
-        if (currentIndex === sequence.t) {
-          throw currentItem;
-        }
-        return Promise.resolve({
-          done: currentIndex === sequence.d,
-          value: currentItem as T,
-        });
-      },
-    };
-  };
-}
-
-export function asyncIteratorToReadableStream<T>(
-  source: AsyncIterable<T>,
-  parser: BaseStreamParserContext,
-): ReadableStream<unknown> {
-  return new ReadableStream({
-    async start(controller): Promise<void> {
-      const iterator = source[Symbol.asyncIterator]();
-      while (parser.isAlive()) {
-        try {
-          const result = await iterator.next();
-          controller.enqueue([result.done ? 2 : 0, result.value]);
-          if (result.done) {
-            controller.close();
-            return;
-          }
-        } catch (error) {
-          controller.enqueue([1, error]);
-        }
-      }
-      controller.close();
-    },
-  });
-}
-
-type RSNext<T> = [0, T];
-type RSThrow = [1, any];
-type RSReturn<T> = [2, T];
-
-export type SerializedAsyncIteratorResult<T> = RSNext<T> | RSThrow | RSReturn<T>;
-
-export function readableStreamToAsyncIterator<T>(
-  source: ReadableStream<SerializedAsyncIteratorResult<T>>,
-): () => AsyncIterableIterator<T> {
-  let current = source;
-  return (): AsyncIterableIterator<T> => {
-    const [left, right] = current.tee();
-    const clone = left;
-    current = right;
-    const reader = clone.getReader();
-    return {
-      [Symbol.asyncIterator](): AsyncIterableIterator<T> {
-        return this;
-      },
-      async next(): Promise<IteratorResult<T>> {
-        const result = await reader.read();
-        if (result.done) {
-          return {
-            done: true,
-            value: undefined,
-          };
-        }
-        const [status, value] = result.value;
-        if (status === 1) {
-          throw value;
-        }
-        return {
-          done: status === 2,
-          value,
-        };
-      },
-    };
-  };
-}
-
-export async function readableStreamToSequence<T>(
-  stream: ReadableStream<T>,
-): Promise<Sequence> {
-  const values: unknown[] = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-
-  const iterator = stream.getReader();
-
-  while (true) {
-    try {
-      const value = await iterator.read();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      doneAt = throwsAt;
-      values.push(error);
-      break;
-    }
-  }
-
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt,
-  };
-}
-
-export function sequenceToReadableStream<T>(
-  sequence: Sequence,
-): ReadableStream<T> {
-  return new ReadableStream<T>({
-    start(controller): void {
-      for (let i = 0; i < sequence.d; i++) {
-        controller.enqueue(sequence.v[i] as T);
-      }
-      if (sequence.t === -1) {
-        controller.close();
-      } else {
-        controller.error(sequence.v[sequence.t] as T);
-      }
-    },
-  });
-}

package/src/core/utils/typed-array.ts

@@ -11,19 +11,43 @@ type TypedArrayConstructor =
   | BigInt64ArrayConstructor
   | BigUint64ArrayConstructor;
 
+export type TypedArrayValue =
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint8Array
+  | Uint16Array
+  | Uint32Array
+  | Uint8ClampedArray
+  | Float32Array
+  | Float64Array;
+
+export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
+
 export function getTypedArrayConstructor(name: string): TypedArrayConstructor {
   switch (name) {
-    case 'Int8Array': return Int8Array;
-    case 'Int16Array': return Int16Array;
-    case 'Int32Array': return Int32Array;
-    case 'Uint8Array': return Uint8Array;
-    case 'Uint16Array': return Uint16Array;
-    case 'Uint32Array': return Uint32Array;
-    case 'Uint8ClampedArray': return Uint8ClampedArray;
-    case 'Float32Array': return Float32Array;
-    case 'Float64Array': return Float64Array;
-    case 'BigInt64Array': return BigInt64Array;
-    case 'BigUint64Array': return BigUint64Array;
+    case 'Int8Array':
+      return Int8Array;
+    case 'Int16Array':
+      return Int16Array;
+    case 'Int32Array':
+      return Int32Array;
+    case 'Uint8Array':
+      return Uint8Array;
+    case 'Uint16Array':
+      return Uint16Array;
+    case 'Uint32Array':
+      return Uint32Array;
+    case 'Uint8ClampedArray':
+      return Uint8ClampedArray;
+    case 'Float32Array':
+      return Float32Array;
+    case 'Float64Array':
+      return Float64Array;
+    case 'BigInt64Array':
+      return BigInt64Array;
+    case 'BigUint64Array':
+      return BigUint64Array;
     default:
       throw new Error(`Unknown TypedArray "${name}"`);
   }

package/src/index.ts

@@ -1,22 +1,15 @@
-import { serialize } from './core/tree';
-
-export type {
-  AsyncServerValue,
-  ServerValue,
-  PrimitiveValue,
-  CommonServerValue,
-  SemiPrimitiveValue,
-  ErrorValue,
-} from './types';
 export { Feature } from './core/compat';
 export { createReference } from './core/reference';
 
 export * from './core/tree';
 export * from './core/cross';
 
+export { getCrossReferenceHeader } from './core/keys';
+
 export { default as Serializer } from './core/Serializer';
 export * from './core/plugin';
 
-export type { SerovalNode } from './core/types';
+export type { Stream } from './core/stream';
+export { createStream } from './core/stream';
 
-export default serialize;
+export type { SerovalNode } from './core/types';

package/dist/types/core/utils/constructors.d.ts

@@ -1,5 +0,0 @@
-export declare function createRequestOptions(current: Request, body: ArrayBuffer | ReadableStream | null): RequestInit;
-export declare function createResponseOptions(current: Response): ResponseInit;
-export declare function createEventOptions(current: Event): EventInit;
-export declare function createCustomEventOptions(current: CustomEvent): CustomEventInit;
-//# sourceMappingURL=constructors.d.ts.map

package/dist/types/core/utils/constructors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constructors.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/constructors.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,GAAG,cAAc,GAAG,IAAI,GACxC,WAAW,CAcb;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,QAAQ,GAChB,YAAY,CAMd;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,KAAK,GACb,SAAS,CAMX;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,WAAW,GACnB,eAAe,CAOjB"}