Skip to content

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.md
new file mode 100644
index 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.ts
index 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 = null
r.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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 }]