seroval 0.4.0-alpha.6 → 0.4.0-alpha.8

package/src/context.ts

@@ -28,16 +28,17 @@ export type Assignment =
 
 export interface ParserContext {
   refs: Map<unknown, number>;
-  markedRefs: Set<number>;
+  markedRefs: Record<number, number>;
   features: number;
 }
 
 export interface SerializationContext {
   stack: number[];
   // Map tree refs to actual refs
-  validRefs: Map<number, number>;
+  validRefs: number[];
+  refSize: number;
   // Refs that are...referenced
-  markedRefs: Set<number>;
+  markedRefs: Record<number, number>;
   // Variables
   vars: string[];
   // Array of assignments to be done (used for recursion)
@@ -58,14 +59,14 @@ export function createParserContext(options: Partial<Options> = {}): ParserConte
   // eslint-disable-next-line prefer-object-spread
   const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
   return {
-    markedRefs: new Set(),
+    markedRefs: {},
     refs: new Map(),
     features: parseTargets(result.target),
   };
 }
 
 export interface SerializationOptions {
-  markedRefs: number[] | Set<number>;
+  markedRefs: Record<number, number>;
   features: number;
 }
 
@@ -74,9 +75,10 @@ export function createSerializationContext(options: SerializationOptions): Seria
     stack: [],
     vars: [],
     assignments: [],
-    validRefs: new Map(),
+    validRefs: [],
+    refSize: 0,
     features: options.features,
-    markedRefs: new Set(options.markedRefs),
+    markedRefs: options.markedRefs,
   };
 }
 
@@ -84,7 +86,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.add(current);
+  ctx.markedRefs[current] = 1;
 }
 
 /**
@@ -97,13 +99,13 @@ function createValidRef(
   ctx: SerializationContext,
   index: number,
 ) {
-  const current = ctx.validRefs.get(index);
-  if (current != null) {
-    return current;
+  const current = ctx.validRefs[index];
+  if (current == null) {
+    const value = ctx.refSize++;
+    ctx.validRefs[index] = value;
+    return value;
   }
-  const id = ctx.validRefs.size;
-  ctx.validRefs.set(index, id);
-  return id;
+  return current;
 }
 
 /**

package/src/index.ts

@@ -106,7 +106,7 @@ type SerovalJSON = [
   root: number,
   isObject: boolean,
   feature: number,
-  markedRefs: number[],
+  markedRefs: Record<number, number>,
 ];
 
 export function toJSON<T extends ServerValue>(
@@ -120,7 +120,7 @@ export function toJSON<T extends ServerValue>(
     root,
     isObject,
     ctx.features,
-    [...ctx.markedRefs],
+    ctx.markedRefs,
   ]);
 }
 
@@ -135,7 +135,7 @@ export async function toJSONAsync<T extends AsyncServerValue>(
     root,
     isObject,
     ctx.features,
-    [...ctx.markedRefs],
+    ctx.markedRefs,
   ]);
 }
 

package/src/tree/async.ts

@@ -30,24 +30,34 @@ import {
   SerovalSetNode,
 } from './types';
 
-async function generateDictionary(
+async function serializePropertiesAsync(
   ctx: ParserContext,
-  properties: Record<string, AsyncServerValue>,
+  properties: Record<string, unknown>,
 ): Promise<SerovalDictionaryNode> {
   const keys = Object.keys(properties);
-  const nodes: SerovalDictionaryNode = {};
-  const deferred: Record<string, AsyncServerValue> = {};
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<AsyncServerValue>(size);
+  let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferred[key] = properties[key];
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as AsyncServerValue;
+      deferredSize++;
     } else {
-      nodes[key] = await generateTreeAsync(ctx, properties[key]);
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key] as AsyncServerValue);
+      nodesSize++;
     }
   }
-  for (const key of Object.keys(deferred)) {
-    nodes[key] = await generateTreeAsync(ctx, deferred[key]);
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return nodes;
+  return [keyNodes, valueNodes, size];
 }
 
 async function generateSetNode(
@@ -147,7 +157,7 @@ async function generateAggregateErrorNode(
 ): Promise<SerovalAggregateErrorNode> {
   const options = getErrorOptions(current);
   const optionsNode = options
-    ? await generateDictionary(ctx, options)
+    ? await serializePropertiesAsync(ctx, options)
     : undefined;
   const errorsNode = await generateTreeAsync(ctx, current.errors as AsyncServerValue);
   return [
@@ -164,7 +174,7 @@ async function generateErrorNode(
 ): Promise<SerovalErrorNode> {
   const options = getErrorOptions(current);
   const optionsNode = options
-    ? await generateDictionary(ctx, options)
+    ? await serializePropertiesAsync(ctx, options)
     : undefined;
   return [
     SerovalNodeType.Error,
@@ -182,9 +192,7 @@ async function generateIterableNode(
   const options = getIterableOptions(current);
   return [SerovalNodeType.Iterable, [
     // Parse options first before the items
-    options
-      ? await generateDictionary(ctx, options as Record<string, AsyncServerValue>)
-      : undefined,
+    options ? await serializePropertiesAsync(ctx, options) : undefined,
     await generateNodeList(ctx, Array.from(current)),
   ], id];
 }
@@ -236,7 +244,7 @@ async function generateTreeAsync(
   if (current.constructor === Object || empty) {
     return [
       empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      await generateDictionary(ctx, current as Record<string, AsyncServerValue>),
+      await serializePropertiesAsync(ctx, current as Record<string, unknown>),
       id,
     ];
   }

package/src/tree/serialize.ts

@@ -96,7 +96,7 @@ function assignRef(
   index: number,
   value: string,
 ) {
-  if (ctx.markedRefs.has(index)) {
+  if (ctx.markedRefs[index]) {
     return `${getRefParam(ctx, index)}=${value}`;
   }
   return value;
@@ -145,7 +145,7 @@ function createMapSet(
 function createArrayAssign(
   ctx: SerializationContext,
   ref: number,
-  index: number,
+  index: number | string,
   value: string,
 ) {
   markRef(ctx, ref);
@@ -157,11 +157,9 @@ function createObjectAssign(
   ref: number,
   key: string,
   value: string,
-  computed: boolean,
 ) {
   markRef(ctx, ref);
-  const member = computed ? `[${key}]` : `.${key}`;
-  createAssignment(ctx, `${getRefParam(ctx, ref)}${member}`, value);
+  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
 }
 
 const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
@@ -169,59 +167,59 @@ const IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
 function serializeAssignments(
   ctx: SerializationContext,
   targetRef: number,
-  record: SerovalDictionaryNode,
+  [keys, values, size]: SerovalDictionaryNode,
 ) {
   ctx.stack.push(targetRef);
   const mainAssignments: Assignment[] = [];
-  for (const key of Object.keys(record)) {
+  for (let i = 0; i < size; i++) {
     const parentStack = ctx.stack;
     ctx.stack = [];
-    const refParam = serializeTree(ctx, record[key]);
+    const refParam = serializeTree(ctx, values[i]);
     ctx.stack = parentStack;
+    const key = keys[i];
     const check = Number(key);
     const parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
     // Test if key is a valid number or JS identifier
     // so that we don't have to serialize the key and wrap with brackets
     const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    createObjectAssign(
-      ctx,
-      targetRef,
-      isIdentifier ? key : quote(key),
-      refParam,
-      !(isIdentifier && Number.isNaN(check)),
-    );
+    if (isIdentifier && Number.isNaN(check)) {
+      createObjectAssign(ctx, targetRef, key, refParam);
+    } else {
+      createArrayAssign(ctx, targetRef, isIdentifier ? key : quote(key), refParam);
+    }
     ctx.assignments = parentAssignment;
   }
   ctx.stack.pop();
   return resolveAssignments(mainAssignments);
 }
 
-function serializeDictionary(
+function serializeObject(
   ctx: SerializationContext,
   sourceID: number,
-  record: SerovalDictionaryNode,
+  [keys, values, size]: SerovalDictionaryNode,
 ) {
+  if (size === 0) {
+    return '{}';
+  }
   let result = '';
   ctx.stack.push(sourceID);
-  for (const key of Object.keys(record)) {
-    const val = record[key];
+  for (let i = 0; i < size; i++) {
+    const key = keys[i];
+    const val = values[i];
     const check = Number(key);
     // Test if key is a valid number or JS identifier
     // so that we don't have to serialize the key and wrap with brackets
     const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    const validKey = isIdentifier ? key : quote(key);
     if (isReferenceInStack(ctx, val)) {
       const refParam = getRefParam(ctx, val[1]);
-      createObjectAssign(
-        ctx,
-        sourceID,
-        validKey,
-        refParam,
-        !(isIdentifier && Number.isNaN(check)),
-      );
+      if (isIdentifier && Number.isNaN(check)) {
+        createObjectAssign(ctx, sourceID, key, refParam);
+      } else {
+        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+      }
     } else {
-      result += `${validKey}:${serializeTree(ctx, val)},`;
+      result += `${isIdentifier ? key : quote(key)}:${serializeTree(ctx, val)},`;
     }
   }
   ctx.stack.pop();
@@ -400,7 +398,7 @@ function serializeWithObjectAssign(
   id: number,
   serialized: string,
 ) {
-  const fields = serializeDictionary(ctx, id, value);
+  const fields = serializeObject(ctx, id, value);
   if (fields !== '{}') {
     return `Object.assign(${serialized},${fields})`;
   }
@@ -551,7 +549,7 @@ export default function serializeTree(
     case SerovalNodeType.NullConstructor:
       return serializeNullConstructor(ctx, value, id);
     case SerovalNodeType.Object:
-      return assignRef(ctx, id, serializeDictionary(ctx, id, value));
+      return assignRef(ctx, id, serializeObject(ctx, id, value));
     default:
       throw new Error('Unsupported type');
   }

package/src/tree/sync.ts

@@ -24,24 +24,34 @@ import {
   SerovalSetNode,
 } from './types';
 
-function generateDictionary(
+function serializePropertiesSync(
   ctx: ParserContext,
-  properties: Record<string, ServerValue>,
+  properties: Record<string, unknown>,
 ): SerovalDictionaryNode {
   const keys = Object.keys(properties);
-  const nodes: SerovalDictionaryNode = {};
-  const deferred: Record<string, ServerValue> = {};
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<ServerValue>(size);
+  let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferred[key] = properties[key];
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as ServerValue;
+      deferredSize++;
     } else {
-      nodes[key] = generateTreeSync(ctx, properties[key]);
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key] as ServerValue);
+      nodesSize++;
     }
   }
-  for (const key of Object.keys(deferred)) {
-    nodes[key] = generateTreeSync(ctx, deferred[key]);
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return nodes;
+  return [keyNodes, valueNodes, size];
 }
 
 function generateSetNode(
@@ -141,7 +151,7 @@ function generateAggregateErrorNode(
 ): SerovalAggregateErrorNode {
   const options = getErrorOptions(current);
   const optionsNode = options
-    ? generateDictionary(ctx, options)
+    ? serializePropertiesSync(ctx, options)
     : undefined;
   const errorsNode = generateTreeSync(ctx, current.errors as ServerValue);
   return [SerovalNodeType.AggregateError, [current.message, optionsNode, errorsNode], id];
@@ -154,7 +164,7 @@ function generateErrorNode(
 ): SerovalErrorNode {
   const options = getErrorOptions(current);
   const optionsNode = options
-    ? generateDictionary(ctx, options)
+    ? serializePropertiesSync(ctx, options)
     : undefined;
   return [
     SerovalNodeType.Error,
@@ -172,9 +182,7 @@ function generateIterableNode(
   const options = getIterableOptions(current);
   return [SerovalNodeType.Iterable, [
     // Parse options first before the items
-    options
-      ? generateDictionary(ctx, options as Record<string, ServerValue>)
-      : undefined,
+    options ? serializePropertiesSync(ctx, options) : undefined,
     generateNodeList(ctx, Array.from(current)),
   ], id];
 }
@@ -218,7 +226,7 @@ function generateTreeSync(
   if (current.constructor === Object || empty) {
     return [
       empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,
-      generateDictionary(ctx, current as Record<string, ServerValue>),
+      serializePropertiesSync(ctx, current as Record<string, unknown>),
       id,
     ];
   }

package/src/tree/types.ts

@@ -39,7 +39,7 @@ export type SerovalSemiPrimitiveNode =
     id: number
   ];
 
-export type SerovalDictionaryNode = Record<string, SerovalNode>;
+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,