seroval 0.4.0-alpha.2 → 0.4.0-alpha.4

package/dist/types/tree.d.ts

@@ -1,5 +1,4 @@
-import { AsyncServerValue, PrimitiveValue, ServerValue, TypedArrayValue } from './types';
-import { Feature } from './compat';
+import { AsyncServerValue, PrimitiveValue, ServerValue } from './types';
 interface IndexAssignment {
     type: 'index';
     source: string;
@@ -17,24 +16,29 @@ interface SetAssignment {
     value: string;
 }
 export type Assignment = IndexAssignment | MapAssignment | SetAssignment;
+export interface ParserContext {
+    refs: Map<unknown, number>;
+    markedRefs: Set<number>;
+    features: number;
+}
 export interface SerializationContext {
     stack: number[];
-    refs: Map<unknown, number>;
     validRefs: Map<number, number>;
-    markedRefs: boolean[];
+    markedRefs: Set<number>;
     vars: string[];
     assignments: Assignment[];
-    features: Set<Feature>;
+    features: number;
 }
 export interface Options {
     target: string | string[];
 }
-export declare function createSerializationContext(options?: Partial<Options>): SerializationContext;
+export declare function createParserContext(options?: Partial<Options>): ParserContext;
+export interface SerializationOptions {
+    markedRefs: number[] | Set<number>;
+    features: number;
+}
+export declare function createSerializationContext(options: SerializationOptions): SerializationContext;
 export declare function resolvePatches(ctx: SerializationContext): string | undefined;
-/**
- * Creates a reference ID from the given values
- */
-export declare function createRef(ctx: SerializationContext, index: unknown): number;
 /**
  * Creates the reference param (identifier) from the given reference ID
  * Calling this function means the value has been referenced somewhere
@@ -42,25 +46,31 @@ export declare function createRef(ctx: SerializationContext, index: unknown): nu
 export declare function getRefParam(ctx: SerializationContext, index: number): string;
 declare const enum SerovalNodeType {
     Primitive = 0,
-    Reference = 1,
-    Date = 2,
-    RegExp = 3,
-    Set = 4,
-    Map = 5,
-    Array = 6,
-    Object = 7,
-    NullConstructor = 8,
-    Promise = 9,
-    Error = 10,
-    AggregateError = 11,
-    Iterable = 12,
-    TypedArray = 13
+    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
 }
 type SerovalPrimitiveNode = [type: SerovalNodeType.Primitive, value: PrimitiveValue];
 type SerovalReferenceNode = [type: SerovalNodeType.Reference, value: number];
-type SerovalSemiPrimitiveNode = [type: SerovalNodeType.Date, value: Date, id: number] | [type: SerovalNodeType.RegExp, value: RegExp, id: number] | [
+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: TypedArrayValue],
+    value: [constructor: string, array: string, byteOffset: number],
+    id: number
+] | [
+    type: SerovalNodeType.BigIntTypedArray,
+    value: [constructor: string, array: string, byteOffset: number],
     id: number
 ];
 type SerovalDictionaryNode = [key: string[], value: SerovalNode[], size: number];
@@ -104,9 +114,9 @@ type SerovalIterableNode = [
     ],
     id: number
 ];
-type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;
-export declare function generateTreeSync(ctx: SerializationContext, current: ServerValue): SerovalNode;
-export declare function generateTreeAsync(ctx: SerializationContext, current: AsyncServerValue): Promise<SerovalNode>;
-export declare function serializePrimitive(ctx: SerializationContext, value: PrimitiveValue): string;
+export type SerovalNode = SerovalPrimitiveNode | SerovalReferenceNode | SerovalSemiPrimitiveNode | SerovalSetNode | SerovalMapNode | SerovalArrayNode | SerovalObjectNode | SerovalNullConstructorNode | SerovalPromiseNode | SerovalErrorNode | SerovalAggregateErrorNode | SerovalIterableNode;
+export declare function parseSync(ctx: ParserContext, current: ServerValue): readonly [SerovalNode, number, boolean];
+export declare function parseAsync(ctx: ParserContext, current: AsyncServerValue): Promise<readonly [SerovalNode, number, boolean]>;
+export declare function serializePrimitive(value: PrimitiveValue): string | number | null;
 export declare function serializeTree(ctx: SerializationContext, [type, value, id]: SerovalNode): string;
 export {};

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.2",
+  "version": "0.4.0-alpha.4",
   "files": [
     "dist",
     "src"
@@ -64,5 +64,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "cb379745d112d53472da3765b20fe5d28323cb47"
+  "gitHead": "1e96ac1ab8304fb09ac7a1bc451b7768f12b7f6b"
 }

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/index.ts

@@ -2,20 +2,20 @@
 import { isPrimitive } from './checks';
 import { Feature } from './compat';
 import {
-  createRef,
+  createParserContext,
   createSerializationContext,
-  generateTreeAsync,
-  generateTreeSync,
   getRefParam,
   Options,
+  parseAsync,
+  parseSync,
   resolvePatches,
   SerializationContext,
   serializePrimitive,
   serializeTree,
+  SerovalNode,
 } from './tree';
 import {
   AsyncServerValue,
-  NonPrimitiveServerValue,
   PrimitiveValue,
   ServerValue,
   CommonServerValue,
@@ -32,9 +32,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 +44,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 +55,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 +63,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 +73,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 +102,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;