feat: add dedupe flag (#247)

* add failing test

* add failing test

* tweak

* fix test

* Update src/plainer.ts

* Update src/plainer.ts

* less diff

* feat: add dedupe flag

* rm useless test

* refactor: name dedupeReferentialEqualities

* fix: dedupe is enough

* fix: test

* fix: test

---------

Co-authored-by: Simon Knott <info@simonknott.de>

src/index.test.ts

@@ -1157,3 +1157,39 @@ test('regression #245: superjson referential equalities only use the top-most pa
   const parsed = SuperJSON.deserialize(res);
   expect(parsed).toEqual(input);
 });
+
+test('dedupe=true', () => {
+  const instance = new SuperJSON({
+    dedupe: true,
+  });
+
+  type Node = {
+    children: Node[];
+  };
+  const root: Node = {
+    children: [],
+  };
+  const input = {
+    a: root,
+    b: root,
+  };
+  const output = instance.serialize(input);
+
+  const json = output.json as any;
+
+  expect(json.a);
+
+  // This has already been seen and should be deduped
+  expect(json.b).toBeNull();
+
+  expect(json).toMatchInlineSnapshot(`
+    Object {
+      "a": Object {
+        "children": Array [],
+      },
+      "b": null,
+    }
+  `);
+
+  expect(instance.deserialize(output)).toEqual(input);
+});

src/index.ts

@@ -1,22 +1,38 @@
-import { SuperJSONResult, SuperJSONValue, Class, JSONValue } from './types';
+import { Class, JSONValue, SuperJSONResult, SuperJSONValue } from './types';
 import { ClassRegistry, RegisterOptions } from './class-registry';
 import { Registry } from './registry';
 import {
   CustomTransfomer,
   CustomTransformerRegistry,
 } from './custom-transformer-registry';
 import {
-  walker,
   applyReferentialEqualityAnnotations,
   applyValueAnnotations,
   generateReferentialEqualityAnnotations,
+  walker,
 } from './plainer';
 import { copy } from 'copy-anything';
 
 export default class SuperJSON {
+  /**
+   * If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  private readonly dedupe: boolean;
+
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({
+    dedupe = false,
+  }: {
+    dedupe?: boolean;
+  } = {}) {
+    this.dedupe = dedupe;
+  }
+
   serialize(object: SuperJSONValue): SuperJSONResult {
     const identities = new Map<any, any[][]>();
-    const output = walker(object, identities, this);
+    const output = walker(object, identities, this, this.dedupe);
     const res: SuperJSONResult = {
       json: output.transformedValue,
     };

src/plainer.spec.ts

@@ -9,7 +9,8 @@ test('walker', () => {
         b: /test/g,
       },
       new Map(),
-      new SuperJSON()
+      new SuperJSON(),
+      false
     )
   ).toEqual({
     transformedValue: {

src/plainer.ts

@@ -154,6 +154,7 @@ export const walker = (
   object: any,
   identities: Map<any, any[][]>,
   superJson: SuperJSON,
+  dedupe: boolean,
   path: any[] = [],
   objectsInThisPath: any[] = [],
   seenObjects = new Map<unknown, Result>()
@@ -166,7 +167,11 @@ export const walker = (
     const seen = seenObjects.get(object);
     if (seen) {
       // short-circuit result if we've seen this object before
-      return seen;
+      return dedupe
+        ? {
+            transformedValue: null,
+          }
+        : seen;
     }
   }
 
@@ -205,6 +210,7 @@ export const walker = (
       value,
       identities,
       superJson,
+      dedupe,
       [...path, index],
       [...objectsInThisPath, object],
       seenObjects