Correct detecting context nodes (fixes #277)

.changeset/sweet-boats-pay.md

@@ -0,0 +1,5 @@
+---
+'@solid-devtools/debugger': patch
+---
+
+Correct detecting context nodes after solid 1.8

packages/debugger/src/main/test/utils.test.ts

@@ -1,56 +1,104 @@
-import {
-    createComponent,
-    createComputed,
-    createEffect,
-    createMemo,
-    createRenderEffect,
-    createRoot,
-} from 'solid-js'
-import {describe, expect, it} from 'vitest'
+import * as s from 'solid-js'
+import * as vi from 'vitest'
 import {NodeType} from '../constants'
-import solidApi from '../solid-api'
+import api from '../solid-api'
 import {Solid} from '../types'
 import {getOwnerType} from '../utils'
 
-const {getOwner} = solidApi
-
-describe('getOwnerType', () => {
-    it('identifies Component', () => {
-        let owner!: Solid.Owner
-        createRoot(dispose => {
-            createComponent(() => {
-                owner = getOwner()!
+vi.describe('getOwnerType', () => {
+    const tests = {
+        Component: () => {
+            let owner!: Solid.Owner
+            s.createComponent(() => {
+                owner = api.getOwner()!
                 return ''
             }, {})
-            dispose()
-        })
-        expect(getOwnerType(owner)).toBe(NodeType.Component)
-    })
-    it('identifies Effect', () =>
-        createRoot(dispose => {
-            createEffect(() => {
-                expect(getOwnerType(getOwner()!)).toBe(NodeType.Effect)
+            vi.expect(getOwnerType(owner)).toBe(NodeType.Component)
+        },
+        Effect: () => {
+            s.createEffect(() => {
+                vi.expect(getOwnerType(api.getOwner()!)).toBe(NodeType.Effect)
+            })
+        },
+        Memo: () => {
+            s.createMemo(() => vi.expect(getOwnerType(api.getOwner()!)).toBe(NodeType.Memo))
+        },
+        Computation: () => {
+            s.createComputed(() =>
+                vi.expect(getOwnerType(api.getOwner()!)).toBe(NodeType.Computation),
+            )
+        },
+        Render: () => {
+            s.createRenderEffect(() =>
+                vi.expect(getOwnerType(api.getOwner()!)).toBe(NodeType.Render),
+            )
+        },
+        Root: () => {
+            s.createRoot(dispose => {
+                vi.expect(getOwnerType(api.getOwner()!)).toBe(NodeType.Root)
                 dispose()
             })
-        }))
-    it('identifies Memo', () =>
-        createRoot(dispose => {
-            createMemo(() => expect(getOwnerType(getOwner()!)).toBe(NodeType.Memo))
-            dispose()
-        }))
-    it('identifies Computation', () =>
-        createRoot(dispose => {
-            createComputed(() => expect(getOwnerType(getOwner()!)).toBe(NodeType.Computation))
-            dispose()
-        }))
-    it('identifies Render Effect', () =>
-        createRoot(dispose => {
-            createRenderEffect(() => expect(getOwnerType(getOwner()!)).toBe(NodeType.Render))
-            dispose()
-        }))
-    it('identifies Root', () =>
-        createRoot(dispose => {
-            expect(getOwnerType(getOwner()!)).toBe(NodeType.Root)
-            dispose()
-        }))
+        },
+        Context: () => {
+            let memo!: Solid.Owner
+            const Ctx = s.createContext(0)
+            Ctx.Provider({
+                value: 1,
+                get children() {
+                    memo = api.getOwner()!
+                    return ''
+                },
+            })
+            const ctx = memo.owner!
+            vi.expect(getOwnerType(ctx)).toBe(NodeType.Context)
+            vi.expect(ctx.owned).toHaveLength(2)
+            vi.expect(getOwnerType(ctx.owned![0]!)).toBe(NodeType.Memo)
+            vi.expect(getOwnerType(ctx.owned![1]!)).toBe(NodeType.Memo)
+            vi.expect(ctx.owned![0]!).toBe(memo)
+        },
+    }
+
+    const apis: Record<string, (cb: () => void) => void> = {
+        root: cb => {
+            let dispose!: () => void
+            s.createRoot(d => {
+                dispose = d
+                cb()
+            })
+            api.onCleanup(dispose)
+        },
+        memo: s.createMemo,
+        effect: s.createEffect,
+        render: s.createRenderEffect,
+        computed: s.createComputed,
+        component: cb => {
+            s.createComponent(() => {
+                cb()
+                return ''
+            }, {})
+        },
+        context: cb => {
+            const Ctx = s.createContext(0)
+            Ctx.Provider({
+                value: 1,
+                get children() {
+                    cb()
+                    return ''
+                },
+            })
+        },
+    }
+
+    for (const [wrapper_name, wrapper] of Object.entries(apis)) {
+        vi.describe('under ' + wrapper_name, () => {
+            for (const [name, test] of Object.entries(tests)) {
+                vi.test('identifies ' + name, () => {
+                    s.createRoot(d => {
+                        wrapper(test)
+                        d()
+                    })
+                })
+            }
+        })
+    }
 })

packages/debugger/src/main/utils.ts

@@ -65,7 +65,12 @@ export const getOwnerType = (o: Readonly<Solid.Owner>): NodeType => {
     // Effect
     if (!o.pure) {
         if (o.user === true) return NodeType.Effect
-        if (o.context !== null) return NodeType.Context
+        /*
+        after solid 1.8 context is being copied to children owners
+        so need to check if the reference is the same
+        */
+        if (o.context !== null && (!o.owner || o.owner.context !== o.context))
+            return NodeType.Context
         return NodeType.Render
     }
     return NodeType.Computation