AI-native design editor. Open-source Figma alternative.
import { describe, expect, test } from 'bun:test'
import type { CanvasKit } from 'canvaskit-wasm'
import { SceneGraph } from '@open-pencil/scene-graph'
import { pixelLength } from '@open-pencil/scene-graph/text'
import { initCanvasKit } from '#cli/headless'
import { buildParagraph, nodeFontReadiness } from '#core/canvas/text'
import { TextLayout } from '#core/canvas/text/layout'
import type { ParagraphNode } from '#core/canvas/text/paragraph/inputs'
import { TextPreparationCache } from '#core/canvas/text/preparation/cache'
import { fontManager } from '#core/text/font/manager'
import { expectDefined } from '#tests/helpers/assert'
async function fixture(maxEntries = 8, maxUnits = 1000) {
const ck = await initCanvasKit()
const provider = ck.TypefaceFontProvider.Make()
const graph = new SceneGraph()
const node = graph.createNode('TEXT', graph.getPages()[0].id, {
text: 'Prepared text',
width: 200,
height: 50
})
const cache = new TextPreparationCache(maxEntries, maxUnits)
const built: TextLayout[] = []
function build() {
const builder = ck.ParagraphBuilder.MakeFromFontProvider(
new ck.ParagraphStyle({ textStyle: { fontSize: 16 } }),
provider
)
builder.addText(node.text)
const layout = TextLayout.ofParagraph(ck, builder.build(), node.text.length)
builder.delete()
layout.layout(node.width)
built.push(layout)
return layout
}
function use(variant = 'draw', generation = 1) {
return cache.use(node, variant, generation, provider, build, ({ paragraph }) =>
paragraph.getHeight()
)
}
return {
ck,
provider,
graph,
node,
cache,
built,
build,
use,
dispose() {
cache.clear()
provider.delete()
}
}
}
describe('text preparation cache', () => {
test('does not repeatedly shape coverage when a dense scan exceeds paragraph capacity', async () => {
const f = await fixture(8)
const data = await Bun.file('packages/core/assets/InterVariable.ttf').arrayBuffer()
f.provider.registerFont(data, 'Inter')
await fontManager.markLoaded('Inter', 'Regular', data)
let builds = 0
const ck: CanvasKit = {
...f.ck,
ParagraphBuilder: {
...f.ck.ParagraphBuilder,
MakeFromFontProvider(
...args: Parameters<typeof f.ck.ParagraphBuilder.MakeFromFontProvider>
) {
builds++
return f.ck.ParagraphBuilder.MakeFromFontProvider(...args)
}
}
}
const renderer = {
ck,
fontProvider: f.provider,
fontsLoaded: true,
textPreparationCache: f.cache
}
const nodes = Array.from({ length: 6 }, (_, i) =>
f.graph.createNode('TEXT', expectDefined(f.node.parentId, 'text node parent'), {
text: `Label ${i}`,
fontFamily: 'Inter',
fontWeight: 400,
width: 100,
height: 30
})
)
function draw() {
for (const node of nodes) {
expect(nodeFontReadiness(renderer, node)).toBe('ready')
f.cache.use(
node,
'draw',
fontManager.generation(),
f.provider,
() => buildParagraph(renderer, node),
({ paragraph }) => paragraph.getHeight()
)
}
}
try {
draw()
expect(builds).toBe(12)
draw()
const warmBuilds = builds
draw()
expect(builds).toBe(warmBuilds)
f.cache.deleteNode(nodes[0].id)
draw()
expect(builds).toBe(warmBuilds + 2)
f.graph.updateNodePreview(nodes[0].id, { text: 'Edited label' })
draw()
expect(builds).toBe(warmBuilds + 4)
f.cache.clear()
draw()
expect(builds).toBe(warmBuilds + 16)
} finally {
f.dispose()
}
})
test('scopes successful coverage to fonts, inputs and explicit invalidation', async () => {
const f = await fixture(2)
const otherProvider = f.ck.TypefaceFontProvider.Make()
try {
f.use('coverage', 1)
f.cache.recordGlyphCoverage(f.node)
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(true)
expect(f.cache.hasGlyphCoverage(f.node, 2, f.provider)).toBe(false)
expect(f.cache.hasGlyphCoverage(f.node, 1, otherProvider)).toBe(false)
f.graph.updateNodePreview(f.node.id, { x: 50, rotation: 20 })
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(true)
// Layout resizing the box shapes the same glyphs, unless truncation hides some of them.
f.graph.updateNodePreview(f.node.id, { width: 80 })
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(true)
f.cache.deleteNode(f.node.id, { keepShaping: true })
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(true)
f.graph.updateNodePreview(f.node.id, { textTruncation: 'ENDING' })
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(false)
f.cache.recordGlyphCoverage(f.node)
f.graph.updateNodePreview(f.node.id, { width: 60 })
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(false)
f.graph.updateNodePreview(f.node.id, { textTruncation: 'DISABLED' })
f.cache.recordGlyphCoverage(f.node)
f.cache.deleteNode(f.node.id)
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(false)
f.use('coverage', 1)
f.cache.recordGlyphCoverage(f.node)
f.cache.deleteNode('unrelated')
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(true)
f.cache.deleteNode('another')
f.cache.deleteNode('overflow')
expect(f.cache.hasGlyphCoverage(f.node, 1, f.provider)).toBe(false)
f.cache.recordGlyphCoverage(f.node)
f.use('draw', 2)
expect(f.cache.hasGlyphCoverage(f.node, 2, f.provider)).toBe(false)
} finally {
otherProvider.delete()
f.dispose()
}
})
test('measures a text once per shaping and layout width', async () => {
const f = await fixture()
let measured = 0
const measure = (width: number, generation = 1) =>
f.cache.measure(f.node, width, generation, f.provider, () => {
measured++
return { width, height: f.node.text.length }
})
try {
measure(200)
measure(200)
measure(120)
expect(measured).toBe(2)
// Layout resizing the box changes neither the shaping nor the sizes at a given width.
f.graph.updateNodePreview(f.node.id, { width: 80, height: 30 })
f.cache.deleteNode(f.node.id, { keepShaping: true })
measure(200)
expect(measured).toBe(2)
// Drawing rebuilds its paragraph for the new box without dropping the measurements.
f.use()
f.graph.updateNodePreview(f.node.id, { width: 90 })
f.use()
expect(f.built).toHaveLength(2)
measure(200)
expect(measured).toBe(2)
f.graph.updateNodePreview(f.node.id, { text: 'Edited text' })
expect(measure(200).height).toBe('Edited text'.length)
expect(measured).toBe(3)
f.cache.deleteNode(f.node.id)
measure(200)
expect(measured).toBe(4)
measure(200, 2)
expect(measured).toBe(5)
} finally {
f.dispose()
}
})
test('shares measured sizes between layers whose text shapes the same', async () => {
const f = await fixture()
let measured = 0
const measure = (node: typeof f.node, width = 200) =>
f.cache.measure(node, width, 1, f.provider, () => {
measured++
return { width, height: node.text.length }
})
const parentId = expectDefined(f.node.parentId, 'text node parent')
// An instance's copies repeat the source text, whatever box each one sits in.
const copy = f.graph.createNode('TEXT', parentId, { text: f.node.text, width: 80 })
const other = f.graph.createNode('TEXT', parentId, { text: 'Other text' })
try {
measure(f.node)
measure(copy)
expect(measured).toBe(1)
measure(copy, 120)
measure(other)
expect(measured).toBe(3)
// An explicit invalidation drops the sizes the layer shares instead of reading them back.
f.cache.deleteNode(f.node.id)
measure(f.node)
expect(measured).toBe(4)
} finally {
f.dispose()
}
})
test('reuses native paragraphs during movement and invalidates text layout inputs', async () => {
const f = await fixture()
try {
f.use()
f.graph.updateNodePreview(f.node.id, { x: 30, y: 40, rotation: 25 })
f.use()
expect(f.built).toHaveLength(1)
// Exhaustive against the same input type accepted by paragraph construction.
const mutations: ParagraphNode = {
text: 'Different text',
fontFamily: 'Other',
fontSize: 20,
fontWeight: 700,
italic: true,
fontStyle: 'Condensed Bold',
fontFeatures: [{ tag: 'liga', enabled: false }],
fontVariations: [{ axis: 'wght', value: 700 }],
opticalSizeFromFontSize: false,
textLanguage: 'ar',
textDirection: 'RTL',
textCase: 'UPPER',
letterSpacing: pixelLength(2),
lineHeight: pixelLength(30),
textAlignHorizontal: 'CENTER',
leadingTrim: 'CAP_HEIGHT',
textDecoration: 'UNDERLINE',
textDecorationStyle: 'WAVY',
textDecorationThickness: 2,
textDecorationFills: [
{ type: 'SOLID', color: { r: 1, g: 0, b: 0, a: 1 }, opacity: 1, visible: true }
],
textDecorationSkipInk: false,
textUnderlineOffset: 4,
textTruncation: 'ENDING',
maxLines: 2,
textParagraphs: [{ listType: 'UNORDERED', indentation: 1 }],
listSpacing: 4,
paragraphSpacing: 6,
paragraphIndent: 8,
hangingList: true,
textAutoResize: 'WIDTH_AND_HEIGHT',
width: 100,
height: 80,
styleRuns: [{ start: 0, length: 4, style: { fontSize: 24 } }]
}
for (const [key, value] of Object.entries(mutations)) {
const previous = f.built.at(-1)
f.graph.updateNodePreview(f.node.id, { [key]: value })
f.use()
expect(previous?.isDeleted()).toBe(true)
}
expect(f.built).toHaveLength(1 + Object.keys(mutations).length)
} finally {
f.dispose()
}
})
test('separates drawing/coverage variants and expires observations on font changes', async () => {
const f = await fixture()
const otherProvider = f.ck.TypefaceFontProvider.Make()
try {
const observe = (generation: number) =>
f.cache.use(f.node, 'coverage', generation, f.provider, f.build, (prepared) => {
const previous = prepared.missingGlyphs
prepared.missingGlyphs = []
return previous
})
expect(observe(1)).toBeUndefined()
expect(observe(1)).toEqual([])
f.use('draw:black')
f.use('draw:blue')
expect(f.built).toHaveLength(3)
expect(observe(2)).toBeUndefined()
expect(f.built.slice(0, 3).every((p) => p.isDeleted())).toBe(true)
f.cache.use(f.node, 'coverage', 2, otherProvider, f.build, (prepared) => {
expect(prepared.missingGlyphs).toBeUndefined()
})
expect(f.built[3].isDeleted()).toBe(true)
} finally {
f.dispose()
otherProvider.delete()
}
})
test('bounds native resource ownership, removes deleted nodes and clears idempotently', async () => {
const f = await fixture(2)
try {
f.use('a')
f.use('b')
f.use('a')
f.use('c')
expect(f.built[0].isDeleted()).toBe(false)
expect(f.built[1].isDeleted()).toBe(true)
f.cache.deleteNode(f.node.id)
expect(f.built.every((p) => p.isDeleted())).toBe(true)
f.use('a')
f.cache.clear()
f.cache.clear()
expect(f.built.every((p) => p.isDeleted())).toBe(true)
} finally {
f.dispose()
}
})
test('evicts by aggregate text budget before reaching the paragraph count limit', async () => {
const f = await fixture(8, 20)
try {
f.use('a')
f.use('b')
expect(f.built).toHaveLength(2)
expect(f.built[0].isDeleted()).toBe(true)
expect(f.built[1].isDeleted()).toBe(false)
f.use('b')
expect(f.built).toHaveLength(2)
} finally {
f.dispose()
}
})
test('does not retain oversized text and deletes uncached paragraphs after errors', async () => {
const f = await fixture(8, 2)
try {
f.use()
f.use()
expect(f.built).toHaveLength(2)
expect(f.built.every((p) => p.isDeleted())).toBe(true)
expect(() =>
f.cache.use(f.node, 'draw', 1, f.provider, f.build, () => {
throw new Error('draw failed')
})
).toThrow('draw failed')
expect(f.built.every((p) => p.isDeleted())).toBe(true)
} finally {
f.dispose()
}
})
})