seroval 0.15.1 → 1.0.0

package/src/core/string.ts

@@ -1,16 +1,27 @@
 export function serializeChar(str: string): string | undefined {
   switch (str) {
-    case '"': return '\\"';
-    case '\\': return '\\\\';
-    case '\n': return '\\n';
-    case '\r': return '\\r';
-    case '\b': return '\\b';
-    case '\t': return '\\t';
-    case '\f': return '\\f';
-    case '<': return '\\x3C';
-    case '\u2028': return '\\u2028';
-    case '\u2029': return '\\u2029';
-    default: return undefined;
+    case '"':
+      return '\\"';
+    case '\\':
+      return '\\\\';
+    case '\n':
+      return '\\n';
+    case '\r':
+      return '\\r';
+    case '\b':
+      return '\\b';
+    case '\t':
+      return '\\t';
+    case '\f':
+      return '\\f';
+    case '<':
+      return '\\x3C';
+    case '\u2028':
+      return '\\u2028';
+    case '\u2029':
+      return '\\u2029';
+    default:
+      return undefined;
   }
 }
 
@@ -38,16 +49,36 @@ export function serializeString(str: string): string {
   return result;
 }
 
+function deserializeReplacer(str: string): string {
+  switch (str) {
+    case '\\\\':
+      return '\\';
+    case '\\"':
+      return '"';
+    case '\\n':
+      return '\n';
+    case '\\r':
+      return '\r';
+    case '\\b':
+      return '\b';
+    case '\\t':
+      return '\t';
+    case '\\f':
+      return '\f';
+    case '\\x3C':
+      return '\x3C';
+    case '\\u2028':
+      return '\u2028';
+    case '\\u2029':
+      return '\u2029';
+    default:
+      return str;
+  }
+}
+
 export function deserializeString(str: string): string {
-  return str
-    .replace(/\\"/g, '"')
-    .replace(/\\\\/g, '\\')
-    .replace(/\\n/g, '\n')
-    .replace(/\\r/g, '\r')
-    .replace(/\\b/g, '\b')
-    .replace(/\\t/g, '\t')
-    .replace(/\\f/g, '\f')
-    .replace(/\\x3C/g, '<')
-    .replace(/\\u2028/g, '\u2028')
-    .replace(/\\u2029/g, '\u2029');
+  return str.replace(
+    /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g,
+    deserializeReplacer,
+  );
 }

package/src/core/tree/async.ts

@@ -2,7 +2,7 @@ import BaseAsyncParserContext from '../context/parser/async';
 import type { BaseParserContextOptions } from '../context/parser';
 import type { SerovalMode } from '../plugin';
 
-export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>
+export type AsyncParserContextOptions = Omit<BaseParserContextOptions, 'refs'>;
 
 export default class AsyncParserContext extends BaseAsyncParserContext {
   readonly mode: SerovalMode = 'vanilla';

package/src/core/tree/deserializer.ts

@@ -2,7 +2,8 @@ import BaseDeserializerContext from '../context/deserializer';
 import type { BaseDeserializerOptions } from '../context/deserializer';
 import type { SerovalMode } from '../plugin';
 
-export interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerOptions, 'refs'> {
+export interface VanillaDeserializerContextOptions
+  extends Omit<BaseDeserializerOptions, 'refs'> {
   markedRefs: number[] | Set<number>;
 }
 
@@ -12,17 +13,11 @@ export default class VanillaDeserializerContext extends BaseDeserializerContext
   marked: Set<number>;
 
   constructor(options: VanillaDeserializerContextOptions) {
-    super({
-      plugins: options.plugins,
-      refs: undefined,
-    });
+    super(options);
     this.marked = new Set(options.markedRefs);
   }
 
-  assignIndexedValue<T>(
-    index: number,
-    value: T,
-  ): T {
+  assignIndexedValue<T>(index: number, value: T): T {
     if (this.marked.has(index)) {
       this.refs.set(index, value);
     }

package/src/core/tree/index.ts

@@ -1,4 +1,4 @@
-import type { PluginAccessOptions } from '../plugin';
+import { resolvePlugins, type PluginAccessOptions } from '../plugin';
 import type { SerovalNode } from '../types';
 import type { AsyncParserContextOptions } from './async';
 import AsyncParserContext from './async';
@@ -11,13 +11,14 @@ export function serialize<T>(
   source: T,
   options: SyncParserContextOptions = {},
 ): string {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   const tree = ctx.parse(source);
   const serial = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     markedRefs: ctx.marked,
   });
@@ -28,13 +29,14 @@ export async function serializeAsync<T>(
   source: T,
   options: AsyncParserContextOptions = {},
 ): Promise<string> {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   const tree = await ctx.parse(source);
   const serial = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: ctx.features,
     markedRefs: ctx.marked,
   });
@@ -42,7 +44,6 @@ export async function serializeAsync<T>(
 }
 
 export function deserialize<T>(source: string): T {
-  // eslint-disable-next-line no-eval
   return (0, eval)(source) as T;
 }
 
@@ -56,8 +57,9 @@ export function toJSON<T>(
   source: T,
   options: SyncParserContextOptions = {},
 ): SerovalJSON {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new SyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   return {
@@ -71,8 +73,9 @@ export async function toJSONAsync<T>(
   source: T,
   options: AsyncParserContextOptions = {},
 ): Promise<SerovalJSON> {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new AsyncParserContext({
-    plugins: options.plugins,
+    plugins,
     disabledFeatures: options.disabledFeatures,
   });
   return {
@@ -83,8 +86,9 @@ export async function toJSONAsync<T>(
 }
 
 export function compileJSON(source: SerovalJSON, options: PluginAccessOptions = {}): string {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new VanillaSerializerContext({
-    plugins: options.plugins,
+    plugins,
     features: source.f,
     markedRefs: source.m,
   });
@@ -92,8 +96,9 @@ export function compileJSON(source: SerovalJSON, options: PluginAccessOptions =
 }
 
 export function fromJSON<T>(source: SerovalJSON, options: PluginAccessOptions = {}): T {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = new VanillaDeserializerContext({
-    plugins: options.plugins,
+    plugins,
     markedRefs: source.m,
   });
   return ctx.deserialize(source.t) as T;

package/src/core/tree/serializer.ts

@@ -3,10 +3,6 @@ import type {
   SerovalPromiseConstructorNode,
   SerovalPromiseRejectNode,
   SerovalPromiseResolveNode,
-  SerovalReadableStreamCloseNode,
-  SerovalReadableStreamConstructorNode,
-  SerovalReadableStreamEnqueueNode,
-  SerovalReadableStreamErrorNode,
 } from '../types';
 import type { BaseSerializerContextOptions } from '../context/serializer';
 import BaseSerializerContext from '../context/serializer';
@@ -14,7 +10,7 @@ import getIdentifier from '../utils/get-identifier';
 import type { SerovalMode } from '../plugin';
 import { SerovalNodeType } from '../constants';
 
-export type VanillaSerializerContextOptions = BaseSerializerContextOptions
+export type VanillaSerializerContextOptions = BaseSerializerContextOptions;
 
 export default class VanillaSerializerContext extends BaseSerializerContext {
   readonly mode: SerovalMode = 'vanilla';
@@ -23,7 +19,7 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
    * Map tree refs to actual refs
    * @private
    */
-  valid = new Map<number | string, number>();
+  valid = new Map<number, number>();
 
   /**
    * Variables
@@ -31,20 +27,11 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
    */
   vars: string[] = [];
 
-  /**
-   * Increments the number of references the referenced value has
-   */
-  markRef(
-    current: number,
-  ): void {
-    this.marked.add(current);
-  }
-
   /**
    * Creates the reference param (identifier) from the given reference ID
    * Calling this function means the value has been referenced somewhere
    */
-  getRefParam(index: number | string): string {
+  getRefParam(index: number): string {
     /**
      * Creates a new reference ID from a given reference ID
      * This new reference ID means that the reference itself
@@ -64,10 +51,7 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
     return identifier;
   }
 
-  protected assignIndexedValue(
-    index: number,
-    value: string,
-  ): string {
+  protected assignIndexedValue(index: number, value: string): string {
     if (this.isMarked(index)) {
       return this.getRefParam(index) + '=' + value;
     }
@@ -80,39 +64,11 @@ export default class VanillaSerializerContext extends BaseSerializerContext {
     throw new Error('Unsupported node type "' + node.t + '".');
   }
 
-  protected serializePromiseResolve(
-    node: SerovalPromiseResolveNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializePromiseReject(
-    node: SerovalPromiseRejectNode,
-  ): string {
+  protected serializePromiseResolve(node: SerovalPromiseResolveNode): string {
     throw new Error('Unsupported node type "' + node.t + '".');
   }
 
-  protected serializeReadableStreamConstructor(
-    node: SerovalReadableStreamConstructorNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializeReadableStreamEnqueue(
-    node: SerovalReadableStreamEnqueueNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializeReadableStreamError(
-    node: SerovalReadableStreamErrorNode,
-  ): string {
-    throw new Error('Unsupported node type "' + node.t + '".');
-  }
-
-  protected serializeReadableStreamClose(
-    node: SerovalReadableStreamCloseNode,
-  ): string {
+  protected serializePromiseReject(node: SerovalPromiseRejectNode): string {
     throw new Error('Unsupported node type "' + node.t + '".');
   }
 

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);
-    },
-  };
-}