@storyteller-platform/epub 0.6.3 → 0.7.1

package/dist/adapters/tmpfs.js

@@ -13,38 +13,23 @@ import {
   stat,
   writeFile
 } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { pipeline } from "node:stream/promises";
-import { fromBuffer, open } from "yauzl-promise";
 import { ZipFile } from "yazl";
+import { scratchPath } from "@storyteller-platform/fs";
+import { MediaType } from "@storyteller-platform/media-types";
 import { dirname, join, sep } from "@storyteller-platform/path";
-const MP3_FILE_EXTENSIONS = [".mp3"];
-const MPEG4_FILE_EXTENSIONS = [".mp4", ".m4a", ".m4b"];
-const AAC_FILE_EXTENSIONS = [".aac"];
-const OGG_FILE_EXTENSIONS = [".ogg", ".oga", ".mogg"];
-const OPUS_FILE_EXTENSIONS = [".opus"];
-const WAVE_FILE_EXTENSIONS = [".wav"];
-const AIFF_FILE_EXTENSIONS = [".aiff"];
-const FLAC_FILE_EXTENSIONS = [".flac"];
-const ALAC_FILE_EXTENSIONS = [".alac"];
-const WEBM_FILE_EXTENSIONS = [".weba"];
-const AUDIO_FILE_EXTENSIONS = [
-  ...MP3_FILE_EXTENSIONS,
-  ...AAC_FILE_EXTENSIONS,
-  ...MPEG4_FILE_EXTENSIONS,
-  ...OPUS_FILE_EXTENSIONS,
-  ...OGG_FILE_EXTENSIONS,
-  ...WAVE_FILE_EXTENSIONS,
-  ...AIFF_FILE_EXTENSIONS,
-  ...FLAC_FILE_EXTENSIONS,
-  ...ALAC_FILE_EXTENSIONS,
-  ...WEBM_FILE_EXTENSIONS
-];
-function isAudioFile(filenameOrExt) {
-  return AUDIO_FILE_EXTENSIONS.some((ext) => filenameOrExt.endsWith(ext));
-}
+import { openZip } from "../zip.js";
+const PRECOMPRESSED_KINDS = /* @__PURE__ */ new Set([
+  "audio",
+  "image",
+  "archive",
+  "package"
+]);
 function mintRootPath() {
-  return join(tmpdir(), `storyteller-platform-epub-${randomUUID()}`);
+  return scratchPath(`storyteller-platform-epub-${randomUUID()}`);
+}
+function isStorableEntryName(entry) {
+  return !entry.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
 }
 class TmpFsAdapter {
   constructor(rootPath) {
@@ -57,7 +42,7 @@ class TmpFsAdapter {
     try {
       var _stack = [];
       try {
-        const zipfile = typeof source === "string" ? await open(source) : await fromBuffer(Buffer.from(source));
+        const zipfile = await openZip(source);
         const stack = __using(_stack, new AsyncDisposableStack(), true);
         stack.defer(async () => {
           await zipfile.close();
@@ -66,7 +51,8 @@ class TmpFsAdapter {
           if (entry.filename.endsWith("/")) {
             continue;
           }
-          const writePath = join(rootPath, entry.filename);
+          if (!isStorableEntryName(entry.filename)) continue;
+          const writePath = join(rootPath, ...entry.filename.split("/"));
           const readStream = await entry.openReadStream();
           await mkdir(dirname(writePath), { recursive: true });
           const writeStream = createWriteStream(writePath);
@@ -89,19 +75,36 @@ class TmpFsAdapter {
     await mkdir(rootPath, { recursive: true });
     return new TmpFsAdapter(rootPath);
   }
-  async read(path, encoding) {
-    return await readFile(path, encoding);
+  diskPath(entry) {
+    if (!isStorableEntryName(entry)) {
+      const err = new Error(`ENOENT: no such entry in EPUB archive: ${entry}`);
+      err.code = "ENOENT";
+      throw err;
+    }
+    return join(this.rootPath, ...entry.split("/"));
+  }
+  async read(entry, encoding) {
+    return await readFile(this.diskPath(entry), encoding);
   }
-  async write(path, data, encoding) {
+  async write(entry, data, encoding) {
+    const path = this.diskPath(entry);
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, data, encoding);
   }
-  async remove(path) {
-    await rm(path);
+  async remove(entry) {
+    await rm(this.diskPath(entry));
+  }
+  async exists(entry) {
+    try {
+      await stat(this.diskPath(entry));
+      return true;
+    } catch {
+      return false;
+    }
   }
-  async archiveLength(path) {
+  async archiveLength(entry) {
     try {
-      const st = await stat(path);
+      const st = await stat(this.diskPath(entry));
       return st.size;
     } catch {
       return 0;
@@ -117,7 +120,7 @@ class TmpFsAdapter {
       const absolutePath = join(entry.parentPath, entry.name);
       yield {
         absolutePath,
-        relativePath: absolutePath.replace(`${this.rootPath}${sep}`, "")
+        relativePath: absolutePath.slice(this.rootPath.length + 1).split(sep).join("/")
       };
     }
   }
@@ -132,31 +135,33 @@ class TmpFsAdapter {
     return new TmpFsAdapter(newRoot);
   }
   async serialize(targetPath) {
+    var _a;
     var _stack = [];
     try {
-      const tmpArchivePath = join(
-        tmpdir(),
-        `storyteller-platform-epub-${randomUUID()}`
-      );
-      const { promise, resolve } = Promise.withResolvers();
+      const tmpArchivePath = mintRootPath();
+      const { promise, resolve, reject } = Promise.withResolvers();
       const zipfile = new ZipFile();
       const writeStream = createWriteStream(tmpArchivePath);
       writeStream.on("close", () => {
         resolve();
       });
+      writeStream.on("error", reject);
+      zipfile.outputStream.on("error", reject);
       const stack = __using(_stack, new AsyncDisposableStack(), true);
       stack.defer(async () => {
         writeStream.close();
         await rm(tmpArchivePath, { force: true });
       });
       zipfile.outputStream.pipe(writeStream);
-      zipfile.addBuffer(Buffer.from("application/epub+zip"), "mimetype", {
+      zipfile.addBuffer(Buffer.from(MediaType.EPUB.mime), "mimetype", {
         compress: false
       });
       for await (const entry of this.list()) {
         if (entry.relativePath === "mimetype") continue;
         zipfile.addFile(entry.absolutePath, entry.relativePath, {
-          compress: !isAudioFile(entry.absolutePath)
+          compress: !PRECOMPRESSED_KINDS.has(
+            (_a = MediaType.fromPath(entry.absolutePath)) == null ? void 0 : _a.kind
+          )
         });
       }
       zipfile.end();

package/dist/epubcheck.cjs

@@ -24,15 +24,15 @@ module.exports = __toCommonJS(epubcheck_exports);
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 var import_promises = require("node:fs/promises");
-var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var import_node_url = require("node:url");
 var import_node_util = require("node:util");
+var import_fs = require("@storyteller-platform/fs");
 const import_meta = {};
 const here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
 const JAR = (0, import_node_path.join)(here, "vendors", "epubcheck-5.3.0", "epubcheck.jar");
 async function epubcheck(epubFile) {
-  const output = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `epubcheck-${(0, import_node_crypto.randomUUID)()}.json`);
+  const output = (0, import_fs.scratchPath)(`epubcheck-${(0, import_node_crypto.randomUUID)()}.json`);
   const execFilePromise = (0, import_node_util.promisify)(import_node_child_process.execFile);
   try {
     await execFilePromise("java", [

package/dist/epubcheck.js

@@ -2,14 +2,14 @@ import "./chunk-BIEQXUOY.js";
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { readFile, unlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import { scratchPath } from "@storyteller-platform/fs";
 const here = dirname(fileURLToPath(import.meta.url));
 const JAR = join(here, "vendors", "epubcheck-5.3.0", "epubcheck.jar");
 async function epubcheck(epubFile) {
-  const output = join(tmpdir(), `epubcheck-${randomUUID()}.json`);
+  const output = scratchPath(`epubcheck-${randomUUID()}.json`);
   const execFilePromise = promisify(execFile);
   try {
     await execFilePromise("java", [