mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-16 14:27:26 +00:00
* fix(slideshow): address split-PR review findings on #1585 Genuinely-open findings from the #1580/#1590/#1591/#1592 reviews (the rest were already fixed on this branch: CSP handlers, manifest version, UUID ids, float keys, presenter 1s-timer): core (#1580): - isManifest rejects a non-object/array manifest (e.g. [42,null]) explicitly - resolveSlideshow flags duplicate slideSequence ids instead of silent overwrite player (#1590): - present() window.open uses noopener,noreferrer (audience syncs via channel) - BroadcastChannel name is per-deck (keyed on pathname) to avoid same-origin cross-talk between decks - add observedAttributes + attributeChangedCallback so runtime sound/mode toggles re-render studio (#1591/#1592): - persistSlideshowManifest no-op gate (skip write when HTML is unchanged) - surface persist failures (console.error) instead of silent .catch(()=>{}) - confirm before deleting a branch sequence (data-loss + dangling hotspots) + tests for the collision + non-object-manifest rejection. 20 core / 106 player / 53 studio pass; tsc/lint/fmt/fallow clean; deck still renders. * fix(slideshow): finish remaining split-PR review findings The larger items from the #1580/#1590/#1591/#1592 reviews (the rest landed in #1585): core (#1580): - dedup isSceneLikeCompositionId — shared slideshow/sceneId.ts, used by both the lint rule and the runtime scene-window computation (no more mirror-and-drift) player (#1590 / #1592): - onKey: when multiple decks share a page, drop the unfocused-convenience so a key drives only the focused deck - slow-iframe recovery: if the scene timeline posts after the wait times out (empty scenes), re-init once so sceneId slides resolve instead of being dropped studio (#1591): - persistSlideshowManifest validates the built island round-trips before writing - reorderBranchSlide helper + BranchTree up/down controls (parallel to main-line reorder), with a branch-position indicator + tests for reorderBranchSlide. core 228 / player 106 / studio (panel) 46 pass; tsc/lint/fmt/fallow clean. * fix(player,cli): use fileURLToPath for path resolution (Windows CI) new URL(...).pathname yields a leading-slash drive path ("/D:/...") on Windows, which broke: - packages/player/vitest.config.ts — the @hyperframes/core/slideshow alias resolved to a nonexistent path, failing the player slideshow tests on the Windows render-verification CI (passed on macOS/Linux where pathname is clean) - packages/cli/src/utils/compositionServer.ts helperDir — same bug in the play/present bundle-path resolution fileURLToPath converts file:// URLs to correct OS paths on all platforms. Player slideshow tests pass; present serves + resolves bundles. * fix(producer): fileURLToPath for the renders dir (Windows) DEFAULT_RENDERS_DIR used new URL(import.meta.url).pathname, which is "/D:/..." on Windows and resolves to a bogus path — affects the Windows render pipeline. Last of the .pathname -> fileURLToPath fixes (repo-wide src sweep now clean).
521 lines
20 KiB
TypeScript
521 lines
20 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
|
import {
|
|
toggleMainLineSlide,
|
|
reorderMainLineSlide,
|
|
reorderBranchSlide,
|
|
setSlideNotes,
|
|
addFragment,
|
|
removeFragment,
|
|
createSequence,
|
|
renameSequence,
|
|
deleteSequence,
|
|
assignToBranch,
|
|
addHotspot,
|
|
removeHotspot,
|
|
safeParseManifest,
|
|
makeSlideshowNotesController,
|
|
} from "./SlideshowPanel";
|
|
import type { SlideshowManifest } from "@hyperframes/core/slideshow";
|
|
|
|
// ── toggleMainLineSlide ────────────────────────────────────────────────────
|
|
|
|
describe("toggleMainLineSlide", () => {
|
|
it("adds a scene as a slide when absent", () => {
|
|
const m = toggleMainLineSlide({ slides: [] }, "a");
|
|
expect(m.slides).toEqual([{ sceneId: "a" }]);
|
|
});
|
|
|
|
it("removes a scene when already present", () => {
|
|
const m = toggleMainLineSlide({ slides: [{ sceneId: "a" }] }, "a");
|
|
expect(m.slides).toEqual([]);
|
|
});
|
|
|
|
it("does not mutate the input manifest", () => {
|
|
const input: SlideshowManifest = { slides: [{ sceneId: "a" }] };
|
|
toggleMainLineSlide(input, "a");
|
|
expect(input.slides.length).toBe(1);
|
|
});
|
|
|
|
it("leaves other slides intact when removing", () => {
|
|
const m = toggleMainLineSlide({ slides: [{ sceneId: "a" }, { sceneId: "b" }] }, "a");
|
|
expect(m.slides).toEqual([{ sceneId: "b" }]);
|
|
});
|
|
});
|
|
|
|
// ── reorderMainLineSlide ───────────────────────────────────────────────────
|
|
|
|
describe("reorderMainLineSlide", () => {
|
|
it("moves a slide up", () => {
|
|
const m = reorderMainLineSlide({ slides: [{ sceneId: "a" }, { sceneId: "b" }] }, "b", "up");
|
|
expect(m.slides.map((s) => s.sceneId)).toEqual(["b", "a"]);
|
|
});
|
|
|
|
it("moves a slide down", () => {
|
|
const m = reorderMainLineSlide({ slides: [{ sceneId: "a" }, { sceneId: "b" }] }, "a", "down");
|
|
expect(m.slides.map((s) => s.sceneId)).toEqual(["b", "a"]);
|
|
});
|
|
|
|
it("returns unchanged manifest when moving first slide up", () => {
|
|
const input: SlideshowManifest = { slides: [{ sceneId: "a" }, { sceneId: "b" }] };
|
|
const m = reorderMainLineSlide(input, "a", "up");
|
|
expect(m.slides.map((s) => s.sceneId)).toEqual(["a", "b"]);
|
|
});
|
|
|
|
it("returns unchanged manifest for unknown sceneId", () => {
|
|
const input: SlideshowManifest = { slides: [{ sceneId: "a" }] };
|
|
const m = reorderMainLineSlide(input, "z", "up");
|
|
expect(m.slides).toEqual(input.slides);
|
|
});
|
|
});
|
|
|
|
// ── reorderBranchSlide ─────────────────────────────────────────────────────
|
|
describe("reorderBranchSlide", () => {
|
|
const base: SlideshowManifest = {
|
|
slides: [{ sceneId: "x" }],
|
|
slideSequences: [
|
|
{ id: "b1", label: "Branch", slides: [{ sceneId: "a" }, { sceneId: "b" }, { sceneId: "c" }] },
|
|
],
|
|
};
|
|
|
|
it("moves a branch slide down within its sequence (main line untouched)", () => {
|
|
const m = reorderBranchSlide(base, "b1", "a", "down");
|
|
expect(m.slideSequences?.[0].slides.map((s) => s.sceneId)).toEqual(["b", "a", "c"]);
|
|
expect(m.slides).toEqual(base.slides);
|
|
});
|
|
|
|
it("is a no-op at the boundary and for an unknown branch/scene", () => {
|
|
expect(reorderBranchSlide(base, "b1", "a", "up").slideSequences?.[0].slides[0].sceneId).toBe(
|
|
"a",
|
|
);
|
|
expect(reorderBranchSlide(base, "nope", "a", "down")).toEqual(base);
|
|
});
|
|
});
|
|
|
|
// ── setSlideNotes ──────────────────────────────────────────────────────────
|
|
|
|
describe("setSlideNotes", () => {
|
|
it("updates notes on an existing slide", () => {
|
|
const m = setSlideNotes({ slides: [{ sceneId: "a" }] }, "a", "hello");
|
|
expect(m.slides[0]).toMatchObject({ sceneId: "a", notes: "hello" });
|
|
});
|
|
|
|
it("creates the slide entry if absent", () => {
|
|
const m = setSlideNotes({ slides: [] }, "a", "note");
|
|
expect(m.slides).toEqual([{ sceneId: "a", notes: "note" }]);
|
|
});
|
|
});
|
|
|
|
// ── branch-scoped authoring (Finding #14) ──────────────────────────────────
|
|
|
|
describe("branch-scoped editing (sequenceId)", () => {
|
|
const base: SlideshowManifest = {
|
|
slides: [{ sceneId: "a" }],
|
|
slideSequences: [{ id: "seq-1", label: "Branch", slides: [{ sceneId: "b" }] }],
|
|
};
|
|
|
|
it("setSlideNotes edits the branch slide, leaving the main line untouched", () => {
|
|
const m = setSlideNotes(base, "b", "branch note", "seq-1");
|
|
expect(m.slideSequences?.[0]?.slides[0]).toMatchObject({ sceneId: "b", notes: "branch note" });
|
|
expect(m.slides[0]).toEqual({ sceneId: "a" }); // main line unchanged
|
|
});
|
|
|
|
it("setSlideNotes does NOT auto-add a slide to a branch when the scene is not assigned", () => {
|
|
const m = setSlideNotes(base, "z", "nope", "seq-1");
|
|
expect(m.slideSequences?.[0]?.slides).toEqual([{ sceneId: "b" }]);
|
|
expect(m.slides).toEqual([{ sceneId: "a" }]);
|
|
});
|
|
|
|
it("addFragment edits the branch slide and does not auto-add when unassigned", () => {
|
|
const added = addFragment(base, "b", 1.5, "seq-1");
|
|
expect(added.slideSequences?.[0]?.slides[0]?.fragments).toEqual([1.5]);
|
|
const noAdd = addFragment(base, "z", 2.0, "seq-1");
|
|
expect(noAdd.slideSequences?.[0]?.slides).toEqual([{ sceneId: "b" }]);
|
|
});
|
|
|
|
it("addHotspot edits the branch slide and does not auto-add when unassigned", () => {
|
|
const hotspot = { id: "h1", label: "Why", target: "seq-2" };
|
|
const added = addHotspot(base, "b", hotspot, "seq-1");
|
|
expect(added.slideSequences?.[0]?.slides[0]?.hotspots).toEqual([hotspot]);
|
|
const noAdd = addHotspot(base, "z", hotspot, "seq-1");
|
|
expect(noAdd.slideSequences?.[0]?.slides).toEqual([{ sceneId: "b" }]);
|
|
});
|
|
});
|
|
|
|
// ── addFragment ───────────────────────────────────────────────────────────
|
|
|
|
describe("addFragment", () => {
|
|
it("adds a fragment time to a slide", () => {
|
|
const m = addFragment({ slides: [{ sceneId: "a" }] }, "a", 1.5);
|
|
expect(m.slides[0]?.fragments).toEqual([1.5]);
|
|
});
|
|
|
|
it("deduplicates repeated fragment values", () => {
|
|
const m1 = addFragment({ slides: [{ sceneId: "a" }] }, "a", 1.5);
|
|
const m2 = addFragment(m1, "a", 1.5);
|
|
expect(m2.slides[0]?.fragments).toEqual([1.5]);
|
|
});
|
|
|
|
it("keeps fragments sorted ascending", () => {
|
|
let m: SlideshowManifest = { slides: [{ sceneId: "a" }] };
|
|
m = addFragment(m, "a", 3.0);
|
|
m = addFragment(m, "a", 1.0);
|
|
m = addFragment(m, "a", 2.0);
|
|
expect(m.slides[0]?.fragments).toEqual([1.0, 2.0, 3.0]);
|
|
});
|
|
|
|
it("creates the slide entry if absent", () => {
|
|
const m = addFragment({ slides: [] }, "a", 0.5);
|
|
expect(m.slides[0]).toMatchObject({ sceneId: "a", fragments: [0.5] });
|
|
});
|
|
});
|
|
|
|
// ── removeFragment ─────────────────────────────────────────────────────────
|
|
|
|
describe("removeFragment", () => {
|
|
it("removes the specified fragment", () => {
|
|
const m = removeFragment({ slides: [{ sceneId: "a", fragments: [1.0, 2.0] }] }, "a", 1.0);
|
|
expect(m.slides[0]?.fragments).toEqual([2.0]);
|
|
});
|
|
|
|
it("no-ops when fragment not present", () => {
|
|
const m = removeFragment({ slides: [{ sceneId: "a", fragments: [1.0] }] }, "a", 9.0);
|
|
expect(m.slides[0]?.fragments).toEqual([1.0]);
|
|
});
|
|
});
|
|
|
|
// ── createSequence ─────────────────────────────────────────────────────────
|
|
|
|
describe("createSequence", () => {
|
|
it("creates a new sequence", () => {
|
|
const m = createSequence({ slides: [] }, "seq-1", "Branch A");
|
|
expect(m.slideSequences).toEqual([{ id: "seq-1", label: "Branch A", slides: [] }]);
|
|
});
|
|
|
|
it("rejects duplicate ids", () => {
|
|
const m1 = createSequence({ slides: [] }, "seq-1", "Branch A");
|
|
const m2 = createSequence(m1, "seq-1", "Branch A duplicate");
|
|
expect((m2.slideSequences ?? []).length).toBe(1);
|
|
});
|
|
|
|
it("preserves existing sequences", () => {
|
|
const m1 = createSequence({ slides: [] }, "seq-1", "A");
|
|
const m2 = createSequence(m1, "seq-2", "B");
|
|
expect((m2.slideSequences ?? []).length).toBe(2);
|
|
});
|
|
});
|
|
|
|
// ── renameSequence ─────────────────────────────────────────────────────────
|
|
|
|
describe("renameSequence", () => {
|
|
it("renames a sequence label", () => {
|
|
const m = renameSequence(
|
|
{ slides: [], slideSequences: [{ id: "seq-1", label: "Old", slides: [] }] },
|
|
"seq-1",
|
|
"New",
|
|
);
|
|
expect(m.slideSequences?.[0]?.label).toBe("New");
|
|
});
|
|
|
|
it("no-ops on unknown id", () => {
|
|
const input: SlideshowManifest = {
|
|
slides: [],
|
|
slideSequences: [{ id: "seq-1", label: "A", slides: [] }],
|
|
};
|
|
const m = renameSequence(input, "unknown", "B");
|
|
expect(m.slideSequences?.[0]?.label).toBe("A");
|
|
});
|
|
});
|
|
|
|
// ── deleteSequence ─────────────────────────────────────────────────────────
|
|
|
|
describe("deleteSequence", () => {
|
|
it("removes the sequence by id", () => {
|
|
const m = deleteSequence(
|
|
{ slides: [], slideSequences: [{ id: "seq-1", label: "A", slides: [] }] },
|
|
"seq-1",
|
|
);
|
|
expect(m.slideSequences).toEqual([]);
|
|
});
|
|
|
|
it("removes hotspots targeting the deleted sequence from main-line slides", () => {
|
|
const input: SlideshowManifest = {
|
|
slides: [
|
|
{
|
|
sceneId: "s1",
|
|
hotspots: [
|
|
{ id: "h1", label: "Go deep", target: "deep" },
|
|
{ id: "h2", label: "Other", target: "other-seq" },
|
|
],
|
|
},
|
|
],
|
|
slideSequences: [
|
|
{ id: "deep", label: "Deep", slides: [] },
|
|
{ id: "other-seq", label: "Other", slides: [] },
|
|
],
|
|
};
|
|
const m = deleteSequence(input, "deep");
|
|
expect(m.slides[0]?.hotspots?.map((h) => h.id)).toEqual(["h2"]);
|
|
expect(m.slideSequences?.some((s) => s.id === "deep")).toBe(false);
|
|
// Verify no slide anywhere references 'deep'
|
|
const allHotspotTargets = [
|
|
...m.slides.flatMap((s) => (s.hotspots ?? []).map((h) => h.target)),
|
|
...(m.slideSequences ?? []).flatMap((seq) =>
|
|
seq.slides.flatMap((s) => (s.hotspots ?? []).map((h) => h.target)),
|
|
),
|
|
];
|
|
expect(allHotspotTargets).not.toContain("deep");
|
|
});
|
|
|
|
it("removes hotspots targeting the deleted sequence from sequence slides", () => {
|
|
const input: SlideshowManifest = {
|
|
slides: [],
|
|
slideSequences: [
|
|
{ id: "deep", label: "Deep", slides: [] },
|
|
{
|
|
id: "other",
|
|
label: "Other",
|
|
slides: [
|
|
{
|
|
sceneId: "s2",
|
|
hotspots: [{ id: "h3", label: "To deep", target: "deep" }],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
const m = deleteSequence(input, "deep");
|
|
const otherSeq = m.slideSequences?.find((s) => s.id === "other");
|
|
expect(otherSeq?.slides[0]?.hotspots).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// ── assignToBranch ─────────────────────────────────────────────────────────
|
|
|
|
describe("assignToBranch", () => {
|
|
it("assigns a scene to a branch", () => {
|
|
const m = assignToBranch(
|
|
{ slides: [], slideSequences: [{ id: "seq-1", label: "A", slides: [] }] },
|
|
"seq-1",
|
|
"s1",
|
|
true,
|
|
);
|
|
expect(m.slideSequences?.[0]?.slides).toEqual([{ sceneId: "s1" }]);
|
|
});
|
|
|
|
it("does not duplicate when assigning twice", () => {
|
|
let m: SlideshowManifest = {
|
|
slides: [],
|
|
slideSequences: [{ id: "seq-1", label: "A", slides: [] }],
|
|
};
|
|
m = assignToBranch(m, "seq-1", "s1", true);
|
|
m = assignToBranch(m, "seq-1", "s1", true);
|
|
expect(m.slideSequences?.[0]?.slides.length).toBe(1);
|
|
});
|
|
|
|
it("removes a scene when assign=false", () => {
|
|
const m = assignToBranch(
|
|
{
|
|
slides: [],
|
|
slideSequences: [{ id: "seq-1", label: "A", slides: [{ sceneId: "s1" }] }],
|
|
},
|
|
"seq-1",
|
|
"s1",
|
|
false,
|
|
);
|
|
expect(m.slideSequences?.[0]?.slides).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// ── addHotspot / removeHotspot ─────────────────────────────────────────────
|
|
|
|
describe("addHotspot", () => {
|
|
it("adds a hotspot to a slide", () => {
|
|
const m = addHotspot({ slides: [{ sceneId: "a" }] }, "a", {
|
|
id: "h1",
|
|
label: "Go to B",
|
|
target: "seq-b",
|
|
});
|
|
expect(m.slides[0]?.hotspots).toEqual([{ id: "h1", label: "Go to B", target: "seq-b" }]);
|
|
});
|
|
|
|
it("does not duplicate hotspot ids", () => {
|
|
let m: SlideshowManifest = { slides: [{ sceneId: "a" }] };
|
|
m = addHotspot(m, "a", { id: "h1", label: "X", target: "seq-b" });
|
|
m = addHotspot(m, "a", { id: "h1", label: "Y", target: "seq-c" });
|
|
expect(m.slides[0]?.hotspots?.length).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("removeHotspot", () => {
|
|
it("removes a hotspot by id", () => {
|
|
const m = removeHotspot(
|
|
{
|
|
slides: [{ sceneId: "a", hotspots: [{ id: "h1", label: "X", target: "seq-b" }] }],
|
|
},
|
|
"a",
|
|
"h1",
|
|
);
|
|
expect(m.slides[0]?.hotspots).toEqual([]);
|
|
});
|
|
|
|
it("no-ops for unknown hotspot id", () => {
|
|
const m = removeHotspot(
|
|
{
|
|
slides: [{ sceneId: "a", hotspots: [{ id: "h1", label: "X", target: "seq-b" }] }],
|
|
},
|
|
"a",
|
|
"no-such-id",
|
|
);
|
|
expect(m.slides[0]?.hotspots?.length).toBe(1);
|
|
});
|
|
});
|
|
|
|
// ── safeParseManifest ──────────────────────────────────────────────────────
|
|
|
|
describe("safeParseManifest", () => {
|
|
it("parses a valid slideshow island", () => {
|
|
const manifest = { slides: [{ sceneId: "a" }] };
|
|
const island = `<script type="application/hyperframes-slideshow+json">${JSON.stringify(manifest)}</script>`;
|
|
const html = `<html><body>${island}</body></html>`;
|
|
const result = safeParseManifest(html);
|
|
expect(result.slides[0]?.sceneId).toBe("a");
|
|
});
|
|
|
|
it("returns {slides:[]} for malformed JSON in the island", () => {
|
|
const html = `<html><body><script type="application/hyperframes-slideshow+json">NOT_JSON</script></body></html>`;
|
|
const result = safeParseManifest(html);
|
|
expect(result).toEqual({ slides: [] });
|
|
});
|
|
|
|
it("returns {slides:[]} when no island is present", () => {
|
|
const result = safeParseManifest("<html><body></body></html>");
|
|
expect(result).toEqual({ slides: [] });
|
|
});
|
|
});
|
|
|
|
// ── makeSlideshowNotesController ──────────────────────────────────────────
|
|
//
|
|
// These tests prove the two stale-closure invariants without needing a DOM:
|
|
// (a) Notes typed in comp A always flush to comp A's callback, never comp B's.
|
|
// (b) A discrete action after typing does NOT drop the typed note.
|
|
|
|
describe("makeSlideshowNotesController", () => {
|
|
beforeEach(() => {
|
|
vi.useFakeTimers();
|
|
});
|
|
afterEach(() => {
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
it("(a) typing notes then switching composition flushes to the ORIGINAL callback", () => {
|
|
const ctrl = makeSlideshowNotesController();
|
|
const persistA = vi.fn().mockResolvedValue(undefined);
|
|
const persistB = vi.fn().mockResolvedValue(undefined);
|
|
|
|
const manifestA = { slides: [{ sceneId: "s1", notes: "typed in A" }] };
|
|
const manifestB = { slides: [{ sceneId: "s2" }] };
|
|
|
|
// User types a note in composition A — schedules debounce with persistA.
|
|
ctrl.schedule(manifestA, persistA, 450);
|
|
|
|
// Before the debounce fires, the composition switches to B.
|
|
// The panel calls flush() so the pending notes go to A's callback.
|
|
ctrl.flush();
|
|
|
|
// Now the panel re-schedules with B's manifest + callback.
|
|
ctrl.schedule(manifestB, persistB, 450);
|
|
|
|
// Advance time past the debounce delay.
|
|
vi.advanceTimersByTime(500);
|
|
|
|
// persistA must have been called with manifestA (the A-composition notes).
|
|
expect(persistA).toHaveBeenCalledOnce();
|
|
expect(persistA.mock.calls[0]?.[0]).toEqual(manifestA);
|
|
|
|
// persistB must have been called with manifestB (the B-composition timer).
|
|
expect(persistB).toHaveBeenCalledOnce();
|
|
expect(persistB.mock.calls[0]?.[0]).toEqual(manifestB);
|
|
});
|
|
|
|
it("(a) flush after composition switch does NOT call the new composition's callback", () => {
|
|
const ctrl = makeSlideshowNotesController();
|
|
const persistA = vi.fn().mockResolvedValue(undefined);
|
|
const persistB = vi.fn().mockResolvedValue(undefined);
|
|
|
|
const manifestA = { slides: [{ sceneId: "s1", notes: "A notes" }] };
|
|
|
|
ctrl.schedule(manifestA, persistA, 450);
|
|
// Simulate comp switch: flush before B's manifest arrives.
|
|
ctrl.flush();
|
|
|
|
// B never schedules anything.
|
|
|
|
vi.advanceTimersByTime(1000);
|
|
|
|
expect(persistA).toHaveBeenCalledOnce();
|
|
expect(persistB).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("(b) discrete action right after typing does NOT drop the note", () => {
|
|
const ctrl = makeSlideshowNotesController();
|
|
const persistNotes = vi.fn().mockResolvedValue(undefined);
|
|
|
|
const manifestWithNotes = { slides: [{ sceneId: "s1", notes: "hello" }] };
|
|
|
|
// User types "hello" — schedules debounce.
|
|
ctrl.schedule(manifestWithNotes, persistNotes, 450);
|
|
|
|
// Before debounce fires, user triggers a discrete action (e.g. mark fragment).
|
|
// The discrete manifest comes from the helper and does NOT include the note yet
|
|
// (it was computed from an older state snapshot).
|
|
const discreteManifest = { slides: [{ sceneId: "s1", fragments: [1.5] }] };
|
|
const merged = ctrl.mergeIntoDiscrete(discreteManifest);
|
|
|
|
// The merged manifest must include BOTH the fragment AND the note.
|
|
expect(merged.slides[0]).toMatchObject({ sceneId: "s1", notes: "hello", fragments: [1.5] });
|
|
|
|
// After mergeIntoDiscrete, pending is cleared — debounce no longer fires.
|
|
vi.advanceTimersByTime(500);
|
|
expect(persistNotes).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("(b) notes from a different scene are not merged into an unrelated slide", () => {
|
|
const ctrl = makeSlideshowNotesController();
|
|
const persistNotes = vi.fn().mockResolvedValue(undefined);
|
|
|
|
// Pending notes are for scene s1.
|
|
const manifestWithNotes = { slides: [{ sceneId: "s1", notes: "s1 notes" }] };
|
|
ctrl.schedule(manifestWithNotes, persistNotes, 450);
|
|
|
|
// Discrete action affects scene s2 only.
|
|
const discreteManifest = { slides: [{ sceneId: "s2", fragments: [2.0] }] };
|
|
const merged = ctrl.mergeIntoDiscrete(discreteManifest);
|
|
|
|
// s2 slide should have no notes (pending notes belong to s1 which is not in discrete).
|
|
expect(merged.slides[0]).toMatchObject({ sceneId: "s2" });
|
|
expect(merged.slides[0]?.notes).toBeUndefined();
|
|
});
|
|
|
|
it("flush is idempotent — second flush does nothing", () => {
|
|
const ctrl = makeSlideshowNotesController();
|
|
const persist = vi.fn().mockResolvedValue(undefined);
|
|
|
|
ctrl.schedule({ slides: [{ sceneId: "x" }] }, persist, 450);
|
|
ctrl.flush();
|
|
ctrl.flush();
|
|
|
|
expect(persist).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it("cancel clears pending without calling persist", () => {
|
|
const ctrl = makeSlideshowNotesController();
|
|
const persist = vi.fn().mockResolvedValue(undefined);
|
|
|
|
ctrl.schedule({ slides: [] }, persist, 450);
|
|
ctrl.cancel();
|
|
|
|
vi.advanceTimersByTime(1000);
|
|
expect(persist).not.toHaveBeenCalled();
|
|
});
|
|
});
|