seroval 0.4.0-alpha.3 → 0.4.0-alpha.5

package/dist/types/tree/shared.d.ts

@@ -0,0 +1,10 @@
+import { SerializationContext, ParserContext } from '../context';
+import { ErrorValue, PrimitiveValue } from '../types';
+import { SerovalNode, SerovalReferenceNode } from './types';
+export declare function getErrorConstructor(error: ErrorValue): "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError" | "Error";
+export declare function getErrorOptions(error: Error): Record<string, any> | undefined;
+export declare function getIterableOptions(obj: Iterable<any>): Record<string, unknown> | undefined;
+export declare function isReferenceInStack(ctx: SerializationContext, node: SerovalNode): node is SerovalReferenceNode;
+export declare function generateRef(ctx: ParserContext, current: unknown): number | SerovalReferenceNode;
+export declare function generateSemiPrimitiveValue(ctx: ParserContext, current: unknown, id: number): SerovalNode | undefined;
+export declare function serializePrimitive(value: PrimitiveValue): string | number | null;

package/dist/types/tree/sync.d.ts

@@ -0,0 +1,4 @@
+import { ParserContext } from '../context';
+import { ServerValue } from '../types';
+import { SerovalNode } from './types';
+export default function parseSync(ctx: ParserContext, current: ServerValue): readonly [SerovalNode, number, boolean];

package/dist/types/tree/types.d.ts

@@ -0,0 +1,79 @@
+import { PrimitiveValue } from '../types';
+export declare const enum SerovalNodeType {
+    Primitive = 0,
+    BigInt = 1,
+    Reference = 2,
+    Date = 3,
+    RegExp = 4,
+    Set = 5,
+    Map = 6,
+    Array = 7,
+    Object = 8,
+    NullConstructor = 9,
+    Promise = 10,
+    Error = 11,
+    AggregateError = 12,
+    Iterable = 13,
+    TypedArray = 14,
+    BigIntTypedArray = 15
+}
+export type SerovalPrimitiveNode = [
+    type: SerovalNodeType.Primitive,
+    value: PrimitiveValue
+];
+export type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
+export type SerovalSemiPrimitiveNode = [type: SerovalNodeType.BigInt, value: string] | [type: SerovalNodeType.Date, value: string, id: number] | [type: SerovalNodeType.RegExp, value: string, id: number] | [
+    type: SerovalNodeType.TypedArray,
+    value: [constructor: string, array: string, byteOffset: number],
+    id: number
+] | [
+    type: SerovalNodeType.BigIntTypedArray,
+    value: [constructor: string, array: string, byteOffset: number],
+    id: number
+];
+export type SerovalDictionaryNode = [key: string[], value: SerovalNode[], size: number];
+export type SerovalSetNode = [type: SerovalNodeType.Set, value: SerovalNode[], id: number];
+export type SerovalMapNode = [
+    type: SerovalNodeType.Map,
+    value: [key: SerovalNode[], value: SerovalNode[], size: number],
+    id: number
+];
+export type SerovalArrayNode = [type: SerovalNodeType.Array, value: SerovalNode[], id: number];
+export type SerovalObjectNode = [
+    type: SerovalNodeType.Object,
+    value: SerovalDictionaryNode,
+    id: number
+];
+export type SerovalNullConstructorNode = [
+    type: SerovalNodeType.NullConstructor,
+    value: SerovalDictionaryNode,
+    id: number
+];
+export type SerovalPromiseNode = [type: SerovalNodeType.Promise, value: SerovalNode, id: number];
+export type SerovalErrorNode = [
+    type: SerovalNodeType.Error,
+    value: [
+        constructor: string,
+        message: string,
+        options?: SerovalDictionaryNode
+    ],
+    id: number
+];
+export type SerovalAggregateErrorNode = [
+    type: SerovalNodeType.AggregateError,
+    value: [
+        message: string,
+        options: SerovalDictionaryNode | undefined,
+        errors: SerovalNode
+    ],
+    id: number
+];
+export type SerovalIterableNode = [
+    type: SerovalNodeType.Iterable,
+    value: [
+        options: SerovalDictionaryNode | undefined,
+        items: SerovalNode[]
+    ],
+    id: number
+];
+export type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;

package/dist/types/types.d.ts

@@ -1,7 +1,7 @@
-export type PrimitiveValue = boolean | string | number | undefined | null | bigint;
+export type PrimitiveValue = boolean | string | number | undefined | null;
 export type ErrorValue = Error | AggregateError | EvalError | RangeError | ReferenceError | TypeError | SyntaxError | URIError;
 export type TypedArrayValue = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export type SemiPrimitiveValue = RegExp | Date | TypedArrayValue;
+export type SemiPrimitiveValue = RegExp | Date | TypedArrayValue | bigint;
 export type CommonServerValue = PrimitiveValue | SemiPrimitiveValue | ErrorValue;
 export type ServerValue = CommonServerValue | Array<ServerValue> | readonly ServerValue[] | Iterable<ServerValue> | {
     [key: string | number]: ServerValue;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.4.0-alpha.3",
+  "version": "0.4.0-alpha.5",
   "files": [
     "dist",
     "src"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "22da3fb0f57fdb4a935cac70d1b9a7e5fdc02816"
+  "gitHead": "b6e4a61b67d1ba6e6e209dd5ba81cd94fb33d021"
 }

package/src/checks.ts

@@ -6,8 +6,7 @@ export function isPrimitive(current: unknown): current is PrimitiveValue {
   }
   const type = typeof current;
   return type === 'number'
-    || type === 'string'
-    || type === 'bigint';
+    || type === 'string';
 }
 
 export function isPromise<T>(obj: unknown): obj is PromiseLike<T> {

package/src/compat.ts

@@ -40,17 +40,18 @@ export interface PlatformVersion {
 export type Platform = keyof PlatformVersion;
 
 export const enum Feature {
-  AggregateError,
-  ArrayPrototypeValues,
-  ArrowFunction,
-  BigInt,
-  Map,
-  MethodShorthand,
-  ObjectAssign,
-  Promise,
-  Set,
-  SymbolIterator,
-  TypedArray,
+  AggregateError = 0x01,
+  ArrayPrototypeValues = 0x02,
+  ArrowFunction = 0x04,
+  BigInt = 0x08,
+  Map = 0x10,
+  MethodShorthand = 0x20,
+  ObjectAssign = 0x40,
+  Promise = 0x80,
+  Set = 0x100,
+  SymbolIterator = 0x200,
+  TypedArray = 0x400,
+  BigIntTypedArray = 0x800,
 }
 
 type VersionTable = {
@@ -201,6 +202,19 @@ const VERSION_TABLE: VersionTable = {
     deno: [1, 0, 0],
     node: [0, 10, 0],
   },
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt64Array#browser_compatibility
+  [Feature.BigIntTypedArray]: {
+    es: [2020, 0, 0],
+    chrome: [67, 0, 0],
+    edge: [79, 0, 0],
+    firefox: [68, 0, 0],
+    opera: [54, 6, 0],
+    safari: [15, 1, 0],
+    ios: [15, 2, 0],
+    samsung: [9, 0, 0],
+    deno: [1, 0, 0],
+    node: [10, 4, 0],
+  },
 };
 
 const TARGET_REGEX = /^(es|chrome|edge|safari|firefox|opera|ios|samsung|deno|node)([0-9]+(\.[0-9]+(\.[0-9]+)?)?)$/i;
@@ -226,9 +240,9 @@ function getTargetVersions(targets: string | string[]): Target[] {
   return [parseTarget(targets)];
 }
 
-export function parseTargets(targets: string | string[]): Set<Feature> {
+export function parseTargets(targets: string | string[]): number {
   const parsed = getTargetVersions(targets);
-  const flags = new Set<Feature>();
+  let flags = 0;
 
   for (const key in VERSION_TABLE) {
     const base = VERSION_TABLE[key as unknown as Feature];
@@ -238,7 +252,7 @@ export function parseTargets(targets: string | string[]): Set<Feature> {
       flag = flag && !!baseVersion && (compareVersion(baseVersion, version) <= 0);
     }
     if (flag) {
-      flags.add(Number(key) as unknown as Feature);
+      flags |= Number(key);
     }
   }
 

package/src/context.ts

@@ -0,0 +1,137 @@
+import { parseTargets } from './compat';
+import getIdentifier from './get-identifier';
+
+interface IndexAssignment {
+  type: 'index';
+  source: string;
+  value: string;
+}
+
+interface MapAssignment {
+  type: 'map';
+  source: string;
+  key: string;
+  value: string;
+}
+
+interface SetAssignment {
+  type: 'set';
+  source: string;
+  value: string;
+}
+
+// Array of assignments to be done (used for recursion)
+export type Assignment =
+  | IndexAssignment
+  | MapAssignment
+  | SetAssignment;
+
+export interface ParserContext {
+  refs: Map<unknown, number>;
+  markedRefs: Set<number>;
+  features: number;
+}
+
+export interface SerializationContext {
+  stack: number[];
+  // Map tree refs to actual refs
+  validRefs: Map<number, number>;
+  // Refs that are...referenced
+  markedRefs: Set<number>;
+  // Variables
+  vars: string[];
+  // Array of assignments to be done (used for recursion)
+  assignments: Assignment[];
+  // Supported features
+  features: number;
+}
+
+export interface Options {
+  target: string | string[];
+}
+
+const DEFAULT_OPTIONS: Options = {
+  target: 'es2023',
+};
+
+export function createParserContext(options: Partial<Options> = {}): ParserContext {
+  // eslint-disable-next-line prefer-object-spread
+  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+  return {
+    markedRefs: new Set(),
+    refs: new Map(),
+    features: parseTargets(result.target),
+  };
+}
+
+export interface SerializationOptions {
+  markedRefs: number[] | Set<number>;
+  features: number;
+}
+
+export function createSerializationContext(options: SerializationOptions): SerializationContext {
+  return {
+    stack: [],
+    vars: [],
+    assignments: [],
+    validRefs: new Map(),
+    features: options.features,
+    markedRefs: new Set(options.markedRefs),
+  };
+}
+
+/**
+ * Increments the number of references the referenced value has
+ */
+export function markRef(ctx: ParserContext | SerializationContext, current: number) {
+  ctx.markedRefs.add(current);
+}
+
+/**
+ * Creates a new reference ID from a given reference ID
+ * This new reference ID means that the reference itself
+ * has been referenced at least once, and is used to generate
+ * the variables
+ */
+function createValidRef(
+  ctx: SerializationContext,
+  index: number,
+) {
+  const current = ctx.validRefs.get(index);
+  if (current != null) {
+    return current;
+  }
+  const id = ctx.validRefs.size;
+  ctx.validRefs.set(index, id);
+  return id;
+}
+
+/**
+ * Creates the reference param (identifier) from the given reference ID
+ * Calling this function means the value has been referenced somewhere
+ */
+export function getRefParam(ctx: SerializationContext, index: number) {
+  const actualIndex = createValidRef(ctx, index);
+  if (ctx.vars[actualIndex]) {
+    return ctx.vars[actualIndex];
+  }
+  const result = getIdentifier(actualIndex);
+  ctx.vars[actualIndex] = result;
+  return result;
+}
+
+/**
+ * Creates a reference ID from the given values
+ */
+export function createRef(
+  ctx: ParserContext,
+  index: unknown,
+) {
+  const current = ctx.refs.get(index);
+  if (current != null) {
+    return current;
+  }
+  const id = ctx.refs.size;
+  ctx.refs.set(index, id);
+  return id;
+}

package/src/index.ts

@@ -2,20 +2,19 @@
 import { isPrimitive } from './checks';
 import { Feature } from './compat';
 import {
-  createRef,
-  createSerializationContext,
-  generateTreeAsync,
-  generateTreeSync,
+  SerializationContext,
   getRefParam,
   Options,
-  resolvePatches,
-  SerializationContext,
-  serializePrimitive,
-  serializeTree,
-} from './tree';
+  createParserContext,
+  createSerializationContext,
+} from './context';
+import parseAsync from './tree/async';
+import serializeTree, { resolvePatches } from './tree/serialize';
+import { serializePrimitive } from './tree/shared';
+import parseSync from './tree/sync';
+import { SerovalNode } from './tree/types';
 import {
   AsyncServerValue,
-  NonPrimitiveServerValue,
   PrimitiveValue,
   ServerValue,
   CommonServerValue,
@@ -32,9 +31,10 @@ export {
   ErrorValue,
 };
 
-function finalize<T extends NonPrimitiveServerValue<ServerValue | AsyncServerValue>>(
+function finalize(
   ctx: SerializationContext,
-  source: T,
+  rootID: number,
+  isObject: boolean,
   result: string,
 ) {
   // Shared references detected
@@ -43,7 +43,7 @@ function finalize<T extends NonPrimitiveServerValue<ServerValue | AsyncServerVal
     let body = result;
     if (patches) {
       // Get (or create) a ref from the source
-      const index = getRefParam(ctx, createRef(ctx, source));
+      const index = getRefParam(ctx, rootID);
       if (result.startsWith(`${index}=`)) {
         body = `${result},${patches}${index}`;
       } else {
@@ -54,7 +54,7 @@ function finalize<T extends NonPrimitiveServerValue<ServerValue | AsyncServerVal
       ? ctx.vars.join(',')
       : ctx.vars[0];
     // Source is probably already assigned
-    if (ctx.features.has(Feature.ArrowFunction)) {
+    if (ctx.features & Feature.ArrowFunction) {
       params = ctx.vars.length > 1 || ctx.vars.length === 0
         ? `(${params})`
         : params;
@@ -62,7 +62,7 @@ function finalize<T extends NonPrimitiveServerValue<ServerValue | AsyncServerVal
     }
     return `(function(${params}){return ${body}})()`;
   }
-  if (source.constructor === Object) {
+  if (isObject) {
     return `(${result})`;
   }
   return result;
@@ -72,26 +72,28 @@ export function serialize<T extends ServerValue>(
   source: T,
   options?: Partial<Options>,
 ) {
-  const ctx = createSerializationContext(options);
+  const ctx = createParserContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(ctx, source);
+    return String(serializePrimitive(source));
   }
-  const tree = generateTreeSync(ctx, source);
-  const result = serializeTree(ctx, tree);
-  return finalize(ctx, source, result);
+  const [tree, rootID, isObject] = parseSync(ctx, source);
+  const serial = createSerializationContext(ctx);
+  const result = serializeTree(serial, tree);
+  return finalize(serial, rootID, isObject, result);
 }
 
 export async function serializeAsync<T extends AsyncServerValue>(
   source: T,
   options?: Partial<Options>,
 ) {
-  const ctx = createSerializationContext(options);
+  const ctx = createParserContext(options);
   if (isPrimitive(source)) {
-    return serializePrimitive(ctx, source);
+    return String(serializePrimitive(source));
   }
-  const tree = await generateTreeAsync(ctx, source);
-  const result = serializeTree(ctx, tree);
-  return finalize(ctx, source, result);
+  const [tree, rootID, isObject] = await parseAsync(ctx, source);
+  const serial = createSerializationContext(ctx);
+  const result = serializeTree(serial, tree);
+  return finalize(serial, rootID, isObject, result);
 }
 
 export function deserialize<T extends AsyncServerValue>(source: string): T {
@@ -99,4 +101,56 @@ export function deserialize<T extends AsyncServerValue>(source: string): T {
   return (0, eval)(source) as T;
 }
 
+type SerovalJSON = [
+  tree: SerovalNode,
+  root: number,
+  isObject: boolean,
+  feature: number,
+  markedRefs: number[],
+];
+
+export function toJSON<T extends ServerValue>(
+  source: T,
+  options?: Partial<Options>,
+) {
+  const ctx = createParserContext(options);
+  const [tree, root, isObject] = parseSync(ctx, source);
+  return JSON.stringify([
+    tree,
+    root,
+    isObject,
+    ctx.features,
+    [...ctx.markedRefs],
+  ]);
+}
+
+export async function toJSONAsync<T extends AsyncServerValue>(
+  source: T,
+  options?: Partial<Options>,
+) {
+  const ctx = createParserContext(options);
+  const [tree, root, isObject] = await parseAsync(ctx, source);
+  return JSON.stringify([
+    tree,
+    root,
+    isObject,
+    ctx.features,
+    [...ctx.markedRefs],
+  ]);
+}
+
+export function compileJSON(source: string): string {
+  const parsed = JSON.parse(source) as SerovalJSON;
+  const serial = createSerializationContext({
+    features: parsed[3],
+    markedRefs: parsed[4],
+  });
+  const result = serializeTree(serial, parsed[0]);
+  return finalize(serial, parsed[1], parsed[2], result);
+}
+
+export function fromJSON<T extends AsyncServerValue>(source: string): T {
+  return deserialize<T>(compileJSON(source));
+}
+
 export default serialize;