seroval 0.9.0 → 0.10.1

package/dist/types/types.d.ts

@@ -1,20 +1,20 @@
-import type { WellKnownSymbols } from './tree/symbols';
-export type PrimitiveValue = boolean | string | number | undefined | null | WellKnownSymbols;
-export type ErrorValue = Error | AggregateError | EvalError | RangeError | ReferenceError | TypeError | SyntaxError | URIError;
-export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
-export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
-export type WebAPIValue = URL | URLSearchParams | Blob | File;
-export type SemiPrimitiveValue = RegExp | Date | ArrayBuffer | DataView | TypedArrayValue | BigIntTypedArrayValue | bigint | WebAPIValue;
-export type CommonServerValue = PrimitiveValue | SemiPrimitiveValue | ErrorValue;
-export type ServerValue = CommonServerValue | Array<ServerValue> | readonly ServerValue[] | Iterable<ServerValue> | {
-    [key: string | number]: ServerValue;
-} | {
-    readonly [key: string | number]: ServerValue;
-} | Set<ServerValue> | Map<ServerValue, ServerValue>;
-export type AsyncServerValue = CommonServerValue | Array<AsyncServerValue> | readonly AsyncServerValue[] | Iterable<AsyncServerValue> | {
-    [key: string | number]: AsyncServerValue;
-} | {
-    readonly [key: string | number]: AsyncServerValue;
-} | Set<AsyncServerValue> | Map<AsyncServerValue, AsyncServerValue> | Promise<AsyncServerValue>;
-export type NonPrimitiveServerValue<T> = T extends PrimitiveValue ? never : T;
-export type MaybePromise<T> = T | Promise<T>;
+import type { WellKnownSymbols } from './core/constants';
+export type PrimitiveValue = boolean | string | number | undefined | null | WellKnownSymbols;
+export type ErrorValue = Error | AggregateError | EvalError | RangeError | ReferenceError | TypeError | SyntaxError | URIError;
+export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+export type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;
+export type WebAPIValue = URL | URLSearchParams | Blob | File;
+export type SemiPrimitiveValue = RegExp | Date | ArrayBuffer | DataView | TypedArrayValue | BigIntTypedArrayValue | bigint | WebAPIValue;
+export type CommonServerValue = PrimitiveValue | SemiPrimitiveValue | ErrorValue;
+export type ServerValue = CommonServerValue | Array<ServerValue> | readonly ServerValue[] | Iterable<ServerValue> | {
+    [key: string | number]: ServerValue;
+} | {
+    readonly [key: string | number]: ServerValue;
+} | Set<ServerValue> | Map<ServerValue, ServerValue>;
+export type AsyncServerValue = CommonServerValue | Array<AsyncServerValue> | readonly AsyncServerValue[] | Iterable<AsyncServerValue> | {
+    [key: string | number]: AsyncServerValue;
+} | {
+    readonly [key: string | number]: AsyncServerValue;
+} | Set<AsyncServerValue> | Map<AsyncServerValue, AsyncServerValue> | Promise<AsyncServerValue>;
+export type NonPrimitiveServerValue<T> = T extends PrimitiveValue ? never : T;
+export type MaybePromise<T> = T | Promise<T>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "files": [
     "dist",
     "src"
@@ -14,9 +14,9 @@
     "pridepack"
   ],
   "devDependencies": {
-    "@types/node": "^20.4.0",
-    "@vitest/ui": "^0.33.0",
-    "eslint": "^8.44.0",
+    "@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",
@@ -67,5 +67,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "a3bfdc3ac2246b5b067f67af1f10d7a416bfed5f"
+  "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,7 +46,8 @@ export function createNumberNode(value: number): SerovalNode {
         l: undefined,
         c: undefined,
         m: undefined,
-        d: undefined,
+        p: undefined,
+        e: undefined,
         a: undefined,
         f: undefined,
         b: undefined,
@@ -70,7 +64,8 @@ export function createStringNode(value: string): SerovalStringNode {
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
@@ -79,7 +74,7 @@ export function createStringNode(value: string): SerovalStringNode {
 }
 
 export function createBigIntNode(
-  ctx: ParserContext,
+  ctx: BaseParserContext,
   current: bigint,
 ): SerovalBigIntNode {
   assert(ctx.features & Feature.BigInt, new UnsupportedTypeError(current));
@@ -90,7 +85,8 @@ export function createBigIntNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
@@ -106,7 +102,8 @@ export function createIndexedValueNode(id: number): SerovalIndexedValueNode {
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
@@ -122,7 +119,8 @@ 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,
@@ -138,7 +136,8 @@ 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,
@@ -163,7 +162,8 @@ export function createArrayBufferNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
@@ -171,66 +171,8 @@ export function createArrayBufferNode(
   };
 }
 
-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,
-    o: undefined,
-  };
-}
-
-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 {
@@ -243,7 +185,8 @@ export function createWKSymbolNode(
     l: undefined,
     c: undefined,
     m: undefined,
-    d: undefined,
+    p: undefined,
+    e: undefined,
     a: undefined,
     f: undefined,
     b: undefined,
@@ -262,57 +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,
-    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);
-}