AI-native design editor. Open-source Figma alternative.
import { expect, test } from 'bun:test'
import { createEditor } from '@open-pencil/core'
import { exportFigFile, parseFigFile, populateFigPage } from '@open-pencil/core/io/formats/fig'
import { initCodec } from '@open-pencil/kiwi/fig/codec'
import { SceneGraph } from '@open-pencil/scene-graph'
import type { PageSwitchProgress } from '#core/editor/pages'
test('core page preparation only reports progress and never owns app suspension', async () => {
const graph = new SceneGraph()
const page = graph.getPages()[0]
if (!page) throw new Error('Expected default page')
graph.createNode('TEXT', page.id, {
text: 'Loading',
fontFamily: 'Loader Test',
fontWeight: 400
})
const progress: PageSwitchProgress[] = []
let release: () => void = () => undefined
const fontReady = new Promise<void>((resolve) => {
release = resolve
})
const editor = createEditor({
graph,
skipInitialGraphSetup: true,
loadFont: async () => {
await fontReady
return null
}
})
const switching = editor.switchPage(page.id, {
onProgress: (next) => progress.push(next)
})
await Promise.resolve()
expect(progress.some((entry) => entry.phase === 'resolving-fonts')).toBe(true)
release()
await switching
expect(progress).toContainEqual(
expect.objectContaining({ phase: 'resolving-fonts', completed: 1, total: 1 })
)
})
test('prepares a target page without exposing it before commit', async () => {
const graph = new SceneGraph()
const firstPage = graph.getPages()[0]
if (!firstPage) throw new Error('Expected default page')
const secondPage = graph.addPage('Prepared page')
graph.createNode('TEXT', secondPage.id, {
text: 'Loading',
fontFamily: 'Loader Test',
fontWeight: 400
})
let release: () => void = () => undefined
const fontReady = new Promise<void>((resolve) => {
release = resolve
})
const editor = createEditor({
graph,
skipInitialGraphSetup: true,
loadFont: async () => {
await fontReady
return null
}
})
const pageChanges: string[] = []
editor.onEditorEvent('page:changed', (pageId) => pageChanges.push(pageId))
const preparing = editor.preparePage(secondPage.id)
await Promise.resolve()
expect(editor.state.currentPageId).toBe(firstPage.id)
expect(pageChanges).toEqual([])
release()
const prepared = await preparing
expect(editor.state.currentPageId).toBe(firstPage.id)
expect(prepared).not.toBeNull()
if (!prepared) throw new Error('Expected prepared page')
expect(editor.commitPageSwitch(prepared)).toBe(true)
expect(editor.state.currentPageId).toBe(secondPage.id)
expect(pageChanges).toEqual([secondPage.id])
})
test('aborted page preparation preserves the visible page', async () => {
const graph = new SceneGraph()
const firstPage = graph.getPages()[0]
if (!firstPage) throw new Error('Expected default page')
const secondPage = graph.addPage('Cancelled page')
graph.createNode('TEXT', secondPage.id, {
text: 'Loading',
fontFamily: 'Loader Test',
fontWeight: 400
})
let release: () => void = () => undefined
const fontReady = new Promise<void>((resolve) => {
release = resolve
})
const editor = createEditor({
graph,
skipInitialGraphSetup: true,
loadFont: async () => {
await fontReady
return null
}
})
const abort = new AbortController()
const preparing = editor.preparePage(secondPage.id, { signal: abort.signal })
await Promise.resolve()
abort.abort()
release()
await expect(preparing).rejects.toHaveProperty('name', 'AbortError')
expect(editor.state.currentPageId).toBe(firstPage.id)
})
test('obsolete prepared pages cannot commit after a newer preparation', async () => {
const graph = new SceneGraph()
const firstPage = graph.getPages()[0]
if (!firstPage) throw new Error('Expected default page')
const secondPage = graph.addPage('Second')
const thirdPage = graph.addPage('Third')
const editor = createEditor({ graph, skipInitialGraphSetup: true })
const second = await editor.preparePage(secondPage.id)
const third = await editor.preparePage(thirdPage.id)
expect(second).not.toBeNull()
expect(third).not.toBeNull()
if (!second || !third) throw new Error('Expected prepared pages')
expect(editor.commitPageSwitch(second)).toBe(false)
expect(editor.state.currentPageId).toBe(firstPage.id)
expect(editor.commitPageSwitch(third)).toBe(true)
expect(editor.state.currentPageId).toBe(thirdPage.id)
})
test('page viewport cleanup remains independent from app preparation state', () => {
const editor = createEditor()
expect(() => editor.clearPageViewports()).not.toThrow()
})
test('loading page nodes for a lookup does not supersede a page switch in progress', async () => {
const graph = new SceneGraph()
const firstPage = graph.getPages()[0]
if (!firstPage) throw new Error('Expected default page')
const target = graph.addPage('Target')
const searched = graph.addPage('Searched')
graph.createNode('TEXT', target.id, { text: 'Loading', fontFamily: 'Loader Test' })
let release: () => void = () => undefined
const fontReady = new Promise<void>((resolve) => {
release = resolve
})
const editor = createEditor({
graph,
skipInitialGraphSetup: true,
loadFont: async () => {
await fontReady
return null
}
})
const switching = editor.switchPage(target.id)
await Promise.resolve()
await editor.loadPageNodes(searched.id)
release()
await switching
expect(editor.state.currentPageId).toBe(target.id)
})
test('preparing a page for rendering loads its fonts and layout once without switching to it', async () => {
const graph = new SceneGraph()
const firstPage = graph.getPages()[0]
if (!firstPage) throw new Error('Expected default page')
const target = graph.addPage('Target')
const prepared = graph.addPage('Prepared')
graph.createNode('TEXT', target.id, { text: 'Loading', fontFamily: 'Loader Test' })
const row = graph.createNode('FRAME', prepared.id, {
width: 10,
height: 10,
layoutMode: 'HORIZONTAL',
primaryAxisSizing: 'HUG',
counterAxisSizing: 'FIXED'
})
graph.createNode('FRAME', row.id, { width: 30, height: 10 })
graph.createNode('TEXT', prepared.id, { text: 'Label', fontFamily: 'Prepared Font' })
const loaded: string[] = []
let release: () => void = () => undefined
const fontReady = new Promise<void>((resolve) => {
release = resolve
})
const editor = createEditor({
graph,
skipInitialGraphSetup: true,
loadFont: async (family) => {
loaded.push(family)
if (family === 'Loader Test') await fontReady
return null
}
})
const switching = editor.switchPage(target.id)
await Promise.resolve()
const concurrent = await Promise.all([
editor.preparePageNodes(prepared.id),
editor.preparePageNodes(prepared.id)
])
const again = await editor.preparePageNodes(prepared.id)
release()
await switching
expect([...concurrent, again]).toEqual([true, true, true])
expect(loaded.filter((family) => family === 'Prepared Font')).toHaveLength(1)
expect(graph.getNode(row.id)?.width).toBe(30)
expect(editor.state.currentPageId).toBe(target.id)
})
test('preparing a page reports failure when the document is replaced meanwhile', async () => {
const graph = new SceneGraph()
const page = graph.addPage('Prepared')
graph.createNode('TEXT', page.id, { text: 'Label', fontFamily: 'Prepared Font' })
let release: () => void = () => undefined
const fontReady = new Promise<void>((resolve) => {
release = resolve
})
const editor = createEditor({
graph,
skipInitialGraphSetup: true,
loadFont: async () => {
await fontReady
return null
}
})
const preparing = editor.preparePageNodes(page.id)
await Promise.resolve()
editor.replaceGraph(new SceneGraph())
release()
expect(await preparing).toBe(false)
})
test("loading a page's layers from the opened file asks for one render", async () => {
await initCodec()
const source = new SceneGraph()
const second = source.addPage('Second')
for (let i = 0; i < 30; i++) source.createNode('RECTANGLE', second.id, { name: `Layer ${i}` })
const bytes = await exportFigFile(source)
const graph = await parseFigFile(bytes.slice().buffer, { populate: 'first-page' })
const editor = createEditor({ graph })
const page = graph.getPages()[1]
if (!page) throw new Error('Expected a second page')
await Promise.resolve()
let renders = 0
const unbind = editor.onEditorEvent('render:requested', () => renders++)
expect(populateFigPage(graph, page.id)).toBe(true)
await Promise.resolve()
unbind()
expect(graph.getChildren(page.id)).toHaveLength(30)
expect(renders).toBe(1)
editor.dispose()
})
test('preparing a page loads the pages holding the component sets its instances use', async () => {
await initCodec()
const source = new SceneGraph()
const [design] = source.getPages()
const set = (pageName: string, name: string) => {
const page = source.addPage(pageName)
const created = source.createNode('COMPONENT_SET', page.id, { name })
const variant = (value: string) =>
source.createNode('COMPONENT', created.id, {
name: `State=${value}`,
componentPropertyValues: { State: value }
})
return { off: variant('Off'), on: variant('On') }
}
// Only the switch's On variant holds a knob, from a set on a third page, so the design page
// reaches that set through the switch's page alone.
const knob = set('Parts', 'Knob')
const toggle = set('Library', 'Switch')
source.createInstance(knob.off.id, toggle.on.id)
source.createInstance(toggle.off.id, design.id)
const bytes = await exportFigFile(source)
const graph = await parseFigFile(bytes.slice().buffer, { populate: 'none' })
const editor = createEditor({ graph, skipInitialGraphSetup: true })
const [first] = graph.getPages()
const variants = (setName: string) => {
const found = [...graph.getAllNodes()].find(
(node) => node.type === 'COMPONENT_SET' && node.name === setName
)
return found ? graph.getChildren(found.id).map((node) => node.name) : []
}
expect(await editor.preparePage(first.id)).not.toBeNull()
expect(variants('Switch')).toEqual(['State=Off', 'State=On'])
expect(variants('Knob')).toEqual(['State=Off', 'State=On'])
editor.dispose()
})