fix: resolve circular references through custom revivers (#154)

* fix: resolve circular references through custom revivers

* Update src/parse.js

* Update test/index.test.js

---------

Co-authored-by: Elliott Johnson <hello+github@ell.iott.dev>

Author: gabrielstellini

.changeset/fix-circular-custom-revivers.md

@@ -0,0 +1,5 @@
+---
+'devalue': patch
+---
+
+fix: resolve circular references through custom revivers when payload is already hydrated

src/parse.js

@@ -78,6 +78,16 @@ export function unflatten(parsed, revivers) {
 						i = values.push(value[1]) - 1;
 					}
 
+					// If the payload is already hydrated, its recursion has already
+					// terminated (e.g. a self-referential object cached itself before
+					// following its own back-reference), so revive it directly. Falling
+					// through to the `hydrating` guard here would wrongly reject a valid
+					// cycle. An actually infinite payload (e.g. `[["Custom", 0]]`) is never
+					// cached, so it still hits the guard below.
+					if (Object.hasOwn(hydrated, i)) {
+						return (hydrated[index] = reviver(hydrated[i]));
+					}
+
 					hydrating ??= new Set();
 
 					if (hydrating.has(i)) {

test/index.test.js

@@ -1805,3 +1805,74 @@ asyncErrorTests('throws for promise resolving to function', async () => {
 });
 
 asyncErrorTests.run();
+
+const circularCustomTypes = uvu.suite('circular references through custom types');
+
+circularCustomTypes('resolves circular reference through two custom types', () => {
+	const foo = new Foo({ name: 'outer' });
+	const bar = new Bar({ name: 'inner', ref: foo });
+	foo.value.ref = bar;
+
+	const reducers = {
+		Foo: (x) => x instanceof Foo && x.value,
+		Bar: (x) => x instanceof Bar && x.value
+	};
+	const fooCache = new WeakMap();
+	const barCache = new WeakMap();
+	const revivers = {
+		Foo: (x) => {
+			let inst = fooCache.get(x);
+			if (!inst) {
+				inst = Object.create(Foo.prototype);
+				fooCache.set(x, inst);
+			}
+			inst.value = x;
+			return inst;
+		},
+		Bar: (x) => {
+			let inst = barCache.get(x);
+			if (!inst) {
+				inst = Object.create(Bar.prototype);
+				barCache.set(x, inst);
+			}
+			inst.value = x;
+			return inst;
+		}
+	};
+
+	const json = stringify(foo, reducers);
+	const result = parse(json, revivers);
+
+	assert.ok(result instanceof Foo);
+	assert.ok(result.value.ref instanceof Bar);
+	assert.is(result.value.ref.value.ref, result);
+});
+
+circularCustomTypes('resolves self-referencing custom type', () => {
+	const foo = new Foo({ name: 'self' });
+	foo.value.ref = foo;
+
+	const reducers = {
+		Foo: (x) => x instanceof Foo && x.value
+	};
+	const fooCache = new WeakMap();
+	const revivers = {
+		Foo: (x) => {
+			let inst = fooCache.get(x);
+			if (!inst) {
+				inst = Object.create(Foo.prototype);
+				fooCache.set(x, inst);
+			}
+			inst.value = x;
+			return inst;
+		}
+	};
+
+	const json = stringify(foo, reducers);
+	const result = parse(json, revivers);
+
+	assert.ok(result instanceof Foo);
+	assert.is(result.value.ref, result);
+});
+
+circularCustomTypes.run();