@storyteller-platform/align 0.1.9 → 0.1.10

package/dist/markup/__tests__/markup.test.js

@@ -1,53 +1,68 @@
 import assert from "node:assert";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { describe, it } from "node:test";
 import { Epub } from "@storyteller-platform/epub";
-import { appendTextNode, markupChapter } from "../markup.js";
+import { markupChapter } from "../markup.js";
 import { getXhtmlSegmentation } from "../segmentation.js";
-void describe("appendTextNode", () => {
-  void it("can append text nodes to empty parents", () => {
-    const input = [];
-    appendTextNode("chapter_one", input, "test", [], /* @__PURE__ */ new Set());
-    assert.deepStrictEqual(input, [{ "#text": "test" }]);
-  });
-  void it("can append text nodes with marks", () => {
-    const input = [];
-    appendTextNode(
-      "chapter_one",
-      input,
-      "test",
-      [{ elementName: "a", attributes: { "@_href": "#" } }],
-      /* @__PURE__ */ new Set()
-    );
-    assert.deepStrictEqual(input, [
-      { a: [{ "#text": "test" }], ":@": { "@_href": "#" } }
-    ]);
-  });
-  void it("can wrap text nodes with sentence spans", () => {
-    const input = [];
-    appendTextNode("chapter_one", input, "test", [], /* @__PURE__ */ new Set(), 0);
-    assert.deepStrictEqual(input, [
-      {
-        span: [{ "#text": "test" }],
-        ":@": { "@_id": "chapter_one-s0" }
+function sanitizeFilename(title) {
+  return title.replace(/[/\\:*?"<>|]/g, "-").replace(/\s+/g, " ").trim().replace(/[.]+$/, "");
+}
+function truncate(input, byteLimit, suffix = "") {
+  const normalized = input.normalize("NFC");
+  const encoder = new TextEncoder();
+  let result = "";
+  for (const char of normalized) {
+    const withSuffix = result + char + suffix;
+    const byteLength = encoder.encode(withSuffix).length;
+    if (byteLength > byteLimit) break;
+    result += char;
+  }
+  return result + suffix;
+}
+function getSafeFilepathSegment(name, suffix = "") {
+  return truncate(sanitizeFilename(name), 150, suffix);
+}
+async function assertMarkupSnapshot(context, output) {
+  const snapshotFilename = getSafeFilepathSegment(context.fullName, ".snapshot");
+  const snapshotFilepath = join(
+    "src",
+    "markup",
+    "__snapshots__",
+    snapshotFilename
+  );
+  if (process.env["UPDATE_SNAPSHOTS"]) {
+    await mkdir(dirname(snapshotFilepath), { recursive: true });
+    await writeFile(snapshotFilepath, output, { encoding: "utf-8" });
+    return;
+  }
+  try {
+    const existingSnapshot = await readFile(snapshotFilepath, {
+      encoding: "utf-8"
+    });
+    const existingLines = existingSnapshot.split("\n");
+    const newLines = output.split("\n");
+    for (let i = 0; i < existingLines.length; i++) {
+      const existingLine = existingLines[i];
+      const newLine = newLines[i];
+      if (existingLine !== newLine) {
+        assert.strictEqual(
+          newLines.slice(Math.max(0, i - 5), i + 5),
+          existingLines.slice(Math.max(0, i - 5), i + 5)
+        );
       }
-    ]);
-  });
-  void it("can join text nodes with the same sentence ids", () => {
-    const input = [
-      {
-        span: [{ "#text": "test" }],
-        ":@": { "@_id": "chapter_one-s0" }
-      }
-    ];
-    appendTextNode("chapter_one", input, "test", [], /* @__PURE__ */ new Set(), 0);
-    assert.deepStrictEqual(input, [
-      {
-        span: [{ "#text": "test" }, { "#text": "test" }],
-        ":@": { "@_id": "chapter_one-s0" }
-      }
-    ]);
-  });
-});
+    }
+  } catch (e) {
+    if (e instanceof assert.AssertionError) {
+      throw e;
+    }
+    throw new assert.AssertionError({
+      actual: output,
+      expected: "",
+      diff: "simple"
+    });
+  }
+}
 void describe("markupChapter", () => {
   void it("can tag sentences", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -86,16 +101,17 @@ void describe("markupChapter", () => {
 </html>
 `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can tag sentences with formatting marks", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -119,16 +135,17 @@ void describe("markupChapter", () => {
 </html>
 `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can tag sentences with formatting marks that overlap sentence boundaries", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -152,16 +169,17 @@ void describe("markupChapter", () => {
 </html>
 `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can tag sentences with nested formatting marks", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -185,16 +203,17 @@ void describe("markupChapter", () => {
 </html>
 `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can tag sentences with atoms", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -218,16 +237,17 @@ void describe("markupChapter", () => {
 </html>
 `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can tag sentences in nested textblocks", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -261,16 +281,17 @@ void describe("markupChapter", () => {
 </html>
     `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can tag sentences that cross textblock boundaries", async (t) => {
     const input = Epub.xhtmlParser.parse(
@@ -297,18 +318,19 @@ void describe("markupChapter", () => {
 </html>
     `
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
-  void it("can handle soft page breaks", async (t) => {
+  void it.only("can handle soft page breaks", async (t) => {
     const input = Epub.xhtmlParser.parse(
       /* xml */
       `
@@ -340,16 +362,17 @@ void describe("markupChapter", () => {
   </body>
 </html>`
     );
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can handle boolean-like text values", async (t) => {
     const input = Epub.xhtmlParser.parse(`
@@ -361,16 +384,17 @@ void describe("markupChapter", () => {
 </body>
 </html>
 `);
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can handle number-like text values", async (t) => {
     const input = Epub.xhtmlParser.parse(`
@@ -382,16 +406,17 @@ void describe("markupChapter", () => {
 </body>
 </html>
 `);
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can handle null-like text values", async (t) => {
     const input = Epub.xhtmlParser.parse(`
@@ -403,16 +428,17 @@ void describe("markupChapter", () => {
 </body>
 </html>
 `);
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
   void it("can preserve nbsp entities", async (t) => {
     const input = Epub.xhtmlParser.parse(`
@@ -427,15 +453,16 @@ void describe("markupChapter", () => {
 </body>
 </html>
 `);
-    const segmentation = await getXhtmlSegmentation(
+    const { result: segmentation, mapping } = await getXhtmlSegmentation(
       Epub.getXhtmlBody(input),
       {}
     );
     const { markedUp: output } = markupChapter(
       "chapter_one",
       input,
-      segmentation
+      segmentation,
+      mapping
     );
-    t.assert.snapshot(Epub.xhtmlBuilder.build(output).split("\n"));
+    await assertMarkupSnapshot(t, Epub.xhtmlBuilder.build(output));
   });
 });

package/dist/markup/__tests__/parseDom.test.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_node_test = require("node:test");
+var import_epub = require("@storyteller-platform/epub");
+var import_model = require("../model.cjs");
+var import_parseDom = require("../parseDom.cjs");
+void (0, import_node_test.describe)("parseDom", () => {
+  void (0, import_node_test.it)("should parse hierarchical XML", () => {
+    const result = (0, import_parseDom.parseDom)([
+      import_epub.Epub.createXmlElement("p", {}, [
+        import_epub.Epub.createXmlElement("span", {}, [
+          import_epub.Epub.createXmlTextNode("Hello, world!")
+        ])
+      ])
+    ]);
+    import_node_assert.default.deepStrictEqual(
+      result,
+      new import_model.Root([
+        new import_model.Node("p", {}, [new import_model.TextNode("Hello, world!", [new import_model.Mark("span")])])
+      ])
+    );
+  });
+  void (0, import_node_test.it)("should parse nested marks", () => {
+    const result = (0, import_parseDom.parseDom)([
+      import_epub.Epub.createXmlElement("p", {}, [
+        import_epub.Epub.createXmlElement("strong", {}, [
+          import_epub.Epub.createXmlElement("em", {}, [
+            import_epub.Epub.createXmlTextNode("Hello, world!")
+          ])
+        ])
+      ])
+    ]);
+    import_node_assert.default.deepStrictEqual(
+      result,
+      new import_model.Root([
+        new import_model.Node("p", {}, [
+          new import_model.TextNode("Hello, world!", [new import_model.Mark("strong"), new import_model.Mark("em")])
+        ])
+      ])
+    );
+  });
+  void (0, import_node_test.it)("should preserve attributes", () => {
+    const result = (0, import_parseDom.parseDom)([
+      import_epub.Epub.createXmlElement("p", { id: "p1" }, [
+        import_epub.Epub.createXmlElement("span", { class: "red" }, [
+          import_epub.Epub.createXmlTextNode("Hello, world!")
+        ])
+      ])
+    ]);
+    import_node_assert.default.deepStrictEqual(
+      result,
+      new import_model.Root([
+        new import_model.Node("p", { id: "p1" }, [
+          new import_model.TextNode("Hello, world!", [new import_model.Mark("span", { class: "red" })])
+        ])
+      ])
+    );
+  });
+  void (0, import_node_test.it)("should preserve leaf nodes", () => {
+    const result = (0, import_parseDom.parseDom)([
+      import_epub.Epub.createXmlElement("p", {}, [
+        import_epub.Epub.createXmlElement("span", {}, [
+          import_epub.Epub.createXmlTextNode("Hello,"),
+          import_epub.Epub.createXmlElement("span", { class: "x-ebookmaker-pageno" }, [
+            import_epub.Epub.createXmlElement("a", { id: "Page_v" })
+          ]),
+          import_epub.Epub.createXmlTextNode(" world!")
+        ])
+      ])
+    ]);
+    import_node_assert.default.deepStrictEqual(
+      result,
+      new import_model.Root([
+        new import_model.Node("p", {}, [
+          new import_model.TextNode("Hello,", [new import_model.Mark("span")]),
+          new import_model.Node(
+            "a",
+            { id: "Page_v" },
+            [],
+            [
+              new import_model.Mark("span"),
+              new import_model.Mark("span", { class: "x-ebookmaker-pageno" })
+            ]
+          ),
+          new import_model.TextNode(" world!", [new import_model.Mark("span")])
+        ])
+      ])
+    );
+  });
+});

package/dist/markup/__tests__/parseDom.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/markup/__tests__/parseDom.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/markup/__tests__/parseDom.test.js

@@ -0,0 +1,89 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Epub } from "@storyteller-platform/epub";
+import { Mark, Node, Root, TextNode } from "../model.js";
+import { parseDom } from "../parseDom.js";
+void describe("parseDom", () => {
+  void it("should parse hierarchical XML", () => {
+    const result = parseDom([
+      Epub.createXmlElement("p", {}, [
+        Epub.createXmlElement("span", {}, [
+          Epub.createXmlTextNode("Hello, world!")
+        ])
+      ])
+    ]);
+    assert.deepStrictEqual(
+      result,
+      new Root([
+        new Node("p", {}, [new TextNode("Hello, world!", [new Mark("span")])])
+      ])
+    );
+  });
+  void it("should parse nested marks", () => {
+    const result = parseDom([
+      Epub.createXmlElement("p", {}, [
+        Epub.createXmlElement("strong", {}, [
+          Epub.createXmlElement("em", {}, [
+            Epub.createXmlTextNode("Hello, world!")
+          ])
+        ])
+      ])
+    ]);
+    assert.deepStrictEqual(
+      result,
+      new Root([
+        new Node("p", {}, [
+          new TextNode("Hello, world!", [new Mark("strong"), new Mark("em")])
+        ])
+      ])
+    );
+  });
+  void it("should preserve attributes", () => {
+    const result = parseDom([
+      Epub.createXmlElement("p", { id: "p1" }, [
+        Epub.createXmlElement("span", { class: "red" }, [
+          Epub.createXmlTextNode("Hello, world!")
+        ])
+      ])
+    ]);
+    assert.deepStrictEqual(
+      result,
+      new Root([
+        new Node("p", { id: "p1" }, [
+          new TextNode("Hello, world!", [new Mark("span", { class: "red" })])
+        ])
+      ])
+    );
+  });
+  void it("should preserve leaf nodes", () => {
+    const result = parseDom([
+      Epub.createXmlElement("p", {}, [
+        Epub.createXmlElement("span", {}, [
+          Epub.createXmlTextNode("Hello,"),
+          Epub.createXmlElement("span", { class: "x-ebookmaker-pageno" }, [
+            Epub.createXmlElement("a", { id: "Page_v" })
+          ]),
+          Epub.createXmlTextNode(" world!")
+        ])
+      ])
+    ]);
+    assert.deepStrictEqual(
+      result,
+      new Root([
+        new Node("p", {}, [
+          new TextNode("Hello,", [new Mark("span")]),
+          new Node(
+            "a",
+            { id: "Page_v" },
+            [],
+            [
+              new Mark("span"),
+              new Mark("span", { class: "x-ebookmaker-pageno" })
+            ]
+          ),
+          new TextNode(" world!", [new Mark("span")])
+        ])
+      ])
+    );
+  });
+});