seroval 0.4.0-alpha.6 → 0.4.0-alpha.7

package/src/tree/serialize.ts

@@ -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,