AI-native design editor. Open-source Figma alternative.
fix: undo a panel edit made while text is edited with the shortcut (#1563)
Danila Poyarkov54e079a9a65e
diff --git a/changes/1563/fixed.md b/changes/1563/fixed.mdnew file mode 100644index 000000000..b7852d3ef--- /dev/null+++ b/changes/1563/fixed.md@@ -0,0 +1 @@+- The undo shortcut undoes a panel edit made while text is edited, such as a typed font size, instead of doing nothing.diff --git a/packages/core/src/canvas/renderer/lifecycle.ts b/packages/core/src/canvas/renderer/lifecycle.tsindex f635bbbc8..542c1ece5 100644--- a/packages/core/src/canvas/renderer/lifecycle.ts+++ b/packages/core/src/canvas/renderer/lifecycle.ts@@ -55,10 +55,13 @@ export function destroyRenderer(r: SkiaRenderer): void {r.componentLabelFont?.delete()r.fontMgr?.delete()const fontProvider = r.fontProvider- fontProvider?.delete()r.fontProvider = nullr.fontsLoaded = false- fontManager.detachProvider(fontProvider)+ // Only its own provider: a renderer that never loaded fonts leaves the others' attached.+ if (fontProvider) {+ fontManager.detachProvider(fontProvider)+ fontProvider.delete()+ }r.rulerBgPaint.delete()r.rulerTickPaint.delete()r.rulerTextPaint.delete()diff --git a/packages/core/src/editor/text.ts b/packages/core/src/editor/text.tsindex 11c51cec1..803593bad 100644--- a/packages/core/src/editor/text.ts+++ b/packages/core/src/editor/text.ts@@ -255,7 +255,16 @@ export function createTextActions(ctx: EditorContext) {recordTextEdit(textState)change()const node = ctx.graph.getNode(textState.nodeId)- if (!node) return+ if (!node) {+ // The change took the text away, such as an undo past the step that made it: the edit+ // ends with it, recording nothing of a node that is gone.+ te.stop()+ ctx.state.editingTextId = null+ activeSession = null+ restoreEmptyLabel = null+ ctx.requestRender()+ return+ }activeSession = createTextEditSession(node)te.syncToNode(node)ctx.requestRender()diff --git a/packages/core/src/text/fonts.ts b/packages/core/src/text/fonts.tsindex ac8d80707..ede0a582e 100644--- a/packages/core/src/text/fonts.ts+++ b/packages/core/src/text/fonts.ts@@ -176,13 +176,7 @@ export class FontManager {}}- detachProvider(provider?: TypefaceFontProvider | null): void {- if (!provider) {- this.fontProviders.clear()- this.fontProvider = null- this.providerRegistrations = new WeakMap()- return- }+ detachProvider(provider: TypefaceFontProvider): void {this.fontProviders.delete(provider)this.providerRegistrations.delete(provider)if (this.fontProvider === provider) {diff --git a/packages/core/tests/canvas/renderer/lifecycle.test.ts b/packages/core/tests/canvas/renderer/lifecycle.test.tsnew file mode 100644index 000000000..46b479eb4--- /dev/null+++ b/packages/core/tests/canvas/renderer/lifecycle.test.ts@@ -0,0 +1,24 @@+import { expect, test } from 'bun:test'++import { expectDefined } from '#core-tests/helpers/assert'++import { SkiaRenderer } from '#core/canvas'+import { initCanvasKit } from '#core/io/formats/raster/headless'+import { fontManager } from '#core/text/fonts'++const ck = await initCanvasKit()++const renderer = () => new SkiaRenderer(ck, expectDefined(ck.MakeSurface(1, 1), 'surface'))++test('destroying a renderer that never loaded fonts leaves the others their fonts', async () => {+ const drawing = renderer()+ await drawing.loadFonts()+ const provider = expectDefined(drawing.getFontProvider(), 'font provider')+ try {+ renderer().destroy()+ expect(fontManager.provider()).toBe(provider)+ } finally {+ drawing.destroy()+ }+ expect(fontManager.provider()).not.toBe(provider)+})diff --git a/packages/core/tests/canvas/text/faces.test.ts b/packages/core/tests/canvas/text/faces.test.tsindex 3b26fea0a..c4fb57d83 100644--- a/packages/core/tests/canvas/text/faces.test.ts+++ b/packages/core/tests/canvas/text/faces.test.ts@@ -99,10 +99,14 @@ describe('text faces', () => {const ck = await getCanvasKit()const fontProvider = ck.TypefaceFontProvider.Make()fontManager.attachProvider(ck, fontProvider)- await fontManager.markLoaded(FAMILY, 'Regular', await bundled('/InterVariable.ttf'))- const regular = drawn(ck, fontProvider, { fontWeight: 400, italic: false })- expect(drawn(ck, fontProvider, { fontWeight: 400, italic: true })).toEqual(regular)- expect(drawn(ck, fontProvider, { fontWeight: 700, italic: false })).toEqual(regular)+ // A family of its own, whose Bold and italic no other test loads.+ const fontFamily = 'Faces Test Missing'+ await fontManager.markLoaded(fontFamily, 'Regular', await bundled('/InterVariable.ttf'))+ const face = (weight: number, italic: boolean) =>+ drawn(ck, fontProvider, { fontFamily, fontWeight: weight, italic })+ const regular = face(400, false)+ expect(face(400, true)).toEqual(regular)+ expect(face(700, false)).toEqual(regular)})test('draws a face the family has loaded', async () => {diff --git a/packages/core/tests/canvas/text/shape.test.ts b/packages/core/tests/canvas/text/shape.test.tsindex c03c8946d..59aa23432 100644--- a/packages/core/tests/canvas/text/shape.test.ts+++ b/packages/core/tests/canvas/text/shape.test.ts@@ -36,15 +36,16 @@ async function shape(props: Partial<SceneNode>): Promise<ShapedText | null> {)}-describe('text shaping for saved glyphs', () => {- beforeAll(async () => {- const inter = expectDefined(- await fontManager.fetchBundledFont('/InterVariable.ttf'),- 'bundled Inter font'- )- await fontManager.markLoaded('Inter', 'Regular', inter)- })+// Every test here shapes Inter, in whatever order they run.+beforeAll(async () => {+ const inter = expectDefined(+ await fontManager.fetchBundledFont('/InterVariable.ttf'),+ 'bundled Inter font'+ )+ await fontManager.markLoaded('Inter', 'Regular', inter)+})+describe('text shaping for saved glyphs', () => {/*** Figma saves every emoji as a 1 em square, a joined sequence or a flag as one: the layout* falls back to the emoji metrics font for them, which gives them that width.diff --git a/src/app/shell/keyboard/registry.ts b/src/app/shell/keyboard/registry.tsindex 1724a8359..c0c457c2c 100644--- a/src/app/shell/keyboard/registry.ts+++ b/src/app/shell/keyboard/registry.ts@@ -2,6 +2,7 @@ import { useEventListener } from '@vueuse/core'import { createKeybindingsHandler } from 'tinykeys'import type { KeyBindingMap } from 'tinykeys'+import { isCanvasTextInput } from '@open-pencil/vue/canvas/text-edit'import { editorCommandMetadata, type EditorCommandId } from '@open-pencil/vue/editor/commands'import { isCloudBinding, openVersionDialog } from '@/app/cloud/integration'@@ -113,6 +114,16 @@ function hasOpenDismissableLayer(allowPickers = false) {)}+/**+ * While text is edited its input handles the keys, undo and redo among them. Focus can leave it+ * for a panel field while the edit stays open, as after a typed font size; undo and redo then+ * run on the editor's history, which records the text edit's steps, rather than go nowhere.+ */+function editingTextHandles(options: KeyboardShortcutOptions, history: boolean) {+ if (!options.store.state.editingTextId) return false+ return !history || isCanvasTextInput(document.activeElement)+}+/*** Other shortcuts wait for open popovers to close, but undo and redo work while a fill, stroke,* or colour picker is open, as in Figma; a text field in it keeps its own undo.@@ -128,7 +139,7 @@ function shouldIgnoreShortcut(originatedInOverlay(event, history) ||isEditing(event) ||options.inputFocused.value ||- !!options.store.state.editingTextId ||+ editingTextHandles(options, history) ||!!options.store.state.numberFieldFocused)}diff --git a/tests/e2e/text/editing.spec.ts b/tests/e2e/text/editing.spec.tsindex 8dc079191..4edabc211 100644--- a/tests/e2e/text/editing.spec.ts+++ b/tests/e2e/text/editing.spec.ts@@ -163,3 +163,36 @@ test('Enter key opens text editing and selects all without erasing', async () =>})expect(after).toBe('Keep this text')})++test('the undo shortcut undoes a panel edit made while text is edited', async () => {+ await editor.page.keyboard.press('Escape')+ await editor.page.evaluate(() => {+ const store = window.openPencil?.getStore?.()+ if (!store) throw new Error('OpenPencil store not initialized')+ const id = store.createShape('TEXT', 300, 400, 200, 30)+ store.graph.updateNode(id, { text: 'Keep this text' })+ store.select([id])+ })+ await editor.canvas.waitForRender()+ // Enter edits the text with every character selected.+ await editor.page.keyboard.press('Enter')+ const runs = () =>+ editor.page.evaluate(() => {+ const store = window.openPencil?.getStore?.()+ if (!store) throw new Error('OpenPencil store not initialized')+ const id = store.state.editingTextId+ return id ? (store.graph.getNode(id)?.styleRuns ?? null) : null+ })+ await expect.poll(runs).toEqual([])++ // Every character is selected, so the size styles them; Enter leaves the field.+ const size = editor.page.getByRole('spinbutton', { name: 'Font size' })+ await size.click()+ await editor.page.keyboard.press('ControlOrMeta+a')+ await editor.page.keyboard.type('30')+ await editor.page.keyboard.press('Enter')+ await expect.poll(runs).toEqual([{ start: 0, length: 14, style: { fontSize: 30 } }])++ await editor.page.keyboard.press('ControlOrMeta+z')+ await expect.poll(runs).toEqual([])+})diff --git a/tests/engine/text/edit-undo.test.ts b/tests/engine/text/edit-undo.test.tsindex 9e31be74c..a64feb90e 100644--- a/tests/engine/text/edit-undo.test.ts+++ b/tests/engine/text/edit-undo.test.ts@@ -163,6 +163,29 @@ describe('text edit undo', () => {expect(getNodeOrThrow(graph, textNode.id).text).toBe('Hello World')})+ test('ends the edit when an undo takes the text away, and leaves its redo in place', () => {+ const { graph, undo, textEditor, state, textNode, actions } = setup()+ const pageId = state.currentPageId+ const snapshot = structuredClone(textNode)+ // The step that made the text, as a duplicate or a paste records one.+ undo.push({+ label: 'Duplicate',+ forward: () => graph.createNodeWithId(snapshot.id, 'TEXT', pageId, snapshot),+ inverse: () => graph.deleteNode(snapshot.id)+ })+ actions.startTextEditing(textNode.id)++ actions.runTextEditStep(() => undo.undo())+ expect(graph.getNode(textNode.id)).toBeUndefined()+ expect(textEditor.isActive).toBe(false)+ expect(state.editingTextId).toBeNull()++ actions.runTextEditStep(() => undo.redo())+ expect(graph.getNode(textNode.id)).toBeDefined()+ expect(undo.canUndo).toBe(true)+ expect(undo.undoLabel).toBe('Duplicate')+ })+test('undoes a change made while editing on its own, then the typing before it', () => {const { graph, undo, textEditor, textNode, actions } = setup()const listed = [{ listType: 'ORDERED' as const, indentation: 1 }]