Skip to content

AI-native design editor. Open-source Figma alternative.

4.1 KB
Raw Blame
import { expect, mock, test } from 'bun:test'

import type { Font, Paint, Surface } from 'canvaskit-wasm'

import { createImageFilterCache, createMaskFilterCache } from '#core/canvas/effects'
import { createRendererImages } from '#core/canvas/images/state'
import { IssueMarkerStage } from '#core/canvas/issues/stage'
import type { NodeEditPaints } from '#core/canvas/node-edit-overlay'
import { createDashEffectCache } from '#core/canvas/overlays/outline'
import { NodePathCaches } from '#core/canvas/paths/cache'
import type { SkiaRenderer } from '#core/canvas/renderer'
import { destroyRenderer } from '#core/canvas/renderer/lifecycle'
import { createCompiledShaders } from '#core/canvas/renderer/shaders'
import { createWholeScenePicture } from '#core/canvas/renderer/state'
import { createTextCaches } from '#core/canvas/text/caches'
import { TextPreparationCache } from '#core/canvas/text/preparation/cache'

import { asDouble, asRenderer } from './helpers'

function deletable<T>() {
  return { delete: mock() } as T & { delete: ReturnType<typeof mock> }
}

function createRenderer() {
  const renderer: Partial<SkiaRenderer> = {
    destroyed: false,
    textPreparationCache: new TextPreparationCache(),
    transientPreviews: new Map(),
    images: createRendererImages(),
    nodePaths: new NodePathCaches(),
    textCaches: createTextCaches(),
    fillPaint: deletable<Paint>(),
    strokePaint: deletable<Paint>(),
    selectionPaint: deletable<Paint>(),
    snapPaint: deletable<Paint>(),
    auxFill: deletable<Paint>(),
    auxStroke: deletable<Paint>(),
    opacityPaint: deletable<Paint>(),
    effectLayerPaint: deletable<Paint>(),
    chromeFonts: {
      text: deletable<Font>(),
      label: deletable<Font>(),
      size: deletable<Font>(),
      value: null,
      sectionTitle: deletable<Font>(),
      componentLabel: deletable<Font>()
    },
    fontProvider: null,
    fontsLoaded: true,
    rulerBgPaint: deletable<Paint>(),
    rulerTickPaint: deletable<Paint>(),
    rulerTextPaint: deletable<Paint>(),
    rulerHlPaint: deletable<Paint>(),
    rulerBadgePaint: deletable<Paint>(),
    rulerLabelPaint: deletable<Paint>(),
    penPathPaint: deletable<Paint>(),
    penLiveStrokePaint: deletable<Paint>(),
    pencilStrokePaint: deletable<Paint>(),
    penHandlePaint: deletable<Paint>(),
    penVertexFill: deletable<Paint>(),
    penVertexStroke: deletable<Paint>(),
    imageFilterCache: createImageFilterCache(),
    dashEffects: createDashEffectCache(),
    shaders: createCompiledShaders(),
    maskFilterCache: createMaskFilterCache(),
    nodeEditPaints: {
      techStrokePaint: deletable<Paint>()
    } as Partial<NodeEditPaints> as NodeEditPaints,
    nodePictures: new Map(),
    issueMarkerStage: new IssueMarkerStage(),
    wholeScene: createWholeScenePicture(),
    tiledScene: asDouble<SkiaRenderer['tiledScene']>({ destroy: mock() }),
    labelParagraphCache: asDouble<SkiaRenderer['labelParagraphCache']>({ clear: mock() }),
    profiler: { destroy: mock() } as Partial<SkiaRenderer['profiler']> as SkiaRenderer['profiler'],
    surface: deletable<Surface>()
  }
  return asRenderer(renderer)
}

test('destroyRenderer releases tiled resources before deleting the main surface', () => {
  const renderer = createRenderer()
  const teardown: string[] = []
  renderer.textPreparationCache.clear = mock(() => {
    teardown.push('text')
  })
  renderer.tiledScene.destroy = mock(() => teardown.push('tiled'))
  renderer.surface.delete = mock(() => teardown.push('surface')) as typeof renderer.surface.delete

  destroyRenderer(renderer)

  expect(renderer.tiledScene.destroy).toHaveBeenCalledTimes(1)
  expect(renderer.surface.delete).toHaveBeenCalledTimes(1)
  expect(teardown).toEqual(['text', 'tiled', 'surface'])
})

test('destroyRenderer deletes all renderer-owned paints and label fonts', () => {
  const renderer = createRenderer()
  const { sectionTitle, componentLabel } = renderer.chromeFonts
  const pencilStrokePaint = renderer.pencilStrokePaint

  destroyRenderer(renderer)

  expect(pencilStrokePaint.delete).toHaveBeenCalled()
  expect(sectionTitle?.delete).toHaveBeenCalled()
  expect(componentLabel?.delete).toHaveBeenCalled()
})