seroval 0.4.0-alpha.4 → 0.4.0-alpha.5

package/dist/types/tree/types.d.ts

@@ -0,0 +1,79 @@
+import { PrimitiveValue } from '../types';
+export 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
+}
+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 = [key: string[], value: SerovalNode[], size: number];
+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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.4.0-alpha.4",
+  "version": "0.4.0-alpha.5",
   "files": [
     "dist",
     "src"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "1e96ac1ab8304fb09ac7a1bc451b7768f12b7f6b"
+  "gitHead": "b6e4a61b67d1ba6e6e209dd5ba81cd94fb33d021"
 }

package/src/context.ts

@@ -0,0 +1,137 @@
+import { parseTargets } from './compat';
+import getIdentifier from './get-identifier';
+
+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;
+}
+
+// Array of assignments to be done (used for recursion)
+export type Assignment =
+  | IndexAssignment
+  | MapAssignment
+  | SetAssignment;
+
+export interface ParserContext {
+  refs: Map<unknown, number>;
+  markedRefs: Set<number>;
+  features: number;
+}
+
+export interface SerializationContext {
+  stack: number[];
+  // Map tree refs to actual refs
+  validRefs: Map<number, number>;
+  // Refs that are...referenced
+  markedRefs: Set<number>;
+  // Variables
+  vars: string[];
+  // Array of assignments to be done (used for recursion)
+  assignments: Assignment[];
+  // Supported features
+  features: number;
+}
+
+export interface Options {
+  target: string | string[];
+}
+
+const DEFAULT_OPTIONS: Options = {
+  target: 'es2023',
+};
+
+export function createParserContext(options: Partial<Options> = {}): ParserContext {
+  // eslint-disable-next-line prefer-object-spread
+  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+  return {
+    markedRefs: new Set(),
+    refs: new Map(),
+    features: parseTargets(result.target),
+  };
+}
+
+export interface SerializationOptions {
+  markedRefs: number[] | Set<number>;
+  features: number;
+}
+
+export function createSerializationContext(options: SerializationOptions): SerializationContext {
+  return {
+    stack: [],
+    vars: [],
+    assignments: [],
+    validRefs: new Map(),
+    features: options.features,
+    markedRefs: new Set(options.markedRefs),
+  };
+}
+
+/**
+ * Increments the number of references the referenced value has
+ */
+export function markRef(ctx: ParserContext | SerializationContext, current: number) {
+  ctx.markedRefs.add(current);
+}
+
+/**
+ * Creates a new reference ID from a given reference ID
+ * This new reference ID means that the reference itself
+ * has been referenced at least once, and is used to generate
+ * the variables
+ */
+function createValidRef(
+  ctx: SerializationContext,
+  index: number,
+) {
+  const current = ctx.validRefs.get(index);
+  if (current != null) {
+    return current;
+  }
+  const id = ctx.validRefs.size;
+  ctx.validRefs.set(index, id);
+  return id;
+}
+
+/**
+ * Creates the reference param (identifier) from the given reference ID
+ * Calling this function means the value has been referenced somewhere
+ */
+export function getRefParam(ctx: SerializationContext, index: number) {
+  const actualIndex = createValidRef(ctx, index);
+  if (ctx.vars[actualIndex]) {
+    return ctx.vars[actualIndex];
+  }
+  const result = getIdentifier(actualIndex);
+  ctx.vars[actualIndex] = result;
+  return result;
+}
+
+/**
+ * Creates a reference ID from the given values
+ */
+export function createRef(
+  ctx: ParserContext,
+  index: unknown,
+) {
+  const current = ctx.refs.get(index);
+  if (current != null) {
+    return current;
+  }
+  const id = ctx.refs.size;
+  ctx.refs.set(index, id);
+  return id;
+}

package/src/index.ts

@@ -2,18 +2,17 @@
 import { isPrimitive } from './checks';
 import { Feature } from './compat';
 import {
-  createParserContext,
-  createSerializationContext,
+  SerializationContext,
   getRefParam,
   Options,
-  parseAsync,
-  parseSync,
-  resolvePatches,
-  SerializationContext,
-  serializePrimitive,
-  serializeTree,
-  SerovalNode,
-} from './tree';
+  createParserContext,
+  createSerializationContext,
+} from './context';
+import parseAsync from './tree/async';
+import serializeTree, { resolvePatches } from './tree/serialize';
+import { serializePrimitive } from './tree/shared';
+import parseSync from './tree/sync';
+import { SerovalNode } from './tree/types';
 import {
   AsyncServerValue,
   PrimitiveValue,

package/src/tree/async.ts

@@ -0,0 +1,260 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import assert from '../assert';
+import {
+  isIterable,
+  isPrimitive,
+  constructorCheck,
+  isPromise,
+} from '../checks';
+import { Feature } from '../compat';
+import { createRef, ParserContext } from '../context';
+import { AsyncServerValue } from '../types';
+import {
+  generateRef,
+  generateSemiPrimitiveValue,
+  getErrorConstructor,
+  getErrorOptions,
+  getIterableOptions,
+  serializePrimitive,
+} from './shared';
+import {
+  SerovalAggregateErrorNode,
+  SerovalArrayNode,
+  SerovalDictionaryNode,
+  SerovalErrorNode,
+  SerovalIterableNode,
+  SerovalMapNode,
+  SerovalNode,
+  SerovalNodeType,
+  SerovalSetNode,
+} from './types';
+
+async function serializePropertiesAsync(
+  ctx: ParserContext,
+  properties: Record<string, unknown>,
+): Promise<SerovalDictionaryNode> {
+  const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<AsyncServerValue>(size);
+  let deferredSize = 0;
+  let nodesSize = 0;
+  for (const key of keys) {
+    if (isIterable(properties[key])) {
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as AsyncServerValue;
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key] as AsyncServerValue);
+      nodesSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
+  }
+  return [keyNodes, valueNodes, size];
+}
+
+async function generateSetNode(
+  ctx: ParserContext,
+  current: Set<AsyncServerValue>,
+  id: number,
+): Promise<SerovalSetNode> {
+  assert(ctx.features & Feature.Set, 'Unsupported type "Set"');
+  const len = current.size;
+  const nodes = new Array<SerovalNode>(len);
+  const deferred = new Array<AsyncServerValue>(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++] = await generateTreeAsync(ctx, item);
+    }
+  }
+  // Parse deferred items
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
+  }
+  return [SerovalNodeType.Set, nodes, id];
+}
+
+async function generateMapNode(
+  ctx: ParserContext,
+  current: Map<AsyncServerValue, AsyncServerValue>,
+  id: number,
+): Promise<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<AsyncServerValue>(len);
+  const deferredValue = new Array<AsyncServerValue>(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] = await generateTreeAsync(ctx, key);
+      valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
+      nodeSize++;
+    }
+  }
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
+  }
+  return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
+}
+
+async function generateNodeList(
+  ctx: ParserContext,
+  current: AsyncServerValue[],
+) {
+  const size = current.length;
+  const nodes = new Array<SerovalNode>(size);
+  const deferred = new Array<AsyncServerValue>(size);
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      if (isIterable(current[i])) {
+        deferred[i] = current[i];
+      } else {
+        nodes[i] = await generateTreeAsync(ctx, current[i]);
+      }
+    }
+  }
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = await generateTreeAsync(ctx, deferred[i]);
+    }
+  }
+  return nodes;
+}
+
+async function generateArrayNode(
+  ctx: ParserContext,
+  current: AsyncServerValue[],
+  id: number,
+): Promise<SerovalArrayNode> {
+  return [SerovalNodeType.Array, await generateNodeList(ctx, current), id];
+}
+
+async function generateAggregateErrorNode(
+  ctx: ParserContext,
+  current: AggregateError,
+  id: number,
+): Promise<SerovalAggregateErrorNode> {
+  const options = getErrorOptions(current);
+  const optionsNode = options
+    ? await serializePropertiesAsync(ctx, options)
+    : undefined;
+  const errorsNode = await generateTreeAsync(ctx, current.errors as AsyncServerValue);
+  return [
+    SerovalNodeType.AggregateError,
+    [current.message, optionsNode, errorsNode],
+    id,
+  ];
+}
+
+async function generateErrorNode(
+  ctx: ParserContext,
+  current: Error,
+  id: number,
+): Promise<SerovalErrorNode> {
+  const options = getErrorOptions(current);
+  const optionsNode = options
+    ? await serializePropertiesAsync(ctx, options)
+    : undefined;
+  return [
+    SerovalNodeType.Error,
+    [getErrorConstructor(current), current.message, optionsNode],
+    id,
+  ];
+}
+
+async function generateIterableNode(
+  ctx: ParserContext,
+  current: Iterable<AsyncServerValue>,
+  id: number,
+): Promise<SerovalIterableNode> {
+  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
+  return [SerovalNodeType.Iterable, [
+    // Parse options first before the items
+    options ? await serializePropertiesAsync(ctx, options) : undefined,
+    await generateNodeList(ctx, Array.from(current)),
+  ], id];
+}
+
+async function generateTreeAsync(
+  ctx: ParserContext,
+  current: AsyncServerValue,
+): Promise<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 (isPromise(current)) {
+    assert(ctx.features & Feature.Promise, 'Unsupported type "Promise"');
+    return current.then(async (value) => [
+      SerovalNodeType.Promise,
+      await generateTreeAsync(ctx, value),
+      id,
+    ]);
+  }
+  if (constructorCheck<Set<AsyncServerValue>>(current, Set)) {
+    return generateSetNode(ctx, current, id);
+  }
+  if (constructorCheck<Map<AsyncServerValue, AsyncServerValue>>(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,
+      await serializePropertiesAsync(ctx, current as Record<string, unknown>),
+      id,
+    ];
+  }
+  throw new Error('Unsupported value');
+}
+
+export default async function parseAsync(
+  ctx: ParserContext,
+  current: AsyncServerValue,
+) {
+  const result = await generateTreeAsync(ctx, current);
+  return [result, createRef(ctx, current), result[0] === SerovalNodeType.Object] as const;
+}