fix(devtools-bundler-core): skip primitive values when walking AST children

getChildKeys caches the object-valued keys of the first node it sees for a
type. A regex Literal has an object `value`, so `value` was cached for every
Literal. A later string Literal then reached `'type' in value` with a string,
which throws. addSourceToJsx catches the error and returns nothing, so after
one regex literal no file got data-tsd-source attributes.

forEachChild now skips every non-object value.

Fixes #523

Author: AlemTuzlak

.changeset/ast-child-keys-primitive.md

@@ -0,0 +1,6 @@
+---
+'@tanstack/devtools-bundler-core': patch
+'@tanstack/devtools-vite': patch
+---
+
+Source injection no longer stops after the dev server parses a regex literal. Before this fix, one regex literal anywhere in the module graph made every later file get zero `data-tsd-source` attributes.

packages/devtools-bundler-core/src/ast-utils.test.ts

@@ -44,6 +44,31 @@ describe('forEachChild', () => {
 
     expect(visited).toEqual([real])
   })
+
+  it('does not throw when a cached child key holds a primitive in a later node', () => {
+    // A regex literal has an object `value`, a string literal has a string
+    // `value`, and both share one type, so the cached keys include `value`.
+    const regexLiteral = {
+      type: 'ForEachSharedLiteral',
+      start: 0,
+      end: 6,
+      value: {},
+    } as unknown as Node
+    const stringLiteral = {
+      type: 'ForEachSharedLiteral',
+      start: 0,
+      end: 12,
+      value: 'use client',
+    } as unknown as Node
+
+    forEachChild(regexLiteral, () => {})
+
+    const visited: Array<Node> = []
+    expect(() =>
+      forEachChild(stringLiteral, (child) => visited.push(child)),
+    ).not.toThrow()
+    expect(visited).toEqual([])
+  })
 })
 
 describe('walk', () => {

packages/devtools-bundler-core/src/ast-utils.ts

@@ -32,7 +32,10 @@ export function forEachChild(node: Node, callback: (child: Node) => void) {
   const keys = getChildKeys(node)
   for (const key of keys) {
     const value = (node as any)[key]
-    if (value === null) continue
+    // Keys are cached from the first node of a type, so another node of the
+    // same type can hold a primitive there (a regex Literal has an object
+    // `value`, a string Literal has a string).
+    if (value === null || typeof value !== 'object') continue
     if (Array.isArray(value)) {
       for (const item of value) {
         if (typeof item === 'object' && item !== null && 'type' in item) {