taleem-slides 0.3.0

package/tests/slides.imageWithCaption.test.js

@@ -0,0 +1,44 @@
+import { describe, test, expect } from "vitest";
+import { ImageWithCaptionSlide } from "../src/slides/ImageWithCaptionSlide.js";
+
+describe("imageWithCaption", () => {
+  test("builds with image and caption", () => {
+    const raw = {
+      type: "imageWithCaption",
+      data: [
+        { name: "image", content: "photo.png" },
+        { name: "caption", content: "A caption" }
+      ]
+    };
+
+    const slide = ImageWithCaptionSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("photo.png");
+    expect(html).toContain("A caption");
+  });
+
+  test("throws if image or caption missing", () => {
+    expect(() =>
+      ImageWithCaptionSlide.fromJSON({
+        type: "imageWithCaption",
+        data: [{ name: "image", content: "photo.png" }]
+      })
+    ).toThrow("imageWithCaption: image and caption required");
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "imageWithCaption",
+      data: [
+        { name: "image", content: "x.png" },
+        { name: "caption", content: "Y" }
+      ]
+    };
+
+    const a = ImageWithCaptionSlide.fromJSON(raw);
+    const b = ImageWithCaptionSlide.fromJSON(raw);
+
+    expect(a.render()).toBe(b.render());
+  });
+});

package/tests/slides.imageWithTitle.test.js

@@ -0,0 +1,45 @@
+
+import { describe, test, expect } from "vitest";
+import { ImageWithTitleSlide } from "../src/slides/ImageWithTitleSlide.js";
+
+describe("imageWithTitle", () => {
+  test("builds with image and title", () => {
+    const raw = {
+      type: "imageWithTitle",
+      data: [
+        { name: "image", content: "hero.png" },
+        { name: "title", content: "Hello World" }
+      ]
+    };
+
+    const slide = ImageWithTitleSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("hero.png");
+    expect(html).toContain("Hello World");
+  });
+
+  test("throws if image or title missing", () => {
+    expect(() =>
+      ImageWithTitleSlide.fromJSON({
+        type: "imageWithTitle",
+        data: [{ name: "title", content: "Only title" }]
+      })
+    ).toThrow("imageWithTitle: image and title required");
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "imageWithTitle",
+      data: [
+        { name: "image", content: "a.png" },
+        { name: "title", content: "B" }
+      ]
+    };
+
+    const a = ImageWithTitleSlide.fromJSON(raw);
+    const b = ImageWithTitleSlide.fromJSON(raw);
+
+    expect(a.render()).toBe(b.render());
+  });
+});

package/tests/slides.quoteSlide.test.js

@@ -0,0 +1,28 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("quoteSlide", () => {
+  test("builds with quote", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{
+        type: "quoteSlide",
+        data: [{ name: "quote", content: "Hello" }]
+      }]
+    };
+
+    const manager = slideBuilder(deck);
+    const html = manager.renderSlide(0);
+
+    expect(html).toContain("Hello");
+  });
+
+  test("throws without quote", () => {
+    expect(() =>
+      slideBuilder({
+        version: "deck-v1",
+        deck: [{ type: "quoteSlide", data: [] }]
+      })
+    ).toThrow();
+  });
+});

package/tests/slides.quoteWithImage.test.js

@@ -0,0 +1,46 @@
+import { describe, test, expect } from "vitest";
+import { QuoteWithImageSlide } from "../src/slides/QuoteWithImageSlide.js";
+
+describe("quoteWithImage", () => {
+  test("builds with quote and image", () => {
+    const raw = {
+      type: "quoteWithImage",
+      data: [
+        { name: "quote", content: "Stay hungry" },
+        { name: "image", content: "img.png" },
+        { name: "author", content: "Steve Jobs" }
+      ]
+    };
+
+    const slide = QuoteWithImageSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("Stay hungry");
+    expect(html).toContain("img.png");
+    expect(html).toContain("Steve Jobs");
+  });
+
+  test("throws if quote or image missing", () => {
+    expect(() =>
+      QuoteWithImageSlide.fromJSON({
+        type: "quoteWithImage",
+        data: [{ name: "quote", content: "Only quote" }]
+      })
+    ).toThrow("quoteWithImage: quote and image required");
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "quoteWithImage",
+      data: [
+        { name: "quote", content: "A" },
+        { name: "image", content: "b.png" }
+      ]
+    };
+
+    const a = QuoteWithImageSlide.fromJSON(raw);
+    const b = QuoteWithImageSlide.fromJSON(raw);
+
+    expect(a.render()).toBe(b.render());
+  });
+});

package/tests/slides.statistic.test.js

@@ -0,0 +1,44 @@
+import { describe, test, expect } from "vitest";
+import { StatisticSlide } from "../src/slides/StatisticSlide.js";
+
+describe("statistic", () => {
+  test("builds with label and value", () => {
+    const raw = {
+      type: "statistic",
+      data: [
+        { name: "label", content: "Users" },
+        { name: "value", content: 120 }
+      ]
+    };
+
+    const slide = StatisticSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("Users");
+    expect(html).toContain("120");
+  });
+
+  test("throws if label or value missing", () => {
+    expect(() =>
+      StatisticSlide.fromJSON({
+        type: "statistic",
+        data: [{ name: "label", content: "Only label" }]
+      })
+    ).toThrow("statistic: requires label and value");
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "statistic",
+      data: [
+        { name: "label", content: "X" },
+        { name: "value", content: 5 }
+      ]
+    };
+
+    const a = StatisticSlide.fromJSON(raw);
+    const b = StatisticSlide.fromJSON(raw);
+
+    expect(a.render()).toBe(b.render());
+  });
+});

package/tests/slides.svgPointer.test.js

@@ -0,0 +1,37 @@
+import { describe, test, expect } from "vitest";
+import { SvgPointerSlide } from "../src/slides/SvgPointerSlide.js";
+
+describe("svgPointer", () => {
+  test("builds with svg content", () => {
+    const raw = {
+      type: "svgPointer",
+      data: [{ name: "svg", content: "<svg></svg>" }]
+    };
+
+    const slide = SvgPointerSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("<svg>");
+  });
+
+  test("throws if svg missing", () => {
+    expect(() =>
+      SvgPointerSlide.fromJSON({
+        type: "svgPointer",
+        data: []
+      })
+    ).toThrow("svgPointer: svg required");
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "svgPointer",
+      data: [{ name: "svg", content: "<svg></svg>" }]
+    };
+
+    const a = SvgPointerSlide.fromJSON(raw);
+    const b = SvgPointerSlide.fromJSON(raw);
+
+    expect(a.render()).toBe(b.render());
+  });
+});

package/tests/slides.table.test.js

@@ -0,0 +1,41 @@
+import { describe, test, expect } from "vitest";
+import { TableSlide } from "../src/slides/TableSlide.js";
+
+describe("table", () => {
+  test("builds with rows", () => {
+    const raw = {
+      type: "table",
+      data: [
+        { name: "row", content: ["A", "B"] },
+        { name: "row", content: ["C", "D"] }
+      ]
+    };
+
+    const slide = TableSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("<td>A</td>");
+    expect(html).toContain("<td>D</td>");
+  });
+
+  test("throws if no rows provided", () => {
+    expect(() =>
+      TableSlide.fromJSON({
+        type: "table",
+        data: []
+      })
+    ).toThrow("table: requires at least one row");
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "table",
+      data: [{ name: "row", content: ["X"] }]
+    };
+
+    const a = TableSlide.fromJSON(raw);
+    const b = TableSlide.fromJSON(raw);
+
+    expect(a.render()).toBe(b.render());
+  });
+});

package/tests/slides.test.js

@@ -0,0 +1,42 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("TitleSlide", () => {
+  test("render() is deterministic", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [
+        {
+          type: "titleSlide",
+          data: [{ name: "title", content: "Deterministic" }]
+        }
+      ]
+    };
+
+    const manager = slideBuilder(deck);
+
+    const html1 = manager.renderSlide(0);
+    const html2 = manager.renderSlide(0);
+
+    expect(html1).toBe(html2);
+  });
+
+  test("rendered output is immutable (string)", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [
+        {
+          type: "titleSlide",
+          data: [{ name: "title", content: "Frozen" }]
+        }
+      ]
+    };
+
+    const manager = slideBuilder(deck);
+    const html = manager.renderSlide(0);
+
+    expect(() => {
+      html.type = "hack";
+    }).toThrow();
+  });
+});

package/tests/slides.titleAndPara.test.js

@@ -0,0 +1,35 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("titleAndPara", () => {
+  test("builds successfully", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{
+        type: "titleAndPara",
+        data: [
+          { name: "title", content: "Heading" },
+          { name: "para", content: "Paragraph" }
+        ]
+      }]
+    };
+
+    const manager = slideBuilder(deck);
+    const html = manager.renderSlide(0);
+
+    expect(html).toContain("Heading");
+    expect(html).toContain("Paragraph");
+  });
+
+  test("throws on missing para", () => {
+    expect(() =>
+      slideBuilder({
+        version: "deck-v1",
+        deck: [{
+          type: "titleAndPara",
+          data: [{ name: "title", content: "X" }]
+        }]
+      })
+    ).toThrow();
+  });
+});

package/tests/slides.titleAndSubtitle.test.js

@@ -0,0 +1,32 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("titleAndSubtitle", () => {
+  test("builds successfully", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{
+        type: "titleAndSubtitle",
+        data: [
+          { name: "title", content: "Hello" },
+          { name: "subtitle", content: "World" }
+        ]
+      }]
+    };
+
+    const manager = slideBuilder(deck);
+    const html = manager.renderSlide(0);
+
+    expect(html).toContain("Hello");
+    expect(html).toContain("World");
+  });
+
+  test("throws on missing data", () => {
+    expect(() =>
+      slideBuilder({
+        version: "deck-v1",
+        deck: [{ type: "titleAndSubtitle", data: [] }]
+      })
+    ).toThrow();
+  });
+});

package/tests/slides.twoColumnText.test.js

@@ -0,0 +1,35 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("twoColumnText", () => {
+  test("builds with left and right", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{
+        type: "twoColumnText",
+        data: [
+          { name: "left", content: "L1" },
+          { name: "right", content: "R1" }
+        ]
+      }]
+    };
+
+    const manager = slideBuilder(deck);
+    const html = manager.renderSlide(0);
+
+    expect(html).toContain("L1");
+    expect(html).toContain("R1");
+  });
+
+  test("throws if one side missing", () => {
+    expect(() =>
+      slideBuilder({
+        version: "deck-v1",
+        deck: [{
+          type: "twoColumnText",
+          data: [{ name: "left", content: "Only" }]
+        }]
+      })
+    ).toThrow();
+  });
+});