seroval 0.8.0 → 0.10.1

package/src/{tree → core/tree}/sync.ts

@@ -1,40 +1,33 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import assert from '../assert';
 import { Feature } from '../compat';
-import type { ParserContext } from '../context';
-import { createIndexedValue } from '../context';
+import type { ParserContext } from './context';
+import { createIndexedValue } from './context';
 import { serializeString } from '../string';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
-import UnsupportedTypeError from './UnsupportedTypeError';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
+import UnsupportedTypeError from '../UnsupportedTypeError';
 import {
   TRUE_NODE,
   FALSE_NODE,
   UNDEFINED_NODE,
   NULL_NODE,
-} from './constants';
+} from '../literals';
 import {
-  createBigIntNode,
   createBigIntTypedArrayNode,
-  createDateNode,
-  createNumberNode,
-  createIndexedValueNode,
-  createRegExpNode,
-  createStringNode,
   createTypedArrayNode,
-  createReferenceNode,
-  createArrayBufferNode,
   createDataViewNode,
   createSymbolNode,
   createFunctionNode,
 } from './primitives';
 import {
   hasReferenceID,
-} from './reference';
+} from '../reference';
 import {
   getErrorConstructorName,
   getErrorOptions,
+  getObjectFlag,
   isIterable,
-} from './shared';
+} from '../shared';
 import type {
   SerovalAggregateErrorNode,
   SerovalArrayNode,
@@ -43,25 +36,35 @@ import type {
   SerovalFormDataNode,
   SerovalHeadersNode,
   SerovalMapNode,
-  SerovalNode,
   SerovalNullConstructorNode,
   SerovalObjectNode,
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
   SerovalPlainRecordNode,
   SerovalSetNode,
-} from './types';
+  SerovalSyncNode,
+} from '../types';
 import {
-  SerovalNodeType,
   SerovalObjectRecordSpecialKey,
-} from './types';
-import { createURLNode, createURLSearchParamsNode } from './web-api';
+} from '../types';
+import { SerovalNodeType } from '../constants';
+import {
+  createArrayBufferNode,
+  createBigIntNode,
+  createDateNode,
+  createIndexedValueNode,
+  createNumberNode,
+  createReferenceNode,
+  createRegExpNode,
+  createStringNode,
+} from '../base-primitives';
+import { createURLNode, createURLSearchParamsNode } from '../web-api';
 
 type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;
 
-function generateNodeList(ctx: ParserContext, current: unknown[]): SerovalNode[] {
+function generateNodeList(ctx: ParserContext, current: unknown[]): SerovalSyncNode[] {
   const size = current.length;
-  const nodes = new Array<SerovalNode>(size);
+  const nodes = new Array<SerovalSyncNode>(size);
   const deferred = new Array<unknown>(size);
   let item: unknown;
   for (let i = 0; i < size; i++) {
@@ -94,10 +97,12 @@ function generateArrayNode(
     l: current.length,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: generateNodeList(ctx, current),
     f: undefined,
     b: undefined,
+    o: getObjectFlag(current),
   };
 }
 
@@ -108,8 +113,8 @@ function generateMapNode(
 ): SerovalMapNode {
   assert(ctx.features & Feature.Map, new UnsupportedTypeError(current));
   const len = current.size;
-  const keyNodes = new Array<SerovalNode>(len);
-  const valueNodes = new Array<SerovalNode>(len);
+  const keyNodes = new Array<SerovalSyncNode>(len);
+  const valueNodes = new Array<SerovalSyncNode>(len);
   const deferredKey = new Array<unknown>(len);
   const deferredValue = new Array<unknown>(len);
   let deferredSize = 0;
@@ -137,10 +142,12 @@ function generateMapNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: { k: keyNodes, v: valueNodes, s: len },
+    p: undefined,
+    e: { k: keyNodes, v: valueNodes, s: len },
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -151,7 +158,7 @@ function generateSetNode(
 ): SerovalSetNode {
   assert(ctx.features & Feature.Set, new UnsupportedTypeError(current));
   const len = current.size;
-  const nodes = new Array<SerovalNode>(len);
+  const nodes = new Array<SerovalSyncNode>(len);
   const deferred = new Array<unknown>(len);
   let deferredSize = 0;
   let nodeSize = 0;
@@ -174,10 +181,12 @@ function generateSetNode(
     l: len,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: nodes,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -188,7 +197,7 @@ function generateProperties(
   const keys = Object.keys(properties);
   let size = keys.length;
   const keyNodes = new Array<SerovalObjectRecordKey>(size);
-  const valueNodes = new Array<SerovalNode>(size);
+  const valueNodes = new Array<SerovalSyncNode>(size);
   const deferredKeys = new Array<SerovalObjectRecordKey>(size);
   const deferredValues = new Array<unknown>(size);
   let deferredSize = 0;
@@ -235,7 +244,7 @@ function generatePlainProperties(
   const keys = Object.keys(properties);
   const size = keys.length;
   const keyNodes = new Array<string>(size);
-  const valueNodes = new Array<SerovalNode>(size);
+  const valueNodes = new Array<SerovalSyncNode>(size);
   const deferredKeys = new Array<string>(size);
   const deferredValues = new Array<unknown>(size);
   let deferredSize = 0;
@@ -279,10 +288,12 @@ function generateObjectNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: generateProperties(ctx, current),
+    p: generateProperties(ctx, current),
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: getObjectFlag(current),
   };
 }
 
@@ -302,10 +313,12 @@ function generateAggregateErrorNode(
     l: undefined,
     c: undefined,
     m: serializeString(current.message),
-    d: optionsNode,
+    p: optionsNode,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -325,10 +338,12 @@ function generateErrorNode(
     l: undefined,
     c: getErrorConstructorName(current),
     m: serializeString(current.message),
-    d: optionsNode,
+    p: optionsNode,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -350,10 +365,12 @@ function generateHeadersNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: generatePlainProperties(ctx, items),
+    p: undefined,
+    e: generatePlainProperties(ctx, items),
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -375,10 +392,12 @@ function generateFormDataNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: generatePlainProperties(ctx, items),
+    p: undefined,
+    e: generatePlainProperties(ctx, items),
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -394,24 +413,26 @@ function generateBoxedNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: parseSync(ctx, current.valueOf()),
     b: undefined,
+    o: undefined,
   };
 }
 
 function parseObject(
   ctx: ParserContext,
   current: object | null,
-): SerovalNode {
+): SerovalSyncNode {
   if (!current) {
     return NULL_NODE;
   }
   // Non-primitive values needs a reference ID
   // mostly because the values themselves are stateful
   const id = createIndexedValue(ctx, current);
-  if (ctx.markedRefs.has(id)) {
+  if (ctx.reference.marked.has(id)) {
     return createIndexedValueNode(id);
   }
   if (hasReferenceID(current)) {
@@ -516,7 +537,7 @@ function parseObject(
 export default function parseSync<T>(
   ctx: ParserContext,
   current: T,
-): SerovalNode {
+): SerovalSyncNode {
   switch (typeof current) {
     case 'boolean':
       return current ? TRUE_NODE : FALSE_NODE;

package/src/{tree → core/tree}/web-api.ts

@@ -1,58 +1,14 @@
 import assert from '../assert';
 import { Feature } from '../compat';
-import type { ParserContext } from '../context';
+import type { ParserContext } from './context';
 import { serializeString } from '../string';
-import UnsupportedTypeError from './UnsupportedTypeError';
+import UnsupportedTypeError from '../UnsupportedTypeError';
 import { serializeArrayBuffer } from './primitives';
 import type {
   SerovalBlobNode,
   SerovalFileNode,
-  SerovalURLNode,
-  SerovalURLSearchParamsNode,
-} from './types';
-import {
-  SerovalNodeType,
-} from './types';
-
-export function createURLNode(
-  ctx: ParserContext,
-  id: number,
-  current: URL,
-): SerovalURLNode {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
-  return {
-    t: SerovalNodeType.URL,
-    i: id,
-    s: serializeString(current.href),
-    l: undefined,
-    c: undefined,
-    m: undefined,
-    d: undefined,
-    f: undefined,
-    a: undefined,
-    b: undefined,
-  };
-}
-
-export function createURLSearchParamsNode(
-  ctx: ParserContext,
-  id: number,
-  current: URLSearchParams,
-): SerovalURLSearchParamsNode {
-  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
-  return {
-    t: SerovalNodeType.URLSearchParams,
-    i: id,
-    s: serializeString(current.toString()),
-    l: undefined,
-    c: undefined,
-    m: undefined,
-    d: undefined,
-    f: undefined,
-    a: undefined,
-    b: undefined,
-  };
-}
+} from '../types';
+import { SerovalNodeType } from '../constants';
 
 export async function createBlobNode(
   ctx: ParserContext,
@@ -67,10 +23,12 @@ export async function createBlobNode(
     l: undefined,
     c: serializeString(current.type),
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     f: serializeArrayBuffer(ctx, await current.arrayBuffer()),
     a: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -87,9 +45,11 @@ export async function createFileNode(
     l: undefined,
     c: serializeString(current.type),
     m: serializeString(current.name),
-    d: undefined,
+    p: undefined,
+    e: undefined,
     f: serializeArrayBuffer(ctx, await current.arrayBuffer()),
     a: undefined,
     b: current.lastModified,
+    o: undefined,
   };
 }

package/src/{tree → core}/types.ts

@@ -1,46 +1,9 @@
-import type { Symbols } from './symbols';
-
-export const enum SerovalConstant {
-  Null = 0,
-  Undefined = 1,
-  True = 2,
-  False = 3,
-  NegativeZero = 4,
-  Infinity = 5,
-  NegativeInfinity = 6,
-  NaN = 7,
-}
-
-export const enum SerovalNodeType {
-  Number = 0,
-  String = 1,
-  Constant = 2,
-  BigInt = 3,
-  IndexedValue = 4,
-  Date = 5,
-  RegExp = 6,
-  Set = 7,
-  Map = 8,
-  Array = 9,
-  Object = 10,
-  NullConstructor = 11,
-  Promise = 12,
-  Error = 13,
-  AggregateError = 14,
-  TypedArray = 15,
-  BigIntTypedArray = 16,
-  WKSymbol = 17,
-  URL = 18,
-  URLSearchParams = 19,
-  Reference = 20,
-  ArrayBuffer = 21,
-  DataView = 22,
-  Blob = 23,
-  File = 24,
-  Headers = 25,
-  FormData = 26,
-  Boxed = 27,
-}
+import type {
+  SerovalNodeType,
+  SerovalObjectFlags,
+  SerovalConstant,
+  Symbols,
+} from './constants';
 
 export interface SerovalBaseNode {
   // Type of the node
@@ -55,14 +18,18 @@ export interface SerovalBaseNode {
   c: string | undefined;
   // message/flags
   m: string | undefined;
-  // dictionary
-  d: SerovalObjectRecordNode | SerovalMapRecordNode | undefined;
+  // properties (objects)
+  p: SerovalObjectRecordNode | undefined;
+  // entries (for Map, Headers, etc.)
+  e: SerovalMapRecordNode | SerovalPlainRecordNode | undefined;
   // array of nodes
   a: (SerovalNode | undefined)[] | undefined;
   // fulfilled node
   f: SerovalNode | undefined;
-  // byte offset
+  // byte offset/object flags
   b: number | undefined;
+  // object flag
+  o: SerovalObjectFlags | undefined;
 }
 
 export const enum SerovalObjectRecordSpecialKey {
@@ -197,7 +164,7 @@ export interface SerovalMapNode extends SerovalBaseNode {
   t: SerovalNodeType.Map;
   i: number;
   // key/value pairs
-  d: SerovalMapRecordNode;
+  e: SerovalMapRecordNode;
 }
 
 export interface SerovalArrayNode extends SerovalBaseNode {
@@ -207,24 +174,28 @@ export interface SerovalArrayNode extends SerovalBaseNode {
   // items
   a: (SerovalNode | undefined)[];
   i: number;
+  o: SerovalObjectFlags;
 }
 
 export interface SerovalObjectNode extends SerovalBaseNode {
   t: SerovalNodeType.Object;
   // key/value pairs
-  d: SerovalObjectRecordNode;
+  p: SerovalObjectRecordNode;
   i: number;
+  o: SerovalObjectFlags;
 }
 
 export interface SerovalNullConstructorNode extends SerovalBaseNode {
   t: SerovalNodeType.NullConstructor;
   // key/value pairs
-  d: SerovalObjectRecordNode;
+  p: SerovalObjectRecordNode;
   i: number;
+  o: SerovalObjectFlags;
 }
 
 export interface SerovalPromiseNode extends SerovalBaseNode {
   t: SerovalNodeType.Promise;
+  s: 0 | 1;
   // resolved value
   f: SerovalNode;
   i: number;
@@ -237,7 +208,7 @@ export interface SerovalErrorNode extends SerovalBaseNode {
   // message
   m: string;
   // other properties
-  d: SerovalObjectRecordNode | undefined;
+  p: SerovalObjectRecordNode | undefined;
   i: number;
 }
 
@@ -247,7 +218,7 @@ export interface SerovalAggregateErrorNode extends SerovalBaseNode {
   // message
   m: string;
   // other properties
-  d: SerovalObjectRecordNode | undefined;
+  p: SerovalObjectRecordNode | undefined;
 }
 
 export interface SerovalWKSymbolNode extends SerovalBaseNode {
@@ -313,13 +284,13 @@ export interface SerovalFileNode extends SerovalBaseNode {
 export interface SerovalHeadersNode extends SerovalBaseNode {
   t: SerovalNodeType.Headers;
   i: number;
-  d: SerovalPlainRecordNode;
+  e: SerovalPlainRecordNode;
 }
 
 export interface SerovalFormDataNode extends SerovalBaseNode {
   t: SerovalNodeType.FormData;
   i: number;
-  d: SerovalPlainRecordNode;
+  e: SerovalPlainRecordNode;
 }
 
 export interface SerovalBoxedNode extends SerovalBaseNode {
@@ -328,7 +299,48 @@ export interface SerovalBoxedNode extends SerovalBaseNode {
   f: SerovalNode;
 }
 
-export type SerovalNode =
+export interface SerovalPromiseConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseConstructor;
+  i: number;
+}
+
+export interface SerovalPromiseResolveNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseResolve;
+  // reference to the resolver
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalPromiseRejectNode extends SerovalBaseNode {
+  t: SerovalNodeType.PromiseReject;
+  // reference to the resolver
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalReadableStreamConstructorNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamConstructor;
+  i: number;
+}
+
+export interface SerovalReadableStreamEnqueueNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamEnqueue;
+  i: number;
+  f: SerovalNode;
+}
+
+export interface SerovalReadableStreamCloseNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamClose;
+  i: number;
+}
+
+export interface SerovalReadableStreamErrorNode extends SerovalBaseNode {
+  t: SerovalNodeType.ReadableStreamError;
+  i: number;
+  f: SerovalNode;
+}
+
+export type SerovalSyncNode =
   | SerovalPrimitiveNode
   | SerovalIndexedValueNode
   | SerovalSemiPrimitiveNode
@@ -351,3 +363,19 @@ export type SerovalNode =
   | SerovalHeadersNode
   | SerovalFormDataNode
   | SerovalBoxedNode;
+
+export type SerovalAsyncNode =
+  | SerovalPromiseNode
+  | SerovalBlobNode
+  | SerovalFileNode
+  | SerovalPromiseConstructorNode
+  | SerovalPromiseResolveNode
+  | SerovalPromiseRejectNode
+  | SerovalReadableStreamConstructorNode
+  | SerovalReadableStreamEnqueueNode
+  | SerovalReadableStreamCloseNode
+  | SerovalReadableStreamErrorNode;
+
+export type SerovalNode =
+  | SerovalSyncNode
+  | SerovalAsyncNode;

package/src/core/web-api.ts

@@ -0,0 +1,51 @@
+import UnsupportedTypeError from './UnsupportedTypeError';
+import assert from './assert';
+import { Feature } from './compat';
+import { SerovalNodeType } from './constants';
+import type { BaseParserContext } from './context';
+import { serializeString } from './string';
+import type { SerovalURLNode, SerovalURLSearchParamsNode } from './types';
+
+export function createURLNode(
+  ctx: BaseParserContext,
+  id: number,
+  current: URL,
+): SerovalURLNode {
+  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
+  return {
+    t: SerovalNodeType.URL,
+    i: id,
+    s: serializeString(current.href),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    f: undefined,
+    a: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createURLSearchParamsNode(
+  ctx: BaseParserContext,
+  id: number,
+  current: URLSearchParams,
+): SerovalURLSearchParamsNode {
+  assert(ctx.features & Feature.WebAPI, new UnsupportedTypeError(current));
+  return {
+    t: SerovalNodeType.URLSearchParams,
+    i: id,
+    s: serializeString(current.toString()),
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    f: undefined,
+    a: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}