seroval 0.5.1 → 0.7.0

package/src/tree/primitives.ts

@@ -1,8 +1,9 @@
 import assert from '../assert';
 import { Feature } from '../compat';
-import { ParserContext } from '../context';
-import quote from '../quote';
+import { ParserContext, createIndexedValue } from '../context';
+import { serializeString } from '../string';
 import { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import { getReferenceID } from './reference';
 import { INV_SYMBOL_REF, WellKnownSymbols } from './symbols';
 import {
   SerovalBigIntNode,
@@ -16,12 +17,15 @@ import {
   SerovalNodeType,
   SerovalNullNode,
   SerovalNumberNode,
-  SerovalReferenceNode,
+  SerovalIndexedValueNode,
   SerovalRegExpNode,
   SerovalStringNode,
   SerovalTypedArrayNode,
   SerovalUndefinedNode,
   SerovalWKSymbolNode,
+  SerovalReferenceNode,
+  SerovalArrayBufferNode,
+  SerovalDataViewNode,
 } from './types';
 
 export const TRUE_NODE: SerovalBooleanNode = {
@@ -34,6 +38,7 @@ export const TRUE_NODE: SerovalBooleanNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const FALSE_NODE: SerovalBooleanNode = {
   t: SerovalNodeType.Boolean,
@@ -45,6 +50,7 @@ export const FALSE_NODE: SerovalBooleanNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const UNDEFINED_NODE: SerovalUndefinedNode = {
   t: SerovalNodeType.Undefined,
@@ -56,6 +62,7 @@ export const UNDEFINED_NODE: SerovalUndefinedNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const NULL_NODE: SerovalNullNode = {
   t: SerovalNodeType.Null,
@@ -67,6 +74,7 @@ export const NULL_NODE: SerovalNullNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
   t: SerovalNodeType.NegativeZero,
@@ -78,6 +86,7 @@ export const NEG_ZERO_NODE: SerovalNegativeZeroNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const INFINITY_NODE: SerovalInfinityNode = {
   t: SerovalNodeType.Infinity,
@@ -89,6 +98,7 @@ export const INFINITY_NODE: SerovalInfinityNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
   t: SerovalNodeType.NegativeInfinity,
@@ -100,6 +110,7 @@ export const NEG_INFINITY_NODE: SerovalNegativeInfinityNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 export const NAN_NODE: SerovalNaNNode = {
   t: SerovalNodeType.NaN,
@@ -111,6 +122,7 @@ export const NAN_NODE: SerovalNaNNode = {
   d: undefined,
   a: undefined,
   f: undefined,
+  b: undefined,
 };
 
 export function createNumberNode(value: number): SerovalNumberNode {
@@ -124,6 +136,7 @@ export function createNumberNode(value: number): SerovalNumberNode {
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -131,13 +144,14 @@ 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,
   };
 }
 
@@ -156,12 +170,13 @@ export function createBigIntNode(
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
-export function createReferenceNode(id: number): SerovalReferenceNode {
+export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
   return {
-    t: SerovalNodeType.Reference,
+    t: SerovalNodeType.IndexedValue,
     i: id,
     s: undefined,
     l: undefined,
@@ -170,6 +185,7 @@ export function createReferenceNode(id: number): SerovalReferenceNode {
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
   };
 }
 
@@ -184,6 +200,7 @@ export function createDateNode(id: number, current: Date): SerovalDateNode {
     d: undefined,
     f: undefined,
     a: undefined,
+    b: undefined,
   };
 }
 
@@ -198,9 +215,45 @@ 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,
+) {
+  const id = createIndexedValue(ctx, current);
+  if (ctx.markedRefs.has(id)) {
+    return createIndexedValueNode(id);
+  }
+  return createArrayBufferNode(id, current);
+}
+
 export function createTypedArrayNode(
   ctx: ParserContext,
   id: number,
@@ -208,21 +261,17 @@ export function createTypedArrayNode(
 ): 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];
-  }
   return {
     t: SerovalNodeType.TypedArray,
     i: id,
-    s: values,
-    l: current.byteOffset,
+    s: undefined,
+    l: current.length,
     c: constructor,
     m: undefined,
     d: undefined,
     a: undefined,
-    f: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
   };
 }
 
@@ -238,27 +287,26 @@ export function createBigIntTypedArrayNode(
     (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
     `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];
-  }
   return {
     t: SerovalNodeType.BigIntTypedArray,
     i: id,
-    s: values,
-    l: current.byteOffset,
+    s: undefined,
+    l: current.length,
     c: constructor,
     m: undefined,
     d: undefined,
     a: undefined,
-    f: undefined,
+    f: serializeArrayBuffer(ctx, current.buffer),
+    b: current.byteOffset,
   };
 }
 
 export function createWKSymbolNode(
+  ctx: ParserContext,
   current: WellKnownSymbols,
 ): SerovalWKSymbolNode {
+  assert(ctx.features & Feature.Symbol, 'Unsupported type "symbol"');
+  assert(current in INV_SYMBOL_REF, 'seroval only supports well-known symbols');
   return {
     t: SerovalNodeType.WKSymbol,
     i: undefined,
@@ -269,5 +317,43 @@ export function createWKSymbolNode(
     d: undefined,
     a: undefined,
     f: undefined,
+    b: undefined,
+  };
+}
+
+export function createReferenceNode<T>(
+  id: number,
+  ref: T,
+): SerovalReferenceNode {
+  return {
+    t: SerovalNodeType.Reference,
+    i: id,
+    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,
   };
 }

package/src/tree/reference.ts

@@ -0,0 +1,61 @@
+/* eslint-disable no-restricted-globals */
+import assert from '../assert';
+
+const REFERENCE = new Map<unknown, string>();
+const INV_REFERENCE = new Map<string, unknown>();
+
+export function createReference<T>(id: string, value: T): T {
+  REFERENCE.set(value, id);
+  INV_REFERENCE.set(id, value);
+  return value;
+}
+
+export function hasReferenceID<T>(value: T): boolean {
+  return REFERENCE.has(value);
+}
+
+export function hasReference(id: string): boolean {
+  return INV_REFERENCE.has(id);
+}
+
+export function getReferenceID<T>(value: T): string {
+  assert(hasReferenceID(value), 'Missing reference id');
+  return REFERENCE.get(value) as string;
+}
+
+export function getReference<T>(id: string): T {
+  assert(hasReference(id), 'Missing reference for id:' + id);
+  return INV_REFERENCE.get(id) as T;
+}
+
+export const GLOBAL_KEY = '__SEROVAL__';
+
+if (typeof globalThis !== undefined) {
+  Object.defineProperty(globalThis, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof window !== undefined) {
+  Object.defineProperty(window, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof self !== undefined) {
+  Object.defineProperty(self, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof global !== undefined) {
+  Object.defineProperty(global, GLOBAL_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+}