seroval 0.4.0-alpha.9 → 0.4.0

package/src/tree/sync.ts

@@ -1,16 +1,28 @@
 /* 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 quote from '../quote';
+import { BigIntTypedArrayValue, ServerValue, TypedArrayValue } from '../types';
+import {
+  createBigIntNode,
+  createBigIntTypedArrayNode,
+  createDateNode,
+  createPrimitiveNode,
+  createReferenceNode,
+  createRegExpNode,
+  createTypedArrayNode,
+  FALSE_NODE,
+  NEG_ZERO_NODE,
+  NULL_NODE,
+  TRUE_NODE,
+  UNDEFINED_NODE,
+} from './primitives';
 import {
-  generateRef,
-  generateSemiPrimitiveValue,
   getErrorConstructor,
   getErrorOptions,
   getIterableOptions,
-  serializePrimitive,
+  isIterable,
 } from './shared';
 import {
   SerovalAggregateErrorNode,
@@ -20,84 +32,59 @@ import {
   SerovalMapNode,
   SerovalNode,
   SerovalNodeType,
+  SerovalNullConstructorNode,
+  SerovalObjectNode,
   SerovalObjectRecordNode,
   SerovalSetNode,
 } from './types';
 
-function serializePropertiesSync(
-  ctx: ParserContext,
-  properties: Record<string, unknown>,
-): SerovalObjectRecordNode {
-  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<ServerValue>(size);
-  let deferredSize = 0;
-  let nodesSize = 0;
-  for (const key of keys) {
-    if (isIterable(properties[key])) {
-      deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key] as ServerValue;
-      deferredSize++;
-    } else {
-      keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key] as ServerValue);
-      nodesSize++;
+type ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode | SerovalIterableNode;
+
+function generateNodeList(ctx: ParserContext, current: ServerValue[]) {
+  const size = current.length;
+  const nodes = new Array<SerovalNode>(size);
+  const deferred = new Array<ServerValue>(size);
+  let item: ServerValue;
+  for (let i = 0; i < size; i++) {
+    if (i in current) {
+      item = current[i];
+      if (isIterable(item)) {
+        deferred[i] = item;
+      } else {
+        nodes[i] = parse(ctx, item);
+      }
     }
   }
-  for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodesSize + i] = deferredKeys[i];
-    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
+  for (let i = 0; i < size; i++) {
+    if (i in deferred) {
+      nodes[i] = parse(ctx, deferred[i]);
+    }
   }
-  return {
-    k: keyNodes,
-    v: valueNodes,
-    s: size,
-  };
+  return nodes;
 }
 
-function generateSetNode(
+function generateArrayNode(
   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]);
-  }
+  current: ServerValue[],
+): SerovalArrayNode {
   return {
-    t: SerovalNodeType.Set,
+    t: SerovalNodeType.Array,
     i: id,
-    a: nodes,
     s: undefined,
     l: undefined,
-    m: undefined,
     c: undefined,
+    m: undefined,
     d: undefined,
+    a: generateNodeList(ctx, current),
     n: undefined,
   };
 }
 
 function generateMapNode(
   ctx: ParserContext,
-  current: Map<ServerValue, ServerValue>,
   id: number,
+  current: Map<ServerValue, ServerValue>,
 ): SerovalMapNode {
   assert(ctx.features & Feature.Map, 'Unsupported type "Map"');
   const len = current.size;
@@ -114,203 +101,291 @@ function generateMapNode(
       deferredValue[deferredSize] = value;
       deferredSize++;
     } else {
-      keyNodes[nodeSize] = generateTreeSync(ctx, key);
-      valueNodes[nodeSize] = generateTreeSync(ctx, value);
+      keyNodes[nodeSize] = parse(ctx, key);
+      valueNodes[nodeSize] = parse(ctx, value);
       nodeSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
-    valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
+    keyNodes[nodeSize + i] = parse(ctx, deferredKey[i]);
+    valueNodes[nodeSize + i] = parse(ctx, deferredValue[i]);
   }
   return {
     t: SerovalNodeType.Map,
     i: id,
-    a: undefined,
     s: undefined,
     l: undefined,
-    m: undefined,
     c: undefined,
+    m: undefined,
     d: { k: keyNodes, v: valueNodes, s: len },
+    a: undefined,
     n: undefined,
   };
 }
 
-function generateNodeList(
+function generateSetNode(
   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]);
-      }
+  id: number,
+  current: Set<ServerValue>,
+): 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++] = parse(ctx, item);
     }
   }
-  for (let i = 0; i < size; i++) {
-    if (i in deferred) {
-      nodes[i] = generateTreeSync(ctx, deferred[i]);
+  // Parse deferred items
+  for (let i = 0; i < deferredSize; i++) {
+    nodes[nodeSize + i] = parse(ctx, deferred[i]);
+  }
+  return {
+    t: SerovalNodeType.Set,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: nodes,
+    n: undefined,
+  };
+}
+
+function generateProperties(
+  ctx: ParserContext,
+  properties: Record<string, ServerValue>,
+): SerovalObjectRecordNode {
+  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<ServerValue>(size);
+  let deferredSize = 0;
+  let nodesSize = 0;
+  let item: ServerValue;
+  for (const key of keys) {
+    item = properties[key];
+    if (isIterable(item)) {
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = item;
+      deferredSize++;
+    } else {
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = parse(ctx, item);
+      nodesSize++;
     }
   }
-  return nodes;
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = parse(ctx, deferredValues[i]);
+  }
+  return {
+    k: keyNodes,
+    v: valueNodes,
+    s: size,
+  };
 }
 
-function generateArrayNode(
+function generateIterableNode(
   ctx: ParserContext,
-  current: ServerValue[],
   id: number,
-): SerovalArrayNode {
+  current: Iterable<ServerValue>,
+): SerovalIterableNode {
+  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
+  const options = getIterableOptions(current);
   return {
-    t: SerovalNodeType.Array,
+    t: SerovalNodeType.Iterable,
     i: id,
-    a: generateNodeList(ctx, current),
     s: undefined,
     l: undefined,
+    c: undefined,
     m: undefined,
+    // Parse options first before the items
+    d: options
+      ? generateProperties(ctx, options as Record<string, ServerValue>)
+      : undefined,
+    a: generateNodeList(ctx, Array.from(current)),
+    n: undefined,
+  };
+}
+
+function generateObjectNode(
+  ctx: ParserContext,
+  id: number,
+  current: Record<string, ServerValue> | Iterable<ServerValue>,
+  empty: boolean,
+): ObjectLikeNode {
+  if (Symbol.iterator in current) {
+    return generateIterableNode(ctx, id, current);
+  }
+  return {
+    t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
+    i: id,
+    s: undefined,
+    l: undefined,
     c: undefined,
-    d: undefined,
+    m: undefined,
+    d: generateProperties(ctx, current),
+    a: undefined,
     n: undefined,
   };
 }
 
 function generateAggregateErrorNode(
   ctx: ParserContext,
-  current: AggregateError,
   id: number,
+  current: AggregateError,
 ): SerovalAggregateErrorNode {
-  const options = getErrorOptions(current);
+  const options = getErrorOptions(ctx, current);
   const optionsNode = options
-    ? serializePropertiesSync(ctx, options)
+    ? generateProperties(ctx, options)
     : undefined;
   return {
     t: SerovalNodeType.AggregateError,
     i: id,
-    a: undefined,
     s: undefined,
     l: undefined,
-    m: current.message,
     c: undefined,
+    m: current.message,
     d: optionsNode,
-    n: generateTreeSync(ctx, current.errors as ServerValue),
+    a: undefined,
+    n: parse(ctx, current.errors),
   };
 }
 
 function generateErrorNode(
   ctx: ParserContext,
-  current: Error,
   id: number,
+  current: Error,
 ): SerovalErrorNode {
-  const options = getErrorOptions(current);
+  const options = getErrorOptions(ctx, current);
   const optionsNode = options
-    ? serializePropertiesSync(ctx, options)
+    ? generateProperties(ctx, options)
     : undefined;
   return {
     t: SerovalNodeType.Error,
     i: id,
-    a: undefined,
     s: undefined,
     l: undefined,
-    m: current.message,
     c: getErrorConstructor(current),
+    m: current.message,
     d: optionsNode,
+    a: undefined,
     n: undefined,
   };
 }
 
-function generateIterableNode(
-  ctx: ParserContext,
-  current: Iterable<ServerValue>,
-  id: number,
-): SerovalIterableNode {
-  assert(ctx.features & Feature.SymbolIterator, 'Unsupported type "Iterable"');
-  const options = getIterableOptions(current);
-  return {
-    t: SerovalNodeType.Iterable,
-    i: id,
-    s: undefined,
-    l: undefined,
-    m: undefined,
-    c: undefined,
-    // Parse options first before the items
-    d: options ? serializePropertiesSync(ctx, options) : undefined,
-    a: generateNodeList(ctx, Array.from(current)),
-    n: undefined,
-  };
-}
-
-function generateTreeSync(
+function parse(
   ctx: ParserContext,
   current: ServerValue,
 ): SerovalNode {
-  if (isPrimitive(current)) {
-    return {
-      t: SerovalNodeType.Primitive,
-      i: undefined,
-      s: serializePrimitive(current),
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      // Parse options first before the items
-      d: undefined,
-      a: undefined,
-      n: undefined,
-    };
-  }
-  // Non-primitive values needs a reference ID
-  // mostly because the values themselves are stateful
-  const id = generateRef(ctx, current);
-  if (typeof id !== 'number') {
-    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 {
-      t: empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      i: id,
-      s: undefined,
-      l: undefined,
-      m: undefined,
-      c: undefined,
-      // Parse options first before the items
-      d: serializePropertiesSync(ctx, current as Record<string, unknown>),
-      a: undefined,
-      n: undefined,
-    };
+  switch (typeof current) {
+    case 'boolean':
+      return current ? TRUE_NODE : FALSE_NODE;
+    case 'undefined':
+      return UNDEFINED_NODE;
+    case 'string':
+      return createPrimitiveNode(quote(current));
+    case 'number':
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
+      }
+      if (Object.is(current, Infinity)) {
+        return createPrimitiveNode('1/0');
+      }
+      if (Object.is(current, -Infinity)) {
+        return createPrimitiveNode('-1/0');
+      }
+      return createPrimitiveNode(current);
+    case 'bigint':
+      return createBigIntNode(ctx, current);
+    case 'object': {
+      if (!current) {
+        return NULL_NODE;
+      }
+      // Non-primitive values needs a reference ID
+      // mostly because the values themselves are stateful
+      const id = createRef(ctx, current, true);
+      if (ctx.markedRefs.has(id)) {
+        return createReferenceNode(id);
+      }
+      if (Array.isArray(current)) {
+        return generateArrayNode(ctx, id, current);
+      }
+      switch (current.constructor) {
+        case Date:
+          return createDateNode(id, current as Date);
+        case RegExp:
+          return createRegExpNode(id, current as RegExp);
+        case Int8Array:
+        case Int16Array:
+        case Int32Array:
+        case Uint8Array:
+        case Uint16Array:
+        case Uint32Array:
+        case Uint8ClampedArray:
+        case Float32Array:
+        case Float64Array:
+          return createTypedArrayNode(ctx, id, current as TypedArrayValue);
+        case BigInt64Array:
+        case BigUint64Array:
+          return createBigIntTypedArrayNode(ctx, id, current as BigIntTypedArrayValue);
+        case Map:
+          return generateMapNode(ctx, id, current as Map<ServerValue, ServerValue>);
+        case Set:
+          return generateSetNode(ctx, id, current as Set<ServerValue>);
+        case Object:
+          return generateObjectNode(ctx, id, current as Record<string, ServerValue>, false);
+        case undefined:
+          return generateObjectNode(ctx, id, current as Record<string, ServerValue>, true);
+        case AggregateError:
+          if (ctx.features & Feature.AggregateError) {
+            return generateAggregateErrorNode(ctx, id, current as AggregateError);
+          }
+          return generateErrorNode(ctx, id, current as AggregateError);
+        case Error:
+        case EvalError:
+        case RangeError:
+        case ReferenceError:
+        case SyntaxError:
+        case TypeError:
+        case URIError:
+          return generateErrorNode(ctx, id, current as Error);
+        default:
+          break;
+      }
+      if (current instanceof AggregateError && ctx.features & Feature.AggregateError) {
+        return generateAggregateErrorNode(ctx, id, current);
+      }
+      if (current instanceof Error) {
+        return generateErrorNode(ctx, id, current);
+      }
+      // Generator functions don't have a global constructor
+      if (Symbol.iterator in current) {
+        return generateIterableNode(ctx, id, current);
+      }
+      throw new Error('Unsupported type');
+    }
+    default:
+      throw new Error('Unsupported type');
   }
-  throw new Error('Unsupported value');
 }
 
 export default function parseSync(
   ctx: ParserContext,
   current: ServerValue,
 ) {
-  const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current), result.t === SerovalNodeType.Object] as const;
+  const result = parse(ctx, current);
+  const isObject = result.t === SerovalNodeType.Object
+    || result.t === SerovalNodeType.Iterable;
+  return [result, createRef(ctx, current, false), isObject] as const;
 }

package/src/types.ts

@@ -25,7 +25,9 @@ export type TypedArrayValue =
   | Uint32Array
   | Uint8ClampedArray
   | Float32Array
-  | Float64Array
+  | Float64Array;
+
+export type BigIntTypedArrayValue =
   | BigInt64Array
   | BigUint64Array;
 
@@ -33,6 +35,7 @@ export type SemiPrimitiveValue =
   | RegExp
   | Date
   | TypedArrayValue
+  | BigIntTypedArrayValue
   | bigint;
 
 export type CommonServerValue =

package/dist/types/checks.d.ts

@@ -1,5 +0,0 @@
-import { AsyncServerValue, PrimitiveValue } from './types';
-export declare function isPrimitive(current: unknown): current is PrimitiveValue;
-export declare function isPromise<T>(obj: unknown): obj is PromiseLike<T>;
-export declare function constructorCheck<T extends NonNullable<AsyncServerValue>>(value: unknown, constructor: unknown): value is T;
-export declare function isIterable<T>(obj: unknown): obj is Iterable<T>;

package/src/checks.ts

@@ -1,40 +0,0 @@
-import { AsyncServerValue, PrimitiveValue } from './types';
-
-export function isPrimitive(current: unknown): current is PrimitiveValue {
-  if (!current || current === true) {
-    return true;
-  }
-  const type = typeof current;
-  return type === 'number'
-    || type === 'string';
-}
-
-export function isPromise<T>(obj: unknown): obj is PromiseLike<T> {
-  return !!obj
-    && (typeof obj === 'object' || typeof obj === 'function')
-    && 'then' in obj
-    && typeof obj.then === 'function';
-}
-
-export function constructorCheck<T extends NonNullable<AsyncServerValue>>(
-  value: unknown,
-  constructor: unknown,
-): value is T {
-  return (value as { constructor: unknown }).constructor === constructor;
-}
-
-function isIterableBuiltin(obj: unknown) {
-  return (
-    Array.isArray(obj)
-    || constructorCheck<Set<any>>(obj, Set)
-    || constructorCheck<Map<any, any>>(obj, Map)
-  );
-}
-
-export function isIterable<T>(obj: unknown): obj is Iterable<T> {
-  return !!obj
-    && typeof obj === 'object'
-    && !isIterableBuiltin(obj)
-    && Symbol.iterator in obj
-    && typeof obj[Symbol.iterator] === 'function';
-}