seroval 1.0.0 → 1.0.3

package/src/core/context/serializer.ts

@@ -48,29 +48,36 @@ import type {
 } from '../types';
 import { isValidIdentifier } from '../utils/is-valid-identifier';
 
+const enum AssignmentType {
+  Index = 0,
+  Add = 1,
+  Set = 2,
+  Delete = 3,
+}
+
 interface IndexAssignment {
-  t: 'index';
+  t: AssignmentType.Index;
   s: string;
   k: undefined;
   v: string;
 }
 
 interface SetAssignment {
-  t: 'set';
+  t: AssignmentType.Set;
   s: string;
   k: string;
   v: string;
 }
 
 interface AddAssignment {
-  t: 'add';
+  t: AssignmentType.Add;
   s: string;
   k: undefined;
   v: string;
 }
 
 interface DeleteAssignment {
-  t: 'delete';
+  t: AssignmentType.Delete;
   s: string;
   k: string;
   v: undefined;
@@ -90,16 +97,14 @@ export interface FlaggedObject {
 
 function getAssignmentExpression(assignment: Assignment): string {
   switch (assignment.t) {
-    case 'index':
+    case AssignmentType.Index:
       return assignment.s + '=' + assignment.v;
-    case 'set':
+    case AssignmentType.Set:
       return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';
-    case 'add':
+    case AssignmentType.Add:
       return assignment.s + '.add(' + assignment.v + ')';
-    case 'delete':
+    case AssignmentType.Delete:
       return assignment.s + '.delete(' + assignment.k + ')';
-    default:
-      return '';
   }
 }
 
@@ -112,35 +117,35 @@ function mergeAssignments(assignments: Assignment[]): Assignment[] {
     i++
   ) {
     item = assignments[i];
-    if (item.t === 'index' && item.v === prev.v) {
+    if (item.t === AssignmentType.Index && item.v === prev.v) {
       // Merge if the right-hand value is the same
       // saves at least 2 chars
       current = {
-        t: 'index',
+        t: AssignmentType.Index,
         s: item.s,
         k: undefined,
         v: getAssignmentExpression(current),
       } as IndexAssignment;
-    } else if (item.t === 'set' && item.s === prev.s) {
+    } else if (item.t === AssignmentType.Set && item.s === prev.s) {
       // Maps has chaining methods, merge if source is the same
       current = {
-        t: 'set',
+        t: AssignmentType.Set,
         s: getAssignmentExpression(current),
         k: item.k,
         v: item.v,
       } as SetAssignment;
-    } else if (item.t === 'add' && item.s === prev.s) {
+    } else if (item.t === AssignmentType.Add && item.s === prev.s) {
       // Sets has chaining methods too
       current = {
-        t: 'add',
+        t: AssignmentType.Add,
         s: getAssignmentExpression(current),
         k: undefined,
         v: item.v,
       } as AddAssignment;
-    } else if (item.t === 'delete' && item.s === prev.s) {
+    } else if (item.t === AssignmentType.Delete && item.s === prev.s) {
       // Maps has chaining methods, merge if source is the same
       current = {
-        t: 'delete',
+        t: AssignmentType.Delete,
         s: getAssignmentExpression(current),
         k: item.k,
         v: undefined,
@@ -319,7 +324,7 @@ export default abstract class BaseSerializerContext
    */
   protected createAssignment(source: string, value: string): void {
     this.assignments.push({
-      t: 'index',
+      t: AssignmentType.Index,
       s: source,
       k: undefined,
       v: value,
@@ -328,7 +333,7 @@ export default abstract class BaseSerializerContext
 
   protected createAddAssignment(ref: number, value: string): void {
     this.assignments.push({
-      t: 'add',
+      t: AssignmentType.Add,
       s: this.getRefParam(ref),
       k: undefined,
       v: value,
@@ -337,7 +342,7 @@ export default abstract class BaseSerializerContext
 
   protected createSetAssignment(ref: number, key: string, value: string): void {
     this.assignments.push({
-      t: 'set',
+      t: AssignmentType.Set,
       s: this.getRefParam(ref),
       k: key,
       v: value,
@@ -346,7 +351,7 @@ export default abstract class BaseSerializerContext
 
   protected createDeleteAssignment(ref: number, key: string): void {
     this.assignments.push({
-      t: 'delete',
+      t: AssignmentType.Delete,
       s: this.getRefParam(ref),
       k: key,
       v: undefined,
@@ -416,11 +421,11 @@ export default abstract class BaseSerializerContext
     const id = node.i;
     if (node.l) {
       this.stack.push(id);
+      const list = node.a;
+      let values = this.serializeArrayItem(id, list[0], 0);
       // This is different than Map and Set
       // because we also need to serialize
       // the holes of the Array
-      const list = node.a;
-      let values = this.serializeArrayItem(id, list[0], 0);
       let isHoley = values === '';
       for (let i = 1, len = node.l, item: string; i < len; i++) {
         item = this.serializeArrayItem(id, list[i], i);
@@ -441,12 +446,24 @@ export default abstract class BaseSerializerContext
   ): string {
     if (typeof key === 'string') {
       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 || isValidIdentifier(key);
+      const isIdentifier = (
+        // Test if key is a valid positive number or JS identifier
+        // so that we don't have to serialize the key and wrap with brackets
+        check >= 0
+        // It's also important to consider that if the key is
+        // indeed numeric, we need to make sure that when
+        // converted back into a string, it's still the same
+        // to the original key. This allows us to differentiate
+        // keys that has numeric formats but in a different
+        // format, which can cause unintentional key declaration
+        // Example: { 0x1: 1 } vs { '0x1': 1 }
+        && check.toString() === key
+      ) || isValidIdentifier(key);
       if (this.isIndexedValueInStack(val)) {
         const refParam = this.getRefParam((val as SerovalIndexedValueNode).i);
         this.markRef(source.i);
+        // Strict identifier check, make sure
+        // that it isn't numeric (except NaN)
         if (isIdentifier && check !== check) {
           this.createObjectAssign(source.i, key, refParam);
         } else {
@@ -469,9 +486,9 @@ export default abstract class BaseSerializerContext
   ): string {
     const len = record.s;
     if (len) {
-      this.stack.push(source.i);
       const keys = record.k;
       const values = record.v;
+      this.stack.push(source.i);
       let result = this.serializeProperty(source, keys[0], values[0]);
       for (let i = 1, item = result; i < len; i++) {
         item = this.serializeProperty(source, keys[i], values[i]);
@@ -511,10 +528,22 @@ export default abstract class BaseSerializerContext
   ): void {
     const serialized = this.serialize(value);
     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 || isValidIdentifier(key);
+    const isIdentifier = (
+      // Test if key is a valid positive number or JS identifier
+      // so that we don't have to serialize the key and wrap with brackets
+      check >= 0
+      // It's also important to consider that if the key is
+      // indeed numeric, we need to make sure that when
+      // converted back into a string, it's still the same
+      // to the original key. This allows us to differentiate
+      // keys that has numeric formats but in a different
+      // format, which can cause unintentional key declaration
+      // Example: { 0x1: 1 } vs { '0x1': 1 }
+      && check.toString() === key
+    ) || isValidIdentifier(key);
     if (this.isIndexedValueInStack(value)) {
+      // Strict identifier check, make sure
+      // that it isn't numeric (except NaN)
       if (isIdentifier && check !== check) {
         this.createObjectAssign(source.i, key, serialized);
       } else {
@@ -527,7 +556,7 @@ export default abstract class BaseSerializerContext
     } else {
       const parentAssignment = this.assignments;
       this.assignments = mainAssignments;
-      if (isIdentifier) {
+      if (isIdentifier && check !== check) {
         this.createObjectAssign(source.i, key, serialized);
       } else {
         this.createArrayAssign(
@@ -566,10 +595,10 @@ export default abstract class BaseSerializerContext
   ): string | undefined {
     const len = node.s;
     if (len) {
-      this.stack.push(source.i);
       const mainAssignments: Assignment[] = [];
       const keys = node.k;
       const values = node.v;
+      this.stack.push(source.i);
       for (let i = 0; i < len; i++) {
         this.serializeAssignment(source, mainAssignments, keys[i], values[i]);
       }
@@ -795,15 +824,17 @@ export default abstract class BaseSerializerContext
   }
 
   protected serializeAggregateError(node: SerovalAggregateErrorNode): string {
-    // Serialize the required arguments
     const id = node.i;
-    this.stack.push(id);
-    const serialized = 'new AggregateError([],"' + node.m + '")';
-    this.stack.pop();
     // `AggregateError` might've been extended
     // either through class or custom properties
     // Make sure to assign extra properties
-    return this.serializeDictionary(node, serialized);
+    this.stack.push(id);
+    const serialized = this.serializeDictionary(
+      node,
+      'new AggregateError([],"' + node.m + '")',
+    );
+    this.stack.pop();
+    return serialized;
   }
 
   protected serializeError(node: SerovalErrorNode): string {
@@ -846,21 +877,6 @@ export default abstract class BaseSerializerContext
     return this.assignIndexedValue(node.i, SYMBOL_STRING[node.s]);
   }
 
-  protected serializeFormDataEntry(
-    id: number,
-    key: string,
-    value: SerovalNode,
-  ): string {
-    return (
-      this.getRefParam(id) +
-      '.append("' +
-      key +
-      '",' +
-      this.serialize(value) +
-      ')'
-    );
-  }
-
   protected serializeBoxed(node: SerovalBoxedNode): string {
     return this.assignIndexedValue(
       node.i,
@@ -943,10 +959,10 @@ export default abstract class BaseSerializerContext
       case SpecialReference.StreamConstructor:
         return this.createFunction(
           ['b', 'a', 's', 'l', 'p', 'f', 'e', 'n'],
-          '(b=[],a=!0,s=!1,l=[],s=0,f=' +
+          '(b=[],a=!0,s=!1,l=[],p=0,f=' +
             this.createEffectfulFunction(
               ['v', 'm', 'x'],
-              'for(x=0;x<s;x++)l[x]&&l[x][m](v)',
+              'for(x=0;x<p;x++)l[x]&&l[x][m](v)',
             ) +
             ',n=' +
             this.createEffectfulFunction(