seroval 0.7.0 → 0.8.0

package/src/tree/primitives.ts

@@ -1,143 +1,64 @@
 import assert from '../assert';
 import { Feature } from '../compat';
-import { ParserContext, createIndexedValue } from '../context';
+import type { ParserContext } from '../context';
+import { createIndexedValue } from '../context';
 import { serializeString } from '../string';
-import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
-import { getReferenceID } from './reference';
-import { INV_SYMBOL_REF, WellKnownSymbols } from './symbols';
+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,
-  b: 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,
-  b: 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,
-  b: 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,
-  b: 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,
-  b: 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,
-  b: 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,
-  b: 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,
-  b: 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,
-    b: 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 {
@@ -159,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,
@@ -246,7 +167,7 @@ export function createArrayBufferNode(
 export function serializeArrayBuffer(
   ctx: ParserContext,
   current: ArrayBuffer,
-) {
+): SerovalNode {
   const id = createIndexedValue(ctx, current);
   if (ctx.markedRefs.has(id)) {
     return createIndexedValueNode(id);
@@ -259,14 +180,13 @@ export function createTypedArrayNode(
   id: number,
   current: TypedArrayValue,
 ): SerovalTypedArrayNode {
-  const constructor = current.constructor.name;
-  assert(ctx.features & Feature.TypedArray, `Unsupported value type "${constructor}"`);
+  assert(ctx.features & Feature.TypedArray, new UnsupportedTypeError(current));
   return {
     t: SerovalNodeType.TypedArray,
     i: id,
     s: undefined,
     l: current.length,
-    c: constructor,
+    c: current.constructor.name,
     m: undefined,
     d: undefined,
     a: undefined,
@@ -282,17 +202,16 @@ 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),
   );
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,
     s: undefined,
     l: current.length,
-    c: constructor,
+    c: current.constructor.name,
     m: undefined,
     d: undefined,
     a: undefined,
@@ -303,13 +222,14 @@ export function createBigIntTypedArrayNode(
 
 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,
@@ -357,3 +277,30 @@ export function createDataViewNode(
     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;
 }