Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Ask to save changes before leaving a project

Bittifd1d1a854384
diff --git a/src/components/ProjectWorkspace.tsx b/src/components/ProjectWorkspace.tsx
index 934cbba..b5c9b13 100644
--- a/src/components/ProjectWorkspace.tsx
+++ b/src/components/ProjectWorkspace.tsx
@@ -9,6 +9,7 @@ import { ExportView } from "./workspace/ExportView";
import { GeneratorView } from "./workspace/GeneratorView";
import { ReferencesView } from "./workspace/ReferencesView";
import { TimelineView, type ConfigUpdate } from "./workspace/TimelineView";
+import { UnsavedProjectDialog } from "./UnsavedProjectDialog";
export type ProjectView = "timeline" | "generator" | "references" | "agent" | "export";
@@ -45,6 +46,8 @@ export function ProjectWorkspace({ project, initialView = "timeline", runtime =
const { config, saving, dirty, saveError } = useSyncExternalStore(session.subscribe, session.getSnapshot);
const items = useSyncExternalStore(queue.subscribe, queue.getSnapshot);
const [view, setView] = useState<ProjectView>(initialView);
+ const [leaving, setLeaving] = useState(false);
+ const [savingToLeave, setSavingToLeave] = useState(false);
const [selectedGenerationJobId, setSelectedGenerationJobId] = useState<string | undefined>(project.config.generationJobs[0]?.id);
const knownSceneIds = useRef(new Set(project.config.generationJobs.map((job) => job.id)));
const projectItems = items.filter((item) => item.projectKey === projectQueueKey(project));
@@ -54,6 +57,15 @@ export function ProjectWorkspace({ project, initialView = "timeline", runtime =
const changeConfig = (next: ConfigUpdate) => session.update(next);
const recordMeasurement = (update: (current: ProjectConfig) => ProjectConfig) => session.update(update, false);
const save = () => session.save().catch(() => undefined);
+ const leave = async (keepChanges: boolean) => {
+ setSavingToLeave(true);
+ try {
+ if (keepChanges) await session.save();
+ else await session.discard();
+ onBack();
+ } catch { /* The session supplies the save error and keeps the dialog open. */ }
+ finally { setSavingToLeave(false); }
+ };
/* Scene removal can come from the Generator or from Slop replacing the
project document. Keep derived disk caches honest at this shared boundary
@@ -67,11 +79,12 @@ export function ProjectWorkspace({ project, initialView = "timeline", runtime =
}, [config.generationJobs, project.folderPath]);
return <div className="project-shell">
+ {leaving && <UnsavedProjectDialog name={config.name} busy={savingToLeave} error={saveError} onSave={() => void leave(true)} onDiscard={() => void leave(false)} />}
<header className="project-topbar">
<div className="project-topbar__lead">
<button
className="icon-button icon-button--strong"
- onClick={onBack}
+ onClick={() => { if (dirty) setLeaving(true); else onBack(); }}
aria-label="Back to project library"
title="Back to your projects"
><ArrowLeft size={18} /></button>
diff --git a/src/components/UnsavedProject.integration.test.tsx b/src/components/UnsavedProject.integration.test.tsx
new file mode 100644
index 0000000..a1fe66d
--- /dev/null
+++ b/src/components/UnsavedProject.integration.test.tsx
@@ -0,0 +1,66 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, expect, it, vi } from "vitest";
+import { createProjectConfig, type ProjectRecord } from "../lib/project";
+import { WorkQueue } from "../lib/workQueue";
+import { ProjectWorkspace } from "./ProjectWorkspace";
+
+afterEach(cleanup);
+const setup = (writer = vi.fn(async (_record: ProjectRecord) => undefined)) => {
+ const config = createProjectConfig({ name: "My project", prompt: "A scene", aspectRatio: "16:9", resolution: "416p", targetDurationSeconds: 10 });
+ config.references = [{ id: "hero", name: "Saved hero", description: "", kind: "text", intendedUse: ["character"], createdAt: config.createdAt }];
+ const project = { config, folderPath: "C:/My project" };
+ const queue = new WorkQueue(writer);
+ const onBack = vi.fn();
+ render(<ProjectWorkspace project={project} workQueue={queue} initialView="references" onBack={onBack} onSave={async () => undefined} />);
+ return { queue, project, session: queue.project(project), writer, onBack };
+};
+const changeName = () => fireEvent.change(screen.getByRole("textbox", { name: "Reference name" }), { target: { value: "Unsaved hero" } });
+const back = () => fireEvent.click(screen.getByRole("button", { name: "Back to project library" }));
+
+it("returns immediately when the project has no unsaved changes", () => {
+ const { onBack } = setup();
+ back();
+ expect(onBack).toHaveBeenCalledOnce();
+ expect(screen.queryByRole("alertdialog")).not.toBeInTheDocument();
+});
+
+it("offers only save or discard and waits for saving before leaving", async () => {
+ let finish!: () => void;
+ const writer = vi.fn((_record: ProjectRecord) => new Promise<void>((resolve) => { finish = resolve; }));
+ const { onBack, session } = setup(writer);
+ changeName(); back();
+ const dialog = screen.getByRole("alertdialog", { name: "Save changes?" });
+ expect(within(dialog).getAllByRole("button").map((button) => button.textContent)).toEqual(["Discard changes", "Save changes"]);
+ fireEvent.click(within(dialog).getByRole("button", { name: "Save changes" }));
+ await waitFor(() => expect(writer).toHaveBeenCalledOnce());
+ expect(onBack).not.toHaveBeenCalled();
+ expect(writer.mock.calls[0][0].config.references[0].name).toBe("Unsaved hero");
+ await act(async () => finish());
+ expect(onBack).toHaveBeenCalledOnce();
+ expect(session.getSnapshot().dirty).toBe(false);
+});
+
+it("discards unsaved changes from the retained session so reopening restores saved values", async () => {
+ const { onBack, session, writer, queue, project } = setup();
+ changeName(); back();
+ fireEvent.click(screen.getByRole("button", { name: "Discard changes" }));
+ await waitFor(() => expect(onBack).toHaveBeenCalledOnce());
+ expect(writer).not.toHaveBeenCalled();
+ expect(session.getSnapshot().dirty).toBe(false);
+ expect(queue.project(project).getSnapshot().config.references[0].name).toBe("Saved hero");
+});
+
+it("keeps changes and reports a save failure before allowing another save attempt", async () => {
+ const writer = vi.fn(async (_record: ProjectRecord) => undefined).mockRejectedValueOnce(new Error("Disk locked"));
+ const { onBack, session } = setup(writer);
+ changeName(); back();
+ const dialog = screen.getByRole("alertdialog");
+ fireEvent.click(within(dialog).getByRole("button", { name: "Save changes" }));
+ expect(await within(dialog).findByRole("alert")).toHaveTextContent("Disk locked");
+ expect(onBack).not.toHaveBeenCalled();
+ expect(session.getSnapshot().dirty).toBe(true);
+ fireEvent.click(within(dialog).getByRole("button", { name: "Save changes" }));
+ await waitFor(() => expect(onBack).toHaveBeenCalledOnce());
+});
diff --git a/src/components/UnsavedProjectDialog.tsx b/src/components/UnsavedProjectDialog.tsx
new file mode 100644
index 0000000..27b06ca
--- /dev/null
+++ b/src/components/UnsavedProjectDialog.tsx
@@ -0,0 +1,41 @@
+import { Save } from "lucide-react";
+import { useEffect, useRef } from "react";
+
+export function UnsavedProjectDialog({ name, busy, error, onSave, onDiscard }: {
+ name: string;
+ busy: boolean;
+ error: string | null;
+ onSave: () => void;
+ onDiscard: () => void;
+}) {
+ const dialog = useRef<HTMLDivElement>(null);
+ const save = useRef<HTMLButtonElement>(null);
+ useEffect(() => { save.current?.focus(); }, []);
+ useEffect(() => {
+ const keyDown = (event: KeyboardEvent) => {
+ if (event.key === "Escape") { event.preventDefault(); event.stopPropagation(); }
+ if (event.key !== "Tab") return;
+ const buttons = Array.from(dialog.current?.querySelectorAll<HTMLButtonElement>("button:not(:disabled)") ?? []);
+ if (buttons.length === 0) { event.preventDefault(); return; }
+ const next = event.shiftKey ? buttons.at(-1)! : buttons[0];
+ if (!dialog.current?.contains(document.activeElement) || (event.shiftKey ? document.activeElement === buttons[0] : document.activeElement === buttons.at(-1))) {
+ event.preventDefault(); next.focus();
+ }
+ };
+ window.addEventListener("keydown", keyDown, true);
+ return () => window.removeEventListener("keydown", keyDown, true);
+ }, []);
+ return <div className="delete-project-backdrop">
+ <div ref={dialog} className="delete-project-dialog" role="alertdialog" aria-modal="true" aria-labelledby="unsaved-project-title" aria-describedby="unsaved-project-description">
+ <div className="delete-project-dialog__head"><h2 id="unsaved-project-title">Save changes?</h2></div>
+ <div className="delete-project-dialog__body">
+ <p id="unsaved-project-description">Save changes to “{name}” before returning to the project library?</p>
+ {error && <p role="alert">Couldn’t save the project: {error}</p>}
+ </div>
+ <div className="delete-project-dialog__actions">
+ <button type="button" className="secondary-button" disabled={busy} onClick={onDiscard}>Discard changes</button>
+ <button ref={save} type="button" className="primary-button" disabled={busy} onClick={onSave}><Save size={16} />{busy ? "Saving…" : "Save changes"}</button>
+ </div>
+ </div>
+ </div>;
+}
diff --git a/src/lib/projectSession.ts b/src/lib/projectSession.ts
index 3d0f174..e3dc2ff 100644
--- a/src/lib/projectSession.ts
+++ b/src/lib/projectSession.ts
@@ -11,7 +11,9 @@ export class ProjectSession {
private writes = Promise.resolve();
private revision = 0;
private pending = 0;
+ private savedConfig: ProjectConfig;
constructor(readonly record: ProjectRecord, private writer: ProjectWriter) {
+ this.savedConfig = record.config;
this.state = { config: record.config, dirty: false, saving: false, saveError: null };
}
getSnapshot = () => this.state;
@@ -27,6 +29,11 @@ export class ProjectSession {
this.publish({ config, dirty: this.state.dirty || dirty });
};
dismissError = () => this.publish({ saveError: null });
+ discard = async (): Promise<void> => {
+ await this.writes;
+ this.revision += 1;
+ this.publish({ config: this.savedConfig, dirty: false, saveError: null });
+ };
save = (): Promise<void> => {
const revision = this.revision;
const record = { ...this.record, config: this.state.config };
@@ -35,6 +42,7 @@ export class ProjectSession {
const write = this.writes.catch(() => undefined).then(() => this.writer(record));
this.writes = write.then(() => undefined, () => undefined);
return write.then(() => {
+ this.savedConfig = record.config;
if (this.revision === revision) this.publish({ dirty: false });
}).catch((reason) => {
const detail = describeDiagnosticError(reason);
diff --git a/src/lib/workQueue.test.ts b/src/lib/workQueue.test.ts
index 1888ca2..f8fb9b5 100644
--- a/src/lib/workQueue.test.ts
+++ b/src/lib/workQueue.test.ts
@@ -217,5 +217,8 @@ describe("project sessions", () => {
expect(session.getSnapshot().dirty).toBe(true);
expect(session.getSnapshot().config.name).toBe("After save");
expect(writer.mock.calls[0][0].config.name).toBe("Before save");
+ await session.discard();
+ expect(session.getSnapshot().config.name).toBe("Before save");
+ expect(session.getSnapshot().dirty).toBe(false);
});
});