seroval 0.7.0 → 0.9.0

package/src/tree/primitives.ts

@@ -1,143 +1,65 @@
 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,
+        o: undefined,
+      };
+  }
 }
 
 export function createStringNode(value: string): SerovalStringNode {
@@ -152,6 +74,7 @@ export function createStringNode(value: string): SerovalStringNode {
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -159,7 +82,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,
@@ -171,6 +94,7 @@ export function createBigIntNode(
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -186,6 +110,7 @@ export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -201,6 +126,7 @@ export function createDateNode(id: number, current: Date): SerovalDateNode {
     f: undefined,
     a: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -216,6 +142,7 @@ export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -240,13 +167,14 @@ export function createArrayBufferNode(
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
 export function serializeArrayBuffer(
   ctx: ParserContext,
   current: ArrayBuffer,
-) {
+): SerovalNode {
   const id = createIndexedValue(ctx, current);
   if (ctx.markedRefs.has(id)) {
     return createIndexedValueNode(id);
@@ -259,19 +187,19 @@ 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,
     f: serializeArrayBuffer(ctx, current.buffer),
     b: current.byteOffset,
+    o: undefined,
   };
 }
 
@@ -282,34 +210,35 @@ 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,
     f: serializeArrayBuffer(ctx, current.buffer),
     b: current.byteOffset,
+    o: undefined,
   };
 }
 
 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,
@@ -318,6 +247,7 @@ export function createWKSymbolNode(
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -336,6 +266,7 @@ export function createReferenceNode<T>(
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -355,5 +286,33 @@ export function createDataViewNode(
     a: undefined,
     f: serializeArrayBuffer(ctx, current.buffer),
     b: current.byteOffset,
+    o: undefined,
   };
 }
+
+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

@@ -19,12 +19,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;
 }