AI-native design editor. Open-source Figma alternative.
import type { SceneGraph, SceneNode } from '@open-pencil/scene-graph'
import { instanceMainComponent } from '@open-pencil/scene-graph/instances'
import type { Color } from '@open-pencil/scene-graph/primitives'
import {
getPageColor,
setDefaultPageBackground,
setPageBackgrounds
} from '#core/figma-api/page-backgrounds'
import {
canUseFigPopulationWorker,
createFigPopulationWorker
} from '#core/kiwi/fig/population/client'
import {
isReaderPagePending,
pendingReaderPageOfNode,
recoverReaderPage
} from '#core/kiwi/fig/session/document-state'
import { computeAllLayouts } from '#core/layout'
import { prepareGraphFonts } from '#core/text/prepare'
import { createPageLayouts } from './pages/layouts'
import { createPageViewportStore } from './pages/viewports'
import type { EditorContext } from './types'
export interface PageSwitchProgress {
phase:
| 'populating-page'
| 'resolving-fonts'
| 'resolving-fallbacks'
| 'layout'
| 'drawing-shaders'
detail?: string
completed?: number
total?: number
}
export interface PreparePageOptions {
onProgress?: (progress: PageSwitchProgress) => void
signal?: AbortSignal
}
export interface PreparedPage {
pageId: string
generation: number
}
export type SwitchPageOptions = PreparePageOptions
function throwIfAborted(signal?: AbortSignal): void {
signal?.throwIfAborted()
}
const MAX_CONCURRENT_FONT_LOADS = 4
/** What preparing a page needs drawn once it is laid out, such as its shaders' frames. */
interface PageDrawing {
drawPageShaderFrames(
pageId: string,
options: { signal?: AbortSignal; onProgress?: (progress: PageSwitchProgress) => void }
): Promise<void>
}
/**
* The other pages that hold the component sets instances on `pageId` show a variant of,
* nested instances included. A set on Figma's internal canvas is a copy of a library's, kept
* with only what the file uses, so its page is left out.
*/
export function componentSetPages(graph: SceneGraph, pageId: string): string[] {
const pages = new Set<string>()
const visit = (id: string): void => {
for (const node of graph.getChildren(id)) {
if (node.type === 'INSTANCE') {
const component = instanceMainComponent(graph, node)
const set = component?.parentId ? graph.getNode(component.parentId) : undefined
const setPageId = set?.type === 'COMPONENT_SET' ? graph.pageOf(set.id) : null
const setPage = setPageId ? graph.getNode(setPageId) : undefined
if (setPage && setPage.id !== pageId && !setPage.internalOnly) pages.add(setPage.id)
}
visit(node.id)
}
}
visit(pageId)
return [...pages]
}
export function createPageActions(ctx: EditorContext, drawing?: PageDrawing) {
const pageViewportStore = createPageViewportStore(ctx)
const pageLayouts = createPageLayouts(ctx)
function syncPageColor() {
ctx.state.pageColor = getPageColor(ctx.graph.getNode(ctx.state.currentPageId))
}
syncPageColor()
ctx.onEditorEvent('graph:replaced', syncPageColor)
ctx.onEditorEvent('node:updated', (id, changes) => {
if (id === ctx.state.currentPageId && changes.source) syncPageColor()
})
let populationWorkerInstance: ReturnType<typeof createFigPopulationWorker> | undefined
let populationWorkerGeneration = 0
let pageSwitchGeneration = 0
// Off-screen preparations per document, shared by concurrent callers and kept once they
// succeed. Later edits lay out their own scope, as they do on the page on screen.
const offscreenPreparations = new WeakMap<SceneGraph, Map<string, Promise<boolean>>>()
function populationWorker() {
if (!canUseFigPopulationWorker(ctx.graph)) return null
populationWorkerInstance ??= createFigPopulationWorker(ctx.graph)
return populationWorkerInstance
}
/** `switchGeneration` is null for a lookup, which no page switch can supersede. */
async function populatePage(
pageId: string,
switchGeneration: number | null,
signal?: AbortSignal
): Promise<boolean | null> {
throwIfAborted(signal)
const worker = populationWorker()
const workerGeneration = populationWorkerGeneration
const workerResult = worker ? await worker.populate(pageId, signal) : null
throwIfAborted(signal)
if (
workerGeneration !== populationWorkerGeneration ||
(switchGeneration !== null && switchGeneration !== pageSwitchGeneration)
) {
return null
}
if (workerResult !== null) return workerResult
worker?.terminate()
populationWorkerInstance = undefined
if (isReaderPagePending(ctx.graph, pageId)) {
return recoverReaderPage(ctx.graph, pageId)
}
return false
}
async function resolvePageFonts(
pageId: string,
pageName: string,
options: PreparePageOptions
): Promise<void> {
const childIds = ctx.graph.getChildren(pageId).map((node) => node.id)
try {
await prepareGraphFonts(ctx.graph, childIds, {
loadFont: ctx.loadFont,
hide: true,
signal: options.signal,
concurrency: MAX_CONCURRENT_FONT_LOADS,
label: pageName,
onProgress: options.onProgress
})
} finally {
ctx.getRenderer()?.invalidateAllPictures()
}
}
async function preparePage(
pageId: string,
options: PreparePageOptions = {}
): Promise<PreparedPage | null> {
const page = ctx.graph.getNode(pageId)
if (page?.type !== 'CANVAS') return null
const generation = ++pageSwitchGeneration
throwIfAborted(options.signal)
options.onProgress?.({ phase: 'populating-page', detail: page.name })
const populated = await populatePage(pageId, generation, options.signal)
if (populated === null || generation !== pageSwitchGeneration) return null
// A file brings in only the variants a page uses; switching a variant, in the panel or in
// preview, needs the rest of its set, laid out with its fonts, so the pages holding those
// sets are prepared with this one, and the pages of sets their variants use in turn.
const seen = new Set([pageId])
const pending = componentSetPages(ctx.graph, pageId)
for (let setPageId = pending.shift(); setPageId !== undefined; setPageId = pending.shift()) {
if (seen.has(setPageId)) continue
seen.add(setPageId)
const ready = await preparePageNodes(setPageId)
throwIfAborted(options.signal)
if (!ready || generation !== pageSwitchGeneration) return null
pending.push(...componentSetPages(ctx.graph, setPageId))
}
await resolvePageFonts(pageId, page.name, options)
throwIfAborted(options.signal)
if (generation !== pageSwitchGeneration) return null
// A page visited before keeps the layout it got then, unless something it depends on changed.
if ((ctx.getRenderer() || populated) && !pageLayouts.isCurrent(pageId)) {
options.onProgress?.({ phase: 'layout', detail: page.name })
ctx.graph.applyDerivedLayoutDuring(() => computeAllLayouts(ctx.graph, pageId))
pageLayouts.record(pageId)
}
throwIfAborted(options.signal)
if (generation !== pageSwitchGeneration) return null
// Frames are drawn at the size layout gives each layer.
await drawing?.drawPageShaderFrames(pageId, options)
throwIfAborted(options.signal)
return generation === pageSwitchGeneration ? { pageId, generation } : null
}
function commitPageSwitch(prepared: PreparedPage): boolean {
if (prepared.generation !== pageSwitchGeneration) return false
const page = ctx.graph.getNode(prepared.pageId)
if (page?.type !== 'CANVAS') return false
pageViewportStore.saveCurrentPageViewport()
const previousPageId = ctx.state.currentPageId
ctx.state.currentPageId = prepared.pageId
ctx.state.enteredContainerId = null
ctx.setSelectedIds(new Set())
pageViewportStore.restorePageViewport(prepared.pageId)
if (previousPageId !== prepared.pageId) {
ctx.emitEditorEvent('page:changed', prepared.pageId, previousPageId)
}
ctx.requestRender()
return true
}
/**
* Loads a page's layers so they can be searched, without fonts, layout, or switching to
* it — and without superseding a page switch the user has in progress.
*/
async function loadPageNodes(pageId: string): Promise<void> {
if (ctx.graph.getNode(pageId)?.type === 'CANVAS') await populatePage(pageId, null)
}
/** The page holding a layer not in the document yet because its page has not loaded. */
function pageHoldingNode(nodeId: string): Promise<string | null> {
return ctx.graph.getNode(nodeId)
? Promise.resolve(null)
: pendingReaderPageOfNode(ctx.graph, nodeId)
}
async function prepareOffscreenPage(graph: SceneGraph, page: SceneNode): Promise<boolean> {
const populated = await populatePage(page.id, null)
if (populated === null || graph !== ctx.graph) return false
await resolvePageFonts(page.id, page.name, {})
if (graph !== ctx.graph) return false
graph.applyDerivedLayoutDuring(() => computeAllLayouts(graph, page.id))
return true
}
/**
* Loads a page's layers with their fonts and layout, ready to render, without switching to
* it or superseding a page switch in progress. False when the document was closed or
* replaced first. The page on screen already was prepared, when it was shown.
*/
function preparePageNodes(pageId: string): Promise<boolean> {
const graph = ctx.graph
const page = graph.getNode(pageId)
if (page?.type !== 'CANVAS') return Promise.resolve(false)
if (pageId === ctx.state.currentPageId) return Promise.resolve(true)
let preparations = offscreenPreparations.get(graph)
if (!preparations) {
preparations = new Map()
offscreenPreparations.set(graph, preparations)
}
const pending = preparations.get(pageId)
if (pending) return pending
// A failed or superseded preparation is retried by the next caller.
const forget = () => preparations.delete(pageId)
const preparation = prepareOffscreenPage(graph, page).then(
(ready) => {
if (!ready) forget()
return ready
},
(error: unknown) => {
forget()
throw error
}
)
preparations.set(pageId, preparation)
return preparation
}
async function switchPage(pageId: string, options: SwitchPageOptions = {}): Promise<void> {
const prepared = await preparePage(pageId, options)
if (prepared) commitPageSwitch(prepared)
}
/** Opens the page before or after the current one in the pages panel, stopping at the ends. */
async function switchToAdjacentPage(step: 1 | -1): Promise<void> {
const pages = ctx.graph.getPages()
const index = pages.findIndex((page) => page.id === ctx.state.currentPageId)
const next = index + step
if (index === -1 || next < 0 || next >= pages.length) return
await switchPage(pages[next].id)
}
function clearPageViewports() {
populationWorkerGeneration++
pageSwitchGeneration++
populationWorkerInstance?.terminate()
populationWorkerInstance = undefined
pageViewportStore.clearPageViewports()
}
function addPage(name?: string) {
const pages = ctx.graph.getPages()
const pageName = name ?? `Page ${pages.length + 1}`
const page = ctx.graph.addPage(pageName)
setDefaultPageBackground(ctx.graph, page, ctx.state.theme)
void switchPage(page.id)
return page.id
}
function deletePage(pageId: string) {
const pages = ctx.graph.getPages()
if (pages.length <= 1) return
const idx = pages.findIndex((p) => p.id === pageId)
ctx.graph.deleteNode(pageId)
pageViewportStore.deletePageViewport(pageId)
if (ctx.state.currentPageId === pageId) {
const newIdx = Math.min(idx, pages.length - 2)
const remaining = ctx.graph.getPages()
void switchPage(remaining[newIdx].id)
}
}
function movePage(pageId: string, index: number) {
const pages = ctx.graph.getPages()
const currentIndex = pages.findIndex((page) => page.id === pageId)
if (currentIndex === -1) return
const nextIndex = Math.max(0, Math.min(index, pages.length - 1))
if (nextIndex === currentIndex) return
ctx.graph.insertChildAt(pageId, ctx.graph.rootId, nextIndex)
}
function renamePage(pageId: string, name: string) {
ctx.graph.updateNode(pageId, { name })
}
function setPageColor(color: Color) {
const page = ctx.graph.getNode(ctx.state.currentPageId)
if (!page) return
setPageBackgrounds(ctx.graph, page, [
{ type: 'SOLID', color: { ...color }, opacity: 1, visible: true, blendMode: 'NORMAL' }
])
syncPageColor()
ctx.requestRender()
}
/** Advances whenever a page switch starts, so a caller can tell it was overtaken. */
function pageSwitchCount(): number {
return pageSwitchGeneration
}
return {
loadPageNodes,
pageHoldingNode,
preparePageNodes,
pageSwitchCount,
preparePage,
commitPageSwitch,
switchPage,
switchToNextPage: () => switchToAdjacentPage(1),
switchToPreviousPage: () => switchToAdjacentPage(-1),
addPage,
deletePage,
movePage,
renamePage,
setPageColor,
clearPageViewports
}
}