openpencil/packages/scene-graph/tests/clone/node-props.test.ts

import { describe, expect, test } from 'bun:test'

import { SceneGraph, getInstanceOverride, setInstanceOverride, type SceneNode } from '@open-pencil/scene-graph'
import { cloneNodeProps } from '@open-pencil/scene-graph/copy'

import { expectDefined, getNodeOrThrow } from '../helpers/assert'

function pageId(graph: SceneGraph): string {
  return graph.getPages()[0].id
}

describe('cloneNodeProps deep-copies vectorNetwork', () => {
  test('cloned vectorNetwork is not the same reference as original', () => {
    const graph = new SceneGraph()
    const node = graph.createNode('RECTANGLE', pageId(graph), {
      name: 'Vector',
      vectorNetwork: {
        vertices: [
          { x: 0, y: 0 },
          { x: 100, y: 0 }
        ],
        segments: [{ start: 0, end: 1, tangentStart: { x: 0, y: 0 }, tangentEnd: { x: 0, y: 0 } }],
        regions: [{ windingRule: 'NONZERO', loops: [[0, 1]] }]
      }
    })
    const original = getNodeOrThrow(graph, node.id)
    const clone = expectDefined(graph.cloneTree(node.id, pageId(graph)), 'clone')
    const clonedNode = getNodeOrThrow(graph, clone.id)

    expect(clonedNode.vectorNetwork).not.toBe(original.vectorNetwork)
    if (original.vectorNetwork && clonedNode.vectorNetwork) {
      expect(clonedNode.vectorNetwork.vertices).not.toBe(original.vectorNetwork.vertices)
      expect(clonedNode.vectorNetwork.segments).not.toBe(original.vectorNetwork.segments)
      expect(clonedNode.vectorNetwork.regions).not.toBe(original.vectorNetwork.regions)
    }
  })

  test('mutating clone vectorNetwork does not affect original', () => {
    const graph = new SceneGraph()
    const node = graph.createNode('RECTANGLE', pageId(graph), {
      name: 'Vector',
      vectorNetwork: {
        vertices: [
          { x: 0, y: 0 },
          { x: 100, y: 50 }
        ],
        segments: [{ start: 0, end: 1, tangentStart: { x: 0, y: 0 }, tangentEnd: { x: 0, y: 0 } }],
        regions: []
      }
    })
    const original = getNodeOrThrow(graph, node.id)
    const clone = expectDefined(graph.cloneTree(node.id, pageId(graph)), 'clone')
    const clonedNode = getNodeOrThrow(graph, clone.id)

    if (clonedNode.vectorNetwork) clonedNode.vectorNetwork.vertices[0].x = 999
    expect(original.vectorNetwork?.vertices[0].x).toBe(0)
  })
})

describe('cloneNodeProps deep-copies textPicture and derivedTextGlyphs', () => {
  test('cloned textPicture is not the same reference as original', () => {
    const graph = new SceneGraph()
    const node = graph.createNode('TEXT', pageId(graph), {
      name: 'Text',
      text: 'Hello',
      fontSize: 14,
      fontFamily: 'Inter',
      textPicture: new Uint8Array([1, 2, 3, 4])
    })
    const original = getNodeOrThrow(graph, node.id)
    const clone = expectDefined(graph.cloneTree(node.id, pageId(graph)), 'clone')
    const clonedNode = getNodeOrThrow(graph, clone.id)

    expect(clonedNode.textPicture).not.toBe(original.textPicture)
    if (original.textPicture && clonedNode.textPicture) {
      clonedNode.textPicture[0] = 99
      expect(original.textPicture[0]).toBe(1)
    }
  })

  test('cloned derivedTextGlyphs is not the same reference as original', () => {
    const graph = new SceneGraph()
    const node = graph.createNode('TEXT', pageId(graph), {
      name: 'Text',
      text: 'Hi',
      fontSize: 14,
      fontFamily: 'Inter',
      derivedTextGlyphs: [
        { commandsBlob: new Uint8Array([10, 20]), x: 0, y: 0, fontSize: 14 },
        { commandsBlob: new Uint8Array([30, 40]), x: 10, y: 0, fontSize: 14 }
      ]
    })
    const original = getNodeOrThrow(graph, node.id)
    const clone = expectDefined(graph.cloneTree(node.id, pageId(graph)), 'clone')
    const clonedNode = getNodeOrThrow(graph, clone.id)

    expect(clonedNode.derivedTextGlyphs).not.toBe(original.derivedTextGlyphs)
    if (original.derivedTextGlyphs && clonedNode.derivedTextGlyphs) {
      expect(clonedNode.derivedTextGlyphs[0]).not.toBe(original.derivedTextGlyphs[0])
      expect(clonedNode.derivedTextGlyphs[0].commandsBlob).not.toBe(
        original.derivedTextGlyphs[0].commandsBlob
      )
      clonedNode.derivedTextGlyphs[0].commandsBlob[0] = 99
      expect(original.derivedTextGlyphs[0].commandsBlob[0]).toBe(10)
    }
  })
})

describe('cloneNodeProps deep-copies overrides values', () => {
  test('mutating clone overrides does not affect original', () => {
    const graph = new SceneGraph()
    const page = pageId(graph)
    const component = graph.createNode('COMPONENT', page, { name: 'Comp', width: 100, height: 40 })
    graph.createNode('RECTANGLE', component.id, {
      name: 'Bg',
      width: 100,
      height: 40,
      fills: [{ type: 'SOLID', color: { r: 1, g: 0, b: 0, a: 1 }, visible: true, opacity: 1 }]
    })

    const instance = expectDefined(graph.createInstance(component.id, page), 'instance')
    if (!instance) throw new Error('instance failed')
    const instanceChild = graph.getChildren(instance.id)[0]
    setInstanceOverride(instance.instanceOverrides, instance.id, instanceChild.id, 'fills', [
      { type: 'SOLID', color: { r: 0, g: 0, b: 1, a: 1 }, visible: true, opacity: 1 }
    ])

    const clone = expectDefined(graph.cloneTree(instance.id, page), 'clone')
    if (!clone) throw new Error('clone failed')
    const clonedInstance = getNodeOrThrow(graph, clone.id)
    const cloneOverrideVal = getInstanceOverride(
      clonedInstance.instanceOverrides,
      clonedInstance.id,
      instanceChild.id,
      'fills'
    ) as Array<{
      color: { r: number }
    }>
    if (cloneOverrideVal) cloneOverrideVal[0].color.r = 0.5

    const origOverrideVal = getInstanceOverride(
      instance.instanceOverrides,
      instance.id,
      instanceChild.id,
      'fills'
    ) as Array<{ color: { r: number } }>

    if (origOverrideVal) expect(origOverrideVal[0].color.r).toBe(0)
  })
})

describe('cloneNodeProps fig import mode', () => {
  test('shares immutable payloads while resetting provenance and mutable maps', () => {
    const graph = new SceneGraph()
    const node = graph.createNode('RECTANGLE', pageId(graph), {
      name: 'Imported component child',
      fills: [{ type: 'SOLID', color: { r: 1, g: 0, b: 0, a: 1 }, visible: true, opacity: 1 }],
      boundVariables: { 'fills/0/color': 'v1' },
      source: {
        format: 'fig',
        id: 'fig-source',
        orderKey: 'a',
        editedFields: [],
        fig: {
          rawSize: { x: 100, y: 40 },
          rawTransform: null,
          rawNodeFields: { derivedTextData: { large: true } },
          layout: null,
          symbolOverrides: [],
          componentPropAssignments: [],
          derivedSymbolData: [],
          derivedSymbolDataLayoutVersion: null,
          uniformScaleFactor: null
        }
      }
    })

    const cloneProps = cloneNodeProps(node, node.id, 'fig-import')

    expect(cloneProps.fills).toBe(node.fills)
    expect(cloneProps.boundVariables).not.toBe(node.boundVariables)
    expect(cloneProps.source?.format).toBeNull()
    expect(cloneProps.source?.fig.rawNodeFields).toEqual({})
  })
})

describe('cloneNodeProps coverage guard', () => {
  test('cloneNodeProps does not crash when array fields are undefined', () => {
    const graph = new SceneGraph()
    const page = pageId(graph)
    const node = graph.createNode('RECTANGLE', page, { name: 'Rect' })
    const raw = getNodeOrThrow(graph, node.id)
    const patch: Partial<
      Pick<
        SceneNode,
        | 'componentPropertyDefinitions'
        | 'symbolLinks'
        | 'exportSettings'
        | 'pluginData'
        | 'pluginRelaunchData'
      >
    > = {
      componentPropertyDefinitions: undefined,
      symbolLinks: undefined,
      exportSettings: undefined,
      pluginData: undefined,
      pluginRelaunchData: undefined
    }
    Object.assign(raw, patch)
    expect(() => graph.cloneTree(node.id, page)).not.toThrow()
  })

  test('cloneNodeProps does not share mutable object fields by default', () => {
    const graph = new SceneGraph()
    const page = pageId(graph)
    const node = graph.createNode('RECTANGLE', page, {
      name: 'Rich node',
      boundVariables: { 'fills/0/color': 'v1' },
      instanceOverrides: { self: new Map(), descendants: new Map() },
      vectorNetwork: {
        vertices: [{ x: 0, y: 0 }],
        segments: [{ start: 0, end: 0, tangentStart: { x: 0, y: 0 }, tangentEnd: { x: 0, y: 0 } }],
        regions: [{ windingRule: 'NONZERO', loops: [[0]] }]
      },
      source: {
        format: 'fig',
        id: 'source-node',
        orderKey: 'a',
        editedFields: [],
        fig: {
          rawSize: { x: 1, y: 2 },
          rawTransform: null,
          rawNodeFields: { nested: { survives: true } },
          layout: null,
          symbolOverrides: [],
          componentPropAssignments: [],
          derivedSymbolData: [],
          derivedSymbolDataLayoutVersion: 1,
          uniformScaleFactor: 1
        }
      },
      textPicture: new Uint8Array([1, 2, 3]),
      derivedTextGlyphs: [{ commandsBlob: new Uint8Array([4, 5]), x: 0, y: 0, fontSize: 12 }],
      gridPosition: { column: 1, row: 1, columnSpan: 1, rowSpan: 1 }
    })

    const cloneProps = cloneNodeProps(node, null)
    for (const [key, value] of Object.entries(node) as Array<[keyof SceneNode, unknown]>) {
      if (key === 'id' || key === 'parentId' || key === 'childIds') continue
      if (value && typeof value === 'object') {
        expect(cloneProps[key], `field ${String(key)} should be copied`).not.toBe(value)
      }
    }

    const clonedNestedRaw = cloneProps.source?.fig.rawNodeFields.nested as { survives: boolean }
    clonedNestedRaw.survives = false
    const originalNestedRaw = node.source.fig.rawNodeFields.nested as { survives: boolean }
    expect(originalNestedRaw.survives).toBe(true)
  })
})