seroval 0.6.0 → 0.8.0

package/src/tree/primitives.ts

@@ -1,145 +1,78 @@
 import assert from '../assert';
 import { Feature } from '../compat';
-import { ParserContext } from '../context';
-import quote from '../quote';
-import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
-import { getReferenceID } from './reference';
-import { INV_SYMBOL_REF, WellKnownSymbols } from './symbols';
+import type { ParserContext } from '../context';
+import { createIndexedValue } from '../context';
+import { serializeString } from '../string';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import UnsupportedTypeError from './UnsupportedTypeError';
 import {
+  INFINITY_NODE,
+  NEG_INFINITY_NODE,
+  NAN_NODE,
+  NEG_ZERO_NODE,
+} from './constants';
+import { getReferenceID, hasReferenceID } from './reference';
+import type { WellKnownSymbols } from './symbols';
+import { INV_SYMBOL_REF } from './symbols';
+import type {
   SerovalBigIntNode,
   SerovalBigIntTypedArrayNode,
-  SerovalBooleanNode,
   SerovalDateNode,
-  SerovalInfinityNode,
-  SerovalNaNNode,
-  SerovalNegativeInfinityNode,
-  SerovalNegativeZeroNode,
-  SerovalNodeType,
-  SerovalNullNode,
-  SerovalNumberNode,
   SerovalIndexedValueNode,
   SerovalRegExpNode,
   SerovalStringNode,
   SerovalTypedArrayNode,
-  SerovalUndefinedNode,
   SerovalWKSymbolNode,
   SerovalReferenceNode,
+  SerovalArrayBufferNode,
+  SerovalDataViewNode,
+  SerovalNode,
+} from './types';
+import {
+  SerovalNodeType,
 } from './types';
 
-export const TRUE_NODE: SerovalBooleanNode = {
-  t: SerovalNodeType.Boolean,
-  i: undefined,
-  s: true,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const FALSE_NODE: SerovalBooleanNode = {
-  t: SerovalNodeType.Boolean,
-  i: undefined,
-  s: false,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const UNDEFINED_NODE: SerovalUndefinedNode = {
-  t: SerovalNodeType.Undefined,
-  i: undefined,
-  s: undefined,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const NULL_NODE: SerovalNullNode = {
-  t: SerovalNodeType.Null,
-  i: undefined,
-  s: undefined,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
-  t: SerovalNodeType.NegativeZero,
-  i: undefined,
-  s: undefined,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const INFINITY_NODE: SerovalInfinityNode = {
-  t: SerovalNodeType.Infinity,
-  i: undefined,
-  s: undefined,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
-  t: SerovalNodeType.NegativeInfinity,
-  i: undefined,
-  s: undefined,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-export const NAN_NODE: SerovalNaNNode = {
-  t: SerovalNodeType.NaN,
-  i: undefined,
-  s: undefined,
-  l: undefined,
-  c: undefined,
-  m: undefined,
-  d: undefined,
-  a: undefined,
-  f: undefined,
-};
-
-export function createNumberNode(value: number): SerovalNumberNode {
-  return {
-    t: SerovalNodeType.Number,
-    i: undefined,
-    s: value,
-    l: undefined,
-    c: undefined,
-    m: undefined,
-    d: undefined,
-    a: undefined,
-    f: undefined,
-  };
+export function createNumberNode(value: number): SerovalNode {
+  switch (value) {
+    case Infinity:
+      return INFINITY_NODE;
+    case -Infinity:
+      return NEG_INFINITY_NODE;
+    default:
+      // eslint-disable-next-line no-self-compare
+      if (value !== value) {
+        return NAN_NODE;
+      }
+      if (Object.is(value, -0)) {
+        return NEG_ZERO_NODE;
+      }
+      return {
+        t: SerovalNodeType.Number,
+        i: undefined,
+        s: value,
+        l: undefined,
+        c: undefined,
+        m: undefined,
+        d: undefined,
+        a: undefined,
+        f: undefined,
+        b: undefined,
+      };
+  }
 }
 
 export function createStringNode(value: string): SerovalStringNode {
   return {
     t: SerovalNodeType.String,
     i: undefined,
-    s: quote(value),
+    s: serializeString(value),
     l: undefined,
     c: undefined,
     m: undefined,
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -147,7 +80,7 @@ export function createBigIntNode(
   ctx: ParserContext,
   current: bigint,
 ): SerovalBigIntNode {
-  assert(ctx.features & Feature.BigInt, 'Unsupported type "BigInt"');
+  assert(ctx.features & Feature.BigInt, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.BigInt,
     i: undefined,
@@ -158,6 +91,7 @@ export function createBigIntNode(
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -172,6 +106,7 @@ export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -186,6 +121,7 @@ export function createDateNode(id: number, current: Date): SerovalDateNode {
     d: undefined,
     f: undefined,
     a: undefined,
+    b: undefined,
   };
 }
 
@@ -200,31 +136,62 @@ export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
+  };
+}
+
+export function createArrayBufferNode(
+  id: number,
+  current: ArrayBuffer,
+): SerovalArrayBufferNode {
+  const bytes = new Uint8Array(current);
+  const len = bytes.length;
+  const values = new Array<number>(len);
+  for (let i = 0; i < len; i++) {
+    values[i] = bytes[i];
+  }
+  return {
+    t: SerovalNodeType.ArrayBuffer,
+    i: id,
+    s: values,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    d: undefined,
+    a: undefined,
+    f: undefined,
+    b: undefined,
   };
 }
 
+export function serializeArrayBuffer(
+  ctx: ParserContext,
+  current: ArrayBuffer,
+): SerovalNode {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createArrayBufferNode(id, current);
+}
+
 export function createTypedArrayNode(
   ctx: ParserContext,
   id: number,
   current: TypedArrayValue,
 ): SerovalTypedArrayNode {
-  const constructor = current.constructor.name;
-  assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
-  const len = current.length;
-  const values = new Array<string>(len);
-  for (let i = 0; i < len; i++) {
-    values[i] = '' + current[i];
-  }
+  assert(ctx.features & Feature.TypedArray, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.TypedArray,
     i: id,
-    s: values,
-    l: current.byteOffset,
-    c: constructor,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
     m: undefined,
     d: undefined,
     a: undefined,
-    f: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
   };
 }
 
@@ -235,38 +202,34 @@ export function createBigIntTypedArrayNode(
   id: number,
   current: BigIntTypedArrayValue,
 ): SerovalBigIntTypedArrayNode {
-  const constructor = current.constructor.name;
   assert(
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
-    `Unsupported value type "${constructor}"`,
+    new UnsupportedTypeError(current),
   );
-  const len = current.length;
-  const values = new Array<string>(len);
-  for (let i = 0; i < len; i++) {
-    values[i] = '' + current[i];
-  }
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,
-    s: values,
-    l: current.byteOffset,
-    c: constructor,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
     m: undefined,
     d: undefined,
     a: undefined,
-    f: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
   };
 }
 
 export function createWKSymbolNode(
   ctx: ParserContext,
+  id: number,
   current: WellKnownSymbols,
 ): SerovalWKSymbolNode {
-  assert(ctx.features & Feature.Symbol, 'Unsupported type "symbol"');
-  assert(current in INV_SYMBOL_REF, 'seroval only supports well-known symbols');
+  assert(ctx.features & Feature.Symbol, new UnsupportedTypeError(current));
+  assert(current in INV_SYMBOL_REF, new Error('Only well-known symbols are supported.'));
   return {
     t: SerovalNodeType.WKSymbol,
-    i: undefined,
+    i: id,
     s: INV_SYMBOL_REF[current],
     l: undefined,
     c: undefined,
@@ -274,6 +237,7 @@ export function createWKSymbolNode(
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -284,12 +248,59 @@ export function createReferenceNode<T>(
   return {
     t: SerovalNodeType.Reference,
     i: id,
-    s: quote(getReferenceID(ref)),
+    s: serializeString(getReferenceID(ref)),
     l: undefined,
     c: undefined,
     m: undefined,
     d: undefined,
     a: undefined,
     f: undefined,
+    b: 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,
+    d: undefined,
+    a: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
   };
 }
+
+export function createSymbolNode(
+  ctx: ParserContext,
+  current: symbol,
+): SerovalNode {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.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,
+): SerovalNode {
+  assert(hasReferenceID(current), new Error('Cannot serialize function without reference ID.'));
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createReferenceNode(id, current);
+}

package/src/tree/reference.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
 /* eslint-disable no-restricted-globals */
 import assert from '../assert';
 
@@ -19,12 +20,12 @@ export function hasReference(id: string): boolean {
 }
 
 export function getReferenceID<T>(value: T): string {
-  assert(hasReferenceID(value), 'Missing reference id');
-  return REFERENCE.get(value) as string;
+  assert(hasReferenceID(value), new Error('Missing reference id'));
+  return REFERENCE.get(value)!;
 }
 
 export function getReference<T>(id: string): T {
-  assert(hasReference(id), 'Missing reference for id:' + id);
+  assert(hasReference(id), new Error('Missing reference for id:' + id));
   return INV_REFERENCE.get(id) as T;
 }