seroval 0.4.0-alpha.8 → 0.4.0

package/src/context.ts

@@ -1,23 +1,25 @@
-import { parseTargets } from './compat';
+import { ALL_ENABLED } from './compat';
 import getIdentifier from './get-identifier';
 
 interface IndexAssignment {
-  type: 'index';
-  source: string;
-  value: string;
+  t: 'index';
+  s: string;
+  k: undefined;
+  v: string;
 }
 
 interface MapAssignment {
-  type: 'map';
-  source: string;
-  key: string;
-  value: string;
+  t: 'map';
+  s: string;
+  k: string;
+  v: string;
 }
 
 interface SetAssignment {
-  type: 'set';
-  source: string;
-  value: string;
+  t: 'set';
+  s: string;
+  k: undefined;
+  v: string;
 }
 
 // Array of assignments to be done (used for recursion)
@@ -28,7 +30,7 @@ export type Assignment =
 
 export interface ParserContext {
   refs: Map<unknown, number>;
-  markedRefs: Record<number, number>;
+  markedRefs: Set<number>;
   features: number;
 }
 
@@ -38,7 +40,7 @@ export interface SerializationContext {
   validRefs: number[];
   refSize: number;
   // Refs that are...referenced
-  markedRefs: Record<number, number>;
+  markedRefs: Set<number>;
   // Variables
   vars: string[];
   // Array of assignments to be done (used for recursion)
@@ -48,25 +50,25 @@ export interface SerializationContext {
 }
 
 export interface Options {
-  target: string | string[];
+  disabledFeatures: number;
 }
 
 const DEFAULT_OPTIONS: Options = {
-  target: 'es2023',
+  disabledFeatures: 0,
 };
 
 export function createParserContext(options: Partial<Options> = {}): ParserContext {
   // eslint-disable-next-line prefer-object-spread
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: {},
+    markedRefs: new Set(),
     refs: new Map(),
-    features: parseTargets(result.target),
+    features: ALL_ENABLED ^ result.disabledFeatures,
   };
 }
 
 export interface SerializationOptions {
-  markedRefs: Record<number, number>;
+  markedRefs: number[] | Set<number>;
   features: number;
 }
 
@@ -78,7 +80,7 @@ export function createSerializationContext(options: SerializationOptions): Seria
     validRefs: [],
     refSize: 0,
     features: options.features,
-    markedRefs: options.markedRefs,
+    markedRefs: new Set(options.markedRefs),
   };
 }
 
@@ -86,7 +88,7 @@ export function createSerializationContext(options: SerializationOptions): Seria
  * Increments the number of references the referenced value has
  */
 export function markRef(ctx: ParserContext | SerializationContext, current: number) {
-  ctx.markedRefs[current] = 1;
+  ctx.markedRefs.add(current);
 }
 
 /**
@@ -127,13 +129,22 @@ export function getRefParam(ctx: SerializationContext, index: number) {
  */
 export function createRef(
   ctx: ParserContext,
-  index: unknown,
-) {
-  const current = ctx.refs.get(index);
-  if (current != null) {
-    return current;
+  current: unknown,
+  mark: boolean,
+): number {
+  // Check if reference number already exists
+  const ref = ctx.refs.get(current);
+  if (ref != null) {
+    // Exists, means this value is currently
+    // being referenced
+    // Mark reference
+    if (mark) {
+      markRef(ctx, ref);
+    }
+    return ref;
   }
+  // Create a new reference ID
   const id = ctx.refs.size;
-  ctx.refs.set(index, id);
+  ctx.refs.set(current, id);
   return id;
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-await-in-loop */
-import { isPrimitive } from './checks';
 import { Feature } from './compat';
 import {
   SerializationContext,
@@ -10,7 +9,6 @@ import {
 } 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 {
@@ -29,6 +27,7 @@ export {
   CommonServerValue,
   SemiPrimitiveValue,
   ErrorValue,
+  Feature,
 };
 
 function finalize(
@@ -44,10 +43,9 @@ function finalize(
     if (patches) {
       // Get (or create) a ref from the source
       const index = getRefParam(ctx, rootID);
-      if (result.startsWith(`${index}=`)) {
-        body = `${result},${patches}${index}`;
-      } else {
-        body = `${index}=${result},${patches}${index}`;
+      body = result + ',' + patches + index;
+      if (!result.startsWith(index + '=')) {
+        body = index + '=' + body;
       }
     }
     let params = ctx.vars.length > 1
@@ -56,14 +54,14 @@ function finalize(
     // Source is probably already assigned
     if (ctx.features & Feature.ArrowFunction) {
       params = ctx.vars.length > 1 || ctx.vars.length === 0
-        ? `(${params})`
+        ? '(' + params + ')'
         : params;
-      return `(${params}=>(${body}))()`;
+      return '(' + params + '=>(' + body + '))()';
     }
-    return `(function(${params}){return ${body}})()`;
+    return '(function(' + params + '){return ' + body + '})()';
   }
   if (isObject) {
-    return `(${result})`;
+    return '(' + result + ')';
   }
   return result;
 }
@@ -73,9 +71,6 @@ export function serialize<T extends ServerValue>(
   options?: Partial<Options>,
 ) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -87,9 +82,6 @@ export async function serializeAsync<T extends AsyncServerValue>(
   options?: Partial<Options>,
 ) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -101,13 +93,13 @@ 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: Record<number, number>,
-];
+interface SerovalJSON {
+  t: SerovalNode,
+  r: number,
+  i: boolean,
+  f: number,
+  m: number[],
+}
 
 export function toJSON<T extends ServerValue>(
   source: T,
@@ -115,13 +107,13 @@ export function toJSON<T extends ServerValue>(
 ) {
   const ctx = createParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs,
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs),
+  });
 }
 
 export async function toJSONAsync<T extends AsyncServerValue>(
@@ -130,23 +122,23 @@ export async function toJSONAsync<T extends AsyncServerValue>(
 ) {
   const ctx = createParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
-  return JSON.stringify([
-    tree,
-    root,
-    isObject,
-    ctx.features,
-    ctx.markedRefs,
-  ]);
+  return JSON.stringify({
+    t: tree,
+    r: root,
+    i: isObject,
+    f: ctx.features,
+    m: Array.from(ctx.markedRefs),
+  });
 }
 
 export function compileJSON(source: string): string {
   const parsed = JSON.parse(source) as SerovalJSON;
   const serial = createSerializationContext({
-    features: parsed[3],
-    markedRefs: parsed[4],
+    features: parsed.f,
+    markedRefs: parsed.m,
   });
-  const result = serializeTree(serial, parsed[0]);
-  return finalize(serial, parsed[1], parsed[2], result);
+  const result = serializeTree(serial, parsed.t);
+  return finalize(serial, parsed.r, parsed.i, result);
 }
 
 export function fromJSON<T extends AsyncServerValue>(source: string): T {

package/src/quote.ts

@@ -41,5 +41,5 @@ export default function quote(str: string) {
   } else {
     result += str.slice(lastPos);
   }
-  return `"${result}"`;
+  return '"' + result + '"';
 }