feat(serdes): dedupe bigint

Author: wmertens

packages/qwik/src/core/shared/serdes/serdes.unit.ts

@@ -909,6 +909,43 @@ describe('shared-serialization', () => {
     });
   });
 
+  describe('dedupe', () => {
+    it('should dedupe identical objects/strings', async () => {
+      const a = { hello: 1 };
+      const objs = await serialize([
+        'hello',
+        'hello',
+        a,
+        a,
+        12345678901234567890n,
+        12345678901234567890n,
+        // small bigint are not deduped
+        9n,
+        9n,
+      ]);
+      expect(dumpState(objs)).toMatchInlineSnapshot(`
+        "
+        0 Array [
+          {string} "hello"
+          RootRef 1
+          Object [
+            RootRef 1
+            {number} 1
+          ]
+          RootRef 2
+          BigInt "12345678901234567890"
+          RootRef 3
+          BigInt "9"
+          BigInt "9"
+        ]
+        1 RootRef "0 0"
+        2 RootRef "0 2"
+        3 RootRef "0 4"
+        (103 chars)"
+      `);
+    });
+  });
+
   describe('Serialization Weak Ref', () => {
     const dump = async (...value: any) => dumpState(await serialize(...value));
     it('should not serialize object', async () => {

packages/qwik/src/core/shared/serdes/serialize.ts

@@ -155,7 +155,9 @@ export async function serialize(serializationContext: SerializationContext): Pro
     if (fastSkipSerialize(value as object | Function)) {
       output(TypeIds.Constant, Constants.Undefined);
     } else if (typeof value === 'bigint') {
-      output(TypeIds.BigInt, value.toString());
+      if (!outputAsRootRef(value)) {
+        output(TypeIds.BigInt, value.toString());
+      }
     } else if (typeof value === 'boolean') {
       output(TypeIds.Constant, value ? Constants.True : Constants.False);
     } else if (typeof value === 'function') {
@@ -667,7 +669,10 @@ export function shouldTrackObj(obj: unknown) {
      * We track all strings greater than 1 character, because those take at least 6 bytes to encode
      * and even with 999 root objects it saves one byte per reference. Tracking more objects makes
      * the map bigger so we want to strike a balance
-     */ (typeof obj === 'string' && obj.length > 1)
+     */
+    (typeof obj === 'string' && obj.length > 1) ||
+    /** Same reasoning but for bigint */
+    (typeof obj === 'bigint' && (obj > 9 || obj < 0))
   );
 } /**
  * When serializing the object we need check if it is URL, RegExp, Map, Set, etc. This is time