@storyteller-platform/epub 0.4.10 → 0.5.0

package/dist/upgrade.cjs

@@ -0,0 +1,555 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  buildNavDocument: () => buildNavDocument,
+  buildTocOl: () => buildTocOl,
+  chooseNavHref: () => chooseNavHref,
+  collectManifestProperties: () => collectManifestProperties,
+  extractGuideLandmarks: () => extractGuideLandmarks,
+  fixFontMimeTypes: () => fixFontMimeTypes,
+  removeGuide: () => removeGuide,
+  removeInvalidDcAttrs: () => removeInvalidDcAttrs,
+  removeNcx: () => removeNcx,
+  removeSpineTocRef: () => removeSpineTocRef,
+  setLastModified: () => setLastModified,
+  setPackageVersion: () => setPackageVersion,
+  upgradeAuthors: () => upgradeAuthors,
+  upgradeCover: () => upgradeCover,
+  upgradeDate: () => upgradeDate,
+  upgradeIdentifiers: () => upgradeIdentifiers,
+  upgradeLanguages: () => upgradeLanguages,
+  upgradeMeta: () => upgradeMeta,
+  upgradePackageMetadata: () => upgradePackageMetadata,
+  upgradeTitle: () => upgradeTitle
+});
+module.exports = __toCommonJS(upgrade_exports);
+var import_nanoid = require("nanoid");
+var import_index = require("./index.cjs");
+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 import_index.Epub.findXmlChildByName("metadata", import_index.Epub.getXmlChildren(pkg));
+}
+function getManifestElement(pkg) {
+  return import_index.Epub.findXmlChildByName("manifest", import_index.Epub.getXmlChildren(pkg));
+}
+function getSpineElement(pkg) {
+  return import_index.Epub.findXmlChildByName("spine", import_index.Epub.getXmlChildren(pkg));
+}
+function ensureId(element) {
+  var _a;
+  const existing = (_a = element[":@"]) == null ? void 0 : _a["@_id"];
+  if (existing) return existing;
+  const id = `id-${(0, import_nanoid.nanoid)(8)}`;
+  element[":@"] ??= {};
+  element[":@"]["@_id"] = id;
+  return id;
+}
+function findAllByName(name, xml) {
+  return xml.filter(
+    (node) => !import_index.Epub.isXmlTextNode(node) && name in node
+  );
+}
+function hasElementDeep(xml, name) {
+  for (const node of xml) {
+    if (import_index.Epub.isXmlTextNode(node)) continue;
+    if (import_index.Epub.getXmlElementName(node) === name) return true;
+    if (hasElementDeep(import_index.Epub.getXmlChildren(node), name)) return true;
+  }
+  return false;
+}
+function textContentOf(element) {
+  return import_index.Epub.getXhtmlTextContent(import_index.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 } : {};
+    import_index.Epub.replaceXmlChildren(ident, [import_index.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(
+    import_index.Epub.createXmlElement(
+      "meta",
+      { refines: `#${titleId}`, property: "title-type" },
+      [import_index.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(
+    import_index.Epub.createXmlElement("dc:language", {}, [import_index.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(
+          import_index.Epub.createXmlElement(
+            "meta",
+            {
+              refines: `#${elemId}`,
+              property: "role",
+              scheme: "marc:relators"
+            },
+            [import_index.Epub.createXmlTextNode(role)]
+          )
+        );
+      }
+      if (sort) {
+        metadata.metadata.push(
+          import_index.Epub.createXmlElement(
+            "meta",
+            { refines: `#${elemId}`, property: "file-as" },
+            [import_index.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;
+    import_index.Epub.replaceXmlChildren(meta, [import_index.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 (import_index.Epub.isXmlTextNode(node)) continue;
+    const name = import_index.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 || import_index.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(
+    import_index.Epub.createXmlElement("meta", { property: "dcterms:modified" }, [
+      import_index.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 = import_index.Epub.findXmlChildByName("guide", import_index.Epub.getXmlChildren(pkg));
+  if (!guide) return [];
+  const landmarks = [];
+  for (const node of import_index.Epub.getXmlChildren(guide)) {
+    if (import_index.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 = import_index.Epub.getXmlChildren(pkg);
+  const guide = import_index.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(
+        import_index.Epub.createXmlElement("a", { href: entry.href }, [
+          import_index.Epub.createXmlTextNode(label)
+        ])
+      );
+    } else {
+      liChildren.push(
+        import_index.Epub.createXmlElement("span", {}, [import_index.Epub.createXmlTextNode(label)])
+      );
+    }
+    if (entry.children && entry.children.length > 0) {
+      liChildren.push(buildTocOl(entry.children));
+    }
+    return import_index.Epub.createXmlElement("li", {}, liChildren);
+  });
+  return import_index.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 = import_index.Epub.createXmlElement("ol", {}, [
+      import_index.Epub.createXmlElement("li", {}, [
+        import_index.Epub.createXmlElement("a", { href: firstHref }, [
+          import_index.Epub.createXmlTextNode("Start")
+        ])
+      ])
+    ]);
+  }
+  const tocNav = import_index.Epub.createXmlElement("nav", { "epub:type": "toc" }, [
+    import_index.Epub.createXmlElement("h1", {}, [
+      import_index.Epub.createXmlTextNode("Table of Contents")
+    ]),
+    tocOl
+  ]);
+  const body = [tocNav];
+  const validLandmarks = landmarks.filter((lm) => lm.type);
+  if (validLandmarks.length > 0) {
+    const lmOl = import_index.Epub.createXmlElement(
+      "ol",
+      {},
+      validLandmarks.map(
+        (lm) => import_index.Epub.createXmlElement("li", {}, [
+          import_index.Epub.createXmlElement("a", { "epub:type": lm.type, href: lm.href }, [
+            import_index.Epub.createXmlTextNode(lm.title || lm.type)
+          ])
+        ])
+      )
+    );
+    body.push(
+      import_index.Epub.createXmlElement("nav", { "epub:type": "landmarks", hidden: "" }, [
+        lmOl
+      ])
+    );
+  }
+  const head = [
+    import_index.Epub.createXmlElement("title", {}, [import_index.Epub.createXmlTextNode("Navigation")])
+  ];
+  const navDoc = await epub.createXhtmlDocument(body, head);
+  return import_index.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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildNavDocument,
+  buildTocOl,
+  chooseNavHref,
+  collectManifestProperties,
+  extractGuideLandmarks,
+  fixFontMimeTypes,
+  removeGuide,
+  removeInvalidDcAttrs,
+  removeNcx,
+  removeSpineTocRef,
+  setLastModified,
+  setPackageVersion,
+  upgradeAuthors,
+  upgradeCover,
+  upgradeDate,
+  upgradeIdentifiers,
+  upgradeLanguages,
+  upgradeMeta,
+  upgradePackageMetadata,
+  upgradeTitle
+});