@storyteller-platform/epub 0.7.0 → 0.8.0

package/dist/adapters/tmpfs.js

@@ -1,179 +1,252 @@
-import {
-  __callDispose,
-  __using
-} from "../chunk-BIEQXUOY.js";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { randomUUID } from "node:crypto";
 import { createWriteStream, rmSync } from "node:fs";
-import {
-  cp,
-  mkdir,
-  readFile,
-  readdir,
-  rm,
-  stat,
-  writeFile
-} from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { cp, mkdir, readFile, readdir, rm, stat, writeFile, } from "node:fs/promises";
 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) {
-  const lowered = filenameOrExt.toLowerCase();
-  return AUDIO_FILE_EXTENSIONS.some((ext) => lowered.endsWith(ext));
-}
+import { openZip } from "../zip.js";
+const PRECOMPRESSED_KINDS = new Set([
+    "audio",
+    "image",
+    "archive",
+    "package",
+]);
 function mintRootPath() {
-  return join(tmpdir(), `storyteller-platform-epub-${randomUUID()}`);
+    return scratchPath(`storyteller-platform-epub-${randomUUID()}`);
 }
-class TmpFsAdapter {
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-  }
-  static kind = "extracted-dir";
-  static capabilities = { writable: true };
-  static async init(source) {
-    const rootPath = mintRootPath();
-    try {
-      var _stack = [];
-      try {
-        const zipfile = typeof source === "string" ? await open(source) : await fromBuffer(Buffer.from(source));
-        const stack = __using(_stack, new AsyncDisposableStack(), true);
-        stack.defer(async () => {
-          await zipfile.close();
-        });
-        for await (const entry of zipfile) {
-          if (entry.filename.endsWith("/")) {
-            continue;
-          }
-          const writePath = join(rootPath, entry.filename);
-          const readStream = await entry.openReadStream();
-          await mkdir(dirname(writePath), { recursive: true });
-          const writeStream = createWriteStream(writePath);
-          await pipeline(readStream, writeStream);
-        }
-      } catch (_) {
-        var _error = _, _hasError = true;
-      } finally {
-        var _promise = __callDispose(_stack, _error, _hasError);
-        _promise && await _promise;
-      }
-    } catch (error) {
-      rmSync(rootPath, { force: true, recursive: true });
-      throw error;
+/**
+ * Whether an entry name can be laid down inside the extract root.
+ *
+ * A `.` or `..` segment cannot name a real file, and joining one onto the
+ * root would walk out of it, so such an entry is unreachable here whether it
+ * came from a hostile archive or from an href that spelled it `%2E%2E`.
+ */
+function isStorableEntryName(entry) {
+    return !entry
+        .split("/")
+        .some((segment) => segment === "" || segment === "." || segment === "..");
+}
+/**
+ * Extracts an EPUB archive to a temp directory and serves all I/O off
+ * the real filesystem.
+ * `Epub.using(TmpFsAdapter).from(...)` returns a writable {@link Epub}.
+ */
+export class TmpFsAdapter {
+    rootPath;
+    static kind = "extracted-dir";
+    static capabilities = { writable: true };
+    static async init(source) {
+        const rootPath = mintRootPath();
+        try {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const zipfile = await openZip(source);
+                const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+                stack.defer(async () => {
+                    await zipfile.close();
+                });
+                for await (const entry of zipfile) {
+                    if (entry.filename.endsWith("/")) {
+                        // directory entries are skipped; parent dirs are created implicitly
+                        continue;
+                    }
+                    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);
+                    await pipeline(readStream, writeStream);
+                }
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
+        }
+        catch (error) {
+            rmSync(rootPath, { force: true, recursive: true });
+            throw error;
+        }
+        return new TmpFsAdapter(rootPath);
+    }
+    static async initEmpty() {
+        const rootPath = mintRootPath();
+        await mkdir(rootPath, { recursive: true });
+        return new TmpFsAdapter(rootPath);
+    }
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    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("/"));
     }
-    return new TmpFsAdapter(rootPath);
-  }
-  static async initEmpty() {
-    const rootPath = mintRootPath();
-    await mkdir(rootPath, { recursive: true });
-    return new TmpFsAdapter(rootPath);
-  }
-  async read(path, encoding) {
-    return await readFile(path, encoding);
-  }
-  async write(path, data, encoding) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, data, encoding);
-  }
-  async remove(path) {
-    await rm(path);
-  }
-  async archiveLength(path) {
-    try {
-      const st = await stat(path);
-      return st.size;
-    } catch {
-      return 0;
+    async read(entry, encoding) {
+        return await readFile(this.diskPath(entry), encoding);
     }
-  }
-  async *list() {
-    const entries = await readdir(this.rootPath, {
-      recursive: true,
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      if (entry.isDirectory()) continue;
-      const absolutePath = join(entry.parentPath, entry.name);
-      yield {
-        absolutePath,
-        relativePath: absolutePath.replace(`${this.rootPath}${sep}`, "")
-      };
+    async write(entry, data, encoding) {
+        const path = this.diskPath(entry);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, data, encoding);
     }
-  }
-  async duplicate() {
-    const newRoot = mintRootPath();
-    try {
-      await cp(this.rootPath, newRoot, { recursive: true });
-    } catch (error) {
-      rmSync(newRoot, { force: true, recursive: true });
-      throw error;
+    async remove(entry) {
+        await rm(this.diskPath(entry));
     }
-    return new TmpFsAdapter(newRoot);
-  }
-  async serialize(targetPath) {
-    var _stack = [];
-    try {
-      const tmpArchivePath = join(
-        tmpdir(),
-        `storyteller-platform-epub-${randomUUID()}`
-      );
-      const { promise, resolve } = Promise.withResolvers();
-      const zipfile = new ZipFile();
-      const writeStream = createWriteStream(tmpArchivePath);
-      writeStream.on("close", () => {
-        resolve();
-      });
-      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", {
-        compress: false
-      });
-      for await (const entry of this.list()) {
-        if (entry.relativePath === "mimetype") continue;
-        zipfile.addFile(entry.absolutePath, entry.relativePath, {
-          compress: !isAudioFile(entry.absolutePath)
+    async exists(entry) {
+        try {
+            await stat(this.diskPath(entry));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async archiveLength(entry) {
+        try {
+            const st = await stat(this.diskPath(entry));
+            return st.size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async *list() {
+        const entries = await readdir(this.rootPath, {
+            recursive: true,
+            withFileTypes: true,
         });
-      }
-      zipfile.end();
-      await promise;
-      await cp(tmpArchivePath, targetPath);
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      var _promise = __callDispose(_stack, _error, _hasError);
-      _promise && await _promise;
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                continue;
+            const absolutePath = join(entry.parentPath, entry.name);
+            yield {
+                absolutePath,
+                relativePath: absolutePath
+                    .slice(this.rootPath.length + 1)
+                    .split(sep)
+                    .join("/"),
+            };
+        }
+    }
+    async duplicate() {
+        const newRoot = mintRootPath();
+        try {
+            await cp(this.rootPath, newRoot, { recursive: true });
+        }
+        catch (error) {
+            rmSync(newRoot, { force: true, recursive: true });
+            throw error;
+        }
+        return new TmpFsAdapter(newRoot);
+    }
+    async serialize(targetPath) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const tmpArchivePath = mintRootPath();
+            // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+            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 = __addDisposableResource(env_2, new AsyncDisposableStack(), true);
+            stack.defer(async () => {
+                writeStream.close();
+                await rm(tmpArchivePath, { force: true });
+            });
+            zipfile.outputStream.pipe(writeStream);
+            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: !PRECOMPRESSED_KINDS.has(MediaType.fromPath(entry.absolutePath)?.kind),
+                });
+            }
+            zipfile.end();
+            await promise;
+            await cp(tmpArchivePath, targetPath);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    dispose() {
+        rmSync(this.rootPath, { recursive: true, force: true });
     }
-  }
-  dispose() {
-    rmSync(this.rootPath, { recursive: true, force: true });
-  }
 }
-export {
-  TmpFsAdapter
-};

package/dist/epubcheck.d.ts

@@ -1,4 +1,4 @@
-interface Location {
+export interface Location {
     url: {
         hierachical: boolean;
         opaque: boolean;
@@ -8,16 +8,14 @@ interface Location {
     column: number;
     context: string | null;
 }
-interface Message {
+export interface Message {
     ID: string;
     severity: "FATAL" | "ERROR" | "WARNING" | "INFO" | "USAGE";
     message: string;
     additionalLocations: number;
     locations: Location[];
 }
-interface Report {
+export interface Report {
     messages: Message[];
 }
-declare function epubcheck(epubFile: string): Promise<Report>;
-
-export { type Location, type Message, type Report, epubcheck };
+export declare function epubcheck(epubFile: string): Promise<Report>;

package/dist/epubcheck.js

@@ -1,36 +1,34 @@
-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 execFilePromise = promisify(execFile);
-  try {
-    await execFilePromise("java", [
-      "-jar",
-      JAR,
-      "--json",
-      output,
-      epubFile
-    ]).catch((error) => {
-      if (error instanceof Error && error.message.includes("Check finished with errors")) {
-        return;
-      }
-      throw error;
-    });
-    const json = await readFile(output, "utf8");
-    return JSON.parse(json);
-  } finally {
-    await unlink(output).catch(() => {
-    });
-  }
+export async function epubcheck(epubFile) {
+    const output = scratchPath(`epubcheck-${randomUUID()}.json`);
+    const execFilePromise = promisify(execFile);
+    try {
+        await execFilePromise("java", [
+            "-jar",
+            JAR,
+            "--json",
+            output,
+            epubFile,
+        ]).catch((error) => {
+            if (error instanceof Error &&
+                error.message.includes("Check finished with errors")) {
+                // dont throw, just let the caller handle it
+                return;
+            }
+            throw error;
+        });
+        const json = await readFile(output, "utf8");
+        return JSON.parse(json);
+    }
+    finally {
+        await unlink(output).catch(() => { });
+    }
 }
-export {
-  epubcheck
-};