Add case

Author: owjs3901

src/codegen/utils/__tests__/node-proxy.test.ts

@@ -716,4 +716,150 @@ describe('nodeProxyTracker', () => {
     const result = await getMainComponentAsync()
     expect(result).toBeNull()
   })
+
+  test('assembleNodeTree should link children by id references', () => {
+    // Create nodes with children as string IDs (how test data comes from toTestCaseFormat)
+    const nodes = [
+      {
+        id: 'parent-1',
+        name: 'Parent',
+        type: 'FRAME',
+        children: ['child-1', 'child-2'],
+      },
+      {
+        id: 'child-1',
+        name: 'Child1',
+        type: 'FRAME',
+      },
+      {
+        id: 'child-2',
+        name: 'Child2',
+        type: 'RECTANGLE',
+      },
+    ]
+
+    const rootNode = assembleNodeTree(nodes)
+
+    expect(rootNode.id).toBe('parent-1')
+    expect(Array.isArray(rootNode.children)).toBe(true)
+    expect(rootNode.children?.length).toBe(2)
+
+    // Children should be linked as objects, not strings
+    const child1 = rootNode.children?.[0]
+    expect(typeof child1).toBe('object')
+    expect((child1 as { id: string })?.id).toBe('child-1')
+
+    const child2 = rootNode.children?.[1]
+    expect(typeof child2).toBe('object')
+    expect((child2 as { id: string })?.id).toBe('child-2')
+  })
+
+  test('assembleNodeTree should filter out undefined children', () => {
+    // Create nodes with children referencing non-existent nodes
+    const nodes = [
+      {
+        id: 'parent-1',
+        name: 'Parent',
+        type: 'FRAME',
+        children: ['child-1', 'non-existent-child'],
+      },
+      {
+        id: 'child-1',
+        name: 'Child1',
+        type: 'FRAME',
+      },
+    ]
+
+    const rootNode = assembleNodeTree(nodes)
+
+    expect(rootNode.id).toBe('parent-1')
+    expect(Array.isArray(rootNode.children)).toBe(true)
+    // Only child-1 should be in children, non-existent-child should be filtered out
+    expect(rootNode.children?.length).toBe(1)
+    expect((rootNode.children?.[0] as { id: string })?.id).toBe('child-1')
+  })
+
+  test('assembleNodeTree TEXT node getStyledTextSegments should return stored segments', () => {
+    // Create TEXT node with styledTextSegments data
+    const nodes = [
+      {
+        id: 'text-1',
+        name: 'TextNode',
+        type: 'TEXT',
+        characters: 'Hello World',
+        styledTextSegments: [
+          {
+            start: 0,
+            end: 5,
+            characters: 'Hello',
+            fontName: { family: 'Arial', style: 'Bold' },
+            fontWeight: 700,
+            fontSize: 20,
+          },
+          {
+            start: 6,
+            end: 11,
+            characters: 'World',
+            fontName: { family: 'Arial', style: 'Regular' },
+            fontWeight: 400,
+            fontSize: 16,
+          },
+        ],
+      },
+    ]
+
+    const rootNode = assembleNodeTree(nodes)
+
+    expect(rootNode.type).toBe('TEXT')
+
+    // Call getStyledTextSegments
+    const getStyledTextSegments = (
+      rootNode as unknown as Record<string, unknown>
+    ).getStyledTextSegments as () => unknown[]
+    expect(typeof getStyledTextSegments).toBe('function')
+
+    const segments = getStyledTextSegments()
+    expect(Array.isArray(segments)).toBe(true)
+    expect(segments.length).toBe(2)
+    expect((segments[0] as { characters: string }).characters).toBe('Hello')
+    expect((segments[1] as { characters: string }).characters).toBe('World')
+  })
+
+  test('assembleNodeTree TEXT node getStyledTextSegments should generate default segment when no styledTextSegments', () => {
+    // Create TEXT node without styledTextSegments
+    const nodes = [
+      {
+        id: 'text-1',
+        name: 'TextNode',
+        type: 'TEXT',
+        characters: 'Test Text',
+        fontName: { family: 'Inter', style: 'Regular' },
+        fontWeight: 400,
+        fontSize: 14,
+        lineHeight: { unit: 'AUTO' },
+        letterSpacing: { unit: 'PERCENT', value: 0 },
+        fills: [{ type: 'SOLID', color: { r: 0, g: 0, b: 0 } }],
+      },
+    ]
+
+    const rootNode = assembleNodeTree(nodes)
+
+    expect(rootNode.type).toBe('TEXT')
+
+    // Call getStyledTextSegments - should generate default segment
+    const getStyledTextSegments = (
+      rootNode as unknown as Record<string, unknown>
+    ).getStyledTextSegments as () => unknown[]
+    const segments = getStyledTextSegments()
+
+    expect(Array.isArray(segments)).toBe(true)
+    expect(segments.length).toBe(1)
+
+    const segment = segments[0] as Record<string, unknown>
+    expect(segment.characters).toBe('Test Text')
+    expect(segment.start).toBe(0)
+    expect(segment.end).toBe(9)
+    expect(segment.textDecoration).toBe('NONE')
+    expect(segment.textCase).toBe('ORIGINAL')
+  })
 })

src/codegen/utils/node-proxy.ts

@@ -225,10 +225,12 @@ class NodeProxyTracker {
           >)[],
         )
         // 세그먼트 직렬화
-        const serializedSegments = segments.map((seg) => ({
-          ...seg,
-          fills: this.serializeArray(seg.fills as unknown[]),
-        }))
+        const serializedSegments = segments.map((seg) => {
+          return {
+            ...seg,
+            fills: this.serializeArray(seg.fills as unknown[]),
+          }
+        })
 
         const log = this.accessLogs.get(node.id)
         if (log) {
@@ -264,14 +266,20 @@ class NodeProxyTracker {
   private isArrayLikeObject(obj: Record<string, unknown>): boolean {
     const keys = Object.keys(obj)
     if (keys.length === 0) return false
-    return keys.every((key) => /^\d+$/.test(key))
+    return keys.every((key) => {
+      return /^\d+$/.test(key)
+    })
   }
 
   private arrayLikeToArray(obj: Record<string, unknown>): unknown[] {
     const keys = Object.keys(obj)
       .map(Number)
-      .sort((a, b) => a - b)
-    return keys.map((key) => obj[key])
+      .sort((a, b) => {
+        return a - b
+      })
+    return keys.map((key) => {
+      return obj[key]
+    })
   }
 
   private serializeObject(
@@ -414,15 +422,19 @@ class NodeProxyTracker {
       return allNodes
     }
 
-    const rootNode = allNodes.find((n) => n.id === rootId)
+    const rootNode = allNodes.find((n) => {
+      return n.id === rootId
+    })
     if (!rootNode) {
       return allNodes
     }
 
     // 하위 노드 ID들을 수집 (children을 재귀적으로 탐색)
     const descendantIds = new Set<string>()
     const collectDescendants = (nodeId: string) => {
-      const node = allNodes.find((n) => n.id === nodeId)
+      const node = allNodes.find((n) => {
+        return n.id === nodeId
+      })
       if (!node) return
       if (Array.isArray(node.children)) {
         for (const childId of node.children) {
@@ -447,7 +459,9 @@ class NodeProxyTracker {
     const parentId =
       typeof rootNode.parent === 'string' ? rootNode.parent : undefined
     if (parentId) {
-      const parentNode = allNodes.find((n) => n.id === parentId)
+      const parentNode = allNodes.find((n) => {
+        return n.id === parentId
+      })
       if (parentNode && parentNode.type === 'SECTION') {
         parentNode.children = [rootId]
         result.push(parentNode)
@@ -465,7 +479,9 @@ class NodeProxyTracker {
       }
     }
     if (Array.isArray(value)) {
-      return value.map((item) => this.resolveNodeRefs(item))
+      return value.map((item) => {
+        return this.resolveNodeRefs(item)
+      })
     }
     return value
   }
@@ -519,7 +535,11 @@ function setupVariableMocks(variables: VariableInfo[]): void {
   const g = globalThis as { figma?: { variables?: Record<string, unknown> } }
   if (!g.figma) return
 
-  const variableMap = new Map(variables.map((v) => [v.id, v]))
+  const variableMap = new Map(
+    variables.map((v) => {
+      return [v.id, v]
+    }),
+  )
 
   // 기존 mock을 보존하면서 새로운 변수들 추가
   const originalGetVariable = g.figma.variables?.getVariableByIdAsync as
@@ -579,7 +599,9 @@ export function assembleNodeTree(
           }
           return childId
         })
-        .filter((child): child is NodeData => child !== undefined)
+        .filter((child): child is NodeData => {
+          return child !== undefined
+        })
     }
     // children이 undefined인 경우 그대로 유지 (RECTANGLE 등 원래 children이 없는 노드)
 
@@ -668,7 +690,9 @@ export function assembleNodeTree(
     // 모든 노드에 getMainComponentAsync 메서드 추가 (아직 없는 경우에만)
     if (!(node as unknown as Record<string, unknown>).getMainComponentAsync) {
       ;(node as unknown as Record<string, unknown>).getMainComponentAsync =
-        async () => null
+        async () => {
+          return null
+        }
     }
 
     // TEXT 노드에 getStyledTextSegments mock 메서드 추가