seroval 0.4.0-alpha.4 → 0.4.0-alpha.6

package/src/tree/shared.ts

@@ -0,0 +1,177 @@
+import assert from '../assert';
+import { constructorCheck } from '../checks';
+import { Feature } from '../compat';
+import { SerializationContext, ParserContext, markRef } from '../context';
+import quote from '../quote';
+import { ErrorValue, PrimitiveValue } from '../types';
+import { SerovalNode, SerovalReferenceNode, SerovalNodeType } from './types';
+
+export function getErrorConstructor(error: ErrorValue) {
+  if (error instanceof EvalError) {
+    return 'EvalError';
+  }
+  if (error instanceof RangeError) {
+    return 'RangeError';
+  }
+  if (error instanceof ReferenceError) {
+    return 'ReferenceError';
+  }
+  if (error instanceof SyntaxError) {
+    return 'SyntaxError';
+  }
+  if (error instanceof TypeError) {
+    return 'TypeError';
+  }
+  if (error instanceof URIError) {
+    return 'URIError';
+  }
+  return 'Error';
+}
+
+export function getErrorOptions(
+  error: Error,
+) {
+  let options: Record<string, any> | undefined;
+  const constructor = getErrorConstructor(error);
+  // Name has been modified
+  if (error.name !== constructor) {
+    options = { name: error.name };
+  } else if (error.constructor.name !== constructor) {
+    // Otherwise, name is overriden because
+    // the Error class is extended
+    options = { name: error.constructor.name };
+  }
+  const names = Object.getOwnPropertyNames(error);
+  for (const name of names) {
+    if (name !== 'name' && name !== 'message') {
+      options = options || {};
+      options[name] = error[name as keyof Error];
+    }
+  }
+  return options;
+}
+
+export function getIterableOptions(obj: Iterable<any>) {
+  const names = Object.getOwnPropertyNames(obj);
+  if (names.length) {
+    const options: Record<string, unknown> = {};
+    for (const name of names) {
+      options[name] = obj[name as unknown as keyof typeof obj];
+    }
+    return options;
+  }
+  return undefined;
+}
+
+export function isReferenceInStack(
+  ctx: SerializationContext,
+  node: SerovalNode,
+): node is SerovalReferenceNode {
+  return node[0] === SerovalNodeType.Reference && ctx.stack.includes(node[1]);
+}
+
+export function generateRef(
+  ctx: ParserContext,
+  current: unknown,
+): number | SerovalReferenceNode {
+  // Check if reference number already exists
+  const ref = ctx.refs.has(current);
+  if (ref) {
+    // Exists, means this value is currently
+    // being referenced
+    const refID = ctx.refs.get(current) || 0;
+    // Mark reference
+    markRef(ctx, refID);
+    return [SerovalNodeType.Reference, refID];
+  }
+  // Create a new reference ID
+  const id = ctx.refs.size;
+  ctx.refs.set(current, id);
+  return id;
+}
+
+export function generateSemiPrimitiveValue(
+  ctx: ParserContext,
+  current: unknown,
+  id: number,
+): SerovalNode | undefined {
+  if (typeof current === 'bigint') {
+    assert(ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
+    return [SerovalNodeType.BigInt, `${current}n`];
+  }
+  if (constructorCheck<Date>(current, Date)) {
+    return [SerovalNodeType.Date, current.toISOString(), id];
+  }
+  if (constructorCheck<RegExp>(current, RegExp)) {
+    return [SerovalNodeType.RegExp, String(current), id];
+  }
+  if (
+    constructorCheck<Int8Array>(current, Int8Array)
+    || constructorCheck<Int16Array>(current, Int16Array)
+    || constructorCheck<Int32Array>(current, Int32Array)
+    || constructorCheck<Uint8Array>(current, Uint8Array)
+    || constructorCheck<Uint16Array>(current, Uint16Array)
+    || constructorCheck<Uint32Array>(current, Uint32Array)
+    || constructorCheck<Uint8ClampedArray>(current, Uint8ClampedArray)
+    || constructorCheck<Float32Array>(current, Float32Array)
+    || constructorCheck<Float64Array>(current, Float64Array)
+  ) {
+    const constructor = current.constructor.name;
+    assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
+    return [SerovalNodeType.TypedArray, [constructor, current.toString(), current.byteOffset], id];
+  }
+  if (
+    constructorCheck<BigInt64Array>(current, BigInt64Array)
+    || constructorCheck<BigUint64Array>(current, BigUint64Array)
+  ) {
+    const constructor = current.constructor.name;
+    assert(
+      ctx.features & (Feature.BigIntTypedArray),
+      `Unsupported value type "${constructor}"`,
+    );
+    let result = '';
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `${current[i]}n,`;
+    }
+    result += `"${current[cap]}"`;
+    return [
+      SerovalNodeType.BigIntTypedArray,
+      [constructor, result, current.byteOffset],
+      id,
+    ];
+  }
+  return undefined;
+}
+
+export function serializePrimitive(
+  value: PrimitiveValue,
+): string | number | null {
+  // Shortened forms
+  if (value === true) {
+    return '!0';
+  }
+  if (value === false) {
+    return '!1';
+  }
+  if (value === undefined) {
+    return 'void 0';
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === 'string') {
+    return quote(value);
+  }
+  // negative 0 isn't the same as 0
+  if (Object.is(value, -0)) {
+    return '-0';
+  }
+  if (Object.is(value, Infinity)) {
+    return '1/0';
+  }
+  if (Object.is(value, -Infinity)) {
+    return '-1/0';
+  }
+  return value;
+}

package/src/tree/sync.ts

@@ -0,0 +1,234 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import assert from '../assert';
+import { isIterable, isPrimitive, constructorCheck } from '../checks';
+import { Feature } from '../compat';
+import { createRef, ParserContext } from '../context';
+import { ServerValue } from '../types';
+import {
+  generateRef,
+  generateSemiPrimitiveValue,
+  getErrorConstructor,
+  getErrorOptions,
+  getIterableOptions,
+  serializePrimitive,
+} from './shared';
+import {
+  SerovalAggregateErrorNode,
+  SerovalArrayNode,
+  SerovalDictionaryNode,
+  SerovalErrorNode,
+  SerovalIterableNode,
+  SerovalMapNode,
+  SerovalNode,
+  SerovalNodeType,
+  SerovalSetNode,
+} from './types';
+
+function generateDictionary(
+  ctx: ParserContext,
+  properties: Record<string, ServerValue>,
+): SerovalDictionaryNode {
+  const keys = Object.keys(properties);
+  const nodes: SerovalDictionaryNode = {};
+  const deferred: Record<string, ServerValue> = {};
+  for (const key of keys) {
+    if (isIterable(properties[key])) {
+      deferred[key] = properties[key];
+    } else {
+      nodes[key] = generateTreeSync(ctx, properties[key]);
+    }
+  }
+  for (const key of Object.keys(deferred)) {
+    nodes[key] = generateTreeSync(ctx, deferred[key]);
+  }
+  return nodes;
+}
+
+function generateSetNode(
+  ctx: ParserContext,
+  current: Set<ServerValue>,
+  id: number,
+): SerovalSetNode {
+  assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
+  const len = current.size;
+  const nodes = new Array<SerovalNode>(len);
+  const deferred = new Array<ServerValue>(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const item of current.keys()) {
+    // Iterables are lazy, so the evaluation must be deferred
+    if (isIterable(item)) {
+      deferred[deferredSize++] = item;
+    } else {
+      nodes[nodeSize++] = generateTreeSync(ctx, item);
+    }
+  }
+  // Parse deferred items
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
+  }
+  return [SerovalNodeType.Set, nodes, id];
+}
+
+function generateMapNode(
+  ctx: ParserContext,
+  current: Map<ServerValue, ServerValue>,
+  id: number,
+): SerovalMapNode {
+  assert(ctx.features & Feature.Map, 'Unsupported type "Map"');
+  const len = current.size;
+  const keyNodes = new Array<SerovalNode>(len);
+  const valueNodes = new Array<SerovalNode>(len);
+  const deferredKey = new Array<ServerValue>(len);
+  const deferredValue = new Array<ServerValue>(len);
+  let deferredSize = 0;
+  let nodeSize = 0;
+  for (const [key, value] of current.entries()) {
+    // Either key or value might be an iterable
+    if (isIterable(key) || isIterable(value)) {
+      deferredKey[deferredSize] = key;
+      deferredValue[deferredSize] = value;
+      deferredSize++;
+    } else {
+      keyNodes[nodeSize] = generateTreeSync(ctx, key);
+      valueNodes[nodeSize] = generateTreeSync(ctx, value);
+      nodeSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
+  }
+  return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
+}
+
+function generateNodeList(
+  ctx: ParserContext,
+  current: ServerValue[],
+) {
+  const size = current.length;
+  const nodes = new Array<SerovalNode>(size);
+  const deferred = new Array<ServerValue>(size);
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      if (isIterable(current[i])) {
+        deferred[i] = current[i];
+      } else {
+        nodes[i] = generateTreeSync(ctx, current[i]);
+      }
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = generateTreeSync(ctx, deferred[i]);
+    }
+  }
+  return nodes;
+}
+
+function generateArrayNode(
+  ctx: ParserContext,
+  current: ServerValue[],
+  id: number,
+): SerovalArrayNode {
+  return [SerovalNodeType.Array, generateNodeList(ctx, current), id];
+}
+
+function generateAggregateErrorNode(
+  ctx: ParserContext,
+  current: AggregateError,
+  id: number,
+): SerovalAggregateErrorNode {
+  const options = getErrorOptions(current);
+  const optionsNode = options
+    ? generateDictionary(ctx, options)
+    : undefined;
+  const errorsNode = generateTreeSync(ctx, current.errors as ServerValue);
+  return [SerovalNodeType.AggregateError, [current.message, optionsNode, errorsNode], id];
+}
+
+function generateErrorNode(
+  ctx: ParserContext,
+  current: Error,
+  id: number,
+): SerovalErrorNode {
+  const options = getErrorOptions(current);
+  const optionsNode = options
+    ? generateDictionary(ctx, options)
+    : undefined;
+  return [
+    SerovalNodeType.Error,
+    [getErrorConstructor(current), current.message, optionsNode],
+    id,
+  ];
+}
+
+function generateIterableNode(
+  ctx: ParserContext,
+  current: Iterable<ServerValue>,
+  id: number,
+): SerovalIterableNode {
+  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return [SerovalNodeType.Iterable, [
+    // Parse options first before the items
+    options
+      ? generateDictionary(ctx, options as Record<string, ServerValue>)
+      : undefined,
+    generateNodeList(ctx, Array.from(current)),
+  ], id];
+}
+
+function generateTreeSync(
+  ctx: ParserContext,
+  current: ServerValue,
+): SerovalNode {
+  if (isPrimitive(current)) {
+    return [SerovalNodeType.Primitive, serializePrimitive(current)];
+  }
+  // Non-primitive values needs a reference ID
+  // mostly because the values themselves are stateful
+  const id = generateRef(ctx, current);
+  if (Array.isArray(id)) {
+    return id;
+  }
+  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
+  if (semiPrimitive) {
+    return semiPrimitive;
+  }
+  if (constructorCheck<Set<ServerValue>>(current, Set)) {
+    return generateSetNode(ctx, current, id);
+  }
+  if (constructorCheck<Map<ServerValue, ServerValue>>(current, Map)) {
+    return generateMapNode(ctx, current, id);
+  }
+  if (Array.isArray(current)) {
+    return generateArrayNode(ctx, current, id);
+  }
+  if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
+    return generateAggregateErrorNode(ctx, current, id);
+  }
+  if (current instanceof Error) {
+    return generateErrorNode(ctx, current, id);
+  }
+  if (isIterable(current)) {
+    return generateIterableNode(ctx, current, id);
+  }
+  const empty = current.constructor == null;
+  if (current.constructor === Object || empty) {
+    return [
+      empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
+      generateDictionary(ctx, current as Record<string, ServerValue>),
+      id,
+    ];
+  }
+  throw new Error('Unsupported value');
+}
+
+export default function parseSync(
+  ctx: ParserContext,
+  current: ServerValue,
+) {
+  const result = generateTreeSync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === SerovalNodeType.Object] as const;
+}

package/src/tree/types.ts

@@ -0,0 +1,101 @@
+import { PrimitiveValue } from '../types';
+
+export const enum SerovalNodeType {
+  Primitive,
+  BigInt,
+  Reference,
+  Date,
+  RegExp,
+  Set,
+  Map,
+  Array,
+  Object,
+  NullConstructor,
+  Promise,
+  Error,
+  AggregateError,
+  Iterable,
+  TypedArray,
+  BigIntTypedArray,
+}
+
+export type SerovalPrimitiveNode = [
+  type: SerovalNodeType.Primitive,
+  value: PrimitiveValue,
+];
+export type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
+export type SerovalSemiPrimitiveNode =
+  | [type: SerovalNodeType.BigInt, value: string]
+  | [type: SerovalNodeType.Date, value: string, id: number]
+  | [type: SerovalNodeType.RegExp, value: string, id: number]
+  | [
+    type: SerovalNodeType.TypedArray,
+    value: [constructor: string, array: string, byteOffset: number],
+    id: number
+  ]
+  | [
+    type: SerovalNodeType.BigIntTypedArray,
+    value: [constructor: string, array: string, byteOffset: number],
+    id: number
+  ];
+
+export type SerovalDictionaryNode = Record<string, SerovalNode>;
+export type SerovalSetNode = [type: SerovalNodeType.Set, value: SerovalNode[], id: number];
+export type SerovalMapNode = [
+  type: SerovalNodeType.Map,
+  value: [key: SerovalNode[], value: SerovalNode[], size: number],
+  id: number
+];
+export type SerovalArrayNode = [type: SerovalNodeType.Array, value: SerovalNode[], id: number];
+export type SerovalObjectNode = [
+  type: SerovalNodeType.Object,
+  value: SerovalDictionaryNode,
+  id: number
+];
+export type SerovalNullConstructorNode = [
+  type: SerovalNodeType.NullConstructor,
+  value: SerovalDictionaryNode,
+  id: number,
+];
+export type SerovalPromiseNode = [type: SerovalNodeType.Promise, value: SerovalNode, id: number];
+export type SerovalErrorNode = [
+  type: SerovalNodeType.Error,
+  value: [
+    constructor: string,
+    message: string,
+    options?: SerovalDictionaryNode,
+  ],
+  id: number
+];
+export type SerovalAggregateErrorNode = [
+  type: SerovalNodeType.AggregateError,
+  value: [
+    message: string,
+    options: SerovalDictionaryNode | undefined,
+    errors: SerovalNode,
+  ],
+  id: number
+];
+
+export type SerovalIterableNode = [
+  type: SerovalNodeType.Iterable,
+  value: [
+    options: SerovalDictionaryNode | undefined,
+    items: SerovalNode[],
+  ],
+  id: number,
+];
+
+export type SerovalNode =
+  | SerovalPrimitiveNode
+  | SerovalReferenceNode
+  | SerovalSemiPrimitiveNode
+  | SerovalSetNode
+  | SerovalMapNode
+  | SerovalArrayNode
+  | SerovalObjectNode
+  | SerovalNullConstructorNode
+  | SerovalPromiseNode
+  | SerovalErrorNode
+  | SerovalAggregateErrorNode
+  | SerovalIterableNode;

package/dist/types/tree.d.ts

@@ -1,122 +0,0 @@
-import { AsyncServerValue, PrimitiveValue, ServerValue } from './types';
-interface IndexAssignment {
-    type: 'index';
-    source: string;
-    value: string;
-}
-interface MapAssignment {
-    type: 'map';
-    source: string;
-    key: string;
-    value: string;
-}
-interface SetAssignment {
-    type: 'set';
-    source: string;
-    value: string;
-}
-export type Assignment = IndexAssignment | MapAssignment | SetAssignment;
-export interface ParserContext {
-    refs: Map<unknown, number>;
-    markedRefs: Set<number>;
-    features: number;
-}
-export interface SerializationContext {
-    stack: number[];
-    validRefs: Map<number, number>;
-    markedRefs: Set<number>;
-    vars: string[];
-    assignments: Assignment[];
-    features: number;
-}
-export interface Options {
-    target: string | string[];
-}
-export declare function createParserContext(options?: Partial<Options>): ParserContext;
-export interface SerializationOptions {
-    markedRefs: number[] | Set<number>;
-    features: number;
-}
-export declare function createSerializationContext(options: SerializationOptions): SerializationContext;
-export declare function resolvePatches(ctx: SerializationContext): string | undefined;
-/**
- * Creates the reference param (identifier) from the given reference ID
- * Calling this function means the value has been referenced somewhere
- */
-export declare function getRefParam(ctx: SerializationContext, index: number): string;
-declare const enum SerovalNodeType {
-    Primitive = 0,
-    BigInt = 1,
-    Reference = 2,
-    Date = 3,
-    RegExp = 4,
-    Set = 5,
-    Map = 6,
-    Array = 7,
-    Object = 8,
-    NullConstructor = 9,
-    Promise = 10,
-    Error = 11,
-    AggregateError = 12,
-    Iterable = 13,
-    TypedArray = 14,
-    BigIntTypedArray = 15
-}
-type SerovalPrimitiveNode = [type: SerovalNodeType.Primitive, value: PrimitiveValue];
-type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
-type SerovalSemiPrimitiveNode = [type: SerovalNodeType.BigInt, value: string] | [type: SerovalNodeType.Date, value: string, id: number] | [type: SerovalNodeType.RegExp, value: string, id: number] | [
-    type: SerovalNodeType.TypedArray,
-    value: [constructor: string, array: string, byteOffset: number],
-    id: number
-] | [
-    type: SerovalNodeType.BigIntTypedArray,
-    value: [constructor: string, array: string, byteOffset: number],
-    id: number
-];
-type SerovalDictionaryNode = [key: string[], value: SerovalNode[], size: number];
-type SerovalSetNode = [type: SerovalNodeType.Set, value: SerovalNode[], id: number];
-type SerovalMapNode = [
-    type: SerovalNodeType.Map,
-    value: [key: SerovalNode[], value: SerovalNode[], size: number],
-    id: number
-];
-type SerovalArrayNode = [type: SerovalNodeType.Array, value: SerovalNode[], id: number];
-type SerovalObjectNode = [type: SerovalNodeType.Object, value: SerovalDictionaryNode, id: number];
-type SerovalNullConstructorNode = [
-    type: SerovalNodeType.NullConstructor,
-    value: SerovalDictionaryNode,
-    id: number
-];
-type SerovalPromiseNode = [type: SerovalNodeType.Promise, value: SerovalNode, id: number];
-type SerovalErrorNode = [
-    type: SerovalNodeType.Error,
-    value: [
-        constructor: string,
-        message: string,
-        options?: SerovalDictionaryNode
-    ],
-    id: number
-];
-type SerovalAggregateErrorNode = [
-    type: SerovalNodeType.AggregateError,
-    value: [
-        message: string,
-        options: SerovalDictionaryNode | undefined,
-        errors: SerovalNode
-    ],
-    id: number
-];
-type SerovalIterableNode = [
-    type: SerovalNodeType.Iterable,
-    value: [
-        options: SerovalDictionaryNode | undefined,
-        items: SerovalNode
-    ],
-    id: number
-];
-export type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;
-export declare function parseSync(ctx: ParserContext, current: ServerValue): readonly [SerovalNode, number, boolean];
-export declare function parseAsync(ctx: ParserContext, current: AsyncServerValue): Promise<readonly [SerovalNode, number, boolean]>;
-export declare function serializePrimitive(value: PrimitiveValue): string | number | null;
-export declare function serializeTree(ctx: SerializationContext, [type, value, id]: SerovalNode): string;
-export {};