taleem-slides 0.3.0

package/src/slides/QuoteWithImageSlide.js

@@ -0,0 +1,30 @@
+export const QuoteWithImageSlide = {
+    type: "quoteWithImage",
+  
+    fromJSON(raw) {
+      const quote = raw.data?.find(d => d.name === "quote")?.content;
+      const image = raw.data?.find(d => d.name === "image")?.content;
+      const author = raw.data?.find(d => d.name === "author")?.content;
+  
+      if (!quote || !image) {
+        throw new Error("quoteWithImage: quote and image required");
+      }
+  
+      return Object.freeze({
+        type: "quoteWithImage",
+        render() {
+          return `
+            <section class="slide quoteWithImage">
+              <img src="${image}" alt="" />
+              <blockquote>
+                <p>${quote}</p>
+                ${author ? `<footer>${author}</footer>` : ""}
+              </blockquote>
+            </section>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/StatisticSlide.js

@@ -0,0 +1,26 @@
+export const StatisticSlide = {
+    type: "statistic",
+  
+    fromJSON(raw) {
+      const label = raw.data?.find(d => d.name === "label")?.content;
+      const value = raw.data?.find(d => d.name === "value")?.content;
+  
+      if (!label || value === undefined) {
+        throw new Error("statistic: requires label and value");
+      }
+  
+      return Object.freeze({
+        type: "statistic",
+        render() {
+          return `
+            <section class="slide statistic">
+              <div class="stat-value">${value}</div>
+              <div class="stat-label">${label}</div>
+            </section>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/SvgPointerSlide.js

@@ -0,0 +1,22 @@
+export const SvgPointerSlide = {
+    type: "svgPointer",
+  
+    fromJSON(raw) {
+      const svg = raw.data?.find(d => d.name === "svg")?.content;
+  
+      if (!svg) throw new Error("svgPointer: svg required");
+  
+      return Object.freeze({
+        type: "svgPointer",
+        render() {
+          return `
+            <section class="slide svgPointer">
+              ${svg}
+            </section>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/TableSlide.js

@@ -0,0 +1,27 @@
+export const TableSlide = {
+    type: "table",
+  
+    fromJSON(raw) {
+      const rows = raw.data?.filter(d => d.name === "row").map(d => d.content);
+  
+      if (!rows || rows.length === 0) {
+        throw new Error("table: requires at least one row");
+      }
+  
+      return Object.freeze({
+        type: "table",
+        render() {
+          return `
+            <table class="slide table">
+              ${rows.map(
+                row =>
+                  `<tr>${row.map(cell => `<td>${cell}</td>`).join("")}</tr>`
+              ).join("")}
+            </table>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/TitleAndParaSlide.js

@@ -0,0 +1,26 @@
+export const TitleAndParaSlide = {
+    type: "titleAndPara",
+  
+    fromJSON(raw) {
+      const title = raw.data?.find(d => d.name === "title")?.content;
+      const para = raw.data?.find(d => d.name === "para")?.content;
+  
+      if (!title || !para) {
+        throw new Error("titleAndPara: requires title and para");
+      }
+  
+      return Object.freeze({
+        type: "titleAndPara",
+        render() {
+          return `
+            <section class="slide titleAndPara">
+              <h1>${title}</h1>
+              <p>${para}</p>
+            </section>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/TitleAndSubtitleSlide.js

@@ -0,0 +1,27 @@
+
+export const TitleAndSubtitleSlide = {
+    type: "titleAndSubtitle",
+  
+    fromJSON(raw) {
+      const title = raw.data?.find(d => d.name === "title")?.content;
+      const subtitle = raw.data?.find(d => d.name === "subtitle")?.content;
+  
+      if (!title || !subtitle) {
+        throw new Error("titleAndSubtitle: requires title and subtitle");
+      }
+  
+      return Object.freeze({
+        type: "titleAndSubtitle",
+        render() {
+          return `
+            <section class="slide titleAndSubtitle">
+              <h1>${title}</h1>
+              <h2>${subtitle}</h2>
+            </section>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/TitleSlide.js

@@ -0,0 +1,41 @@
+// src/slides/TitleSlide.js
+
+/**
+ * TitleSlide
+ * Private implementation – not exported publicly
+ */
+export const TitleSlide = {
+    type: "titleSlide",
+  
+    /**
+     * Build a TitleSlide from raw deck JSON
+     */
+    fromJSON(rawSlide, index) {
+      if (!Array.isArray(rawSlide.data)) {
+        throw new Error(`TitleSlide: data must be an array`);
+      }
+  
+      const titleItem = rawSlide.data.find(d => d.name === "title");
+  
+      if (!titleItem || typeof titleItem.content !== "string") {
+        throw new Error(`TitleSlide: missing or invalid title content`);
+      }
+  
+      const title = titleItem.content;
+  
+      // immutable slide object
+      return Object.freeze({
+        type: "titleSlide",
+  
+        render() {
+          return `
+            <div class="slide titleSlide">
+              <h1>${title}</h1>
+            </div>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/src/slides/TwoColumnTextSlide.js

@@ -0,0 +1,27 @@
+
+export const TwoColumnTextSlide = {
+    type: "twoColumnText",
+  
+    fromJSON(raw) {
+      const left = raw.data?.filter(d => d.name === "left").map(d => d.content);
+      const right = raw.data?.filter(d => d.name === "right").map(d => d.content);
+  
+      if (!left?.length || !right?.length) {
+        throw new Error("twoColumnText: requires left and right columns");
+      }
+  
+      return Object.freeze({
+        type: "twoColumnText",
+        render() {
+          return `
+            <section class="slide twoColumnText">
+              <div class="col left">${left.join("<br/>")}</div>
+              <div class="col right">${right.join("<br/>")}</div>
+            </section>
+          `;
+        }
+        
+      });
+    }
+  };
+  

package/tests/interpreter.test.js

@@ -0,0 +1,47 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("slideBuilder", () => {
+  test("builds slide manager from a valid deck", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [
+        {
+          type: "titleSlide",
+          start: 0,
+          end: 10,
+          data: [{ name: "title", content: "Hello World" }]
+        }
+      ]
+    };
+
+    const manager = slideBuilder(deck);
+
+    expect(manager).toBeDefined();
+    expect(typeof manager.renderSlide).toBe("function");
+
+    const html = manager.renderSlide(0);
+    expect(typeof html).toBe("string");
+    expect(html).toContain("Hello World");
+  });
+
+  test("throws on unknown slide type", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{ type: "unknownSlide", data: [] }]
+    };
+
+    expect(() => slideBuilder(deck)).toThrow(
+      /unsupported slide type "unknownSlide"/
+    );
+  });
+
+  test("throws on malformed slide data", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{ type: "titleSlide", data: [] }]
+    };
+
+    expect(() => slideBuilder(deck)).toThrow();
+  });
+});

package/tests/slides.barChart.test.js

@@ -0,0 +1,64 @@
+import { describe, test, expect } from "vitest";
+import { BarChartSlide } from "../src/slides/BarChartSlide.js";
+
+describe("barChart", () => {
+  test("builds successfully with valid bars", () => {
+    const raw = {
+      type: "barChart",
+      data: [
+        { name: "bar", content: { label: "A", value: 10 } },
+        { name: "bar", content: { label: "B", value: 20 } }
+      ]
+    };
+
+    const slide = BarChartSlide.fromJSON(raw);
+
+    expect(slide.type).toBe("barChart");
+
+    const html = slide.render();
+
+    // semantic assertions (NOT snapshot)
+    expect(html).toContain("A");
+    expect(html).toContain("10");
+    expect(html).toContain("B");
+    expect(html).toContain("20");
+  });
+
+  test("throws if no bars are provided", () => {
+    const raw = {
+      type: "barChart",
+      data: []
+    };
+
+    expect(() => BarChartSlide.fromJSON(raw)).toThrow(
+      "barChart: requires at least one bar"
+    );
+  });
+
+  test("throws on invalid bar structure", () => {
+    const raw = {
+      type: "barChart",
+      data: [
+        { name: "bar", content: { label: "A", value: "wrong" } }
+      ]
+    };
+
+    expect(() => BarChartSlide.fromJSON(raw)).toThrow(
+      "barChart: invalid bar"
+    );
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "barChart",
+      data: [
+        { name: "bar", content: { label: "X", value: 5 } }
+      ]
+    };
+
+    const slide1 = BarChartSlide.fromJSON(raw);
+    const slide2 = BarChartSlide.fromJSON(raw);
+
+    expect(slide1.render()).toBe(slide2.render());
+  });
+});

package/tests/slides.bigNumber.test.js

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

package/tests/slides.bulletList.test.js

@@ -0,0 +1,32 @@
+import { describe, test, expect } from "vitest";
+import { slideBuilder } from "../src/interpreter/slideBuilder.js";
+
+describe("bulletList", () => {
+  test("builds with bullets", () => {
+    const deck = {
+      version: "deck-v1",
+      deck: [{
+        type: "bulletList",
+        data: [
+          { name: "bullet", content: "A" },
+          { name: "bullet", content: "B" }
+        ]
+      }]
+    };
+
+    const manager = slideBuilder(deck);
+    const html = manager.renderSlide(0);
+
+    expect(html).toContain("A");
+    expect(html).toContain("B");
+  });
+
+  test("throws with no bullets", () => {
+    expect(() =>
+      slideBuilder({
+        version: "deck-v1",
+        deck: [{ type: "bulletList", data: [] }]
+      })
+    ).toThrow();
+  });
+});

package/tests/slides.contactSlide.test.js

@@ -0,0 +1,48 @@
+import { describe, test, expect } from "vitest";
+import { ContactSlide } from "../src/slides/ContactSlide.js";
+
+describe("contactSlide", () => {
+  test("builds with contact items", () => {
+    const raw = {
+      type: "contactSlide",
+      data: [
+        { name: "line", content: "Email: test@example.com" },
+        { name: "line", content: "Phone: 123456" }
+      ]
+    };
+
+    const slide = ContactSlide.fromJSON(raw);
+
+    expect(slide.type).toBe("contactSlide");
+
+    const html = slide.render();
+
+    expect(html).toContain("Email: test@example.com");
+    expect(html).toContain("Phone: 123456");
+  });
+
+  test("throws if no content is provided", () => {
+    const raw = {
+      type: "contactSlide",
+      data: []
+    };
+
+    expect(() => ContactSlide.fromJSON(raw)).toThrow(
+      "contactSlide: content required"
+    );
+  });
+
+  test("render output is deterministic", () => {
+    const raw = {
+      type: "contactSlide",
+      data: [
+        { name: "line", content: "Address: Somewhere" }
+      ]
+    };
+
+    const slide1 = ContactSlide.fromJSON(raw);
+    const slide2 = ContactSlide.fromJSON(raw);
+
+    expect(slide1.render()).toBe(slide2.render());
+  });
+});

package/tests/slides.cornerWordsSlide.test.js

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

package/tests/slides.donutChart.test.js

@@ -0,0 +1,28 @@
+import { describe, test, expect } from "vitest";
+import { DonutChartSlide } from "../src/slides/DonutChartSlide.js";
+
+describe("donutChart", () => {
+  test("builds with segments", () => {
+    const raw = {
+      type: "donutChart",
+      data: [
+        { name: "segment", content: { label: "A", value: 40 } },
+        { name: "segment", content: { label: "B", value: 60 } }
+      ]
+    };
+
+    const slide = DonutChartSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("A");
+    expect(html).toContain("40");
+    expect(html).toContain("B");
+    expect(html).toContain("60");
+  });
+
+  test("throws without segments", () => {
+    expect(() =>
+      DonutChartSlide.fromJSON({ type: "donutChart", data: [] })
+    ).toThrow("donutChart: requires at least one segment");
+  });
+});

package/tests/slides.eq.test.js

@@ -0,0 +1,26 @@
+import { describe, test, expect } from "vitest";
+import { EqSlide } from "../src/slides/EqSlide.js";
+
+describe("eq", () => {
+  test("renders equations", () => {
+    const raw = {
+      type: "eq",
+      data: [
+        { content: "a + b = c" },
+        { content: "x = y" }
+      ]
+    };
+
+    const slide = EqSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("a + b = c");
+    expect(html).toContain("x = y");
+  });
+
+  test("throws if data is not array", () => {
+    expect(() =>
+      EqSlide.fromJSON({ type: "eq", data: null })
+    ).toThrow("eq: data must be array");
+  });
+});

package/tests/slides.fillImage.test.js

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

package/tests/slides.imageLeftBulletsRight.test.js

@@ -0,0 +1,28 @@
+import { describe, test, expect } from "vitest";
+import { ImageLeftBulletsRightSlide } from "../src/slides/ImageLeftBulletsRightSlide.js";
+
+describe("imageLeftBulletsRight", () => {
+  test("builds with image and bullets", () => {
+    const raw = {
+      type: "imageLeftBulletsRight",
+      data: [
+        { name: "image", content: "img.png" },
+        { name: "bullet", content: "One" },
+        { name: "bullet", content: "Two" }
+      ]
+    };
+
+    const slide = ImageLeftBulletsRightSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("img.png");
+    expect(html).toContain("One");
+    expect(html).toContain("Two");
+  });
+
+  test("throws if image or bullets missing", () => {
+    expect(() =>
+      ImageLeftBulletsRightSlide.fromJSON({ type: "imageLeftBulletsRight", data: [] })
+    ).toThrow("imageLeftBulletsRight: image and bullets required");
+  });
+});

package/tests/slides.imageRightBulletsLeft.test.js

@@ -0,0 +1,26 @@
+import { describe, test, expect } from "vitest";
+import { ImageRightBulletsLeftSlide } from "../src/slides/ImageRightBulletsLeftSlide.js";
+
+describe("imageRightBulletsLeft", () => {
+  test("builds with image and bullets", () => {
+    const raw = {
+      type: "imageRightBulletsLeft",
+      data: [
+        { name: "image", content: "img.png" },
+        { name: "bullet", content: "A" }
+      ]
+    };
+
+    const slide = ImageRightBulletsLeftSlide.fromJSON(raw);
+    const html = slide.render();
+
+    expect(html).toContain("img.png");
+    expect(html).toContain("A");
+  });
+
+  test("throws if image or bullets missing", () => {
+    expect(() =>
+      ImageRightBulletsLeftSlide.fromJSON({ type: "imageRightBulletsLeft", data: [] })
+    ).toThrow("imageRightBulletsLeft: image and bullets required");
+  });
+});

package/tests/slides.imageSlide.test.js

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