seroval 0.8.0 → 0.10.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.10.1",
   "files": [
     "dist",
     "src"
@@ -14,15 +14,15 @@
     "pridepack"
   ],
   "devDependencies": {
-    "@types/node": "^18.15.3",
-    "@vitest/ui": "^0.30.1",
-    "eslint": "^8.39.0",
-    "eslint-config-lxsmnsyc": "^0.6.4",
+    "@types/node": "^20.6.2",
+    "@vitest/ui": "^0.34.4",
+    "eslint": "^8.49.0",
+    "eslint-config-lxsmnsyc": "^0.6.5",
     "node-fetch-native": "^1.1.0",
     "pridepack": "2.4.4",
     "tslib": "^2.5.0",
     "typescript": "^4.9.4",
-    "vitest": "^0.30.1"
+    "vitest": "^0.33.0"
   },
   "scripts": {
     "prepublishOnly": "pridepack clean && pridepack build",
@@ -67,5 +67,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "f7fe3305e0295499989d9f675ff54f9305db23b0"
+  "gitHead": "aa589c20369bfbeb28d7a3d9ab0e86ed92205195"
 }

package/src/core/Serializer.ts

@@ -0,0 +1,46 @@
+import { crossSerializeStream } from './cross';
+import { serializeString } from './string';
+
+export interface SerializerOptions {
+  globalIdentifier: string;
+  disabledFeatures?: number;
+  onData: (result: string) => void;
+}
+
+export default class Serializer {
+  private alive = true;
+
+  private cleanups: (() => void)[] = [];
+
+  private refs = new Map<unknown, number>();
+
+  constructor(
+    private options: SerializerOptions,
+  ) {
+  }
+
+  write(key: string, value: unknown): void {
+    if (this.alive) {
+      this.cleanups.push(crossSerializeStream(value, {
+        refs: this.refs,
+        disabledFeatures: this.options.disabledFeatures,
+        onSerialize: (data, initial) => {
+          this.options.onData(
+            initial
+              ? this.options.globalIdentifier + '["' + serializeString(key) + '"]=' + data
+              : data,
+          );
+        },
+      }));
+    }
+  }
+
+  close(): void {
+    if (this.alive) {
+      for (let i = 0, len = this.cleanups.length; i < len; i++) {
+        this.cleanups[i]();
+      }
+      this.alive = false;
+    }
+  }
+}

package/src/{tree → core}/UnsupportedTypeError.ts

@@ -2,7 +2,7 @@
 const { toString } = Object.prototype;
 
 export default class UnsupportedTypeError extends Error {
-  constructor(value: unknown) {
+  constructor(public value: unknown) {
     super('Unsupported type "' + toString.call(value) + '"');
   }
 }

package/src/core/assignments.ts

@@ -0,0 +1,159 @@
+import { SerovalObjectFlags } from './constants';
+
+interface IndexAssignment {
+  t: 'index';
+  s: string;
+  k: undefined;
+  v: string;
+}
+
+interface SetAssignment {
+  t: 'set';
+  s: string;
+  k: string;
+  v: string;
+}
+
+interface AddAssignment {
+  t: 'add';
+  s: string;
+  k: undefined;
+  v: string;
+}
+
+interface AppendAssignment {
+  t: 'append';
+  s: string;
+  k: string;
+  v: string;
+}
+
+// Array of assignments to be done (used for recursion)
+export type Assignment =
+  | IndexAssignment
+  | AddAssignment
+  | SetAssignment
+  | AppendAssignment;
+
+export interface FlaggedObject {
+  type: SerovalObjectFlags;
+  value: string;
+}
+
+function getAssignmentExpression(assignment: Assignment): string {
+  switch (assignment.t) {
+    case 'index':
+      return assignment.s + '=' + assignment.v;
+    case 'set':
+      return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';
+    case 'add':
+      return assignment.s + '.add(' + assignment.v + ')';
+    case 'append':
+      return assignment.s + '.append(' + assignment.k + ',' + assignment.v + ')';
+    default:
+      return '';
+  }
+}
+
+const OBJECT_FLAG_CONSTRUCTOR: Record<SerovalObjectFlags, string | undefined> = {
+  [SerovalObjectFlags.Frozen]: 'Object.freeze',
+  [SerovalObjectFlags.Sealed]: 'Object.seal',
+  [SerovalObjectFlags.NonExtensible]: 'Object.preventExtensions',
+  [SerovalObjectFlags.None]: undefined,
+};
+
+function mergeAssignments(assignments: Assignment[]): Assignment[] {
+  const newAssignments: Assignment[] = [];
+  let current = assignments[0];
+  let prev = current;
+  let item: Assignment;
+  for (let i = 1, len = assignments.length; i < len; i++) {
+    item = assignments[i];
+    if (item.t === prev.t) {
+      switch (item.t) {
+        case 'index':
+          if (item.v === prev.v) {
+            // Merge if the right-hand value is the same
+            // saves at least 2 chars
+            current = {
+              t: 'index',
+              s: item.s,
+              k: undefined,
+              v: getAssignmentExpression(current),
+            };
+          } else {
+            // Different assignment, push current
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case 'set':
+          if (item.s === prev.s) {
+            // Maps has chaining methods, merge if source is the same
+            current = {
+              t: 'set',
+              s: getAssignmentExpression(current),
+              k: item.k,
+              v: item.v,
+            };
+          } else {
+            // Different assignment, push current
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case 'add':
+          if (item.s === prev.s) {
+            // Sets has chaining methods too
+            current = {
+              t: 'add',
+              s: getAssignmentExpression(current),
+              k: undefined,
+              v: item.v,
+            };
+          } else {
+            // Different assignment, push current
+            newAssignments.push(current);
+            current = item;
+          }
+          break;
+        case 'append':
+          // Different assignment, push current
+          newAssignments.push(current);
+          current = item;
+          break;
+        default:
+          break;
+      }
+    } else {
+      newAssignments.push(current);
+      current = item;
+    }
+    prev = item;
+  }
+
+  newAssignments.push(current);
+
+  return newAssignments;
+}
+
+export function resolveAssignments(assignments: Assignment[]): string | undefined {
+  if (assignments.length) {
+    let result = '';
+    const merged = mergeAssignments(assignments);
+    for (let i = 0, len = merged.length; i < len; i++) {
+      result += getAssignmentExpression(merged[i]) + ',';
+    }
+    return result;
+  }
+  return undefined;
+}
+
+export function resolveFlags(flags: FlaggedObject[]): string | undefined {
+  let result = '';
+  for (let i = 0, len = flags.length; i < len; i++) {
+    const flag = flags[i];
+    result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';
+  }
+  return result;
+}

package/src/{tree/primitives.ts → core/base-primitives.ts}

@@ -1,38 +1,31 @@
-import assert from '../assert';
-import { Feature } from '../compat';
-import type { ParserContext } from '../context';
-import { createIndexedValue } from '../context';
-import { serializeString } from '../string';
-import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
 import UnsupportedTypeError from './UnsupportedTypeError';
+import assert from './assert';
+import { Feature } from './compat';
+import type { WellKnownSymbols } from './constants';
+import { INV_SYMBOL_REF, SerovalNodeType } from './constants';
+import type { BaseParserContext } from './context';
 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';
+} from './literals';
+import { getReferenceID } from './reference';
+import { serializeString } from './string';
 import type {
+  SerovalArrayBufferNode,
   SerovalBigIntNode,
-  SerovalBigIntTypedArrayNode,
+  SerovalConstantNode,
   SerovalDateNode,
   SerovalIndexedValueNode,
+  SerovalNumberNode,
+  SerovalReferenceNode,
   SerovalRegExpNode,
   SerovalStringNode,
-  SerovalTypedArrayNode,
   SerovalWKSymbolNode,
-  SerovalReferenceNode,
-  SerovalArrayBufferNode,
-  SerovalDataViewNode,
-  SerovalNode,
-} from './types';
-import {
-  SerovalNodeType,
 } from './types';
 
-export function createNumberNode(value: number): SerovalNode {
+export function createNumberNode(value: number): SerovalConstantNode | SerovalNumberNode {
   switch (value) {
     case Infinity:
       return INFINITY_NODE;
@@ -53,10 +46,12 @@ export function createNumberNode(value: number): SerovalNode {
         l: undefined,
         c: undefined,
         m: undefined,
-        d: undefined,
+        p: undefined,
+        e: undefined,
         a: undefined,
         f: undefined,
         b: undefined,
+        o: undefined,
       };
   }
 }
@@ -69,15 +64,17 @@ export function createStringNode(value: string): SerovalStringNode {
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
 export function createBigIntNode(
-  ctx: ParserContext,
+  ctx: BaseParserContext,
   current: bigint,
 ): SerovalBigIntNode {
   assert(ctx.features & Feature.BigInt, new UnsupportedTypeError(current));
@@ -88,10 +85,12 @@ export function createBigIntNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -103,10 +102,12 @@ export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -118,10 +119,12 @@ export function createDateNode(id: number, current: Date): SerovalDateNode {
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     f: undefined,
     a: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -133,10 +136,12 @@ export function createRegExpNode(id: number, current: RegExp): SerovalRegExpNode
     l: undefined,
     c: current.source,
     m: current.flags,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -157,71 +162,17 @@ export function createArrayBufferNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: 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 {
-  assert(ctx.features & Feature.TypedArray, new UnsupportedTypeError(current));
-  return {
-    t: SerovalNodeType.TypedArray,
-    i: id,
-    s: undefined,
-    l: current.length,
-    c: current.constructor.name,
-    m: undefined,
-    d: undefined,
-    a: undefined,
-    f: serializeArrayBuffer(ctx, current.buffer),
-    b: current.byteOffset,
-  };
-}
-
-const BIGINT_FLAG = Feature.BigIntTypedArray | Feature.BigInt;
-
-export function createBigIntTypedArrayNode(
-  ctx: ParserContext,
-  id: number,
-  current: BigIntTypedArrayValue,
-): SerovalBigIntTypedArrayNode {
-  assert(
-    (ctx.features & BIGINT_FLAG) === BIGINT_FLAG,
-    new UnsupportedTypeError(current),
-  );
-  return {
-    t: SerovalNodeType.BigIntTypedArray,
-    i: id,
-    s: undefined,
-    l: current.length,
-    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,
+  ctx: BaseParserContext,
   id: number,
   current: WellKnownSymbols,
 ): SerovalWKSymbolNode {
@@ -234,10 +185,12 @@ export function createWKSymbolNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: undefined,
   };
 }
 
@@ -252,55 +205,11 @@ export function createReferenceNode<T>(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
+    o: 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/core/constants.ts

@@ -0,0 +1,169 @@
+import type { SerovalConstantNode } from './types';
+
+export const enum SerovalConstant {
+  Null = 0,
+  Undefined = 1,
+  True = 2,
+  False = 3,
+  NegativeZero = 4,
+  Infinity = 5,
+  NegativeInfinity = 6,
+  NaN = 7,
+}
+
+export const enum SerovalNodeType {
+  Number = 0,
+  String = 1,
+  Constant = 2,
+  BigInt = 3,
+  IndexedValue = 4,
+  Date = 5,
+  RegExp = 6,
+  Set = 7,
+  Map = 8,
+  Array = 9,
+  Object = 10,
+  NullConstructor = 11,
+  Promise = 12,
+  Error = 13,
+  AggregateError = 14,
+  TypedArray = 15,
+  BigIntTypedArray = 16,
+  WKSymbol = 17,
+  URL = 18,
+  URLSearchParams = 19,
+  Reference = 20,
+  ArrayBuffer = 21,
+  DataView = 22,
+  Blob = 23,
+  File = 24,
+  Headers = 25,
+  FormData = 26,
+  Boxed = 27,
+  PromiseConstructor = 28,
+  PromiseResolve = 29,
+  PromiseReject = 30,
+  ReadableStreamConstructor = 31,
+  ReadableStreamEnqueue = 32,
+  ReadableStreamClose = 33,
+  ReadableStreamError = 34,
+}
+
+export const enum SerovalObjectFlags {
+  None = 0,
+  NonExtensible = 1,
+  Sealed = 2,
+  Frozen = 3,
+}
+
+export const enum Symbols {
+  AsyncIterator = 0,
+  HasInstance = 1,
+  IsConcatSpreadable = 2,
+  Iterator = 3,
+  Match = 4,
+  MatchAll = 5,
+  Replace = 6,
+  Search = 7,
+  Species = 8,
+  Split = 9,
+  ToPrimitive = 10,
+  ToStringTag = 11,
+  Unscopables = 12,
+}
+
+export const SYMBOL_STRING: Record<Symbols, string> = {
+  [Symbols.AsyncIterator]: 'Symbol.asyncIterator',
+  [Symbols.HasInstance]: 'Symbol.hasInstance',
+  [Symbols.IsConcatSpreadable]: 'Symbol.isConcatSpreadable',
+  [Symbols.Iterator]: 'Symbol.iterator',
+  [Symbols.Match]: 'Symbol.match',
+  [Symbols.MatchAll]: 'Symbol.matchAll',
+  [Symbols.Replace]: 'Symbol.replace',
+  [Symbols.Search]: 'Symbol.search',
+  [Symbols.Species]: 'Symbol.species',
+  [Symbols.Split]: 'Symbol.split',
+  [Symbols.ToPrimitive]: 'Symbol.toPrimitive',
+  [Symbols.ToStringTag]: 'Symbol.toStringTag',
+  [Symbols.Unscopables]: 'Symbol.unscopables',
+};
+
+export const INV_SYMBOL_REF = {
+  [Symbol.asyncIterator]: Symbols.AsyncIterator,
+  [Symbol.hasInstance]: Symbols.HasInstance,
+  [Symbol.isConcatSpreadable]: Symbols.IsConcatSpreadable,
+  [Symbol.iterator]: Symbols.Iterator,
+  [Symbol.match]: Symbols.Match,
+  [Symbol.matchAll]: Symbols.MatchAll,
+  [Symbol.replace]: Symbols.Replace,
+  [Symbol.search]: Symbols.Search,
+  [Symbol.species]: Symbols.Species,
+  [Symbol.split]: Symbols.Split,
+  [Symbol.toPrimitive]: Symbols.ToPrimitive,
+  [Symbol.toStringTag]: Symbols.ToStringTag,
+  [Symbol.unscopables]: Symbols.Unscopables,
+};
+
+export type WellKnownSymbols = keyof typeof INV_SYMBOL_REF;
+
+export const SYMBOL_REF: Record<Symbols, WellKnownSymbols> = {
+  [Symbols.AsyncIterator]: Symbol.asyncIterator,
+  [Symbols.HasInstance]: Symbol.hasInstance,
+  [Symbols.IsConcatSpreadable]: Symbol.isConcatSpreadable,
+  [Symbols.Iterator]: Symbol.iterator,
+  [Symbols.Match]: Symbol.match,
+  [Symbols.MatchAll]: Symbol.matchAll,
+  [Symbols.Replace]: Symbol.replace,
+  [Symbols.Search]: Symbol.search,
+  [Symbols.Species]: Symbol.species,
+  [Symbols.Split]: Symbol.split,
+  [Symbols.ToPrimitive]: Symbol.toPrimitive,
+  [Symbols.ToStringTag]: Symbol.toStringTag,
+  [Symbols.Unscopables]: Symbol.unscopables,
+};
+
+export function serializeConstant(node: SerovalConstantNode): string {
+  switch (node.s) {
+    case SerovalConstant.True:
+      return '!0';
+    case SerovalConstant.False:
+      return '!1';
+    case SerovalConstant.Undefined:
+      return 'void 0';
+    case SerovalConstant.Null:
+      return 'null';
+    case SerovalConstant.NegativeZero:
+      return '-0';
+    case SerovalConstant.Infinity:
+      return '1/0';
+    case SerovalConstant.NegativeInfinity:
+      return '-1/0';
+    case SerovalConstant.NaN:
+      return 'NaN';
+    default:
+      throw new Error('invariant');
+  }
+}
+
+export function deserializeConstant(node: SerovalConstantNode): unknown {
+  switch (node.s) {
+    case SerovalConstant.True:
+      return true;
+    case SerovalConstant.False:
+      return false;
+    case SerovalConstant.Undefined:
+      return undefined;
+    case SerovalConstant.Null:
+      return null;
+    case SerovalConstant.NegativeZero:
+      return -0;
+    case SerovalConstant.Infinity:
+      return Infinity;
+    case SerovalConstant.NegativeInfinity:
+      return -Infinity;
+    case SerovalConstant.NaN:
+      return NaN;
+    default:
+      throw new Error('invariant');
+  }
+}