seroval 0.9.0 → 0.10.2

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

@@ -1,14 +1,12 @@
 /* eslint-disable prefer-spread */
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import type {
-  SerializationContext,
-} from '../context';
+  DeserializerContext,
+} from './context';
 import { deserializeString } from '../string';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
-import { deserializeConstant } from './constants';
-import { getReference } from './reference';
-import { getErrorConstructor, getTypedArrayConstructor } from './shared';
-import { SYMBOL_REF } from './symbols';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
+import { getReference } from '../reference';
+import { getErrorConstructor, getTypedArrayConstructor } from '../shared';
 import type {
   SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
@@ -35,12 +33,16 @@ import type {
   SerovalTypedArrayNode,
   SerovalURLNode,
   SerovalURLSearchParamsNode,
-} from './types';
+} from '../types';
 import {
-  SerovalObjectFlags,
-  SerovalNodeType,
   SerovalObjectRecordSpecialKey,
-} from './types';
+} from '../types';
+import {
+  SYMBOL_REF,
+  SerovalNodeType,
+  SerovalObjectFlags,
+  deserializeConstant,
+} from '../constants';
 
 function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
   switch (flag) {
@@ -56,18 +58,18 @@ function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
 }
 
 function assignIndexedValue<T>(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   index: number,
   value: T,
 ): T {
-  if (ctx.markedRefs.has(index)) {
-    ctx.valueMap.set(index, value);
+  if (ctx.refs.has(index)) {
+    ctx.values.set(index, value);
   }
   return value;
 }
 
 function deserializeArray(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalArrayNode,
 ): unknown[] {
   const len = node.l;
@@ -88,7 +90,7 @@ function deserializeArray(
 }
 
 function deserializeProperties(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalObjectRecordNode,
   result: Record<string | symbol, unknown>,
 ): Record<string | symbol, unknown> {
@@ -117,7 +119,7 @@ function deserializeProperties(
 }
 
 function deserializeObject(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalObjectNode | SerovalNullConstructorNode,
 ): Record<string, unknown> {
   const result = assignIndexedValue(
@@ -127,13 +129,13 @@ function deserializeObject(
       ? {}
       : Object.create(null)) as Record<string, unknown>,
   );
-  deserializeProperties(ctx, node.d, result);
+  deserializeProperties(ctx, node.p, result);
   applyObjectFlag(result, node.o);
   return result;
 }
 
 function deserializeSet(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalSetNode,
 ): Set<unknown> {
   const result = assignIndexedValue(ctx, node.i, new Set<unknown>());
@@ -145,7 +147,7 @@ function deserializeSet(
 }
 
 function deserializeMap(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalMapNode,
 ): Map<unknown, unknown> {
   const result = assignIndexedValue(
@@ -153,9 +155,9 @@ function deserializeMap(
     node.i,
     new Map<unknown, unknown>(),
   );
-  const keys = node.d.k;
-  const vals = node.d.v;
-  for (let i = 0, len = node.d.s; i < len; i++) {
+  const keys = node.e.k;
+  const vals = node.e.v;
+  for (let i = 0, len = node.e.s; i < len; i++) {
     result.set(
       deserializeTree(ctx, keys[i]),
       deserializeTree(ctx, vals[i]),
@@ -168,19 +170,19 @@ type AssignableValue = AggregateError | Error | Iterable<unknown>
 type AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;
 
 function deserializeDictionary<T extends AssignableValue>(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: AssignableNode,
   result: T,
 ): T {
-  if (node.d) {
-    const fields = deserializeProperties(ctx, node.d, {});
+  if (node.p) {
+    const fields = deserializeProperties(ctx, node.p, {});
     Object.assign(result, fields);
   }
   return result;
 }
 
 function deserializeAggregateError(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalAggregateErrorNode,
 ): AggregateError {
   // Serialize the required arguments
@@ -196,7 +198,7 @@ function deserializeAggregateError(
 }
 
 function deserializeError(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalErrorNode,
 ): Error {
   const ErrorConstructor = getErrorConstructor(node.c);
@@ -206,33 +208,44 @@ function deserializeError(
 
 interface Deferred {
   resolve(value: unknown): void;
+  reject(value: unknown): void;
   promise: Promise<unknown>;
 }
 
 function createDeferred(): Deferred {
-  let resolver: Deferred['resolve'];
+  let resolve: Deferred['resolve'];
+  let reject: Deferred['reject'];
   return {
     resolve(v): void {
-      resolver(v);
+      resolve(v);
+    },
+    reject(v): void {
+      reject(v);
     },
-    promise: new Promise((res) => {
-      resolver = res as Deferred['resolve'];
+    promise: new Promise((res, rej) => {
+      resolve = res as Deferred['resolve'];
+      reject = rej as Deferred['reject'];
     }),
   };
 }
 
 async function deserializePromise(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalPromiseNode,
 ): Promise<unknown> {
   const deferred = createDeferred();
   const result = assignIndexedValue(ctx, node.i, deferred.promise);
-  deferred.resolve(deserializeTree(ctx, node.f));
+  const deserialized = deserializeTree(ctx, node.f);
+  if (node.s) {
+    deferred.resolve(deserialized);
+  } else {
+    deferred.reject(deserialized);
+  }
   return result;
 }
 
 function deserializeArrayBuffer(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalArrayBufferNode,
 ): ArrayBuffer {
   const bytes = new Uint8Array(node.s);
@@ -241,7 +254,7 @@ function deserializeArrayBuffer(
 }
 
 function deserializeTypedArray(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,
 ): TypedArrayValue | BigIntTypedArrayValue {
   const TypedArray = getTypedArrayConstructor(node.c);
@@ -255,42 +268,42 @@ function deserializeTypedArray(
 }
 
 function deserializeDate(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalDateNode,
 ): Date {
   return assignIndexedValue(ctx, node.i, new Date(node.s));
 }
 
 function deserializeRegExp(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalRegExpNode,
 ): RegExp {
   return assignIndexedValue(ctx, node.i, new RegExp(node.c, node.m));
 }
 
 function deserializeURL(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalURLNode,
 ): URL {
   return assignIndexedValue(ctx, node.i, new URL(deserializeString(node.s)));
 }
 
 function deserializeURLSearchParams(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalURLSearchParamsNode,
 ): URLSearchParams {
   return assignIndexedValue(ctx, node.i, new URLSearchParams(deserializeString(node.s)));
 }
 
 function deserializeReference(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalReferenceNode,
 ): unknown {
   return assignIndexedValue(ctx, node.i, getReference(deserializeString(node.s)));
 }
 
 function deserializeDataView(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalDataViewNode,
 ): DataView {
   const source = deserializeTree(ctx, node.f) as ArrayBuffer;
@@ -303,7 +316,7 @@ function deserializeDataView(
 }
 
 function deserializeBlob(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalBlobNode,
 ): Blob {
   const source = deserializeTree(ctx, node.f) as ArrayBuffer;
@@ -315,7 +328,7 @@ function deserializeBlob(
 }
 
 function deserializeFile(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalFileNode,
 ): File {
   const source = deserializeTree(ctx, node.f) as ArrayBuffer;
@@ -328,13 +341,13 @@ function deserializeFile(
 }
 
 function deserializeHeaders(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalHeadersNode,
 ): Headers {
   const result = assignIndexedValue(ctx, node.i, new Headers());
-  const keys = node.d.k;
-  const vals = node.d.v;
-  for (let i = 0, len = node.d.s; i < len; i++) {
+  const keys = node.e.k;
+  const vals = node.e.v;
+  for (let i = 0, len = node.e.s; i < len; i++) {
     result.set(
       deserializeString(keys[i]),
       deserializeTree(ctx, vals[i]) as string,
@@ -344,13 +357,13 @@ function deserializeHeaders(
 }
 
 function deserializeFormData(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalFormDataNode,
 ): FormData {
   const result = assignIndexedValue(ctx, node.i, new FormData());
-  const keys = node.d.k;
-  const vals = node.d.v;
-  for (let i = 0, len = node.d.s; i < len; i++) {
+  const keys = node.e.k;
+  const vals = node.e.v;
+  for (let i = 0, len = node.e.s; i < len; i++) {
     result.set(
       deserializeString(keys[i]),
       deserializeTree(ctx, vals[i]) as FormDataEntryValue,
@@ -360,7 +373,7 @@ function deserializeFormData(
 }
 
 function deserializeBoxed(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalBoxedNode,
 ): unknown {
   return assignIndexedValue(
@@ -371,7 +384,7 @@ function deserializeBoxed(
 }
 
 export default function deserializeTree(
-  ctx: SerializationContext,
+  ctx: DeserializerContext,
   node: SerovalNode,
 ): unknown {
   switch (node.t) {
@@ -384,7 +397,7 @@ export default function deserializeTree(
     case SerovalNodeType.BigInt:
       return BigInt(node.s);
     case SerovalNodeType.IndexedValue:
-      return ctx.valueMap.get(node.i);
+      return ctx.values.get(node.i);
     case SerovalNodeType.Array:
       return deserializeArray(ctx, node);
     case SerovalNodeType.Object:

package/src/core/tree/index.ts

@@ -0,0 +1,142 @@
+import { Feature } from '../compat';
+import { SerovalNodeType } from '../constants';
+import type { SerovalNode } from '../types';
+import parseAsync from './async';
+import type {
+  ParserOptions,
+  SerializerContext,
+} from './context';
+import {
+  createDeserializerContext,
+  createParserContext,
+  createSerializerContext,
+  getRefParam,
+} from './context';
+import deserializeTree from './deserialize';
+import serializeTree, { resolvePatches } from './serialize';
+import parseSync from './sync';
+
+function finalize(
+  ctx: SerializerContext,
+  rootID: number | undefined,
+  isObject: boolean,
+  result: string,
+): string {
+  // Shared references detected
+  if (rootID != null && ctx.vars.length) {
+    const patches = resolvePatches(ctx);
+    let body = result;
+    if (patches) {
+      // Get (or create) a ref from the source
+      const index = getRefParam(ctx, rootID);
+      body = result + ',' + patches + index;
+      if (!result.startsWith(index + '=')) {
+        body = index + '=' + body;
+      }
+    }
+    let params = ctx.vars.length > 1
+      ? ctx.vars.join(',')
+      : ctx.vars[0];
+    // Source is probably already assigned
+    if (ctx.features & Feature.ArrowFunction) {
+      params = ctx.vars.length > 1 || ctx.vars.length === 0
+        ? '(' + params + ')'
+        : params;
+      return '(' + params + '=>(' + body + '))()';
+    }
+    return '(function(' + params + '){return ' + body + '})()';
+  }
+  if (isObject) {
+    return '(' + result + ')';
+  }
+  return result;
+}
+
+export function serialize<T>(
+  source: T,
+  options?: Partial<ParserOptions>,
+): string {
+  const ctx = createParserContext(options);
+  const tree = parseSync(ctx, source);
+  const serial = createSerializerContext({
+    markedRefs: ctx.reference.marked,
+    features: ctx.features,
+  });
+  const result = serializeTree(serial, tree);
+  return finalize(
+    serial,
+    tree.i,
+    tree.t === SerovalNodeType.Object,
+    result,
+  );
+}
+
+export async function serializeAsync<T>(
+  source: T,
+  options?: Partial<ParserOptions>,
+): Promise<string> {
+  const ctx = createParserContext(options);
+  const tree = await parseAsync(ctx, source);
+  const serial = createSerializerContext({
+    markedRefs: ctx.reference.marked,
+    features: ctx.features,
+  });
+  const result = serializeTree(serial, tree);
+  return finalize(
+    serial,
+    tree.i,
+    tree.t === SerovalNodeType.Object,
+    result,
+  );
+}
+
+export function deserialize<T>(source: string): T {
+  // eslint-disable-next-line no-eval
+  return (0, eval)(source) as T;
+}
+
+export interface SerovalJSON {
+  t: SerovalNode;
+  f: number;
+  m: number[];
+}
+
+export function toJSON<T>(
+  source: T,
+  options?: Partial<ParserOptions>,
+): SerovalJSON {
+  const ctx = createParserContext(options);
+  return {
+    t: parseSync(ctx, source),
+    f: ctx.features,
+    m: Array.from(ctx.reference.marked),
+  };
+}
+
+export async function toJSONAsync<T>(
+  source: T,
+  options?: Partial<ParserOptions>,
+): Promise<SerovalJSON> {
+  const ctx = createParserContext(options);
+  return {
+    t: await parseAsync(ctx, source),
+    f: ctx.features,
+    m: Array.from(ctx.reference.marked),
+  };
+}
+
+export function compileJSON(source: SerovalJSON): string {
+  const serial = createSerializerContext({
+    features: source.f,
+    markedRefs: source.m,
+  });
+  const result = serializeTree(serial, source.t);
+  return finalize(serial, source.t.i, source.t.i === SerovalNodeType.Object, result);
+}
+
+export function fromJSON<T>(source: SerovalJSON): T {
+  const serial = createDeserializerContext({
+    markedRefs: source.m,
+  });
+  return deserializeTree(serial, source.t) as T;
+}

package/src/core/tree/primitives.ts

@@ -0,0 +1,132 @@
+import assert from '../assert';
+import { Feature } from '../compat';
+import type { ParserContext } from './context';
+import { createIndexedValue } from './context';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
+import UnsupportedTypeError from '../UnsupportedTypeError';
+import { hasReferenceID } from '../reference';
+import type {
+  SerovalBigIntTypedArrayNode,
+  SerovalTypedArrayNode,
+  SerovalWKSymbolNode,
+  SerovalReferenceNode,
+  SerovalDataViewNode,
+  SerovalNode,
+  SerovalIndexedValueNode,
+} from '../types';
+import type { WellKnownSymbols } from '../constants';
+import { SerovalNodeType } from '../constants';
+import {
+  createArrayBufferNode,
+  createIndexedValueNode,
+  createReferenceNode,
+  createWKSymbolNode,
+} from '../base-primitives';
+
+export function serializeArrayBuffer(
+  ctx: ParserContext,
+  current: ArrayBuffer,
+): SerovalNode {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.reference.marked.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createArrayBufferNode(id, current);
+}
+
+export function createTypedArrayNode(
+  ctx: ParserContext,
+  id: number,
+  current: TypedArrayValue,
+): SerovalTypedArrayNode {
+  assert(ctx.features & Feature.TypedArray, new UnsupportedTypeError(current));
+  return {
+    t: SerovalNodeType.TypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+const BIGINT_FLAG = Feature.BigIntTypedArray | Feature.BigInt;
+
+export function createBigIntTypedArrayNode(
+  ctx: ParserContext,
+  id: number,
+  current: BigIntTypedArrayValue,
+): SerovalBigIntTypedArrayNode {
+  assert(
+    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
+    new UnsupportedTypeError(current),
+  );
+  return {
+    t: SerovalNodeType.BigIntTypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createDataViewNode(
+  ctx: ParserContext,
+  id: number,
+  current: DataView,
+): SerovalDataViewNode {
+  return {
+    t: SerovalNodeType.DataView,
+    i: id,
+    s: undefined,
+    l: current.byteLength,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createSymbolNode(
+  ctx: ParserContext,
+  current: symbol,
+): SerovalIndexedValueNode | SerovalReferenceNode | SerovalWKSymbolNode {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.reference.marked.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  if (hasReferenceID(current)) {
+    return createReferenceNode(id, current);
+  }
+  return createWKSymbolNode(ctx, id, current as WellKnownSymbols);
+}
+
+export function createFunctionNode(
+  ctx: ParserContext,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  current: Function,
+): SerovalIndexedValueNode | SerovalReferenceNode {
+  assert(hasReferenceID(current), new Error('Cannot serialize function without reference ID.'));
+  const id = createIndexedValue(ctx, current);
+  if (ctx.reference.marked.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createReferenceNode(id, current);
+}