Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

:bug: Preserve mind map state during undo and redo https://github.com/siyuan-note/siyuan/issues/20854

Daniel000875a98f0e
diff --git a/app/src/protyle/render/listMindmap/focus.test.ts b/app/src/protyle/render/listMindmap/focus.test.ts
index 457303a959..8efe68c10f 100644
--- a/app/src/protyle/render/listMindmap/focus.test.ts
+++ b/app/src/protyle/render/listMindmap/focus.test.ts
@@ -21,11 +21,13 @@ const visit = (item: import("typescript").Node) => {
};
visit(controller);
assert.ok(editorUndo);
-const compiled = transpileModule(`class Controller {
+const compiled = transpileModule(readFileSync("src/protyle/undo/viewport.ts", "utf8").replace(/^export /gm, "") + `
+class Controller {
${methods.map(item => item.getText(source)).join("\n")}
makeEditorUndo(id) { return ${editorUndo}; }
}
-globalThis.Controller = Controller;`, {compilerOptions: {target: ScriptTarget.ES2021}}).outputText;
+globalThis.Controller = Controller;
+globalThis.isUndoViewportPreserved = isUndoViewportPreserved;`, {compilerOptions: {target: ScriptTarget.ES2021}}).outputText;
test("canvas history follows embedded source documents, local stacks, busy state and subscription lifetime", () => {
const listeners = new Map<string, () => void>();
@@ -82,10 +84,38 @@ test("new mind map nodes become selected before editing", async () => {
assert.deepEqual(steps, ["focus:new", "edit:new"]);
});
+test("canvas undo and redo preserve the viewport throughout replay and release it on errors", async () => {
+ const editor = {isConnected: true};
+ let fail = false;
+ const history = async () => {
+ assert.equal(context.isUndoViewportPreserved(editor), true);
+ await Promise.resolve();
+ assert.equal(context.isUndoViewportPreserved(editor), true);
+ if (fail) { throw new Error("history failed"); }
+ };
+ const owner = {block: {rootID: "doc"}, wysiwyg: {element: editor}, undo: {undo: history, redo: history}};
+ const roots = new WeakMap([[owner, {focusRevision: 0, restoreFocus() {}}]]);
+ const context: any = {roots, canEdit: () => true, cleanListMindmapHTML: (html: string) => html,
+ hasMindmapFocusOverlay: () => false};
+ runInNewContext(compiled, context);
+ const target = Object.assign(new context.Controller(), {owner,
+ list: {dataset: {nodeId: "map"}, outerHTML: "map", isConnected: true, closest: (): null => null},
+ model: {nodes: new Map()}, view: {getSelectedId: (): undefined => undefined},
+ });
+ for (const redo of [false, true]) {
+ await target.undo(redo);
+ assert.equal(context.isUndoViewportPreserved(editor), false);
+ fail = true;
+ await assert.rejects(target.undo(redo), /history failed/);
+ assert.equal(context.isUndoViewportPreserved(editor), false);
+ fail = false;
+ }
+});
+
test("embedded history uses the source document and transaction owner without depending on the selection", async () => {
for (const lite of [false, true]) {
const submitted: unknown[] = [];
- const mainOwner = {lite: false};
+ const mainOwner = {lite: false, wysiwyg: {element: {}}};
const owner = {lite, block: {rootID: "host-document"}, wysiwyg: {element: {isConnected: true}},
undo: {undo: assert.fail, redo: assert.fail}};
const embed = {dataset: {rootId: "source-document"}};
@@ -134,7 +164,10 @@ test("undo from a node editor restores that node or its previous sibling", async
const target = new context.Controller();
Object.assign(target, {
owner, list: {dataset: {nodeId: "map"}, isConnected: true, outerHTML: "map", closest: (): null => null}, model: {nodes, root},
- view: {getSelectedId: () => "root", focusNode: (id: string) => selected.push(id)},
+ view: {getSelectedId: () => "root", focusNode: (id: string, reveal: boolean) => {
+ assert.equal(reveal, false, "history selection must not reveal or pan to the node");
+ selected.push(id);
+ }},
});
roots.set(owner, {restoreFocus: (_listID: string, ids: string[]) => target.focusNode(ids)});
const onEditorUndo = target.makeEditorUndo("new");
diff --git a/app/src/protyle/render/listMindmap/history.test.ts b/app/src/protyle/render/listMindmap/history.test.ts
index 47bbc30298..7c505b7f1b 100644
--- a/app/src/protyle/render/listMindmap/history.test.ts
+++ b/app/src/protyle/render/listMindmap/history.test.ts
@@ -56,9 +56,11 @@ const browserCases = async (source: string, css: string) => {
`${key} fits the ${width}px canvas at scale ${scale}`);
}
};
- visible();
check.equal(button("undo").disabled, true); check.equal(button("redo").disabled, true);
+ check.equal(button("undo").getClientRects().length, 0, "empty history hides both controls");
+ check.equal(button("redo").getClientRects().length, 0);
view.setUndoState({canUndo: true, canRedo: false});
+ await settle(); visible();
const bounds = button("undo").getBoundingClientRect();
await require("electron").ipcRenderer.invoke("mindmap-history-touch", [
{type: "touchStart", touchPoints: [{id: 1, x: (bounds.left + bounds.right) / 2, y: (bounds.top + bounds.bottom) / 2}]},
@@ -71,6 +73,11 @@ const browserCases = async (source: string, css: string) => {
check.ok(!document.activeElement.matches("input, textarea, [contenteditable='true']"), "undo does not focus text input");
check.equal(outer.scrollTop, 220, "history activation preserves document scroll position");
view.setUndoState({canUndo: false, canRedo: true}); release(); await settle();
+ visible();
+ view.offsetX = 500; view.offsetY = -500; view.draw(); await settle();
+ view.focusNode(model.root.id, false); await settle();
+ check.deepEqual([view.offsetX, view.offsetY, outer.scrollTop], [500, -500, 220],
+ "history restores an offscreen node selection without panning the canvas or scrolling the document");
check.equal(button("undo").disabled, true); check.equal(button("redo").disabled, false);
button("redo").focus();
check.equal(document.activeElement, button("redo"));
@@ -80,6 +87,38 @@ const browserCases = async (source: string, css: string) => {
button("undo").click(); await settle();
check.equal(undo, 1, "failed pending edits prevent history execution");
check.equal(button("undo").disabled, false, "canceled execution releases the local busy state");
+ finishAllowed = true;
+ const selectedID = model.root.children[0].id;
+ const selectedNode = host.querySelector<HTMLElement>(`[data-mindmap-id="${selectedID}"]`);
+ view.focusNode(selectedID, false);
+ const mouseClick = async (key: string) => {
+ const rect = button(key).getBoundingClientRect();
+ await require("electron").ipcRenderer.invoke("mindmap-history-mouse", {
+ x: (rect.left + rect.right) / 2, y: (rect.top + rect.bottom) / 2,
+ });
+ await settle();
+ check.equal(view.getSelectedId(), selectedID, "history pointerdown preserves the selected node");
+ check.equal(selectedNode.classList.contains("mindmap-view__node--selected"), true,
+ "the node selection cannot disappear while history is pending");
+ };
+ await mouseClick("undo");
+ check.equal(undo, 2);
+ check.equal(button("undo").disabled, true);
+ view.setUndoState({canUndo: false, canRedo: true}); release(); await settle();
+ await mouseClick("redo");
+ check.equal(redo, 2);
+ view.setUndoState({canUndo: true, canRedo: false});
+ const touchBounds = button("undo").getBoundingClientRect();
+ await require("electron").ipcRenderer.invoke("mindmap-history-touch", [
+ {type: "touchStart", touchPoints: [{id: 1, x: (touchBounds.left + touchBounds.right) / 2,
+ y: (touchBounds.top + touchBounds.bottom) / 2}]},
+ {type: "touchEnd", touchPoints: []},
+ ]);
+ await settle();
+ check.equal(undo, 3);
+ check.equal(view.getSelectedId(), selectedID, "touch undo also keeps the selected node visible while pending");
+ check.equal(selectedNode.classList.contains("mindmap-view__node--selected"), true);
+ view.setUndoState({canUndo: true, canRedo: false}); release(); await settle();
stage = "short";
outer.style.height = "60px"; outer.dispatchEvent(new Event("scroll")); await settle(); visible();
outer.style.height = "360px"; outer.dispatchEvent(new Event("scroll")); await settle();
@@ -91,6 +130,9 @@ const browserCases = async (source: string, css: string) => {
check.equal(button("undo"), null); check.equal(button("redo"), null);
view.setReadOnly(false); await settle(); visible();
check.equal(button("undo").disabled, false);
+ view.setUndoState({canUndo: false, canRedo: false}); await settle();
+ check.equal(button("undo").getClientRects().length, 0, "clearing both histories hides the controls again");
+ check.equal(button("redo").getClientRects().length, 0);
check.equal(holder.innerHTML, original, "history controls never write document metadata");
view.destroy(); outer.remove();
}
@@ -98,7 +140,7 @@ const browserCases = async (source: string, css: string) => {
return "Mindmap history controls passed";
};
-test("desktop and mobile canvas history stays visible and supports touch, keyboard, pending and read-only states", {
+test("desktop and mobile canvas history hides empty controls and preserves selection through touch, mouse and keyboard", {
skip: process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY, timeout: 60000,
}, async () => {
const source = ["../av/richTextValue.ts", "summary.ts", "connectors.ts", "appearance.ts", "model.ts", "fold.ts", "routing.ts", "pan.ts", "view.ts"]
@@ -121,6 +163,7 @@ await win.webContents.debugger.sendCommand("Emulation.setTouchEmulationEnabled",
try{for(const event of events){await win.webContents.debugger.sendCommand("Input.dispatchTouchEvent",event);await new Promise(resolve=>setTimeout(resolve,30));}}
finally{await win.webContents.debugger.sendCommand("Emulation.setTouchEmulationEnabled",{enabled:false});}});
ipcMain.handle("mindmap-history-key",()=>{win.webContents.sendInputEvent({type:"keyDown",keyCode:"Return"});win.webContents.sendInputEvent({type:"char",keyCode:"\\r"});win.webContents.sendInputEvent({type:"keyUp",keyCode:"Return"});});
+ipcMain.handle("mindmap-history-mouse",(_event,point)=>{for(const type of ["mouseDown","mouseUp"]){win.webContents.sendInputEvent({type,...point,button:"left",clickCount:1});}});
try{await win.loadURL("data:text/html,<html><body></body></html>");
await win.webContents.executeJavaScript(require("fs").readFileSync(${JSON.stringify(path.resolve(__dirname, "../../../../stage/protyle/js/lute/lute.min.js"))},"utf8"));
console.log(await win.webContents.executeJavaScript(${JSON.stringify(`const __name=value=>value;(${browserSource})(${JSON.stringify(source)},${JSON.stringify(css)})`)}));
diff --git a/app/src/protyle/render/listMindmap/index.ts b/app/src/protyle/render/listMindmap/index.ts
index 1bdd12e1ed..8d02925fc6 100644
--- a/app/src/protyle/render/listMindmap/index.ts
+++ b/app/src/protyle/render/listMindmap/index.ts
@@ -59,6 +59,7 @@ import {getDefaultListMindmapConnectorStyle, setDefaultListMindmapConnectorStyle
import {assignListMindmapBranchColors, getListMindmapAppearanceMenu} from "./appearance";
import {getEmbedChildOperationContext} from "../../wysiwyg/getBlock";
import {getUndoStateSnapshot, hasUndoStateMirror, initMirror, requestRedo, requestUndo, subscribeUndoState} from "../../undo/globalUndo";
+import {preserveUndoViewport} from "../../undo/viewport";
import {buildBlockDOMClipboardData} from "../../util/blockDOMClipboard";
import {buildWebClipboardHTML, getTextSiyuanFromTextHTML} from "../../util/clipboardData";
import {readClipboard, writeClipboardData} from "../../util/compatibility";
@@ -993,6 +994,7 @@ class ListMindmapController {
const editorRoot = this.owner.wysiwyg.element;
const documentID = this.owner.block.rootID;
const notebookID = this.owner.notebookId;
+ const releaseViewport = preserveUndoViewport(editorRoot);
const guard = () => roots.get(this.owner) === root && editorRoot.isConnected &&
this.owner.block.rootID === documentID && this.owner.notebookId === notebookID &&
root?.interactionRevision === interactionRevision && !hasMindmapFocusOverlay();
@@ -1007,7 +1009,7 @@ class ListMindmapController {
}
const before = cleanListMindmapHTML(this.list.outerHTML);
if (editingID && guard()) {
- this.view.focusNode(editingID);
+ this.view.focusNode(editingID, false);
}
const focusRevision = root?.focusRevision;
const sourceRootID = this.list.closest<HTMLElement>(".protyle-wysiwyg__embed")?.dataset.rootId;
@@ -1016,7 +1018,12 @@ class ListMindmapController {
const owner = this.owner.lite && getProtyleTransactionOwner(this.owner,
[{action: "update", id: this.list.dataset.nodeId, data: before}]) || this.owner;
if (!owner.lite) {
- await (redo ? requestRedo(owner, sourceRootID) : requestUndo(owner, sourceRootID));
+ const releaseOwnerViewport = preserveUndoViewport(owner.wysiwyg.element);
+ try {
+ await (redo ? requestRedo(owner, sourceRootID) : requestUndo(owner, sourceRootID));
+ } finally {
+ releaseOwnerViewport();
+ }
if (this.owner.lite && this.list.isConnected && !this.disposed) {
// 全屏中的片段不在外层编辑器内,按源块补齐撤销结果,并保留等待期间的新修改。
const snapshot = cleanListMindmapHTML(this.list.outerHTML);
@@ -1039,6 +1046,7 @@ class ListMindmapController {
root?.restoreFocus(this.list.dataset.nodeId, candidateIDs, unchanged ? selection : undefined, this.list);
}
} finally {
+ releaseViewport();
if (root?.focusGuard === guard) {
root.focusGuard = undefined;
root.undoPending = false;
@@ -1052,7 +1060,7 @@ class ListMindmapController {
return;
}
const id = candidateIDs.find(id => this.model.nodes.has(id)) || this.model.root.id;
- this.view.focusNode(id);
+ this.view.focusNode(id, false);
const node = this.model.nodes.get(id);
const content = selection && node && !node.virtual && this.view.getContentHost(id);
const ids = new Set(node?.contentBlocks?.flatMap(block => [block, ...Array.from(block.querySelectorAll("[data-node-id]"))])
diff --git a/app/src/protyle/render/listMindmap/model.test.ts b/app/src/protyle/render/listMindmap/model.test.ts
index becbceb0ba..5981d6bfa0 100644
--- a/app/src/protyle/render/listMindmap/model.test.ts
+++ b/app/src/protyle/render/listMindmap/model.test.ts
@@ -392,6 +392,7 @@ const browserCases = async (sourceCode: string, css: string, taskSource: string,
getUndoStateSnapshot: () => ({canUndo: true, canRedo: true, pending: false}),
hasUndoStateMirror: () => true,
subscribeUndoState: (_rootID: string, listener: () => void) => { listener(); return () => {}; },
+ preserveUndoViewport: () => () => {},
isEncryptedBox: () => false,
setStorageVal: () => check.fail("Embedded previews cannot persist viewport positions"),
fetchSyncPost: async () => ({code: 0, data: {dom: full}}),
@@ -1826,8 +1827,10 @@ const browserCases = async (sourceCode: string, css: string, taskSource: string,
view.setEditing();
view.update(api.readListMindmap(list));
check.equal(host.querySelector<HTMLButtonElement>('[aria-label="undo"]').disabled, true,
- "the canvas exposes undo while an empty history keeps it disabled");
+ "an empty history keeps undo disabled");
check.equal(host.querySelector<HTMLButtonElement>('[aria-label="redo"]').disabled, true);
+ check.equal(host.querySelector<HTMLButtonElement>('[aria-label="undo"]').hidden, true);
+ check.equal(host.querySelector<HTMLButtonElement>('[aria-label="redo"]').hidden, true);
check.equal(undo, 0);
check.equal(redo, 0);
finishAllowed = false;
@@ -2129,6 +2132,7 @@ const browserCases = async (sourceCode: string, css: string, taskSource: string,
check.equal(fitButton.parentElement, toolbarPopup, "fit shares the zoom panel with the slider and reset");
check.equal(toolbarGroup.querySelector(':scope > [aria-label="listMindmapFit"]'), null,
"fit no longer occupies a separate top-level toolbar slot");
+ view.setUndoState({canUndo: true, canRedo: false});
for (const width of [96, 180, 240, 260, 320, 360, 700]) {
for (const fontSize of [14, 32]) {
host.style.width = `${width}px`;
@@ -2182,6 +2186,7 @@ const browserCases = async (sourceCode: string, css: string, taskSource: string,
}
}
}
+ view.setUndoState({canUndo: false, canRedo: false});
host.style.cssText = originalHostStyle;
host.focus();
view.zoomAt(1);
diff --git a/app/src/protyle/render/listMindmap/view.ts b/app/src/protyle/render/listMindmap/view.ts
index b0d33298f7..fb2339bc20 100644
--- a/app/src/protyle/render/listMindmap/view.ts
+++ b/app/src/protyle/render/listMindmap/view.ts
@@ -516,6 +516,7 @@ export class ListMindmapView {
}
if (this.inspector.contains(target) || this.inspectorPopover.contains(target) || this.buttons.get("style")?.contains(target) ||
this.buttons.get("relation")?.contains(target) || this.buttons.get("expandLevel")?.contains(target) ||
+ this.buttons.get("undo")?.contains(target) || this.buttons.get("redo")?.contains(target) ||
this.buttons.get("summary")?.contains(target) || this.buttons.get("multiSelect")?.contains(target) ||
this.levelSelect?.contains(target)) {
return;
@@ -563,13 +564,16 @@ export class ListMindmapView {
}
private updateUndoControls() {
+ const hidden = !this.undoState.canUndo && !this.undoState.canRedo && !this.historyPending;
for (const key of ["undo", "redo"] as const) {
const button = this.buttons.get(key);
if (button) {
+ button.hidden = hidden;
button.disabled = this.readOnly || this.historyPending || this.undoState.pending ||
!(key === "undo" ? this.undoState.canUndo : this.undoState.canRedo);
}
}
+ this.queueInspectorLayout();
}
private async runHistory(redo: boolean) {
@@ -1239,15 +1243,17 @@ export class ListMindmapView {
.filter(id => this.model.nodes.has(id)) : [];
}
- public focusNode(id: string) {
+ public focusNode(id: string, reveal = true) {
if (this.destroyed || !this.model.nodes.has(id)) {
return;
}
this.setInteractionActive(true);
this.selectNode(id);
this.options.host.focus({preventScroll: true});
- this.queueInspectorLayout(true);
- this.revealNode(id);
+ this.queueInspectorLayout(reveal);
+ if (reveal) {
+ this.revealNode(id);
+ }
}
public setEditing(id?: string) {
diff --git a/app/src/protyle/undo/globalUndo.test.ts b/app/src/protyle/undo/globalUndo.test.ts
index 8a91f27365..86e606803f 100644
--- a/app/src/protyle/undo/globalUndo.test.ts
+++ b/app/src/protyle/undo/globalUndo.test.ts
@@ -3,21 +3,37 @@ import {readFileSync} from "node:fs";
import test from "node:test";
import {runInNewContext} from "node:vm";
import {ScriptTarget, transpileModule} from "typescript";
+import {isUndoViewportPreserved, preserveUndoViewport} from "./viewport";
const compiled = transpileModule(readFileSync("src/protyle/undo/globalUndo.ts", "utf8")
.replace(/^import [\s\S]*?;\r?\n/gm, "").replace(/^export /gm, "") +
- ";globalThis.api = {markMirror, getMirror, getUndoStateSnapshot, subscribeUndoState, syncMirrorFromBroadcast, initMirror, requestUndo, requestRedo};",
+ ";globalThis.api = {markMirror, getMirror, getUndoStateSnapshot, subscribeUndoState, syncMirrorFromBroadcast, initMirror, requestUndo, requestRedo, focusRootIDs};",
{compilerOptions: {target: ScriptTarget.ES2021}}).outputText;
const load = (extra: Record<string, unknown> = {}) => {
- const context: any = {console, Constants: {SIYUAN_APPID: "test"},
+ const context: any = {console, Constants: {SIYUAN_APPID: "test"}, isUndoViewportPreserved,
getMobileToolbarProtyle: (): undefined => undefined, getCurrentEditor: (): undefined => undefined,
getSelection: () => ({rangeCount: 0}), waitForPendingTransactions: async () => {}, ...extra};
runInNewContext(compiled, context);
- return context.api as typeof import("./globalUndo");
+ return context.api as typeof import("./globalUndo") & {focusRootIDs: (ids: string[], focus?: string) => void};
};
const plain = (value: unknown) => JSON.parse(JSON.stringify(value));
+test("canvas history does not scroll to an offscreen historical block, while ordinary history still locates it", () => {
+ let scrolls = 0;
+ const target = {getBoundingClientRect: () => ({top: -300, bottom: -200}), scrollIntoView: () => scrolls++};
+ const root = {querySelectorAll: () => [target]} as unknown as Element;
+ const owner = {block: {rootID: "doc"}, wysiwyg: {element: root}};
+ const api = load({getCurrentEditor: () => ({protyle: owner}), window: {innerHeight: 800},
+ getUndoFocusTarget: (targets: unknown[]) => targets[0]});
+ const release = preserveUndoViewport(root);
+ api.focusRootIDs(["doc"], "offscreen");
+ assert.equal(scrolls, 0);
+ release();
+ api.focusRootIDs(["doc"], "offscreen");
+ assert.equal(scrolls, 1);
+});
+
test("history subscriptions follow their document, include broadcasts and dispose independently", () => {
const api = load();
const first: unknown[] = [];
diff --git a/app/src/protyle/undo/globalUndo.ts b/app/src/protyle/undo/globalUndo.ts
index 37e248d589..a78fc41a0c 100644
--- a/app/src/protyle/undo/globalUndo.ts
+++ b/app/src/protyle/undo/globalUndo.ts
@@ -7,6 +7,7 @@ import {hasClosestByClassName} from "../util/hasClosest";
import {getUndoFocusTarget} from "../util/selectionFocus";
import {isKnownTransactionOperation} from "../util/transactionContract";
import type {APIPOSTRoutes} from "../../types/api";
+import {isUndoViewportPreserved} from "./viewport";
/// #if !MOBILE
import {getActiveTab} from "../../layout/tabUtil";
/// #endif
@@ -229,7 +230,8 @@ const resolveRootNames = async (rootIDs: string[]): Promise<string[]> => {
const focusRootIDs = (rootIDs: string[], focusBlockId?: string) => {
// 只滚动发起窗口的焦点 protyle 到变更块;其他文档不强制重开(撤销物理结果在发起文档)
const protyle = getActiveProtyle();
- if (protyle && rootIDs.includes(protyle.block?.rootID) && focusBlockId) {
+ if (protyle && !isUndoViewportPreserved(protyle.wysiwyg.element) &&
+ rootIDs.includes(protyle.block?.rootID) && focusBlockId) {
const targets = Array.from(protyle.wysiwyg.element.querySelectorAll(`[data-node-id="${focusBlockId}"]`));
const selection = getSelection();
const range = selection.rangeCount > 0 ? selection.getRangeAt(0) : undefined;
diff --git a/app/src/protyle/undo/viewport.test.ts b/app/src/protyle/undo/viewport.test.ts
new file mode 100644
index 0000000000..5195d5da18
--- /dev/null
+++ b/app/src/protyle/undo/viewport.test.ts
@@ -0,0 +1,63 @@
+import * as assert from "node:assert/strict";
+import {readFileSync} from "node:fs";
+import test from "node:test";
+import {runInNewContext} from "node:vm";
+import {ModuleKind, ScriptTarget, transpileModule} from "typescript";
+import {isUndoViewportPreserved, preserveUndoViewport} from "./viewport";
+
+test("canvas history suppresses caret scrolling only in its editor and releases nested scopes independently", () => {
+ const scrolled: unknown[] = [];
+ class Target {
+ getBoundingClientRect() { return {top: -300, bottom: -200, height: 100}; }
+ }
+ const root = {closest: (): null => null} as unknown as Element;
+ const other = {closest: (): null => null} as unknown as Element;
+ const editor = (element: Element) => ({wysiwyg: {element}, contentElement: {
+ scrollTop: 500, getBoundingClientRect: () => ({top: 0, bottom: 400, height: 400}),
+ scroll: (options: unknown) => scrolled.push(options),
+ }});
+ const code = transpileModule(readFileSync("src/util/highlightById.ts", "utf8"), {
+ compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
+ }).outputText;
+ const exports: {scrollCenter?: (owner: unknown, target: unknown) => void} = {};
+ runInNewContext(code, {exports, HTMLElement: Target, getSelection: () => ({rangeCount: 0}),
+ require: () => ({isUndoViewportPreserved, resolveVisibleListMindmapBlock: (): undefined => undefined,
+ revealTabsForTarget() {}})});
+ const stop = preserveUndoViewport(root);
+ const stopNested = preserveUndoViewport(root);
+ exports.scrollCenter(editor(root), new Target());
+ assert.equal(scrolled.length, 0);
+ exports.scrollCenter(editor(other), new Target());
+ assert.equal(scrolled.length, 1, "history does not block scrolling another document");
+ stop(); stop();
+ exports.scrollCenter(editor(root), new Target());
+ assert.equal(scrolled.length, 1, "disposing twice cannot release the nested operation");
+ stopNested();
+ exports.scrollCenter(editor(root), new Target());
+ assert.equal(scrolled.length, 2, "ordinary caret scrolling resumes after history");
+ assert.equal(isUndoViewportPreserved(root), false);
+});
+
+test("embedded history retains its viewport choice until asynchronous rendering finishes", () => {
+ const source = readFileSync("src/protyle/wysiwyg/transaction.ts", "utf8");
+ const start = source.indexOf(" const preserveViewport = isUndoViewportPreserved(");
+ const end = source.indexOf(" queueHeadingNumberRefresh", start);
+ assert.ok(start > 0 && end > start);
+ const code = transpileModule(source.slice(start, end), {compilerOptions: {target: ScriptTarget.ES2021}}).outputText;
+ let complete: () => void;
+ let focused = 0;
+ let scrolled = 0;
+ const root = {} as Element;
+ const replay = new Function("isUndoViewportPreserved", "protyle", "pendingUndoEmbedElements", "blockRender",
+ "restoreUndoFocus", "scrollCenter", "operations", code);
+ const render = () => replay(isUndoViewportPreserved, {wysiwyg: {element: root}},
+ new Set([{isConnected: true, removeAttribute() {}}]),
+ (_owner: unknown, _item: unknown, _options: unknown, callback: () => void) => complete = callback,
+ () => { focused++; return true; }, () => scrolled++, []);
+ const release = preserveUndoViewport(root);
+ render(); release(); complete();
+ assert.equal(focused, 1, "embedded selection restoration still finishes");
+ assert.equal(scrolled, 0, "late rendering cannot scroll after the history request has completed");
+ render(); complete();
+ assert.equal(scrolled, 1, "ordinary embedded history retains its caret scrolling");
+});
diff --git a/app/src/protyle/undo/viewport.ts b/app/src/protyle/undo/viewport.ts
new file mode 100644
index 0000000000..8c4e93c8dd
--- /dev/null
+++ b/app/src/protyle/undo/viewport.ts
@@ -0,0 +1,21 @@
+const preservedViewports = new WeakMap<Element, number>();
+
+export const isUndoViewportPreserved = (root: Element) => preservedViewports.has(root);
+
+// 画布历史只回放内容和选择,不按正文光标或历史节点重新定位视口。
+export const preserveUndoViewport = (root: Element) => {
+ preservedViewports.set(root, (preservedViewports.get(root) || 0) + 1);
+ let active = true;
+ return () => {
+ if (!active) {
+ return;
+ }
+ active = false;
+ const remaining = (preservedViewports.get(root) || 1) - 1;
+ if (remaining) {
+ preservedViewports.set(root, remaining);
+ } else {
+ preservedViewports.delete(root);
+ }
+ };
+};
diff --git a/app/src/protyle/wysiwyg/transaction.ts b/app/src/protyle/wysiwyg/transaction.ts
index 58e6d430de..b54c976ada 100644
--- a/app/src/protyle/wysiwyg/transaction.ts
+++ b/app/src/protyle/wysiwyg/transaction.ts
@@ -44,6 +44,7 @@ import {reloadProtyle} from "../util/reload";
import {countBlockWord} from "../../layout/status";
import {resize} from "../util/resize";
import {scrollCenter} from "../../util/highlightById";
+import {isUndoViewportPreserved} from "../undo/viewport";
import {consumeGutterFoldRestore} from "../ui/gutterVisibility";
import {setFold} from "../util/blockFold";
import {refreshHeadingFoldIndicators} from "../util/headingFoldIndicator";
@@ -1573,13 +1574,14 @@ export const onTransaction = (protyle: IProtyle, operations: IOperation[], isUnd
syncTrackedRanges(protyle, operations);
}
void applyViewFoldStates(protyle);
+ const preserveViewport = isUndoViewportPreserved(protyle.wysiwyg.element);
pendingUndoEmbedElements.forEach(item => {
if (!item.isConnected) {
return;
}
item.removeAttribute("data-render");
blockRender(protyle, item, undefined, () => {
- if (restoreUndoFocus(protyle, operations)) {
+ if (restoreUndoFocus(protyle, operations) && !preserveViewport) {
scrollCenter(protyle);
}
});
diff --git a/app/src/protyle/wysiwyg/transactionInsertRendering.test.ts b/app/src/protyle/wysiwyg/transactionInsertRendering.test.ts
index c4edb537b4..19cc19ed88 100644
--- a/app/src/protyle/wysiwyg/transactionInsertRendering.test.ts
+++ b/app/src/protyle/wysiwyg/transactionInsertRendering.test.ts
@@ -3,6 +3,7 @@ import {readFileSync} from "node:fs";
import {test} from "node:test";
import {runInNewContext} from "node:vm";
import {ModuleKind, ScriptTarget, transpileModule} from "typescript";
+import {isUndoViewportPreserved} from "../undo/viewport";
const compiled = transpileModule(readFileSync("src/protyle/wysiwyg/transaction.ts", "utf8"), {
compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
@@ -172,6 +173,7 @@ const fixture = (containerType: ContainerType = "editor") => {
const identity = (value: string) => value;
const record = (kind: keyof typeof rendered, element: TestElement) => rendered[kind].push(element.getAttribute("data-node-id"));
const dependencies = {
+ isUndoViewportPreserved,
Constants: {CUSTOM_SY_AV_STATIC_TEXT: "custom-sy-av-s-text-"},
normalizeHTMLAssetIFrameBlockDOM: identity,
invalidateTrackedRangesByOperations: noop, invalidateViewFoldRequests: noop,
diff --git a/app/src/util/highlightById.ts b/app/src/util/highlightById.ts
index 5a774a5830..794e70268d 100644
--- a/app/src/util/highlightById.ts
+++ b/app/src/util/highlightById.ts
@@ -5,6 +5,7 @@ import {getEditorRange} from "../protyle/util/selection";
import {focusByRange} from "../protyle/util/selectionOffsets";
import {getStartScrollTop} from "./highlightPosition";
import {isMobile} from "./functions";
+import {isUndoViewportPreserved} from "../protyle/undo/viewport";
export const bgFade = (element: Element) => {
element.classList.add("protyle-wysiwyg--hl");
@@ -60,6 +61,9 @@ export const scrollCenter = (
position: ScrollLogicalPosition = "nearest",
behavior: ScrollBehavior = "auto"
) => {
+ if (isUndoViewportPreserved(protyle.wysiwyg.element)) {
+ return;
+ }
if (nodeElement instanceof HTMLElement) {
const visible = resolveVisibleListMindmapBlock(nodeElement);
if (visible === null) {