Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(project-tree): Undo restores files deleted in the Project view (#1103)

l0ng-ai5ad5dc2a285b
diff --git a/src/features/app/appActions.ts b/src/features/app/appActions.ts
index 39f33ce9f..383dbf650 100644
--- a/src/features/app/appActions.ts
+++ b/src/features/app/appActions.ts
@@ -3,7 +3,7 @@ import { EditorView } from "@codemirror/view";
import type { Action } from "@/platform/actions";
import { t } from "@/platform/i18n";
import { call, commands, isTauri } from "@/platform/ipc";
-import { maybeEditorService, notifications } from "@/workbench/contributions";
+import { maybeEditorService, notifications, runUndoHandlers } from "@/workbench/contributions";
import { showAbout } from "./AboutDialog";
import { quitApp } from "./closeGuard";
import { guessOs } from "./host";
@@ -46,6 +46,7 @@ export function editCommand(command: "undo" | "redo" | "cut" | "copy" | "paste"
(command === "undo" ? undo : redo)(view);
return;
}
+ if (focused instanceof Element && runUndoHandlers(command, focused)) return;
}
if (command === "paste" && navigator.clipboard?.readText) {
void navigator.clipboard.readText().then((text) => document.execCommand("insertText", false, text));
diff --git a/src/features/project-tree/ProjectView.tsx b/src/features/project-tree/ProjectView.tsx
index b0f1fa9d8..c09523c9d 100644
--- a/src/features/project-tree/ProjectView.tsx
+++ b/src/features/project-tree/ProjectView.tsx
@@ -60,7 +60,6 @@ import { relativePath } from "@/platform/project";
import { folderKind } from "./folderKind";
import { useHomeDir } from "./home";
import { keyLike, memberNodes, nodeKeyFor, visibleInfo, type ProjectNode } from "./model";
-import { lastFileRefactoring, undoFileRefactoring } from "./fileRefactor";
import {
cancelEditing,
checkEditingName,
@@ -77,6 +76,7 @@ import {
paste,
refreshOsClipboard,
targetFolder,
+ undoLastFileOperation,
} from "./operations";
import { isInside, nameOf, parentOf, splitExtension, tildify } from "./paths";
import {
@@ -111,7 +111,7 @@ export function showNewPopup(): boolean {
const lead = treeHandle.current?.leadKey();
const row = lead ? document.querySelector<HTMLElement>(`[data-project-key="${CSS.escape(lead)}"]`) : null;
const rect = (
- row ?? document.querySelector<HTMLElement>('[role="tree"][aria-label="Project"]')
+ row ?? document.querySelector<HTMLElement>('[data-project-view] [role="tree"]')
)?.getBoundingClientRect();
if (!rect) return false;
openNewPopup({ x: rect.left + 24, y: rect.bottom }, newMenuItems(targetFolder()));
@@ -705,8 +705,7 @@ export function ProjectView() {
openMoveDialog();
break;
case "Meta+Z":
- if (lastFileRefactoring()) void undoFileRefactoring();
- else handled = false;
+ handled = undoLastFileOperation();
break;
case "Meta+C":
copySelection(false);
@@ -767,6 +766,7 @@ export function ProjectView() {
<div
ref={containerRef}
className={styles.view}
+ data-project-view=""
{...OWNS_FILE_DROP}
onKeyDown={onKeyDown}
// The native Edit menu may take ⌘C/⌘X/⌘V before the keymap sees them; it then sends DOM clipboard events.
diff --git a/src/features/project-tree/fileRefactor.ts b/src/features/project-tree/fileRefactor.ts
index 6676af2d0..4e090a7a1 100644
--- a/src/features/project-tree/fileRefactor.ts
+++ b/src/features/project-tree/fileRefactor.ts
@@ -208,7 +208,11 @@ async function withEditorsFollowing<T>(run: () => Promise<T>, done: (r: T) => Fi
// ---------------------------------------------------------------------------
// Run / undo
-let lastMove: { id: number; title: string } | null = null;
+let lastMove: { id: number; title: string; seq: number } | null = null;
+let fileOperations = 0;
+
+/** Orders file operations (move / rename, delete) for Undo, which reverts the latest. */
+export const nextFileOperation = () => ++fileOperations;
/** The latest file refactoring that Undo reverts. */
export function lastFileRefactoring() {
@@ -270,7 +274,7 @@ export async function runFileRefactoring(
});
return "failed";
}
- lastMove = { id, title };
+ lastMove = { id, title, seq: nextFileOperation() };
if (collected.errors.length)
notifications().notify({
level: "warning",
diff --git a/src/features/project-tree/index.ts b/src/features/project-tree/index.ts
index b4d699fb5..efcc5d9af 100644
--- a/src/features/project-tree/index.ts
+++ b/src/features/project-tree/index.ts
@@ -12,6 +12,7 @@ import {
registerOverlay,
registerProjectViewRoot,
registerToolWindow,
+ registerUndoHandler,
useLocalChanges,
useProjectViewRoots,
} from "@/workbench/contributions";
@@ -22,7 +23,7 @@ import { NewPopupHost } from "./NewPopup";
import { RefactoringPreviewHost } from "./RefactoringPreview";
import { ProjectHeaderActions, useProjectHeaderMenu, useProjectTitleMenu } from "./HeaderActions";
import { loadHomeDir } from "./home";
-import { selectedNodes } from "./operations";
+import { selectedNodes, undoLastFileOperation } from "./operations";
import { ProjectView } from "./ProjectView";
import {
applyFsChange,
@@ -157,6 +158,14 @@ export function activate(): () => void {
registerOverlay({ id: "project.refactoringPreview", component: RefactoringPreviewHost }),
registerOverlay({ id: "project.newPopup", component: NewPopupHost }),
registerProjectActions(),
+ // Edit › Undo while the Project view has focus.
+ registerUndoHandler(
+ (command, focused) =>
+ command === "undo" &&
+ focused.getAttribute("role") === "tree" &&
+ !!focused.closest("[data-project-view]") &&
+ undoLastFileOperation(),
+ ),
provideProjectViewSelection(() =>
selectedNodes()
.filter((n) => !n.group)
diff --git a/src/features/project-tree/operations.ts b/src/features/project-tree/operations.ts
index 0f4711f68..09b1938de 100644
--- a/src/features/project-tree/operations.ts
+++ b/src/features/project-tree/operations.ts
@@ -8,10 +8,10 @@ import { executeAction, getAction } from "@/platform/actions";
import { maybeEditorService, notifications } from "@/workbench/contributions";
import { ask, confirmChecked } from "@/workbench/messages";
import { osClipboard } from "./clipboard";
-import { runFileRefactoring } from "./fileRefactor";
+import { lastFileRefactoring, nextFileOperation, runFileRefactoring, undoFileRefactoring } from "./fileRefactor";
import { openFileRefactorDialog, rememberedOptions } from "./FileRefactorDialogs";
import { beginLocalImport, projectFs } from "./fs";
-import { isCancelled } from "@/platform/ipc";
+import { call, commands, isCancelled } from "@/platform/ipc";
import { MEMBER_PREFIX, type ProjectNode } from "./model";
import {
isInside,
@@ -459,20 +459,80 @@ export async function deleteSelection(nodes: ProjectNode[] = selectedNodes()) {
const fs = projectFs(root);
const parents = new Set<string>();
const errors: string[] = [];
+ const deleted: string[] = [];
for (const p of paths) {
try {
await fs.delete(p);
parents.add(parentOf(p));
+ deleted.push(p);
} catch (e) {
errors.push(`${nameOf(p)}: ${errorMessage(e)}`);
}
}
+ if (deleted.length) {
+ const dirs = new Set(nodes.filter((n) => n.dir).map((n) => n.path));
+ lastDelete = { paths: deleted, dirs: deleted.filter((p) => dirs.has(p)), seq: nextFileOperation() };
+ }
if (errors.length)
notifications().notify({ level: "error", title: "Some items could not be deleted", body: errors.join("\n") });
await Promise.all([...parents].map((d) => loadDir(d, true)));
if (next) revealPath(next, refocus);
}
+/** The last Delete in the Project view; Undo brings its files back from Local History. */
+let lastDelete: { paths: string[]; dirs: string[]; seq: number } | null = null;
+
+/** Undo in the Project view: reverts the latest delete or move / rename; false when there is none. */
+export function undoLastFileOperation(): boolean {
+ const move = lastFileRefactoring();
+ if (lastDelete && (!move || lastDelete.seq > move.seq)) {
+ void undoDelete();
+ return true;
+ }
+ if (!move) return false;
+ void undoFileRefactoring();
+ return true;
+}
+
+/** Restores the deleted files (and folders) from their last Local History snapshots. */
+export async function undoDelete(): Promise<boolean> {
+ const op = lastDelete;
+ const { root } = get();
+ if (!op || !root) return false;
+ lastDelete = null;
+ const fs = projectFs(root);
+ const failed: string[] = [];
+ const parents = new Set<string>();
+ for (const p of op.paths) {
+ try {
+ const history = await call(commands.historyListDir(p));
+ const gone = new Set(history.deleted);
+ const latest = new Map<string, string>();
+ for (const e of history.entries)
+ if (e.kind === "snapshot" && e.id && gone.has(e.path) && !latest.has(e.path)) latest.set(e.path, e.id);
+ const dir = op.dirs.includes(p);
+ if (!latest.size && !dir) throw new Error("no Local History snapshot");
+ if (dir) await fs.createDir(p);
+ for (const [path, id] of latest) await call(commands.historyRestore(path, id));
+ parents.add(parentOf(p));
+ } catch {
+ failed.push(nameOf(p));
+ }
+ }
+ await Promise.all([...parents].map((d) => loadDir(d, true)));
+ const restored = op.paths.find((p) => !failed.includes(nameOf(p)));
+ if (restored) revealPath(restored, true);
+ const names = failed.join(", ");
+ if (failed.length)
+ notifications().notify({
+ level: "warning",
+ title: "Some items could not be restored",
+ body: tx`Not in Local History: ${names}. They are in the Trash.`,
+ key: "project.undoDelete",
+ });
+ return !failed.length;
+}
+
// ---------------------------------------------------------------------------
// Clipboard / move / copy
diff --git a/src/features/project-tree/undoDelete.test.ts b/src/features/project-tree/undoDelete.test.ts
new file mode 100644
index 000000000..867283b84
--- /dev/null
+++ b/src/features/project-tree/undoDelete.test.ts
@@ -0,0 +1,79 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const history = vi.hoisted(() => ({
+ restored: [] as Array<[string, string]>,
+ snapshots: [] as Array<{ id: string; path: string }>,
+}));
+
+vi.mock("@/workbench/messages", () => ({
+ confirm: async () => true,
+ confirmChecked: async () => ({ checked: false }),
+ ask: async () => ({ button: "cancel", checked: false }),
+}));
+vi.mock("@/editor/refactor", () => ({
+ fileUsages: async () => ({ status: "ok", usages: [] }),
+ askUsagesDetected: async () => "cancel",
+ viewUsages: () => {},
+}));
+vi.mock("@/platform/ipc", async (importOriginal) => {
+ const real = await importOriginal<typeof import("@/platform/ipc")>();
+ const ok = <T>(data: T) => Promise.resolve({ status: "ok" as const, data });
+ return {
+ ...real,
+ commands: {
+ ...real.commands,
+ // Local History as the backend keeps it: deleted files' snapshots, newest first.
+ historyListDir: (dir: string) => {
+ const entries = history.snapshots
+ .filter((s) => s.path === dir || s.path.startsWith(`${dir}/`))
+ .map((s) => ({ ...s, timestampMs: 0, label: "Deleted", size: 1, kind: "snapshot" }));
+ return ok({ entries, deleted: [...new Set(entries.map((e) => e.path))] });
+ },
+ historyRestore: (path: string, id: string) => {
+ history.restored.push([path, id]);
+ return fs.createFile(path).then(() => ok(null));
+ },
+ },
+ };
+});
+
+const { MemoryFs, setProjectFsForTests } = await import("./fs");
+const { currentModel, initProjectTree, loadDir } = await import("./store");
+const { deleteSelection, undoLastFileOperation } = await import("./operations");
+let fs: InstanceType<typeof MemoryFs>;
+
+describe("Undo in the Project view", () => {
+ beforeEach(() => {
+ fs = new MemoryFs({ "/p/a.txt": "a", "/p/lib/x.ts": "x", "/p/lib/empty/": null }, "/p");
+ setProjectFsForTests(fs, "/p");
+ initProjectTree("/p", "proj");
+ history.restored.length = 0;
+ history.snapshots = [
+ { id: "new-a", path: "/p/a.txt" },
+ { id: "old-a", path: "/p/a.txt" },
+ { id: "x1", path: "/p/lib/x.ts" },
+ ];
+ });
+ afterEach(() => {
+ setProjectFsForTests(null);
+ initProjectTree(null);
+ });
+
+ const labels = (dir: string) => (currentModel().children.get(dir) ?? []).map((n) => n.label);
+
+ it("brings deleted files and folders back from their latest Local History snapshots", async () => {
+ await loadDir("/p");
+ expect(labels("/p")).toEqual(["lib", "a.txt"]);
+ await deleteSelection([currentModel().byKey.get("/p/a.txt")!, currentModel().byKey.get("/p/lib")!]);
+ expect(labels("/p")).toEqual([]);
+
+ expect(undoLastFileOperation()).toBe(true);
+ await vi.waitFor(() => expect(labels("/p")).toEqual(["lib", "a.txt"]));
+ expect(history.restored).toEqual([
+ ["/p/a.txt", "new-a"],
+ ["/p/lib/x.ts", "x1"],
+ ]);
+ // Undone once: nothing left to undo.
+ expect(undoLastFileOperation()).toBe(false);
+ });
+});
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index c09faefbf..05fe82741 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5784,5 +5784,7 @@
"Unexpected token": "意外的标记",
"Syntax": "语法",
"Syntax errors": "语法错误",
- "Reports code the built-in parser cannot read, in files no language server checks (none is configured for the language, or it is not installed, stopped or crashed). A running language server reports syntax errors itself.": "报告内置解析器无法解析的代码,仅针对没有语言服务器检查的文件(该语言未配置语言服务器,或未安装、已停止、已崩溃)。语言服务器运行时由它自己报告语法错误。"
+ "Reports code the built-in parser cannot read, in files no language server checks (none is configured for the language, or it is not installed, stopped or crashed). A running language server reports syntax errors itself.": "报告内置解析器无法解析的代码,仅针对没有语言服务器检查的文件(该语言未配置语言服务器,或未安装、已停止、已崩溃)。语言服务器运行时由它自己报告语法错误。",
+ "Some items could not be restored": "部分项目无法恢复",
+ "Not in Local History: {names}. They are in the Trash.": "本地历史中没有:{names}。它们在回收站中。"
}
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index 62d0823f1..4c1161958 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -1211,6 +1211,24 @@ export function occurrenceNavigator(toolWindow: string): OccurrenceNavigator | n
return occurrenceNavigators.get(toolWindow)?.at(-1) ?? null;
}
+// ---------------------------------------------------------------------------
+// Edit › Undo / Redo outside text fields and editors
+
+/** Undo / Redo for `focused` in a view with its own history (Project view file operations); true when handled. */
+export type UndoHandler = (command: "undo" | "redo", focused: Element) => boolean;
+
+const undoHandlers = new Set<UndoHandler>();
+
+export function registerUndoHandler(handler: UndoHandler): () => void {
+ undoHandlers.add(handler);
+ return () => void undoHandlers.delete(handler);
+}
+
+/** Offers Undo / Redo to the registered views, latest first. */
+export function runUndoHandlers(command: "undo" | "redo", focused: Element): boolean {
+ return [...undoHandlers].reverse().some((h) => h(command, focused));
+}
+
/** Registers `nav` (the latest render's) for `toolWindow` while the calling view is mounted. */
export function useOccurrenceNavigator(toolWindow: string, nav: OccurrenceNavigator["go"]) {
const latest = useRef(nav);