mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-18 07:50:13 +00:00
fix(studio): each drag shows as its own undo step once its save lands (#8033)
* test(studio): three quick drags give three undo entries in the history list * fix(studio): each drag shows as its own undo step once its save lands * test(studio): the edit bench fails a gesture missing from the history list * refactor(studio): the held-entry close is a plain function, and the bench helper stays private * chore(studio): mark the history hook's existing complexity the way other large hooks are * fix(studio): a drag's history claim waits for the previous drag's close to land
This commit is contained in:
@@ -724,3 +724,87 @@ it("stores DOM targets in existing history and retains them through undo and red
|
||||
await act(() => hook().redo({ readFile }));
|
||||
expect(history.list().at(-1)?.targets).toEqual(targets);
|
||||
});
|
||||
|
||||
it("three quick drags are three entries in the list as soon as each drag's saves are in", async () => {
|
||||
const { hook, save, history } = await studio();
|
||||
const moves = [
|
||||
["A", "B"],
|
||||
["B", "C"],
|
||||
["C", "D"],
|
||||
] as const;
|
||||
for (const [i, [before, after]] of moves.entries()) {
|
||||
// A drag claims under its own key with no idle limit, as a plain move does, and settles after its save.
|
||||
const drag = beginStudioPendingEdit(() => () => {});
|
||||
save(after);
|
||||
const saved = hook().recordEdit({
|
||||
label: "Move layer",
|
||||
coalesceKey: `move:${i}`,
|
||||
coalesceMs: Number.POSITIVE_INFINITY,
|
||||
files: { "index.html": { before, after } },
|
||||
});
|
||||
drag.settle(saved);
|
||||
await act(() => saved);
|
||||
}
|
||||
await vi.waitFor(() =>
|
||||
expect(history.list().filter((entry) => entry.label === "Move layer")).toHaveLength(3),
|
||||
);
|
||||
});
|
||||
|
||||
it("the next drag's claim reaches the server after the settled drag's empty claim, however slow that one is", async () => {
|
||||
const { hook, save } = await studio();
|
||||
const forward = globalThis.fetch;
|
||||
const arrived: string[] = [];
|
||||
let release = () => {};
|
||||
const held = new Promise<void>((resolve) => (release = resolve));
|
||||
vi.stubGlobal("fetch", async (url: string, init?: RequestInit) => {
|
||||
const claim = url.endsWith("/claim")
|
||||
? (JSON.parse(String(init?.body)) as { paths: string[] })
|
||||
: null;
|
||||
if (claim && !claim.paths.length) await held;
|
||||
if (claim) arrived.push(claim.paths.length ? "claim" : "empty");
|
||||
return forward(url, init);
|
||||
});
|
||||
const drag = (i: number, before: string, after: string) => {
|
||||
const pending = beginStudioPendingEdit(() => () => {});
|
||||
save(after);
|
||||
const saved = hook().recordEdit({
|
||||
label: "Move layer",
|
||||
coalesceKey: `move:${i}`,
|
||||
coalesceMs: Number.POSITIVE_INFINITY,
|
||||
files: { "index.html": { before, after } },
|
||||
});
|
||||
pending.settle(saved);
|
||||
return saved;
|
||||
};
|
||||
await act(() => drag(0, "A", "B"));
|
||||
const next = drag(1, "B", "C");
|
||||
await new Promise((resolve) => setTimeout(resolve, 20));
|
||||
release();
|
||||
await act(() => next);
|
||||
expect(arrived.slice(0, 3)).toEqual(["claim", "empty", "claim"]);
|
||||
});
|
||||
|
||||
it("a gesture that writes twice under one key stays one entry once it settles", async () => {
|
||||
const { hook, save, history } = await studio();
|
||||
const resize = beginStudioPendingEdit(() => () => {});
|
||||
const writes = (async () => {
|
||||
for (const [before, after] of [
|
||||
["A", "B"],
|
||||
["B", "C"],
|
||||
] as const) {
|
||||
save(after);
|
||||
await hook().recordEdit({
|
||||
label: "Resize layer",
|
||||
coalesceKey: "tx:resize",
|
||||
coalesceMs: Number.POSITIVE_INFINITY,
|
||||
files: { "index.html": { before, after } },
|
||||
});
|
||||
}
|
||||
})();
|
||||
resize.settle(writes);
|
||||
await act(() => writes);
|
||||
await vi.waitFor(() =>
|
||||
expect(history.list().filter((entry) => entry.label === "Resize layer")).toHaveLength(1),
|
||||
);
|
||||
expect(history.list().find((entry) => entry.label === "Resize layer")?.files.length).toBe(1);
|
||||
});
|
||||
|
||||
@@ -3,7 +3,10 @@ import type { HistoryListItem, HistoryResult } from "@hyperframes/studio-server"
|
||||
import { studioFileContentVersion, studioWriteHeaders } from "../utils/studioFileVersion";
|
||||
import type { RestoreFiles } from "../utils/gsapUndoRestore";
|
||||
import { studioApiFetch } from "../utils/studioApiFetch";
|
||||
import { setStudioPendingEditClaimClock } from "../utils/studioPendingEdits";
|
||||
import {
|
||||
setStudioPendingEditClaimClock,
|
||||
setStudioPendingEditsSettled,
|
||||
} from "../utils/studioPendingEdits";
|
||||
import type { RecordEditInput } from "../utils/studioFileHistory";
|
||||
import { generateId } from "../utils/generateId";
|
||||
|
||||
@@ -41,6 +44,7 @@ interface HistoryView {
|
||||
forward: NextStep | null;
|
||||
}
|
||||
|
||||
const APP_KEEPS_NO_HISTORY = 404;
|
||||
const EMPTY: HistoryView = { entries: [], back: null, forward: null };
|
||||
/** ponytail: the newest entries' content is kept; older ones step through the server only. */
|
||||
const OWN_ENTRIES_KEPT = 100;
|
||||
@@ -201,12 +205,28 @@ function redoneAt(view: HistoryView): number | null {
|
||||
return view.entries.find((entry) => entry.id === undo?.undoes)?.endedAt ?? null;
|
||||
}
|
||||
|
||||
function closeHeldClaimWithAClaimOfNothing(
|
||||
projectId: string,
|
||||
heldClaimRef: { current: { paths: string[]; at: number } | null },
|
||||
refresh: () => Promise<void>,
|
||||
): Promise<void> {
|
||||
if (!heldClaimRef.current) return Promise.resolve();
|
||||
heldClaimRef.current = null;
|
||||
return post(historyUrl(projectId, "/claim"), { label: "Edited in Studio", paths: [] }).then(
|
||||
(reply) => {
|
||||
if (reply.ok) void refresh();
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
/** Studio's undo over the server's project history: an edit claims what it wrote; Cmd+Z steps the person's. */
|
||||
// fallow-ignore-next-line complexity
|
||||
export function usePersistentEditHistory({ projectId }: UsePersistentEditHistoryOptions) {
|
||||
const [view, setView] = useState<HistoryView>(EMPTY);
|
||||
const [loaded, setLoaded] = useState(false);
|
||||
// A coalescing claim the server just took, until `refresh()` brings its entry into `view`.
|
||||
const heldClaimRef = useRef<{ paths: string[]; at: number } | null>(null);
|
||||
const claimsAfterTheClose = useRef<Promise<void>>(Promise.resolve());
|
||||
const projectIdRef = useRef(projectId);
|
||||
projectIdRef.current = projectId;
|
||||
const [own] = useState(createOwnHistory);
|
||||
@@ -239,11 +259,24 @@ export function usePersistentEditHistory({ projectId }: UsePersistentEditHistory
|
||||
return () => setStudioPendingEditClaimClock(null);
|
||||
}, [own]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!projectId) return;
|
||||
setStudioPendingEditsSettled(() => {
|
||||
claimsAfterTheClose.current = closeHeldClaimWithAClaimOfNothing(
|
||||
projectId,
|
||||
heldClaimRef,
|
||||
refresh,
|
||||
);
|
||||
});
|
||||
return () => setStudioPendingEditsSettled(null);
|
||||
}, [projectId, refresh]);
|
||||
|
||||
const recordEdit = useCallback(
|
||||
async ({ label, coalesceKey, coalesceMs, files, targets, created = [] }: RecordEditInput) => {
|
||||
if (!projectId) return;
|
||||
const paths = [...Object.keys(files), ...created];
|
||||
own.overtake();
|
||||
await claimsAfterTheClose.current;
|
||||
const reply = await post(historyUrl(projectId, "/claim"), {
|
||||
label,
|
||||
paths,
|
||||
@@ -286,8 +319,8 @@ export function usePersistentEditHistory({ projectId }: UsePersistentEditHistory
|
||||
);
|
||||
heldClaimRef.current = null;
|
||||
void refresh();
|
||||
// 404: this app keeps no history, so there is nothing to step.
|
||||
if (!posted.ok && posted.status === 404) return { ok: false, reason: "empty" };
|
||||
if (!posted.ok && posted.status === APP_KEEPS_NO_HISTORY)
|
||||
return { ok: false, reason: "empty" };
|
||||
if (!posted.ok) return { ok: false, reason: "failed", message: posted.error };
|
||||
const reply = posted.body as HistoryResult;
|
||||
if (!reply.ok) {
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// @vitest-environment jsdom
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import {
|
||||
setStudioPendingEditsSettled,
|
||||
addStudioPendingEditFlushListener,
|
||||
adoptingStudioPendingEdit,
|
||||
beginStudioPendingEdit,
|
||||
@@ -514,3 +515,22 @@ it("counts an edit whose later write failed as saved once an earlier write lande
|
||||
const shown = paintBackNewestStudioPendingEdit()!;
|
||||
await expect(shown.landed()).resolves.toBe(true);
|
||||
});
|
||||
|
||||
describe("every pending edit settled", () => {
|
||||
it("is told once, when the last of two overlapping edits settles", async () => {
|
||||
const told = vi.fn();
|
||||
setStudioPendingEditsSettled(told);
|
||||
try {
|
||||
const first = beginStudioPendingEdit(null);
|
||||
const second = beginStudioPendingEdit(null);
|
||||
first.settle();
|
||||
await Promise.resolve();
|
||||
await Promise.resolve();
|
||||
expect(told).not.toHaveBeenCalled();
|
||||
second.settle();
|
||||
await vi.waitFor(() => expect(told).toHaveBeenCalledOnce());
|
||||
} finally {
|
||||
setStudioPendingEditsSettled(null);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
@@ -33,6 +33,12 @@ let historyClaims: () => number = () => 0;
|
||||
export function setStudioPendingEditClaimClock(read: (() => number) | null): void {
|
||||
historyClaims = read ?? (() => 0);
|
||||
}
|
||||
|
||||
let allSettled: (() => void) | null = null;
|
||||
|
||||
export function setStudioPendingEditsSettled(run: (() => void) | null): void {
|
||||
allSettled = run;
|
||||
}
|
||||
const NOT_SAVED = () => Promise.resolve(false);
|
||||
let cancelWaitingPress: (() => boolean) | null = null;
|
||||
|
||||
@@ -119,10 +125,11 @@ export function trackStudioPendingEdit(
|
||||
showAgain: null,
|
||||
claimsAtBegin: historyClaims(),
|
||||
});
|
||||
promise.then(
|
||||
() => pendingEdits.delete(promise),
|
||||
() => pendingEdits.delete(promise),
|
||||
);
|
||||
const done = () => {
|
||||
pendingEdits.delete(promise);
|
||||
if (!pendingEdits.size) allSettled?.();
|
||||
};
|
||||
promise.then(done, done);
|
||||
return promise;
|
||||
}
|
||||
|
||||
|
||||
@@ -96,6 +96,7 @@ export function score(spec, r) {
|
||||
undo:
|
||||
!r.undoTimeout &&
|
||||
r.undo.groups !== false &&
|
||||
r.undo.listed !== false &&
|
||||
r.undo.bytes &&
|
||||
r.undo.redoBytes &&
|
||||
Math.max(r.undo.box, r.undo.redoBox) <= LIMIT_PX &&
|
||||
|
||||
@@ -124,9 +124,11 @@ export function watchVersions(dir, files) {
|
||||
/** Studio's own history replies in arrival order: each claim's group, each undo or redo's entry and what it reverts. */
|
||||
function watchHistory(page) {
|
||||
const replies = [];
|
||||
const at = { list: null };
|
||||
const read = (response) => {
|
||||
const kind = /\/history\/(claim|step|undo)$/.exec(new URL(response.url()).pathname)?.[1];
|
||||
if (!kind || response.request().method() !== "POST") return;
|
||||
at.list ??= response.url().replace(/\/(claim|step|undo)$/, "");
|
||||
const status = response.status();
|
||||
replies.push(
|
||||
response
|
||||
@@ -141,7 +143,20 @@ function watchHistory(page) {
|
||||
);
|
||||
};
|
||||
page.on("response", read);
|
||||
return { replies, stop: () => page.off("response", read) };
|
||||
return { replies, at, stop: () => page.off("response", read) };
|
||||
}
|
||||
|
||||
/** Whether every group the gestures took is already an entry in the history list, polled for `ms`. */
|
||||
async function groupsListed(listUrl, ids, ms = 3000) {
|
||||
if (!listUrl || !ids.length) return null;
|
||||
for (const deadline = Date.now() + ms; ; await sleep(100)) {
|
||||
const view = await fetch(listUrl)
|
||||
.then((r) => r.json())
|
||||
.catch(() => null);
|
||||
const listed = new Set((view?.entries ?? []).map((entry) => entry.id));
|
||||
if (ids.every((id) => listed.has(id))) return true;
|
||||
if (Date.now() > deadline) return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** The groups left to undo, oldest first: a claim opens one unless it names the newest (one gesture writing
|
||||
@@ -523,6 +538,8 @@ async function measureSequence({ spec, dir, files, evidence }, session, control,
|
||||
const groups = historyGroups(await Promise.all(history.replies));
|
||||
const ids = groups.stack.toReversed();
|
||||
const groupsOk = !groups.faults.length && groups.stack.length === state.depth;
|
||||
// Each gesture is its own entry in the list once its saves are in, before anything else happens.
|
||||
const listed = await groupsListed(history.at.list, groups.stack);
|
||||
// A settled case knows each step's bytes (its saves ended before the next step); a fast one only
|
||||
// where all are undone and all redone, since one gesture may write more than once.
|
||||
const stack = [];
|
||||
@@ -619,6 +636,7 @@ async function measureSequence({ spec, dir, files, evidence }, session, control,
|
||||
reloaded: { ...reloaded, time: state.time },
|
||||
undo: {
|
||||
groups: groupsOk,
|
||||
listed,
|
||||
bytes: undo.ok && sameFiles(committedFiles, expected ?? {}),
|
||||
box: quadDistance(undone.visible, pre.visible),
|
||||
redoBytes: redo.ok,
|
||||
|
||||
Reference in New Issue
Block a user