✨ 🐛 fix, add support for circular references

astoilkov · Jun 6, 2024 · 2c324c0 · 2c324c0
1 parent 696a784
commit 2c324c0
Show file tree

Hide file tree

Showing 6 changed files with 46 additions and 5 deletions.
diff --git a/playground/playground.ts b/playground/playground.ts
@@ -294,3 +294,10 @@ const array = [1, 2, 3];
 consoleInspect(array);
 (array as any).innerObj = { a: 1 };
 consoleInspect(array);
+
+// circular refs
+const circular = { a: 1, b: { a: 3 } };
+circular.b = circular;
+consoleInspect(circular, {
+    depth: 5,
+})
diff --git a/src/extras/consoleTable/consoleTableCell.ts b/src/extras/consoleTable/consoleTableCell.ts
@@ -35,6 +35,7 @@ function findOptimalExpansion(
                 wrap: "single-line",
             },
             {
+                circular: new Set(),
                 depth: depth,
                 keys: new Set(),
                 wrap: Number.MAX_SAFE_INTEGER,

diff --git a/src/inspect/consoleInspect.ts b/src/inspect/consoleInspect.ts
@@ -28,6 +28,7 @@ export interface ConsoleInspectContext {
     depth: number;
     wrap: number;
     keys: Set<string>;
+    circular: Set<unknown>
 }
 
 export default function consoleInspect(
@@ -66,6 +67,7 @@ function inspect(
 
     const context: ConsoleInspectContext = {
         depth: 0,
+        circular: new Set(),
         keys: new Set(options.keys),
         wrap:
             options.wrap === "auto"

diff --git a/src/inspect/inspectors/inspectAny.ts b/src/inspect/inspectors/inspectAny.ts
@@ -9,6 +9,7 @@ import {
 import { inspectIterable } from "./inspectIterable";
 import { inspectObject } from "./inspectObject";
 import ConsoleInspection from "../utils/ConsoleInspection";
+import consoleStyles from "../utils/consoleStyles";
 
 export default function inspectAny(
     value: unknown,
@@ -27,9 +28,15 @@ export default function inspectAny(
             ],
         };
     } else if (Array.isArray(value) || isIterable(value)) {
-        return inspectIterable(value, options, context);
+        return (
+            maybeCircular(value, options, context) ??
+            inspectIterable(value, options, context)
+        );
     } else if (typeof value === "object" && value !== null) {
-        return inspectObject(value, options, context);
+        return (
+            maybeCircular(value, options, context) ??
+            inspectObject(value, options, context)
+        );
     }
 
     // fallback
@@ -38,3 +45,20 @@ export default function inspectAny(
         spans: [consoleText(String(value))],
     };
 }
+
+function maybeCircular(
+    value: unknown,
+    options: Required<ConsoleInspectOptions>,
+    context: ConsoleInspectContext,
+): ConsoleInspection | undefined {
+    if (context.circular.has(value)) {
+        return {
+            type: "inline",
+            spans: [
+                consoleText("[Circular]", consoleStyles[options.theme].dimmed),
+            ],
+        };
+    }
+    context.circular.add(value);
+    return undefined;
+}
diff --git a/src/inspect/inspectors/inspectIterable.ts b/src/inspect/inspectors/inspectIterable.ts
@@ -111,6 +111,7 @@ export function inspectIterableMultiLine(
                     iterableType(iterable) === "Map"
                         ? inspectEntry(value, options, context)
                         : inspectAny(value, options, {
+                              circular: context.circular,
                               keys: context.keys,
                               depth: context.depth + 1,
                               wrap: Math.max(
@@ -144,11 +145,14 @@ export function inspectIterableMultiLine(
                     spans.push(consoleText("\n"));
                 }
 
-                spans.push(consoleText(key, consoleStyles[options.theme].highlight));
+                spans.push(
+                    consoleText(key, consoleStyles[options.theme].highlight),
+                );
                 spans.push(consoleText(": "));
 
                 const value = array[key as keyof typeof array];
                 const inspection = inspectAny(value, options, {
+                    circular: context.circular,
                     keys: context.keys,
                     depth: context.depth + 1,
                     wrap: Math.max(
@@ -162,8 +166,8 @@ export function inspectIterableMultiLine(
                 } else {
                     spans.push(...inspection.spans);
                 }
-                return spans
-            })
+                return spans;
+            }),
         ],
     };
 }
@@ -176,6 +180,7 @@ function inspectEntry(
     const [key, value] = entry as [unknown, unknown];
     const keySpan = inspectInline(key, options.theme);
     const valueInspection = inspectAny(value, options, {
+        circular: context.circular,
         keys: context.keys,
         depth: context.depth + 1,
         wrap: Math.max(
@@ -186,6 +191,7 @@ function inspectEntry(
 
     if (!isPrimitive(key)) {
         return inspectObject({ key, value }, options, {
+            circular: context.circular,
             keys: context.keys,
             depth: context.depth,
             wrap: Math.max(context.wrap - options.indent, 0),

diff --git a/src/inspect/inspectors/inspectObject.ts b/src/inspect/inspectors/inspectObject.ts
@@ -102,6 +102,7 @@ export function inspectObjectMultiLine(
 
         const value = object[key as keyof typeof object];
         const inspection = inspectAny(value, options, {
+            circular: context.circular,
             keys: context.keys,
             depth: context.depth + 1,
             wrap: Math.max(