@storyteller-platform/epub 0.4.10 → 0.5.1

package/dist/upgrade.js

@@ -0,0 +1,515 @@
+import "./chunk-BIEQXUOY.js";
+import { nanoid } from "nanoid";
+import {
+  Epub
+} from "./index.js";
+const GUIDE_TO_EPUBTYPE = {
+  acknowledgements: "acknowledgments",
+  "other.afterword": "afterword",
+  "other.appendix": "appendix",
+  "other.backmatter": "backmatter",
+  bibliography: "bibliography",
+  text: "bodymatter",
+  "other.chapter": "chapter",
+  colophon: "colophon",
+  "other.conclusion": "conclusion",
+  "other.contributors": "contributors",
+  "copyright-page": "copyright-page",
+  cover: "cover",
+  dedication: "dedication",
+  "other.division": "division",
+  epigraph: "epigraph",
+  "other.epilogue": "epilogue",
+  "other.errata": "errata",
+  "other.footnotes": "footnotes",
+  foreword: "foreword",
+  "other.frontmatter": "frontmatter",
+  glossary: "glossary",
+  "other.halftitlepage": "halftitlepage",
+  "other.imprint": "imprint",
+  "other.imprimatur": "imprimatur",
+  index: "index",
+  "other.introduction": "introduction",
+  "other.landmarks": "landmarks",
+  "other.loa": "loa",
+  loi: "loi",
+  lot: "lot",
+  "other.lov": "lov",
+  notes: "",
+  "other.notice": "notice",
+  "other.other-credits": "other-credits",
+  "other.part": "part",
+  "other.preamble": "preamble",
+  preface: "preface",
+  "other.prologue": "prologue",
+  "other.rearnotes": "rearnotes",
+  "other.subchapter": "subchapter",
+  "title-page": "titlepage",
+  toc: "toc",
+  "other.volume": "volume",
+  "other.warning": "warning"
+};
+const XHTML_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "application/xhtml+xml",
+  "application/vnd.adobe-page-template+xml",
+  "text/html"
+]);
+const OEB_FONTS = /* @__PURE__ */ new Set([
+  "application/vnd.ms-opentype",
+  "application/x-font-ttf",
+  "application/x-font-otf",
+  "application/x-font-truetype",
+  "application/font-sfnt",
+  "application/font-woff",
+  "application/font-woff2",
+  "font/woff",
+  "font/woff2",
+  "font/otf",
+  "font/ttf",
+  "font/sfnt"
+]);
+const FONT_MIME_BY_EXT = {
+  ".ttf": "application/font-sfnt",
+  ".otf": "application/font-sfnt",
+  ".woff": "application/font-woff",
+  ".woff2": "font/woff2"
+};
+function getMetadataElement(pkg) {
+  return Epub.findXmlChildByName("metadata", Epub.getXmlChildren(pkg));
+}
+function getManifestElement(pkg) {
+  return Epub.findXmlChildByName("manifest", Epub.getXmlChildren(pkg));
+}
+function getSpineElement(pkg) {
+  return Epub.findXmlChildByName("spine", Epub.getXmlChildren(pkg));
+}
+function ensureId(element) {
+  var _a;
+  const existing = (_a = element[":@"]) == null ? void 0 : _a["@_id"];
+  if (existing) return existing;
+  const id = `id-${nanoid(8)}`;
+  element[":@"] ??= {};
+  element[":@"]["@_id"] = id;
+  return id;
+}
+function findAllByName(name, xml) {
+  return xml.filter(
+    (node) => !Epub.isXmlTextNode(node) && name in node
+  );
+}
+function hasElementDeep(xml, name) {
+  for (const node of xml) {
+    if (Epub.isXmlTextNode(node)) continue;
+    if (Epub.getXmlElementName(node) === name) return true;
+    if (hasElementDeep(Epub.getXmlChildren(node), name)) return true;
+  }
+  return false;
+}
+function textContentOf(element) {
+  return Epub.getXhtmlTextContent(Epub.getXmlChildren(element)).trim();
+}
+function removeFromArray(array, item) {
+  const idx = array.indexOf(item);
+  if (idx !== -1) array.splice(idx, 1);
+}
+function upgradeIdentifiers(pkg) {
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  for (const ident of findAllByName("dc:identifier", metadata.metadata)) {
+    const attrs = ident[":@"] ?? {};
+    let val = textContentOf(ident);
+    let scheme = attrs["@_opf:scheme"];
+    if (val.toLowerCase().startsWith("urn:")) {
+      const rest = val.slice(4);
+      const colonIdx = rest.indexOf(":");
+      if (colonIdx > 0) {
+        scheme = rest.slice(0, colonIdx);
+        val = rest.slice(colonIdx + 1);
+      }
+    }
+    if (scheme && val && !scheme.toLowerCase().startsWith("uri")) {
+      val = `${scheme}:${val}`;
+    }
+    const id = attrs["@_id"];
+    ident[":@"] = id ? { "@_id": id } : {};
+    Epub.replaceXmlChildren(ident, [Epub.createXmlTextNode(val)]);
+  }
+}
+function upgradeTitle(pkg) {
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  const titles = findAllByName("dc:title", metadata.metadata);
+  let firstTitle = null;
+  for (const title of titles) {
+    const text = textContentOf(title);
+    if (!text) {
+      removeFromArray(metadata.metadata, title);
+      continue;
+    }
+    firstTitle ??= title;
+  }
+  if (!firstTitle) return;
+  const titleId = ensureId(firstTitle);
+  metadata.metadata.push(
+    Epub.createXmlElement(
+      "meta",
+      { refines: `#${titleId}`, property: "title-type" },
+      [Epub.createXmlTextNode("main")]
+    )
+  );
+}
+function upgradeLanguages(pkg) {
+  var _a;
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  const langs = findAllByName("dc:language", metadata.metadata);
+  if (langs.length > 0) {
+    for (const lang of langs) {
+      const id = (_a = lang[":@"]) == null ? void 0 : _a["@_id"];
+      lang[":@"] = id ? { "@_id": id } : {};
+    }
+    return;
+  }
+  metadata.metadata.push(
+    Epub.createXmlElement("dc:language", {}, [Epub.createXmlTextNode("und")])
+  );
+}
+function upgradeAuthors(pkg) {
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  for (const which of ["dc:creator", "dc:contributor"]) {
+    for (const elem of findAllByName(which, metadata.metadata)) {
+      const attrs = elem[":@"] ?? {};
+      const role = attrs["@_opf:role"];
+      const sort = attrs["@_opf:file-as"];
+      const elemId = role || sort ? ensureId(elem) : attrs["@_id"];
+      elem[":@"] = elemId ? { "@_id": elemId } : {};
+      if (role) {
+        metadata.metadata.push(
+          Epub.createXmlElement(
+            "meta",
+            {
+              refines: `#${elemId}`,
+              property: "role",
+              scheme: "marc:relators"
+            },
+            [Epub.createXmlTextNode(role)]
+          )
+        );
+      }
+      if (sort) {
+        metadata.metadata.push(
+          Epub.createXmlElement(
+            "meta",
+            { refines: `#${elemId}`, property: "file-as" },
+            [Epub.createXmlTextNode(sort)]
+          )
+        );
+      }
+    }
+  }
+}
+function upgradeDate(pkg) {
+  var _a;
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  const dates = findAllByName("dc:date", metadata.metadata);
+  let kept = false;
+  for (const date of dates) {
+    const text = textContentOf(date);
+    if (!text || kept) {
+      removeFromArray(metadata.metadata, date);
+      continue;
+    }
+    kept = true;
+    const id = (_a = date[":@"]) == null ? void 0 : _a["@_id"];
+    date[":@"] = id ? { "@_id": id } : {};
+  }
+}
+function upgradeMeta(pkg) {
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  for (const meta of findAllByName("meta", metadata.metadata)) {
+    const attrs = meta[":@"] ?? {};
+    const name = attrs["@_name"] ?? "";
+    const content = attrs["@_content"] ?? "";
+    let prop = null;
+    let value = content;
+    const cleanName = name.startsWith("rendition:") ? name.slice("rendition:".length) : name;
+    if (["orientation", "layout", "spread"].includes(cleanName)) {
+      prop = `rendition:${cleanName}`;
+    } else if (name === "fixed-layout") {
+      prop = "rendition:layout";
+      value = content.toLowerCase() === "true" ? "pre-paginated" : "reflowable";
+    } else if (name === "orientation-lock") {
+      prop = "rendition:orientation";
+      const map = {
+        portrait: "portrait",
+        landscape: "landscape"
+      };
+      value = map[content.toLowerCase()] ?? "auto";
+    }
+    if (!prop) continue;
+    delete attrs["@_name"];
+    delete attrs["@_content"];
+    attrs["@_property"] = prop;
+    Epub.replaceXmlChildren(meta, [Epub.createXmlTextNode(value)]);
+  }
+}
+function upgradeCover(pkg) {
+  const metadata = getMetadataElement(pkg);
+  const manifest = getManifestElement(pkg);
+  if (!metadata || !manifest) return;
+  for (const meta of findAllByName("meta", metadata.metadata)) {
+    const attrs = meta[":@"];
+    const isCoverMeta = (attrs == null ? void 0 : attrs["@_name"]) === "cover" && attrs["@_content"];
+    if (!isCoverMeta) continue;
+    const itemId = attrs["@_content"];
+    for (const item of findAllByName("item", manifest.manifest)) {
+      const itemAttrs = item[":@"];
+      if (!itemAttrs || itemAttrs["@_id"] !== itemId) continue;
+      const mediaType = (itemAttrs["@_media-type"] ?? "").toLowerCase();
+      const isImage = mediaType && !mediaType.includes("xml") && !mediaType.includes("html");
+      if (!isImage) continue;
+      const existing = (itemAttrs["@_properties"] ?? "").split(" ").filter(Boolean);
+      const props = new Set(existing);
+      props.add("cover-image");
+      itemAttrs["@_properties"] = [...props].sort().join(" ");
+    }
+  }
+}
+function removeInvalidDcAttrs(pkg) {
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  for (const node of metadata.metadata) {
+    if (Epub.isXmlTextNode(node)) continue;
+    const name = Epub.getXmlElementName(node);
+    if (!name.startsWith("dc:")) continue;
+    const attrs = node[":@"];
+    if (!attrs) continue;
+    const id = attrs["@_id"];
+    node[":@"] = id ? { "@_id": id } : {};
+  }
+}
+function setLastModified(pkg) {
+  var _a;
+  const metadata = getMetadataElement(pkg);
+  if (!metadata) return;
+  for (let i = metadata.metadata.length - 1; i >= 0; i--) {
+    const node = metadata.metadata[i];
+    if (!node || Epub.isXmlTextNode(node)) continue;
+    if (((_a = node[":@"]) == null ? void 0 : _a["@_property"]) === "dcterms:modified") {
+      metadata.metadata.splice(i, 1);
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+/, "");
+  metadata.metadata.push(
+    Epub.createXmlElement("meta", { property: "dcterms:modified" }, [
+      Epub.createXmlTextNode(now)
+    ])
+  );
+}
+function upgradePackageMetadata(pkg) {
+  upgradeIdentifiers(pkg);
+  upgradeTitle(pkg);
+  upgradeLanguages(pkg);
+  upgradeAuthors(pkg);
+  upgradeDate(pkg);
+  upgradeMeta(pkg);
+  upgradeCover(pkg);
+  removeInvalidDcAttrs(pkg);
+  setLastModified(pkg);
+}
+function extractGuideLandmarks(pkg) {
+  const guide = Epub.findXmlChildByName("guide", Epub.getXmlChildren(pkg));
+  if (!guide) return [];
+  const landmarks = [];
+  for (const node of Epub.getXmlChildren(guide)) {
+    if (Epub.isXmlTextNode(node)) continue;
+    if (!("reference" in node)) continue;
+    const attrs = node[":@"] ?? {};
+    const href = attrs["@_href"] ?? "";
+    const title = attrs["@_title"] ?? "";
+    const guideType = (attrs["@_type"] ?? "").toLowerCase();
+    const epubType = GUIDE_TO_EPUBTYPE[guideType];
+    if (epubType === void 0 || !href) continue;
+    landmarks.push({ href, title, type: epubType });
+  }
+  return landmarks;
+}
+function removeGuide(pkg) {
+  const children = Epub.getXmlChildren(pkg);
+  const guide = Epub.findXmlChildByName("guide", children);
+  if (guide) {
+    removeFromArray(children, guide);
+  }
+}
+function removeSpineTocRef(pkg) {
+  const spine = getSpineElement(pkg);
+  if (!(spine == null ? void 0 : spine[":@"])) return;
+  delete spine[":@"]["@_toc"];
+}
+async function collectManifestProperties(epub) {
+  var _a;
+  const manifest = await epub.getManifest();
+  for (const item of Object.values(manifest)) {
+    const mediaType = ((_a = item.mediaType) == null ? void 0 : _a.toLowerCase()) ?? "";
+    if (!XHTML_MEDIA_TYPES.has(mediaType)) continue;
+    let xml;
+    try {
+      xml = await epub.readXhtmlItemContents(item.id);
+    } catch {
+      continue;
+    }
+    const props = new Set(item.properties ?? []);
+    const before = props.size;
+    if (hasElementDeep(xml, "svg")) props.add("svg");
+    if (hasElementDeep(xml, "script")) props.add("scripted");
+    if (hasElementDeep(xml, "math")) props.add("mathml");
+    if (hasElementDeep(xml, "epub:switch")) props.add("switch");
+    if (props.size === before) continue;
+    await epub.updateManifestItem(item.id, {
+      ...item,
+      properties: [...props].sort()
+    });
+  }
+}
+function fixFontMimeTypes(pkg) {
+  var _a, _b;
+  const manifest = getManifestElement(pkg);
+  if (!manifest) return;
+  for (const item of findAllByName("item", manifest.manifest)) {
+    const mt = (((_a = item[":@"]) == null ? void 0 : _a["@_media-type"]) ?? "").toLowerCase();
+    if (!OEB_FONTS.has(mt)) continue;
+    const href = ((_b = item[":@"]) == null ? void 0 : _b["@_href"]) ?? "";
+    const dotIdx = href.lastIndexOf(".");
+    if (dotIdx === -1) continue;
+    const ext = href.slice(dotIdx).toLowerCase();
+    const corrected = FONT_MIME_BY_EXT[ext];
+    if (corrected && corrected !== mt) {
+      item[":@"] ??= {};
+      item[":@"]["@_media-type"] = corrected;
+    }
+  }
+}
+function buildTocOl(entries) {
+  const children = entries.map((entry) => {
+    const label = entry.title.replace(/\s+/g, " ").trim();
+    const liChildren = [];
+    if (entry.href) {
+      liChildren.push(
+        Epub.createXmlElement("a", { href: entry.href }, [
+          Epub.createXmlTextNode(label)
+        ])
+      );
+    } else {
+      liChildren.push(
+        Epub.createXmlElement("span", {}, [Epub.createXmlTextNode(label)])
+      );
+    }
+    if (entry.children && entry.children.length > 0) {
+      liChildren.push(buildTocOl(entry.children));
+    }
+    return Epub.createXmlElement("li", {}, liChildren);
+  });
+  return Epub.createXmlElement("ol", {}, children);
+}
+async function buildNavDocument(epub, tocEntries, landmarks) {
+  var _a;
+  let tocOl;
+  if (tocEntries.length > 0) {
+    tocOl = buildTocOl(tocEntries);
+  } else {
+    const spineItems = await epub.getSpineItems();
+    const firstHref = ((_a = spineItems[0]) == null ? void 0 : _a.href) ?? "#";
+    tocOl = Epub.createXmlElement("ol", {}, [
+      Epub.createXmlElement("li", {}, [
+        Epub.createXmlElement("a", { href: firstHref }, [
+          Epub.createXmlTextNode("Start")
+        ])
+      ])
+    ]);
+  }
+  const tocNav = Epub.createXmlElement("nav", { "epub:type": "toc" }, [
+    Epub.createXmlElement("h1", {}, [
+      Epub.createXmlTextNode("Table of Contents")
+    ]),
+    tocOl
+  ]);
+  const body = [tocNav];
+  const validLandmarks = landmarks.filter((lm) => lm.type);
+  if (validLandmarks.length > 0) {
+    const lmOl = Epub.createXmlElement(
+      "ol",
+      {},
+      validLandmarks.map(
+        (lm) => Epub.createXmlElement("li", {}, [
+          Epub.createXmlElement("a", { "epub:type": lm.type, href: lm.href }, [
+            Epub.createXmlTextNode(lm.title || lm.type)
+          ])
+        ])
+      )
+    );
+    body.push(
+      Epub.createXmlElement("nav", { "epub:type": "landmarks", hidden: "" }, [
+        lmOl
+      ])
+    );
+  }
+  const head = [
+    Epub.createXmlElement("title", {}, [Epub.createXmlTextNode("Navigation")])
+  ];
+  const navDoc = await epub.createXhtmlDocument(body, head);
+  return Epub.xhtmlBuilder.build(navDoc);
+}
+function setPackageVersion(pkg, version) {
+  pkg[":@"] ??= {};
+  pkg[":@"]["@_version"] = version;
+}
+async function chooseNavHref(epub) {
+  const manifest = await epub.getManifest();
+  const existingHrefs = new Set(
+    Object.values(manifest).map((item) => item.href)
+  );
+  let candidate = "nav.xhtml";
+  let i = 1;
+  while (existingHrefs.has(candidate)) {
+    candidate = `nav${i}.xhtml`;
+    i++;
+  }
+  return candidate;
+}
+async function removeNcx(epub) {
+  const manifest = await epub.getManifest();
+  const ncxItem = Object.values(manifest).find(
+    (item) => {
+      var _a;
+      return ((_a = item.mediaType) == null ? void 0 : _a.toLowerCase()) === "application/x-dtbncx+xml";
+    }
+  );
+  if (ncxItem) {
+    await epub.removeManifestItem(ncxItem.id);
+  }
+}
+export {
+  buildNavDocument,
+  buildTocOl,
+  chooseNavHref,
+  collectManifestProperties,
+  extractGuideLandmarks,
+  fixFontMimeTypes,
+  removeGuide,
+  removeInvalidDcAttrs,
+  removeNcx,
+  removeSpineTocRef,
+  setLastModified,
+  setPackageVersion,
+  upgradeAuthors,
+  upgradeCover,
+  upgradeDate,
+  upgradeIdentifiers,
+  upgradeLanguages,
+  upgradeMeta,
+  upgradePackageMetadata,
+  upgradeTitle
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storyteller-platform/epub",
-  "version": "0.4.10",
+  "version": "0.5.1",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,8 +23,8 @@
     "readme:toc": "markdown-toc --maxdepth=5 --append='\n- [API Docs](#api-docs)' --bullets='-' -i readme-stub.md",
     "readme:api": "typedoc",
     "readme": "yarn readme:api && yarn readme:toc && cat readme-stub.md > README.md && tail -n +2 gen/README.md >> README.md",
-    "test": "tsx -C @storyteller --test index.test.ts",
-    "test:watch": "tsx -C @storyteller --test --watch index.test.ts",
+    "test": "tsx -C @storyteller --test *.test.ts",
+    "test:watch": "tsx -C @storyteller --test --watch *.test.ts",
     "prepack": "yarn build"
   },
   "devDependencies": {
@@ -35,6 +35,7 @@
     "@types/node": "^24.0.0",
     "@types/yauzl-promise": "^4",
     "@types/yazl": "^3",
+    "epubchecker": "^5.2.1",
     "eslint": "^8.0.0",
     "markdown-toc": "^1.2.0",
     "remark-toc": "^9.0.0",
@@ -47,7 +48,7 @@
   },
   "dependencies": {
     "@storyteller-platform/fs": "^0.1.4",
-    "@storyteller-platform/path": "^0.1.1",
+    "@storyteller-platform/path": "^0.1.2",
     "@zip.js/zip.js": "^2.0.0",
     "async-mutex": "^0.5.0",
     "fast-xml-parser": "^4.0.1",