A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
/* Copyright 2026 Marimo. All rights reserved. */
import { describe, it, expect } from "vitest";
import {
buildSlideIndices,
composeSlides,
computeDeckNavigation,
resolveDeckNavigationTarget,
resolveActiveCellIndex,
} from "../compose-slides";
import type { SlideType } from "@/components/editor/renderers/slides-layout/types";
interface Cell {
id: string;
/**
* Optional for ergonomics; mirrors the on-disk shape where a missing
* `type` means "use the default slide type". The `compose` helper below
* normalizes this to `"slide"` before passing through.
*/
type?: SlideType;
}
const compose = (cells: Cell[]) =>
composeSlides({
cells,
getType: (c) => c.type ?? "slide",
});
/**
* Collapse the tree to a readable shape so failures produce tiny, obvious
* diffs:
* stacks -> subslides -> blocks -> { f: isFragment, ids: [...] }
*/
const shape = (cells: Cell[]) =>
compose(cells).stacks.map((s) =>
s.subslides.map((sub) =>
sub.blocks.map((b) => ({
f: b.isFragment,
ids: b.cells.map((x) => x.id),
})),
),
);
describe("composeSlides", () => {
it("returns an empty composition for empty input", () => {
expect(compose([])).toEqual({ stacks: [] });
});
it("treats each 'slide' cell as its own stack", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b", type: "slide" },
{ id: "c", type: "slide" },
]),
).toEqual([
[[{ f: false, ids: ["a"] }]],
[[{ f: false, ids: ["b"] }]],
[[{ f: false, ids: ["c"] }]],
]);
});
it("nests 'sub-slide' cells under the current slide (vertical stack)", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b", type: "sub-slide" },
{ id: "c", type: "sub-slide" },
{ id: "d", type: "slide" },
]),
).toEqual([
[
[{ f: false, ids: ["a"] }],
[{ f: false, ids: ["b"] }],
[{ f: false, ids: ["c"] }],
],
[[{ f: false, ids: ["d"] }]],
]);
});
it("wraps fragments in their own block on the current subslide", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b", type: "fragment" },
{ id: "c", type: "fragment" },
]),
).toEqual([
[
[
{ f: false, ids: ["a"] },
{ f: true, ids: ["b"] },
{ f: true, ids: ["c"] },
],
],
]);
});
it("treats cells with no type as their own new slide (the default)", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b" },
{ id: "c", type: "fragment" },
{ id: "d" },
]),
).toEqual([
[[{ f: false, ids: ["a"] }]],
[
[
{ f: false, ids: ["b"] },
{ f: true, ids: ["c"] },
],
],
[[{ f: false, ids: ["d"] }]],
]);
});
it("creates an implicit initial subslide when the first cell is a fragment", () => {
expect(shape([{ id: "a", type: "fragment" }])).toEqual([
[[{ f: true, ids: ["a"] }]],
]);
});
it("creates an implicit initial stack when the first cell is a sub-slide", () => {
expect(
shape([
{ id: "a", type: "sub-slide" },
{ id: "b", type: "sub-slide" },
]),
).toEqual([[[{ f: false, ids: ["a"] }], [{ f: false, ids: ["b"] }]]]);
});
it("drops 'skip' cells from the deck", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b", type: "skip" },
{ id: "c", type: "fragment" },
]),
).toEqual([
[
[
{ f: false, ids: ["a"] },
{ f: true, ids: ["c"] },
],
],
]);
});
it("skip at the very start does not create an empty leading stack", () => {
expect(
shape([
{ id: "a", type: "skip" },
{ id: "b", type: "slide" },
]),
).toEqual([[[{ f: false, ids: ["b"] }]]]);
});
it("opens a fresh fragment block for each consecutive fragment cell", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b", type: "fragment" },
{ id: "c", type: "fragment" },
{ id: "d", type: "fragment" },
]),
).toEqual([
[
[
{ f: false, ids: ["a"] },
{ f: true, ids: ["b"] },
{ f: true, ids: ["c"] },
{ f: true, ids: ["d"] },
],
],
]);
});
it("resets fragment context when a new subslide opens", () => {
expect(
shape([
{ id: "a", type: "slide" },
{ id: "b", type: "fragment" },
{ id: "c", type: "sub-slide" },
{ id: "d", type: "fragment" },
]),
).toEqual([
[
[
{ f: false, ids: ["a"] },
{ f: true, ids: ["b"] },
],
[
{ f: false, ids: ["c"] },
{ f: true, ids: ["d"] },
],
],
]);
});
it("handles a realistic mixed sequence", () => {
expect(
shape([
{ id: "title", type: "slide" },
{ id: "intro", type: "fragment" },
{ id: "deep", type: "sub-slide" },
{ id: "deep-body", type: "fragment" },
{ id: "debug", type: "skip" },
{ id: "outro", type: "slide" },
]),
).toEqual([
[
[
{ f: false, ids: ["title"] },
{ f: true, ids: ["intro"] },
],
[
{ f: false, ids: ["deep"] },
{ f: true, ids: ["deep-body"] },
],
],
[[{ f: false, ids: ["outro"] }]],
]);
});
it("is generic over cell shape (preserves object identity)", () => {
const a = { id: "a", type: "slide" as const, extra: 42 };
const b = { id: "b", type: "fragment" as const, extra: 7 };
const result = composeSlides({ cells: [a, b], getType: (c) => c.type });
expect(result.stacks[0].subslides[0].blocks[0].cells[0]).toBe(a);
expect(result.stacks[0].subslides[0].blocks[1].cells[0]).toBe(b);
});
});
describe("buildSlideIndices", () => {
const build = (cells: Cell[]) => {
const composition = composeSlides({
cells,
getType: (c) => c.type ?? "slide",
});
return buildSlideIndices({ composition, cells, getId: (c) => c.id });
};
it("maps each cell to its {h, v, f} location", () => {
const cells: Cell[] = [
{ id: "a", type: "slide" },
{ id: "b", type: "fragment" },
{ id: "c", type: "sub-slide" },
{ id: "d", type: "slide" },
{ id: "e", type: "fragment" },
{ id: "f", type: "fragment" },
];
const { cellToTarget } = build(cells);
expect(cellToTarget.get("a")).toEqual({ h: 0, v: 0, f: -1 });
expect(cellToTarget.get("b")).toEqual({ h: 0, v: 0, f: 0 });
expect(cellToTarget.get("c")).toEqual({ h: 0, v: 1, f: -1 });
expect(cellToTarget.get("d")).toEqual({ h: 1, v: 0, f: -1 });
expect(cellToTarget.get("e")).toEqual({ h: 1, v: 0, f: 0 });
expect(cellToTarget.get("f")).toEqual({ h: 1, v: 0, f: 1 });
});
it("maps {h, v, f} back to the flat index of the last visible cell", () => {
const cells: Cell[] = [
{ id: "a", type: "slide" },
{ id: "b", type: "fragment" },
{ id: "c", type: "fragment" },
];
const { targetToCellIndex } = build(cells);
// Before any fragment is revealed, the active cell is the last pre-fragment cell.
expect(targetToCellIndex.get("0,0,-1")).toBe(0); // "a"
// After fragment 0 is shown, active advances to "b".
expect(targetToCellIndex.get("0,0,0")).toBe(1); // "b"
// After fragment 1 is shown, active advances to "c".
expect(targetToCellIndex.get("0,0,1")).toBe(2); // "c"
});
it("populates f=-1 with the first cell when the subslide starts with a fragment", () => {
const cells: Cell[] = [{ id: "a", type: "fragment" }];
const { targetToCellIndex } = build(cells);
expect(targetToCellIndex.get("0,0,-1")).toBe(0);
expect(targetToCellIndex.get("0,0,0")).toBe(0);
});
it("drops skipped cells from the index entirely", () => {
const cells: Cell[] = [
{ id: "a", type: "slide" },
{ id: "b", type: "skip" },
];
const { cellToTarget } = build(cells);
expect(cellToTarget.has("a")).toBe(true);
expect(cellToTarget.has("b")).toBe(false);
});
});
describe("resolveActiveCellIndex", () => {
const map = new Map<string, number>([
["0,0,-1", 0],
["0,0,0", 1],
["0,0,1", 2],
["1,0,-1", 3],
]);
it("returns the exact match when one exists", () => {
expect(resolveActiveCellIndex(map, { h: 0, v: 0, f: 1 })).toBe(2);
});
it("falls back to f=-1 when there is no fragment-specific entry", () => {
// reveal may report f=0 for slides without any fragments
expect(resolveActiveCellIndex(map, { h: 1, v: 0, f: 0 })).toBe(3);
});
it("returns undefined for unknown stacks", () => {
expect(resolveActiveCellIndex(map, { h: 9, v: 0, f: 0 })).toBeUndefined();
});
});
describe("resolveDeckNavigationTarget", () => {
const resolve = (cells: Cell[], activeIndex: number | undefined) => {
const composition = compose(cells);
const { cellToTarget } = buildSlideIndices({
composition,
cells,
getId: (cell) => cell.id,
});
return resolveDeckNavigationTarget({
activeIndex,
cells,
cellToTarget,
getId: (cell) => cell.id,
});
};
it("returns the selected cell target when the cell is part of the deck", () => {
expect(
resolve(
[
{ id: "a", type: "slide" },
{ id: "b", type: "fragment" },
],
1,
),
).toEqual({ h: 0, v: 0, f: 0 });
});
it("parks a skipped cell on the closest earlier deck cell", () => {
expect(
resolve(
[
{ id: "a", type: "slide" },
{ id: "skip", type: "skip" },
{ id: "b", type: "slide" },
],
1,
),
).toEqual({ h: 0, v: 0, f: -1 });
});
it("falls forward when a skipped cell appears before any real slide", () => {
expect(
resolve(
[
{ id: "skip", type: "skip" },
{ id: "a", type: "slide" },
],
0,
),
).toEqual({ h: 0, v: 0, f: -1 });
});
it("returns undefined when there is no real slide to park on", () => {
expect(resolve([{ id: "skip", type: "skip" }], 0)).toBeUndefined();
});
});
describe("computeDeckNavigation", () => {
it("returns null when the deck is already on a non-fragment target", () => {
expect(
computeDeckNavigation({ h: 0, v: 0, f: -1 }, { h: 0, v: 0, f: -1 }),
).toBeNull();
});
it("returns null when the deck is already on the target fragment", () => {
expect(
computeDeckNavigation({ h: 0, v: 0, f: 1 }, { h: 0, v: 0, f: 1 }),
).toBeNull();
});
it("navigates to a different stack", () => {
expect(
computeDeckNavigation({ h: 0, v: 0, f: -1 }, { h: 2, v: 0, f: -1 }),
).toEqual({ h: 2, v: 0, f: -1 });
});
it("navigates to a different subslide within the same stack", () => {
expect(
computeDeckNavigation({ h: 1, v: 0, f: -1 }, { h: 1, v: 2, f: -1 }),
).toEqual({ h: 1, v: 2, f: -1 });
});
it("collapses revealed fragments when jumping to the parent slide", () => {
// Regression: previously left `f` unchanged, so the deck would stay on
// the last-revealed fragment when the user clicked the parent slide in
// the minimap.
expect(
computeDeckNavigation({ h: 0, v: 0, f: 2 }, { h: 0, v: 0, f: -1 }),
).toEqual({ h: 0, v: 0, f: -1 });
});
it("collapses fragments when jumping to a parent slide in a different stack", () => {
expect(
computeDeckNavigation({ h: 1, v: 0, f: 3 }, { h: 0, v: 0, f: -1 }),
).toEqual({ h: 0, v: 0, f: -1 });
});
it("advances to a specific fragment on the same slide", () => {
expect(
computeDeckNavigation({ h: 0, v: 0, f: -1 }, { h: 0, v: 0, f: 2 }),
).toEqual({ h: 0, v: 0, f: 2 });
});
it("rewinds to an earlier fragment on the same slide", () => {
expect(
computeDeckNavigation({ h: 0, v: 0, f: 3 }, { h: 0, v: 0, f: 1 }),
).toEqual({ h: 0, v: 0, f: 1 });
});
it("jumps across stacks directly to a fragment", () => {
expect(
computeDeckNavigation({ h: 0, v: 0, f: -1 }, { h: 2, v: 1, f: 0 }),
).toEqual({ h: 2, v: 1, f: 0 });
});
});