Files
hyperframes/packages/studio/src/components/panels/SlideshowPanel.test.ts
T
Vance Ingalls f05b3f9c7c fix(slideshow): finish remaining split-PR review findings (#1594)
* 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).
2026-06-19 04:31:12 -07:00

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();
});
});