Skip to content

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

fix: keep tiles on canvas resize and show opened pages only when fully drawn (#1753)

Danila Poyarkov4716fcdd93cd
diff --git a/changes/1753/breaking.md b/changes/1753/breaking.md
new file mode 100644
index 000000000..5957c1816
--- /dev/null
+++ b/changes/1753/breaking.md
@@ -0,0 +1 @@
+- `useCanvas` from `@open-pencil/vue/canvas/surface` no longer takes `onPresented`; listen for the editor's `render:presented` event with `editor.onEditorEvent('render:presented', …)`, which fires once a frame shows the whole visible scene (#1753).
diff --git a/changes/1753/fixed.md b/changes/1753/fixed.md
new file mode 100644
index 000000000..90f73d282
--- /dev/null
+++ b/changes/1753/fixed.md
@@ -0,0 +1 @@
+- Opening a document keeps the loader up until its page is fully drawn where it opens, instead of showing the canvas while it still fills in (#1753).
diff --git a/changes/1753/performance.md b/changes/1753/performance.md
new file mode 100644
index 000000000..d0648dca3
--- /dev/null
+++ b/changes/1753/performance.md
@@ -0,0 +1 @@
+- Resizing the canvas, such as dragging a panel, keeps what is already drawn and renders only the newly exposed edge, instead of blanking and redrawing the whole scene (#1753).
diff --git a/packages/core/src/canvas/images/state.ts b/packages/core/src/canvas/images/state.ts
index 378c4902b..e9cde5696 100644
--- a/packages/core/src/canvas/images/state.ts
+++ b/packages/core/src/canvas/images/state.ts
@@ -12,7 +12,7 @@ export interface RendererImages {
* Images drawn in place of stored ones while they play, such as a shader's live frames, each
* with the surface whose GL context holds its texture.
*/
- readonly live: Map<string, { image: Image; surface: Surface }>
+ readonly live: Map<string, { readonly image: Image; surface: Surface }>
/** The document and page whose images the cache and previews hold. */
memoryGraph: SceneGraph | null
memoryPage: string | null
diff --git a/packages/core/src/canvas/renderer.ts b/packages/core/src/canvas/renderer.ts
index 24cfc7982..157afa1d9 100644
--- a/packages/core/src/canvas/renderer.ts
+++ b/packages/core/src/canvas/renderer.ts
@@ -409,10 +409,21 @@ export class SkiaRenderer {
return RendererFonts.prepareForExport(this, graph, pageId, nodeIds)
}
- replaceSurface(surface: Surface): void {
- this.tiledScene.destroy()
- // Live textures belong to the old surface's context, so they go before it does.
- releaseLiveImages(this)
+ /**
+ * Draws into `surface` from now on. A surface on the same GPU context, such as the canvas
+ * resized, keeps the rendered tiles and live textures, which belong to the context; only
+ * newly exposed tiles render. A new context starts them over.
+ */
+ replaceSurface(surface: Surface, { sameContext = false }: { sameContext?: boolean } = {}): void {
+ if (sameContext) {
+ for (const live of this.images.live.values()) {
+ if (live.surface === this.surface) live.surface = surface
+ }
+ } else {
+ this.tiledScene.destroy()
+ // Live textures belong to the old surface's context, so they go before it does.
+ releaseLiveImages(this)
+ }
this.surface.delete()
this.surface = surface
this.invalidateScenePicture()
diff --git a/packages/core/src/canvas/renderer/pipeline.ts b/packages/core/src/canvas/renderer/pipeline.ts
index 44b7e93c6..37b2c38b1 100644
--- a/packages/core/src/canvas/renderer/pipeline.ts
+++ b/packages/core/src/canvas/renderer/pipeline.ts
@@ -306,7 +306,11 @@ export function render(
)
if (layer !== 'overlays') {
- if (requiresUncachedSceneRender) r.tiledScenePending = false
+ // Drawn directly, the whole scene is on screen this frame.
+ if (requiresUncachedSceneRender) {
+ r.tiledScenePending = false
+ r.tiledSceneCovered = true
+ }
canvas.save()
canvas.scale(r.dpr, r.dpr)
diff --git a/packages/core/src/editor/create.ts b/packages/core/src/editor/create.ts
index 95c84867b..129b5f36c 100644
--- a/packages/core/src/editor/create.ts
+++ b/packages/core/src/editor/create.ts
@@ -71,7 +71,8 @@ import type {
EditorEventName,
EditorEvents,
EditorOptions,
- EditorState
+ EditorState,
+ RenderVersions
} from './types'
import { createUndoActions } from './undo'
import { createVariableActions } from './variables'
@@ -151,6 +152,11 @@ export function createEditor(options?: EditorOptions) {
state.sceneVersion++
}
+ /** A canvas showed a frame of `versions` with nothing left to fill in. */
+ function reportPresented(versions: RenderVersions) {
+ emitEditorEvent('render:presented', versions)
+ }
+
function requestRepaint() {
state.renderVersion++
emitNavigationTrace('render:requested', {
@@ -456,6 +462,7 @@ export function createEditor(options?: EditorOptions) {
requestRefresh,
textSelectionChanged,
requestRepaint,
+ reportPresented,
onEditorEvent,
setCanvasKit,
setNavigationPhase,
diff --git a/packages/core/src/editor/index.ts b/packages/core/src/editor/index.ts
index 7d7f2c1b9..f329b13a2 100644
--- a/packages/core/src/editor/index.ts
+++ b/packages/core/src/editor/index.ts
@@ -78,6 +78,7 @@ export type {
EditorContext,
EditorEventName,
EditorEvents,
+ RenderVersions,
EditorOptions,
EditorState,
EditorSharedState,
diff --git a/packages/core/src/editor/types.ts b/packages/core/src/editor/types.ts
index b8de39e7a..be6c42ed8 100644
--- a/packages/core/src/editor/types.ts
+++ b/packages/core/src/editor/types.ts
@@ -217,9 +217,24 @@ export type FigmaClipboardImageResolver = (
hashes: string[]
) => Promise<ReadonlyMap<string, Uint8Array>>
+/**
+ * What a frame draws: `sceneVersion` counts the document's content, `renderVersion` everything
+ * on screen, the viewport included.
+ */
+export interface RenderVersions {
+ renderVersion: number
+ sceneVersion: number
+}
+
export interface EditorEvents extends SceneGraphEvents {
- 'render:requested': (versions: { renderVersion: number; sceneVersion: number }) => void
- 'repaint:requested': (versions: { renderVersion: number; sceneVersion: number }) => void
+ 'render:requested': (versions: RenderVersions) => void
+ 'repaint:requested': (versions: RenderVersions) => void
+ /**
+ * A canvas drawing the editor's own state showed a frame of these versions with the whole
+ * visible scene on screen, nothing left to fill in. Overlay-only canvases and split panes
+ * showing another view do not report.
+ */
+ 'render:presented': (versions: RenderVersions) => void
'graph:replaced': (graph: SceneGraph) => void
'document:color-space-changed': (colorSpace: DocumentColorSpace) => void
'document:libraries-changed': () => void
diff --git a/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue b/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue
index cb5a817a9..b97222ea9 100644
--- a/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue
+++ b/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue
@@ -37,9 +37,7 @@ const { hitTestSectionTitle, hitTestComponentLabel, hitTestFrameTitle, hitTestIs
showRulers: false,
shouldSuspendRender,
onReady: store.markCanvasReady,
- onViewportResize: (width, height) => store.setViewportSize(width, height),
- onPresented: ({ sceneVersion }) =>
- store.preparationController.acknowledgePresentation(sceneVersion)
+ onViewportResize: (width, height) => store.setViewportSize(width, height)
})
const { cursorOverride } = useCanvasInput(
diff --git a/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts b/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts
index f0dcc729a..0ba567956 100644
--- a/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts
+++ b/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts
@@ -42,10 +42,7 @@ export function useStageDocument(scene: SceneBuilder) {
// As the app does when it opens a page: render, and finish once that frame is on screen,
// so whatever stands in for the stage until now never gives way to an empty canvas.
preparation.update({ phase: 'preparing-render' })
- await store.preparationController.waitForPresentation(
- preparation.id,
- store.state.sceneVersion
- )
+ await store.preparationController.waitForPresentation(preparation.id, store.state)
preparation.complete()
ready.value = true
} catch (error) {
diff --git a/packages/vue/src/canvas/surface/lifecycle.ts b/packages/vue/src/canvas/surface/lifecycle.ts
index 9462b6641..ceb29e800 100644
--- a/packages/vue/src/canvas/surface/lifecycle.ts
+++ b/packages/vue/src/canvas/surface/lifecycle.ts
@@ -147,9 +147,18 @@ export function createCanvasSurfaceManager({
return true
}
- function acknowledgePresentation() {
+ /**
+ * Reports the frame as shown once the whole visible scene is on it. A scene frame with tiles
+ * still to draw is not: a loader waiting on it would give way to a canvas that then fills in.
+ * Only a canvas drawing the editor's own state reports, since the versions are the editor's:
+ * a split pane showing another view, perhaps another page, says nothing about this one.
+ */
+ function reportPresented(renderer: SkiaRenderer) {
+ const layer = options?.layer ?? 'full'
+ if (layer === 'overlays' || (layer === 'scene' && !renderer.tiledSceneCovered)) return
const renderedState = options?.getRenderState?.() ?? editor.state
- options?.onPresented?.({
+ if (renderedState !== editor.state) return
+ editor.reportPresented({
renderVersion: renderedState.renderVersion,
sceneVersion: renderedState.sceneVersion
})
@@ -181,7 +190,7 @@ export function createCanvasSurfaceManager({
)
renderLoop.markRendered()
options?.onFrame?.({ panX: view.panX, panY: view.panY, zoom: view.zoom })
- acknowledgePresentation()
+ reportPresented(state.renderer)
if (options?.layer === 'scene' && tileWorkPending(state.renderer)) {
renderLoop.markDirty()
}
@@ -218,8 +227,13 @@ export function createCanvasSurfaceManager({
createSurface(canvas, { reloadFonts: true })
return
}
- state.renderer.presentationColorSpace = result.presentation ?? 'srgb'
- state.renderer.replaceSurface(surface)
+ // Tiles keep the colours they were recorded in, so a resize that changes the presentation
+ // color space starts them over like a new context.
+ const presentation = result.presentation ?? 'srgb'
+ const sameContext =
+ result.glHandle === null && state.renderer.presentationColorSpace === presentation
+ state.renderer.presentationColorSpace = presentation
+ state.renderer.replaceSurface(surface, { sameContext })
renderNow()
}
diff --git a/packages/vue/src/canvas/surface/types.ts b/packages/vue/src/canvas/surface/types.ts
index 5de373786..e765fa93e 100644
--- a/packages/vue/src/canvas/surface/types.ts
+++ b/packages/vue/src/canvas/surface/types.ts
@@ -11,7 +11,6 @@ export type CanvasRenderLayer = 'full' | 'scene' | 'overlays'
export interface UseCanvasOptions {
shouldSuspendRender?: () => boolean
- onPresented?: (versions: { renderVersion: number; sceneVersion: number }) => void
/**
* Selects which render layer this canvas owns.
*/
diff --git a/src/app/document/io/read.ts b/src/app/document/io/read.ts
index 90204b8a7..a4225e6fd 100644
--- a/src/app/document/io/read.ts
+++ b/src/app/document/io/read.ts
@@ -68,6 +68,14 @@ export function createOpenActions({
await fitCurrentPageToViewport()
load.update({ phase: 'preparing-render', detail: state.documentName })
editor.requestRender()
+ // The document is open by now: a canvas that cannot show it fails the render, not the read.
+ await preparationController
+ .waitForPresentation(load.id, editor.state)
+ .catch((error: unknown) => {
+ const message = error instanceof Error ? error.message : String(error)
+ load.fail({ code: 'render-failed', message, retryable: true })
+ toast.error(notificationMessages.get().operationFailed({ error: message }))
+ })
succeeded = true
} catch (e) {
if (load.signal.aborted) return
diff --git a/src/app/editor/fonts/status.ts b/src/app/editor/fonts/status.ts
index 69cca49c5..b40d0b4a4 100644
--- a/src/app/editor/fonts/status.ts
+++ b/src/app/editor/fonts/status.ts
@@ -73,10 +73,7 @@ export function useDocumentFontStatus() {
preparation.update({ phase: 'preparing-render' })
editor.requestRender()
if (editor.renderer) {
- await editor.preparationController.waitForPresentation(
- preparation.id,
- editor.state.sceneVersion
- )
+ await editor.preparationController.waitForPresentation(preparation.id, editor.state)
}
refresh()
succeeded = true
diff --git a/src/app/editor/preparation/controller.ts b/src/app/editor/preparation/controller.ts
index 4bcf0959a..e1e38a842 100644
--- a/src/app/editor/preparation/controller.ts
+++ b/src/app/editor/preparation/controller.ts
@@ -1,5 +1,7 @@
import { TimeoutError } from 'es-toolkit/error'
+import type { Editor, RenderVersions } from '@open-pencil/core'
+
import type { EditorPreparationEventEmitter } from '@/app/editor/preparation/events'
import type {
BeginEditorPreparation,
@@ -13,7 +15,7 @@ import type { AppEditorState } from '@/app/editor/session/types'
const PRESENTATION_TIMEOUT_MS = 10_000
interface PresentationWaiter {
- sceneVersion: number
+ versions: RenderVersions
resolve: () => void
reject: (error: Error) => void
/** Runs only while a canvas shows the document, which is the only place it is presented. */
@@ -26,12 +28,19 @@ interface PresentationWaiter {
export interface EditorPreparationControllerOptions {
presentationTimeoutMs?: number
+ /** The editor whose canvases report frames shown, through `render:presented`. */
+ editor?: Pick<Editor, 'onEditorEvent'>
}
export interface EditorPreparationController {
begin(options: BeginEditorPreparation): EditorPreparationHandle
- acknowledgePresentation(sceneVersion: number): void
- waitForPresentation(id: number, sceneVersion: number): Promise<void>
+ /** A frame of these versions is fully shown; `render:presented` reports it from canvases. */
+ acknowledgePresentation(versions: RenderVersions): void
+ /**
+ * Resolves once a frame at least as new as `versions` in both is fully drawn. The versions are
+ * read when called, so an editor's live state can be passed.
+ */
+ waitForPresentation(id: number, versions: RenderVersions): Promise<void>
/**
* A canvas started showing the document; returns its detach. A tab in the background has no
* canvas, so its scene waits to be presented until the tab is shown, without timing out.
@@ -54,7 +63,10 @@ export function createEditorPreparationController(
let nextId = 0
let activeAbort: AbortController | null = null
let activeCancel: ((reason: EditorPreparationCancelReason) => void) | null = null
- let presentedSceneVersion = -1
+ /** The newest frame shown; its two versions came together, so one frame meets a wait. */
+ let presented: RenderVersions = { renderVersion: -1, sceneVersion: -1 }
+ const covers = (frame: RenderVersions, versions: RenderVersions) =>
+ frame.renderVersion >= versions.renderVersion && frame.sceneVersion >= versions.sceneVersion
let canvases = 0
let canvasFailure: Error | null = null
const presentationWaiters = new Map<number, PresentationWaiter>()
@@ -83,6 +95,18 @@ export function createEditorPreparationController(
const isActive = (id: number) => state.preparation?.id === id
+ function acknowledgePresentation(versions: RenderVersions) {
+ presented = { renderVersion: versions.renderVersion, sceneVersion: versions.sceneVersion }
+ for (const [id, waiter] of presentationWaiters) {
+ if (covers(presented, waiter.versions)) settle(id, null)
+ }
+ }
+
+ const stopPresentations = options.editor?.onEditorEvent(
+ 'render:presented',
+ acknowledgePresentation
+ )
+
return {
begin(options) {
activeCancel?.('superseded')
@@ -157,18 +181,13 @@ export function createEditorPreparationController(
cancel
}
},
- acknowledgePresentation(sceneVersion) {
- presentedSceneVersion = Math.max(presentedSceneVersion, sceneVersion)
- for (const [id, waiter] of presentationWaiters) {
- if (waiter.sceneVersion <= presentedSceneVersion) settle(id, null)
- }
- },
- waitForPresentation(id, sceneVersion) {
- if (!isActive(id) || presentedSceneVersion >= sceneVersion) return Promise.resolve()
+ acknowledgePresentation,
+ waitForPresentation(id, versions) {
+ if (!isActive(id) || covers(presented, versions)) return Promise.resolve()
settle(id, null)
return new Promise<void>((resolve, reject) => {
const waiter: PresentationWaiter = {
- sceneVersion,
+ versions: { renderVersion: versions.renderVersion, sceneVersion: versions.sceneVersion },
resolve,
reject,
timer: null,
@@ -203,6 +222,7 @@ export function createEditorPreparationController(
for (const id of presentationWaiters.keys()) settle(id, error)
},
dispose() {
+ stopPresentations?.()
activeCancel?.('tab-closed')
activeAbort?.abort()
activeAbort = null
diff --git a/src/app/editor/session/create.ts b/src/app/editor/session/create.ts
index f9a5956fe..06c728b7a 100644
--- a/src/app/editor/session/create.ts
+++ b/src/app/editor/session/create.ts
@@ -24,14 +24,18 @@ import {
type EditorPreparationEventName,
type EditorPreparationEvents
} from '@/app/editor/preparation/events'
-import { pageProgressUnit, type EditorPreparationHandle } from '@/app/editor/preparation/types'
+import { pageProgressUnit } from '@/app/editor/preparation/types'
import {
createEditorComputedRefs,
createEditorStoreModules,
defineEditorStoreAccessors
} from '@/app/editor/session/modules'
import { scopedStoreFactory } from '@/app/editor/session/scope'
-import { createInitialAppEditorState, type AppEditorState } from '@/app/editor/session/types'
+import {
+ createInitialAppEditorState,
+ type AppEditorState,
+ type AppSwitchPageOptions
+} from '@/app/editor/session/types'
import { notificationMessages } from '@/app/i18n/notifications'
import { createDeferred } from '@/app/runtime/deferred'
import { toast } from '@/app/shell/ui'
@@ -133,7 +137,9 @@ function buildEditorStore(initialGraph?: SceneGraph) {
})
preparationLifecycle.delete(failure.id)
})
- const preparationController = createEditorPreparationController(state, preparationEvents)
+ const preparationController = createEditorPreparationController(state, preparationEvents, {
+ editor
+ })
const modules = createEditorStoreModules(editor, state, io, viewportSize, preparationController)
// ─── Public API ───────────────────────────────────────────────
@@ -141,17 +147,7 @@ function buildEditorStore(initialGraph?: SceneGraph) {
const panes = createCanvasPaneRegistry(state)
- async function switchPage(
- pageId: string,
- options: {
- preparation?: EditorPreparationHandle
- onProgress?: Parameters<typeof editor.switchPage>[1] extends infer Options
- ? Options extends { onProgress?: infer Progress }
- ? Progress
- : never
- : never
- } = {}
- ) {
+ async function switchPage(pageId: string, options: AppSwitchPageOptions = {}) {
const page = editor.graph.getNode(pageId)
const preparation =
options.preparation ??
@@ -177,7 +173,9 @@ function buildEditorStore(initialGraph?: SceneGraph) {
if (prepared) {
editor.commitPageSwitch(prepared)
preparation.update({ phase: 'preparing-render', detail: page?.name ?? null })
- await preparationController.waitForPresentation(preparation.id, editor.state.sceneVersion)
+ await options.beforePresentation?.()
+ preparation.signal.throwIfAborted()
+ await preparationController.waitForPresentation(preparation.id, editor.state)
preparation.signal.throwIfAborted()
}
succeeded = true
diff --git a/src/app/editor/session/types.ts b/src/app/editor/session/types.ts
index 1bf0d26ca..276a9d7ca 100644
--- a/src/app/editor/session/types.ts
+++ b/src/app/editor/session/types.ts
@@ -1,8 +1,12 @@
-import { createDefaultEditorState, type EditorState } from '@open-pencil/core'
+import {
+ createDefaultEditorState,
+ type EditorState,
+ type SwitchPageOptions
+} from '@open-pencil/core'
import type { DocumentColorSpace } from '@open-pencil/scene-graph'
import type { PresentationColorSpace } from '@open-pencil/vue/canvas/surface'
-import type { EditorPreparation } from '@/app/editor/preparation/types'
+import type { EditorPreparation, EditorPreparationHandle } from '@/app/editor/preparation/types'
import type { NodeEditState } from '@/app/editor/vector/types'
import { appPreferences } from '@/app/settings/preferences/store'
import { resolvedAppTheme } from '@/app/shell/theme'
@@ -63,3 +67,15 @@ export type AppEditorState = EditorState & {
/** Mirror of the document's color space, kept reactive for UI. */
documentColorSpace: DocumentColorSpace
}
+
+/** How the app switches pages: inside a preparation, with the loader up until the page is shown. */
+export interface AppSwitchPageOptions {
+ /** The preparation the switch belongs to, such as a document opening; else it starts its own. */
+ preparation?: EditorPreparationHandle
+ /**
+ * Runs once the page is committed and before its first frame counts as shown, such as
+ * fitting the viewport, so what appears is drawn where it will stay.
+ */
+ beforePresentation?: () => void | Promise<void>
+ onProgress?: SwitchPageOptions['onProgress']
+}
diff --git a/src/app/tabs/index.ts b/src/app/tabs/index.ts
index a4404a24b..d3d485612 100644
--- a/src/app/tabs/index.ts
+++ b/src/app/tabs/index.ts
@@ -363,15 +363,20 @@ async function showImportedGraph(
const firstPageId = store.graph.getPages()[0]?.id ?? store.graph.rootId
const pageId = remembered?.pageId ?? firstPageId
load?.update({ phase: 'populating-page', detail: store.graph.getNode(pageId)?.name ?? null })
- await store.switchPage(pageId, { preparation: load })
+ // The view is placed before the first frame counts as shown, so the loader gives way to the
+ // page drawn where it opens rather than one that then moves and fills in.
+ await store.switchPage(pageId, {
+ preparation: load,
+ beforePresentation: async () => {
+ if (remembered) {
+ await yieldToUI()
+ store.centerOn(remembered.center.x, remembered.center.y, remembered.zoom)
+ } else {
+ await store.fitCurrentPageToViewport()
+ }
+ }
+ })
load?.signal.throwIfAborted()
- load?.update({ phase: 'preparing-render', detail: store.state.documentName })
- if (remembered) {
- await yieldToUI()
- store.centerOn(remembered.center.x, remembered.center.y, remembered.zoom)
- } else {
- await store.fitCurrentPageToViewport()
- }
}
async function cacheOpenedFigCover(path: string, store: EditorStore): Promise<void> {
diff --git a/src/components/EditorCanvas.vue b/src/components/EditorCanvas.vue
index d57f1ada5..0d4dcc42a 100644
--- a/src/components/EditorCanvas.vue
+++ b/src/components/EditorCanvas.vue
@@ -125,8 +125,6 @@ useCanvas(sceneCanvasRef, store, {
showRulers: false,
getRenderState,
onViewportResize,
- onPresented: ({ sceneVersion }) =>
- store.preparationController.acknowledgePresentation(sceneVersion),
onPresentation: (colorSpace) => {
store.state.canvasPresentation = colorSpace
}
diff --git a/tests/app/ai/chat/trace/rebuild.test.ts b/tests/app/ai/chat/trace/rebuild.test.ts
index 6f697b685..a7f6c7e97 100644
--- a/tests/app/ai/chat/trace/rebuild.test.ts
+++ b/tests/app/ai/chat/trace/rebuild.test.ts
@@ -69,7 +69,10 @@ async function recordRun({ steps, contextLimits }: RunOptions) {
api.currentPage = api.wrapNode(pageId ?? editor.state.currentPageId)
return api
})
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
aiToolOverrides.value = { create_shape: true }
let call = 0
diff --git a/tests/app/ai/reply/run.test.ts b/tests/app/ai/reply/run.test.ts
index 07d7683b9..46d4a6d31 100644
--- a/tests/app/ai/reply/run.test.ts
+++ b/tests/app/ai/reply/run.test.ts
@@ -102,7 +102,10 @@ async function withStore(
return api
})
// No canvas presents frames here; treat every page switch as presented.
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
try {
aiToolOverrides.value = { create_shape: true, switch_page: true }
const a = store.state.currentPageId
diff --git a/tests/app/automation/bridge/handlers.test.ts b/tests/app/automation/bridge/handlers.test.ts
index bb756d737..d030198b8 100644
--- a/tests/app/automation/bridge/handlers.test.ts
+++ b/tests/app/automation/bridge/handlers.test.ts
@@ -44,7 +44,7 @@ async function settle<T>(pending: Promise<T>): Promise<T> {
const idle = Symbol('idle')
for (const tab of getTabsSnapshot()) {
if (tab.store.state.preparation?.phase !== 'preparing-render') continue
- tab.store.preparationController.acknowledgePresentation(tab.store.state.sceneVersion)
+ tab.store.preparationController.acknowledgePresentation(tab.store.state)
}
const result = await Promise.race([
pending,
diff --git a/tests/app/comments/session.test.ts b/tests/app/comments/session.test.ts
index cba2c7f8a..2acca225a 100644
--- a/tests/app/comments/session.test.ts
+++ b/tests/app/comments/session.test.ts
@@ -126,7 +126,10 @@ test('going to a comment opens its page and its thread', async () => {
const store = openDocument()
const first = store.state.currentPageId
const added = comment(store, 40, 40, 'on page one')
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
await store.switchPage(store.graph.addPage('Second').id)
expect(store.state.currentPageId).not.toBe(first)
diff --git a/tests/app/editor/preparation/controller.test.ts b/tests/app/editor/preparation/controller.test.ts
index d78ff8f74..2730a6cea 100644
--- a/tests/app/editor/preparation/controller.test.ts
+++ b/tests/app/editor/preparation/controller.test.ts
@@ -1,10 +1,15 @@
import { describe, expect, jest, test } from 'bun:test'
+import { createEditor } from '@open-pencil/core'
+
import { createEditorPreparationController } from '@/app/editor/preparation/controller'
import { createEditorPreparationEvents } from '@/app/editor/preparation/events'
import type { EditorPreparationResult } from '@/app/editor/preparation/types'
import { createInitialAppEditorState } from '@/app/editor/session/types'
+/** Versions of a frame whose view and scene both reached `version`. */
+const at = (version: number) => ({ renderVersion: version, sceneVersion: version })
+
describe('editor preparation controller', () => {
test('keeps one reactive preparation snapshot until its owner finishes', () => {
const state = createInitialAppEditorState('page')
@@ -55,24 +60,92 @@ describe('editor preparation controller', () => {
expect(state.preparation).toBeNull()
})
+ test('hears frames shown on the editor bus until disposed', async () => {
+ const state = createInitialAppEditorState('page')
+ const editor = createEditor()
+ const controller = createEditorPreparationController(state, undefined, { editor })
+ const first = controller.begin({ kind: 'page-switch' })
+ const waiting = controller.waitForPresentation(first.id, at(3))
+ editor.reportPresented(at(3))
+ await waiting
+ first.complete()
+
+ controller.dispose()
+ const second = controller.begin({ kind: 'page-switch' })
+ let settled = false
+ void controller.waitForPresentation(second.id, at(4)).finally(() => {
+ settled = true
+ })
+ editor.reportPresented(at(4))
+ await Promise.resolve()
+ expect(settled).toBe(false)
+ })
+
+ test('waits for a frame of both the scene and the view, such as a fit after the page', async () => {
+ const state = createInitialAppEditorState('page')
+ const controller = createEditorPreparationController(state)
+ const handle = controller.begin({ kind: 'page-switch' })
+
+ let presented = false
+ const waiting = controller
+ .waitForPresentation(handle.id, { renderVersion: 9, sceneVersion: 7 })
+ .then(() => {
+ presented = true
+ return presented
+ })
+ // The page's scene drawn at the view it had before the fit does not count.
+ controller.acknowledgePresentation({ renderVersion: 8, sceneVersion: 7 })
+ await Promise.resolve()
+ expect(presented).toBe(false)
+
+ controller.acknowledgePresentation({ renderVersion: 9, sceneVersion: 7 })
+ await waiting
+ expect(presented).toBe(true)
+ handle.complete()
+ })
+
+ test('waits for the scene as well as the view, and for one frame that has both', async () => {
+ const state = createInitialAppEditorState('page')
+ const controller = createEditorPreparationController(state)
+ const handle = controller.begin({ kind: 'page-switch' })
+
+ let presented = false
+ const waiting = controller
+ .waitForPresentation(handle.id, { renderVersion: 9, sceneVersion: 7 })
+ .then(() => {
+ presented = true
+ return presented
+ })
+ // The view without the scene, then the scene in an older view: neither frame has both.
+ controller.acknowledgePresentation({ renderVersion: 9, sceneVersion: 6 })
+ controller.acknowledgePresentation({ renderVersion: 8, sceneVersion: 7 })
+ await Promise.resolve()
+ expect(presented).toBe(false)
+
+ controller.acknowledgePresentation({ renderVersion: 9, sceneVersion: 7 })
+ await waiting
+ expect(presented).toBe(true)
+ handle.complete()
+ })
+
test('waits for the prepared scene to be presented before finishing', async () => {
const state = createInitialAppEditorState('page')
const controller = createEditorPreparationController(state)
const handle = controller.begin({ kind: 'page-switch' })
let presented = false
- const waiting = controller.waitForPresentation(handle.id, 7).then(() => {
+ const waiting = controller.waitForPresentation(handle.id, at(7)).then(() => {
presented = true
return presented
})
await Promise.resolve()
expect(presented).toBe(false)
- controller.acknowledgePresentation(6)
+ controller.acknowledgePresentation(at(6))
await Promise.resolve()
expect(presented).toBe(false)
- controller.acknowledgePresentation(7)
+ controller.acknowledgePresentation(at(7))
await waiting
expect(presented).toBe(true)
handle.complete()
@@ -85,7 +158,7 @@ describe('editor preparation controller', () => {
const handle = controller.begin({ kind: 'page-switch' })
controller.attachCanvas()
- await expect(controller.waitForPresentation(handle.id, 7)).rejects.toHaveProperty(
+ await expect(controller.waitForPresentation(handle.id, at(7))).rejects.toHaveProperty(
'message',
'The operation was timed out'
)
@@ -101,7 +174,7 @@ describe('editor preparation controller', () => {
})
const handle = controller.begin({ kind: 'page-switch' })
let settled = false
- const waiting = controller.waitForPresentation(handle.id, 7).finally(() => {
+ const waiting = controller.waitForPresentation(handle.id, at(7)).finally(() => {
settled = true
})
// A tab opened in the background: nothing draws it, and that is not a failure.
@@ -118,7 +191,7 @@ describe('editor preparation controller', () => {
expect(settled).toBe(false)
controller.attachCanvas()
- controller.acknowledgePresentation(7)
+ controller.acknowledgePresentation(at(7))
await waiting
handle.complete()
} finally {
@@ -132,20 +205,20 @@ describe('editor preparation controller', () => {
const failure = new Error('The canvas could not start')
const first = controller.begin({ kind: 'page-switch' })
- const waiting = controller.waitForPresentation(first.id, 7)
+ const waiting = controller.waitForPresentation(first.id, at(7))
controller.failCanvas(failure)
await expect(waiting).rejects.toBe(failure)
first.fail({ code: 'render-failed', message: failure.message, retryable: true })
const second = controller.begin({ kind: 'page-switch' })
- await expect(controller.waitForPresentation(second.id, 8)).rejects.toBe(failure)
+ await expect(controller.waitForPresentation(second.id, at(8))).rejects.toBe(failure)
second.fail({ code: 'render-failed', message: failure.message, retryable: true })
// A canvas that starts later presents scenes again.
controller.attachCanvas()
const third = controller.begin({ kind: 'page-switch' })
- const presenting = controller.waitForPresentation(third.id, 9)
- controller.acknowledgePresentation(9)
+ const presenting = controller.waitForPresentation(third.id, at(9))
+ controller.acknowledgePresentation(at(9))
await presenting
third.complete()
})
@@ -156,7 +229,7 @@ describe('editor preparation controller', () => {
const failure = new Error('The canvas could not start')
const handle = controller.begin({ kind: 'page-switch' })
const detach = controller.attachCanvas()
- const waiting = controller.waitForPresentation(handle.id, 7)
+ const waiting = controller.waitForPresentation(handle.id, at(7))
// Another pane fails while this one still draws; then this one closes before presenting.
controller.failCanvas(failure)
detach()
@@ -173,7 +246,7 @@ describe('editor preparation controller', () => {
})
const handle = controller.begin({ kind: 'page-switch' })
let failure: unknown = null
- const waiting = controller.waitForPresentation(handle.id, 7).catch((error: unknown) => {
+ const waiting = controller.waitForPresentation(handle.id, at(7)).catch((error: unknown) => {
failure = error
})
// Two visits of 60 ms each: the scene had longer than its 100 ms to draw.
@@ -184,7 +257,7 @@ describe('editor preparation controller', () => {
jest.advanceTimersByTime(60)
await Promise.resolve()
expect(failure).toHaveProperty('message', 'The operation was timed out')
- controller.acknowledgePresentation(7)
+ controller.acknowledgePresentation(at(7))
await waiting
handle.fail({ code: 'render-failed', message: 'Timed out', retryable: true })
} finally {
diff --git a/tests/app/editor/session/page-switch.test.ts b/tests/app/editor/session/page-switch.test.ts
index c5081b471..cc21557fa 100644
--- a/tests/app/editor/session/page-switch.test.ts
+++ b/tests/app/editor/session/page-switch.test.ts
@@ -8,7 +8,7 @@ test('a page switch overtaken by another resolves instead of rejecting', async (
// Stand in for the canvas, which acknowledges each scene it presents.
store.onPreparationEvent('preparation:updated', (preparation) => {
if (preparation.phase === 'preparing-render')
- store.preparationController.acknowledgePresentation(store.state.sceneVersion)
+ store.preparationController.acknowledgePresentation(store.state)
})
const b = store.graph.addPage('B').id
const c = store.graph.addPage('C').id
diff --git a/tests/app/presence/registry.test.ts b/tests/app/presence/registry.test.ts
index d241fcd5b..d7130a4e6 100644
--- a/tests/app/presence/registry.test.ts
+++ b/tests/app/presence/registry.test.ts
@@ -80,7 +80,10 @@ test('follows the page on screen', async () => {
const { store, other } = setup()
addAgent(store, 'chat').update({ status: 'editing', cursor: { x: 1, y: 1, pageId: other } })
expect(store.state.presenceCursors).toHaveLength(0)
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
await store.switchPage(other)
expect(store.state.presenceCursors).toHaveLength(1)
})
@@ -93,7 +96,10 @@ function centered(store: ReturnType<typeof createEditorStore>) {
test('following an agent takes the view to its page and keeps its cursor centered', async () => {
const { store, other } = setup()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
const agent = addAgent(store, 'chat')
agent.update({ status: 'editing', cursor: { x: 300, y: 200, pageId: other } })
const switched = new Promise<string>((resolve) => {
@@ -131,7 +137,10 @@ test('following a person matches their zoom, and stops when they leave', () => {
test('switching to another page yourself stops following', async () => {
const { store, pageId, other } = setup()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
const ana = { clientId: 4, name: 'Ana', color: red, agents: [] }
setPeers(store, [{ ...ana, cursor: { x: 40, y: 50, pageId, zoom: 1 } }])
follow(store, { kind: 'person', clientId: 4 })
@@ -142,7 +151,10 @@ test('switching to another page yourself stops following', async () => {
test('following survives the target moving on while its page switch is in flight', async () => {
const { store, other } = setup()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
const third = store.graph.addPage('Third').id
const agent = addAgent(store, 'chat')
agent.update({ status: 'editing', cursor: { x: 10, y: 10, pageId: other } })
@@ -161,7 +173,10 @@ test('following survives the target moving on while its page switch is in flight
test('switching pages yourself stops following a resting agent too', async () => {
const { store, other } = setup()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
const agent = addAgent(store, 'chat')
follow(store, { kind: 'agent', agentId: agent.id })
await store.switchPage(other)
@@ -191,7 +206,10 @@ test('zooming yourself stops following', () => {
test('cursor updates while heading to a page do not restart the switch', async () => {
const { store, other } = setup()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
const switchPage = spyOn(store, 'switchPage')
const agent = addAgent(store, 'chat')
agent.update({ status: 'editing', cursor: { x: 10, y: 10, pageId: other } })
@@ -226,7 +244,10 @@ test('a cursor on a page this document lacks is waited out, not switched to', ()
test('stopping while following heads to another page stays where you are', async () => {
const { store, pageId, other } = setup()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
const agent = addAgent(store, 'chat')
agent.update({ status: 'editing', cursor: { x: 10, y: 10, pageId: other } })
follow(store, { kind: 'agent', agentId: agent.id })
diff --git a/tests/app/recent-files/view.test.ts b/tests/app/recent-files/view.test.ts
index 11027a1ee..6d6eaf45f 100644
--- a/tests/app/recent-files/view.test.ts
+++ b/tests/app/recent-files/view.test.ts
@@ -37,7 +37,10 @@ describe("a document's remembered view", () => {
const store = openedFromPath()
rememberRecentFile(PATH, 'design')
const second = store.graph.addPage('Second').id
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
await store.switchPage(second)
store.centerOn(300, 200, 2)
@@ -81,7 +84,10 @@ describe("a document's remembered view", () => {
}))
expect(rememberedDocumentView(store)).toBeNull()
- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)
+ store.preparationController.acknowledgePresentation({
+ renderVersion: Number.MAX_SAFE_INTEGER,
+ sceneVersion: Number.MAX_SAFE_INTEGER
+ })
await store.switchPage(hidden.id)
rememberDocumentView(store)
expect(recentDocuments.value[0]?.view?.pageId).toBe(hidden.id)
diff --git a/tests/engine/app/tabs/open-file-dedup.test.ts b/tests/engine/app/tabs/open-file-dedup.test.ts
index 459a929d5..b11bb353f 100644
--- a/tests/engine/app/tabs/open-file-dedup.test.ts
+++ b/tests/engine/app/tabs/open-file-dedup.test.ts
@@ -57,7 +57,7 @@ function setupGlobals() {
function acknowledgePendingPresentation(): void {
for (const tab of getTabsSnapshot()) {
if (tab.store.state.preparation?.phase !== 'preparing-render') continue
- tab.store.preparationController.acknowledgePresentation(tab.store.state.sceneVersion)
+ tab.store.preparationController.acknowledgePresentation(tab.store.state)
}
}
diff --git a/tests/engine/render/canvas/surface-replacement.test.ts b/tests/engine/render/canvas/surface-replacement.test.ts
index c3d35a76a..94c4db430 100644
--- a/tests/engine/render/canvas/surface-replacement.test.ts
+++ b/tests/engine/render/canvas/surface-replacement.test.ts
@@ -1,6 +1,6 @@
import { describe, expect, mock, test } from 'bun:test'
-import type { Surface } from 'canvaskit-wasm'
+import type { Image, Surface } from 'canvaskit-wasm'
import { SkiaRenderer } from '#core/canvas/renderer'
@@ -10,24 +10,54 @@ function surface() {
return { delete: mock() } as Surface & { delete: ReturnType<typeof mock> }
}
+function liveImage() {
+ return asDouble<Image & { delete: ReturnType<typeof mock> }>({ delete: mock() })
+}
+
+function rendererOn(previous: Surface, image: Image) {
+ const renderer: Pick<
+ SkiaRenderer,
+ 'surface' | 'images' | 'tiledScene' | 'invalidateScenePicture' | 'replaceSurface'
+ > = {
+ surface: previous,
+ images: asDouble<SkiaRenderer['images']>({
+ live: new Map([['shader', { image, surface: previous }]])
+ }),
+ tiledScene: asDouble<SkiaRenderer['tiledScene']>({ destroy: mock() }),
+ invalidateScenePicture: mock(),
+ replaceSurface: SkiaRenderer.prototype.replaceSurface
+ }
+ return renderer
+}
+
describe('renderer surface replacement', () => {
- test('clears context-owned tiled resources before replacing the main surface', () => {
+ test('clears context-owned resources when the surface comes from a new context', () => {
const previous = surface()
const next = surface()
- const renderer: Pick<
- SkiaRenderer,
- 'surface' | 'images' | 'tiledScene' | 'invalidateScenePicture' | 'replaceSurface'
- > = {
- surface: previous,
- images: asDouble<SkiaRenderer['images']>({ live: new Map() }),
- tiledScene: asDouble<SkiaRenderer['tiledScene']>({ destroy: mock() }),
- invalidateScenePicture: mock(),
- replaceSurface: SkiaRenderer.prototype.replaceSurface
- }
+ const image = liveImage()
+ const renderer = rendererOn(previous, image)
renderer.replaceSurface.call(asRenderer(renderer), next)
expect(renderer.tiledScene.destroy).toHaveBeenCalledTimes(1)
+ expect(image.delete).toHaveBeenCalledTimes(1)
+ expect(renderer.images.live.size).toBe(0)
+ expect(previous.delete).toHaveBeenCalledTimes(1)
+ expect(renderer.surface).toBe(next)
+ expect(renderer.invalidateScenePicture).toHaveBeenCalledTimes(1)
+ })
+
+ test('keeps tiles and live textures when the surface shares the context, as on resize', () => {
+ const previous = surface()
+ const next = surface()
+ const image = liveImage()
+ const renderer = rendererOn(previous, image)
+
+ renderer.replaceSurface.call(asRenderer(renderer), next, { sameContext: true })
+
+ expect(renderer.tiledScene.destroy).not.toHaveBeenCalled()
+ expect(image.delete).not.toHaveBeenCalled()
+ expect(renderer.images.live.get('shader')).toEqual({ image, surface: next })
expect(previous.delete).toHaveBeenCalledTimes(1)
expect(renderer.surface).toBe(next)
expect(renderer.invalidateScenePicture).toHaveBeenCalledTimes(1)